ref: 83d6d0c7dfa7c26bc3d1134fd18124c3acde8f08
dir: /src/util.c/
/* * util.c. * Incorporate Jimen Ching's fixes for real library operation: Aug 3, 1994. * Redo all work from scratch, unfortunately. * Separate out all common variables used by effects & handlers, * and utility routines for other main programs to use. */ /* * July 5, 1991 * Copyright 1991 Lance Norskog And Sundry Contributors * This source code is freely redistributable and may be used for * any purpose. This copyright notice must be maintained. * Lance Norskog And Sundry Contributors are not responsible for * the consequences of using this software. */ #include "st_i.h" #include <stddef.h> #include <string.h> #include <ctype.h> #include <stdarg.h> struct st_output_message_s { char const * filename; char const * fmt; va_list ap; }; st_output_message_handler_t st_output_message_handler = NULL; int st_output_verbosity_level = 2; void st_output_message(FILE * file, st_output_message_t message) { char buffer[10]; char const * drivername; char const * dot_pos; drivername = strrchr(message->filename, '/'); if (drivername != NULL) { ++drivername; } else { drivername = strrchr(message->filename, '\\'); if (drivername != NULL) ++drivername; else drivername = message->filename; } dot_pos = strrchr(drivername, '.'); if (dot_pos != NULL && dot_pos - drivername <= (ptrdiff_t)(sizeof(buffer) - 1)) { strncpy(buffer, drivername, (size_t)(dot_pos - drivername)); buffer[dot_pos - drivername] = '\0'; drivername = buffer; } fprintf(file, "%s: ", drivername); vfprintf(file, message->fmt, message->ap); } /* This is a bit of a hack. It's useful to have the ST library * report which driver (i.e. format or effect handler) is outputing * the message. Using the filename for this purpose is only an * approximation, but it saves a lot of work. ;) */ char const * st_message_filename = 0; static void st_emit_message(int level, char const * fmt, va_list ap) { if (st_output_message_handler != NULL) { struct st_output_message_s m; m.filename = st_message_filename; m.fmt = fmt; m.ap = ap; (*st_output_message_handler)(level, &m); } } #undef st_fail #undef st_warn #undef st_report #undef st_debug #undef st_debug_more #undef st_debug_most #define ST_MESSAGE_FUNCTION(name,level) \ void name(char const * fmt, ...) \ { \ va_list args; \ \ va_start(args, fmt); \ st_emit_message(level, fmt, args); \ va_end(args); \ } ST_MESSAGE_FUNCTION(st_fail , 1) ST_MESSAGE_FUNCTION(st_warn , 2) ST_MESSAGE_FUNCTION(st_report, 3) ST_MESSAGE_FUNCTION(st_debug , 4) ST_MESSAGE_FUNCTION(st_debug_more , 5) ST_MESSAGE_FUNCTION(st_debug_most , 6) #undef ST_MESSAGE_FUNCTION void st_fail_errno(ft_t ft, int st_errno, const char *fmt, ...) { va_list args; ft->st_errno = st_errno; va_start(args, fmt); vsnprintf(ft->st_errstr, sizeof(ft->st_errstr), fmt, args); va_end(args); ft->st_errstr[255] = '\0'; } /* * Check that we have a known format suffix string. */ int st_gettype(ft_t formp, bool is_file_extension) { const char * const *list; int i; const st_format_t *f; if (! formp->filetype){ st_fail_errno(formp, ST_EFMT, "Filetype was not specified"); return(ST_EFMT); } for(i = 0; st_format_fns[i]; i++) { f = st_format_fns[i](); if (is_file_extension && (f->flags & ST_FILE_NOFEXT)) continue; /* don't match special device names in real file names */ for (list = f->names; *list; list++) { const char *s1 = *list, *s2 = formp->filetype; if (! strcasecmp(s1, s2)) break; /* not a match */ } if (! *list) continue; /* Found it! */ formp->h = f; return ST_SUCCESS; } st_fail_errno(formp, ST_EFMT, "File type '%s' is not known", formp->filetype); return ST_EFMT; } /* * Check that we have a known effect name. If found, copy name of * effect into structure and place a pointer to internal data. * Returns -1 on error else it turns the total number of arguments * that should be passed to this effects getopt() function. */ int st_geteffect_opt(eff_t effp, int argc, char **argv) { int i, optind; for (i = 0; st_effect_fns[i]; i++) { const st_effect_t *e = st_effect_fns[i](); if (e && e->name && strcasecmp(e->name, argv[0]) == 0) { effp->name = e->name; effp->h = e; for (optind = 1; optind < argc; optind++) { for (i = 0; st_effect_fns[i]; i++) { const st_effect_t *e = st_effect_fns[i](); if (e && e->name && strcasecmp(e->name, argv[optind]) == 0) return (optind - 1); } /* Didn't find a match, try the next argument. */ } /* * No matches found, all the following arguments are * for this effect passed in. */ return (optind - 1); } } return (ST_EOF); } /* * Check that we have a known effect name. If found, copy name of * effect into structure and place a pointer to internal data. * Returns -1 on on failure. */ int st_geteffect(eff_t effp, const char *effect_name) { int i; for(i = 0; st_effect_fns[i]; i++) { const st_effect_t *e = st_effect_fns[i](); if (e && e->name && strcasecmp(e->name, effect_name) == 0) { effp->name = e->name; effp->h = e; return ST_SUCCESS; } } return (ST_EOF); } /* * Check if we have a known effect name. */ bool is_effect_name(char const * text) { int i; for(i = 0; st_effect_fns[i]; i++) { const st_effect_t *e = st_effect_fns[i](); if (e && e->name && strcasecmp(e->name, text) == 0) return true; } return false; } /* * Copy input and output signal info into effect structures. * Must pass in a bitmask containing info of wheither ST_EFF_CHAN * or ST_EFF_RATE has been used previously on this effect stream. * If not running multiple effects then just pass in a value of 0. * * Return value is the same mask plus addition of ST_EFF_CHAN or * ST_EFF_RATE if it was used in this effect. That make this * return value can be passed back into this function in future * calls. */ int st_updateeffect(eff_t effp, const st_signalinfo_t *in, const st_signalinfo_t *out, int effect_mask) { effp->ininfo = *in; effp->outinfo = *out; if (in->channels != out->channels) { /* Only effects with ST_EFF_CHAN flag can actually handle * outputing a different number of channels then the input. */ if (!(effp->h->flags & ST_EFF_CHAN)) { /* If this effect is being ran before a ST_EFF_CHAN effect * then effect's output is the same as the input file. Else its * input contains same number of channels as the output * file. */ if (effect_mask & ST_EFF_CHAN) effp->ininfo.channels = out->channels; else effp->outinfo.channels = in->channels; } } if (in->rate != out->rate) { /* Only the ST_EFF_RATE effect can handle an input that * is a different sample rate then the output. */ if (!(effp->h->flags & ST_EFF_RATE)) { if (effect_mask & ST_EFF_RATE) effp->ininfo.rate = out->rate; else effp->outinfo.rate = in->rate; } } if (effp->h->flags & ST_EFF_CHAN) effect_mask |= ST_EFF_CHAN; if (effp->h->flags & ST_EFF_RATE) effect_mask |= ST_EFF_RATE; return effect_mask; } /* * st_parsesamples * * Parse a string for # of samples. If string ends with a 's' * then the string is interpreted as a user calculated # of samples. * If string contains ':' or '.' or if it ends with a 't' then its * treated as an amount of time. This is converted into seconds and * fraction of seconds and then use the sample rate to calculate * # of samples. * Returns ST_EOF on error. */ int st_parsesamples(st_rate_t rate, const char *str, st_size_t *samples, char def) { int found_samples = 0, found_time = 0; int time = 0; long long_samples; float frac = 0; if (strchr(str, ':') || strchr(str, '.') || str[strlen(str)-1] == 't') found_time = 1; else if (str[strlen(str)-1] == 's') found_samples = 1; if (found_time || (def == 't' && !found_samples)) { *samples = 0; while(1) { if (str[0] != '.' && sscanf(str, "%d", &time) != 1) return ST_EOF; *samples += time; while (*str != ':' && *str != '.' && *str != 0) str++; if (*str == '.' || *str == 0) break; /* Skip past ':' */ str++; *samples *= 60; } if (*str == '.') { if (sscanf(str, "%f", &frac) != 1) return ST_EOF; } *samples *= rate; *samples += (rate * frac) + 0.5; return ST_SUCCESS; } if (found_samples || (def == 's' && !found_time)) { if (sscanf(str, "%ld", &long_samples) != 1) return ST_EOF; *samples = long_samples; return ST_SUCCESS; } return ST_EOF; }