/* 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 <ctype.h>

int lsx_usage(sox_effect_t * effp)
{
  if (effp->handler.usage) {
    lsx_fail("usage: %s", effp->handler.usage);
    lsx_fail("for help, say %s --help-effect %s",
             sox_globals.myname, effp->handler.name);
  } else
    lsx_fail("this effect takes no parameters");
  return SOX_EOF;
}

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;
    }

    /* Converting a floating point type to an signed integral type truncates
     * towards zero, which would compress the two halves of the wave
     * towards zero creating distortion, so compensate.
     */
    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;
        }
      case SOX_SAMPLE:
        {
          int *ip = table;
          *ip++ = (sox_sample_t)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 || !isfinite(part) || fabs(part) == HUGE_VAL)
          return NULL; /* error: empty or infinite 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 || !isfinite(part) || fabs(part) == HUGE_VAL)
        return NULL; /* error: no (or infinite) 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((int)*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 || !isfinite(result) || fabs(result) == HUGE_VAL)
      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 || !isfinite(result) || fabs(result) == HUGE_VAL)
      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 = lsx_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;
}
