/* Implements a libSoX internal interface for implementing effects. * All public functions & data are prefixed with lsx_ . * * Copyright (c) 2005-2012 Chris Bagwell and SoX contributors * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation; either version 2.1 of the License, or (at * your option) any later version. * * This library is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser * General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this library; if not, write to the Free Software Foundation, * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA */ #define LSX_EFF_ALIAS#include "sox_i.h"#include <string.h>#include <ctype.h> int lsx_usage(sox_effect_t * effp){  if (effp->handler.usage)    lsx_fail("usage: %s", effp->handler.usage);  else    lsx_fail("this effect takes no parameters");  return SOX_EOF;} char * lsx_usage_lines(char * * usage, char const * const * lines, size_t n){  if (!*usage) {    size_t i, len;    for (len = i = 0; i < n; len += strlen(lines[i++]) + 1);    *usage = lsx_malloc(len); /* FIXME: this memory will never be freed */    strcpy(*usage, lines[0]);    for (i = 1; i < n; ++i) {      strcat(*usage, "\n");      strcat(*usage, lines[i]);    }  }  return *usage;} static lsx_enum_item const s_lsx_wave_enum[] = {  LSX_ENUM_ITEM(SOX_WAVE_,SINE)  LSX_ENUM_ITEM(SOX_WAVE_,TRIANGLE)  {0, 0}}; lsx_enum_item const * lsx_get_wave_enum(void){  return s_lsx_wave_enum;} void lsx_generate_wave_table(    lsx_wave_t wave_type,    sox_data_t data_type,    void *table,    size_t table_size,    double min,    double max,    double phase){  uint32_t t;  uint32_t phase_offset = phase / M_PI / 2 * table_size + 0.5;   for (t = 0; t < table_size; t++)  {    uint32_t point = (t + phase_offset) % table_size;    double d;    switch (wave_type)    {      case SOX_WAVE_SINE:      d = (sin((double)point / table_size * 2 * M_PI) + 1) / 2;      break;       case SOX_WAVE_TRIANGLE:      d = (double)point * 2 / table_size;      switch (4 * point / table_size)      {        case 0:         d = d + 0.5; break;        case 1: case 2: d = 1.5 - d; break;        case 3:         d = d - 1.5; break;      }      break;       default: /* Oops! FIXME */        d = 0.0; /* Make sure we have a value */      break;    }    d  = d * (max - min) + min;    switch (data_type)    {      case SOX_FLOAT:        {          float *fp = (float *)table;          *fp++ = (float)d;          table = fp;          continue;        }      case SOX_DOUBLE:        {          double *dp = (double *)table;          *dp++ = d;          table = dp;          continue;        }      default: break;    }    d += d < 0? -0.5 : +0.5;    switch (data_type)    {      case SOX_SHORT:        {          short *sp = table;          *sp++ = (short)d;          table = sp;          continue;        }      case SOX_INT:        {          int *ip = table;          *ip++ = (int)d;          table = ip;          continue;        }      default: break;    }  }} /* * lsx_parsesamples * * Parse a string for # of samples.  The input consists of one or more * parts, with '+' or '-' between them indicating if the sample count * should be added to or subtracted from the previous value. * If a part ends with a 's' then it is interpreted as a * user-calculated # of samples. * If a part contains ':' or '.' but no 'e' or if it ends with a 't' * then it is treated as an amount of time.  This is converted into * seconds and fraction of seconds, then the sample rate is used to * calculate # of samples. * Parameter def specifies which interpretation should be the default * for a bare number like "123".  It can either be 't' or 's'. * Returns NULL on error, pointer to next char to parse otherwise. */static char const * parsesamples(sox_rate_t rate, const char *str0, uint64_t *samples, int def, int combine); char const * lsx_parsesamples(sox_rate_t rate, const char *str0, uint64_t *samples, int def){  *samples = 0;  return parsesamples(rate, str0, samples, def, '+');} static char const * parsesamples(sox_rate_t rate, const char *str0, uint64_t *samples, int def, int combine){  char * str = (char *)str0;   do {    uint64_t samples_part;    sox_bool found_samples = sox_false, found_time = sox_false;    char const * end;    char const * pos;    sox_bool found_colon, found_dot, found_e;     for (;*str == ' '; ++str);    for (end = str; *end && strchr("0123456789:.ets", *end); ++end);    if (end == str)      return NULL; /* error: empty input */     pos = strchr(str, ':');    found_colon = pos && pos < end;     pos = strchr(str, '.');    found_dot = pos && pos < end;     pos = strchr(str, 'e');    found_e = pos && pos < end;     if (found_colon || (found_dot && !found_e) || *(end-1) == 't')      found_time = sox_true;    else if (*(end-1) == 's')      found_samples = sox_true;     if (found_time || (def == 't' && !found_samples)) {      int i;      if (found_e)        return NULL; /* error: e notation in time */       for (samples_part = 0, i = 0; *str != '.' && i < 3; ++i) {        char * last_str = str;        long part = strtol(str, &str, 10);        if (!i && str == last_str)          return NULL; /* error: empty first component */        samples_part += rate * part;        if (i < 2) {          if (*str != ':')            break;          ++str;          samples_part *= 60;        }      }      if (*str == '.') {        char * last_str = str;        double part = strtod(str, &str);        if (str == last_str)          return NULL; /* error: empty fractional part */        samples_part += rate * part + .5;      }      if (*str == 't')        str++;    } else {      char * last_str = str;      double part = strtod(str, &str);      if (str == last_str)        return NULL; /* error: no sample count */      samples_part = part + .5;      if (*str == 's')        str++;    }    if (str != end)      return NULL; /* error: trailing characters */     switch (combine) {      case '+': *samples += samples_part; break;      case '-': *samples = samples_part <= *samples ?                           *samples - samples_part : 0;        break;    }    combine = '\0';    if (*str && strchr("+-", *str))      combine = *str++;  } while (combine);  return str;} #if 0 #include <assert.h> #define TEST(st, samp, len) \  str = st; \  next = lsx_parsesamples(10000, str, &samples, 't'); \  assert(samples == samp && next == str + len); int main(int argc, char * * argv){  char const * str, * next;  uint64_t samples;   TEST("0"  , 0, 1)  TEST("1" , 10000, 1)   TEST("0s" , 0, 2)  TEST("0s,", 0, 2)  TEST("0s/", 0, 2)  TEST("0s@", 0, 2)   TEST("0t" , 0, 2)  TEST("0t,", 0, 2)  TEST("0t/", 0, 2)  TEST("0t@", 0, 2)   TEST("1s" , 1, 2)  TEST("1s,", 1, 2)  TEST("1s/", 1, 2)  TEST("1s@", 1, 2)  TEST(" 01s" , 1, 4)  TEST("1e6s" , 1000000, 4)   TEST("1t" , 10000, 2)  TEST("1t,", 10000, 2)  TEST("1t/", 10000, 2)  TEST("1t@", 10000, 2)  TEST("1.1t" , 11000, 4)  TEST("1.1t,", 11000, 4)  TEST("1.1t/", 11000, 4)  TEST("1.1t@", 11000, 4)  assert(!lsx_parsesamples(10000, "1e6t", &samples, 't'));   TEST(".0", 0, 2)  TEST("0.0", 0, 3)  TEST("0:0.0", 0, 5)  TEST("0:0:0.0", 0, 7)   TEST(".1", 1000, 2)  TEST(".10", 1000, 3)  TEST("0.1", 1000, 3)  TEST("1.1", 11000, 3)  TEST("1:1.1", 611000, 5)  TEST("1:1:1.1", 36611000, 7)  TEST("1:1", 610000, 3)  TEST("1:01", 610000, 4)  TEST("1:1:1", 36610000, 5)  TEST("1:", 600000, 2)  TEST("1::", 36000000, 3)   TEST("0.444444", 4444, 8)  TEST("0.555555", 5556, 8)   assert(!lsx_parsesamples(10000, "x", &samples, 't'));   TEST("1:23+37", 1200000, 7)  TEST("12t+12s",  120012, 7)  TEST("1e6s-10",  900000, 7)  TEST("10-2:00",       0, 7)  TEST("123-45+12s+2:00-3e3s@foo", 1977012, 20)   TEST("1\0" "2", 10000, 1)   return 0;}#endif /* * lsx_parseposition * * Parse a string for an audio position.  Similar to lsx_parsesamples * above, but an initial '=', '+' or '-' indicates that the specified time * is relative to the start of audio, last used position or end of audio, * respectively.  Parameter def states which of these is the default. * Parameters latest and end are the positions to which '+' and '-' relate; * end may be SOX_UNKNOWN_LEN, in which case "-0" is the only valid * end-relative input and will result in a position of SOX_UNKNOWN_LEN. * Other parameters and return value are the same as for lsx_parsesamples. * * A test parse that only checks for valid syntax can be done by * specifying samples = NULL.  If this passes, a later reparse of the same * input will only fail if it is relative to the end ("-"), not "-0", and * the end position is unknown. */char const * lsx_parseposition(sox_rate_t rate, const char *str0, uint64_t *samples, uint64_t latest, uint64_t end, int def){  char *str = (char *)str0;  char anchor, combine;   if (!strchr("+-=", def))    return NULL; /* error: invalid default anchor */  anchor = def;  if (*str && strchr("+-=", *str))    anchor = *str++;   combine = '+';  if (strchr("+-", anchor)) {    combine = anchor;    if (*str && strchr("+-", *str))      combine = *str++;  }   if (!samples) {    /* dummy parse, syntax checking only */    uint64_t dummy = 0;    return parsesamples(0., str, &dummy, 't', '+');  }   switch (anchor) {    case '=': *samples = 0; break;    case '+': *samples = latest; break;    case '-': *samples = end; break;  }   if (anchor == '-' && end == SOX_UNKNOWN_LEN) {    /* "-0" only valid input here */    char const *l;    for (l = str; *l && strchr("0123456789:.ets+-", *l); ++l);    if (l == str+1 && *str == '0') {      /* *samples already set to SOX_UNKNOWN_LEN */      return l;    }    return NULL; /* error: end-relative position, but end unknown */  }   return parsesamples(rate, str, samples, 't', combine);} /* a note is given as an int, * 0   => 440 Hz = A * >0  => number of half notes 'up', * <0  => number of half notes down, * example 12 => A of next octave, 880Hz * * calculated by freq = 440Hz * 2**(note/12) */static double calc_note_freq(double note, int key){  if (key != INT_MAX) {                         /* Just intonation. */    static const int n[] = {16, 9, 6, 5, 4, 7}; /* Numerator. */    static const int d[] = {15, 8, 5, 4, 3, 5}; /* Denominator. */    static double j[13];                        /* Just semitones */    int i, m = floor(note);     if (!j[1]) for (i = 1; i <= 12; ++i)      j[i] = i <= 6? log((double)n[i - 1] / d[i - 1]) / log(2.) : 1 - j[12 - i];    note -= m;    m -= key = m - ((INT_MAX / 2 - ((INT_MAX / 2) % 12) + m - key) % 12);    return 440 * pow(2., key / 12. + j[m] + (j[m + 1] - j[m]) * note);  }  return 440 * pow(2., note / 12);} int lsx_parse_note(char const * text, char * * end_ptr){  int result = INT_MAX;   if (*text >= 'A' && *text <= 'G') {    result = (int)(5/3. * (*text++ - 'A') + 9.5) % 12 - 9;    if (*text == 'b') {--result; ++text;}    else if (*text == '#') {++result; ++text;}    if (isdigit((unsigned char)*text))      result += 12 * (*text++ - '4');   }  *end_ptr = (char *)text;  return result;} /* Read string 'text' and convert to frequency. * 'text' can be a positive number which is the frequency in Hz. * If 'text' starts with a '%' and a following number the corresponding * note is calculated. * Return -1 on error. */double lsx_parse_frequency_k(char const * text, char * * end_ptr, int key){  double result;   if (*text == '%') {    result = strtod(text + 1, end_ptr);    if (*end_ptr == text + 1)      return -1;    return calc_note_freq(result, key);  }  if (*text >= 'A' && *text <= 'G') {    int result2 = lsx_parse_note(text, end_ptr);    return result2 == INT_MAX? - 1 : calc_note_freq((double)result2, key);  }  result = strtod(text, end_ptr);  if (end_ptr) {    if (*end_ptr == text)      return -1;    if (**end_ptr == 'k') {      result *= 1000;      ++*end_ptr;    }  }  return result < 0 ? -1 : result;} FILE * lsx_open_input_file(sox_effect_t * effp, char const * filename, sox_bool text_mode){  FILE * file;   if (!filename || !strcmp(filename, "-")) {    if (effp->global_info->global_info->stdin_in_use_by) {      lsx_fail("stdin already in use by `%s'", effp->global_info->global_info->stdin_in_use_by);      return NULL;    }    effp->global_info->global_info->stdin_in_use_by = effp->handler.name;    file = stdin;  }  else if (!(file = fopen(filename, text_mode ? "r" : "rb"))) {    lsx_fail("couldn't open file %s: %s", filename, strerror(errno));    return NULL;  }  return file;} int lsx_effects_init(void){  init_fft_cache();  return SOX_SUCCESS;} int lsx_effects_quit(void){  clear_fft_cache();  return SOX_SUCCESS;}