/* libSoX raw I/O
 *
 * Copyright 1991-2007 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 "sox_i.h"
#include "g711.h"

typedef sox_uint16_t sox_uint14_t;
typedef sox_uint16_t sox_uint13_t;
typedef sox_int16_t sox_int14_t;
typedef sox_int16_t sox_int13_t;
#define SOX_ULAW_BYTE_TO_SAMPLE(d,clips)   SOX_SIGNED_16BIT_TO_SAMPLE(sox_ulaw2linear16(d),clips)
#define SOX_ALAW_BYTE_TO_SAMPLE(d,clips)   SOX_SIGNED_16BIT_TO_SAMPLE(sox_alaw2linear16(d),clips)
#define SOX_SAMPLE_TO_ULAW_BYTE(d,c) sox_14linear2ulaw(SOX_SAMPLE_TO_UNSIGNED(14,d,c) - 0x2000)
#define SOX_SAMPLE_TO_ALAW_BYTE(d,c) sox_13linear2alaw(SOX_SAMPLE_TO_UNSIGNED(13,d,c) - 0x1000)

int lsx_rawseek(sox_format_t * ft, uint64_t offset)
{
  return lsx_offset_seek(ft, (off_t)ft->data_start, (off_t)offset);
}

/* Works nicely for starting read and write; lsx_rawstart{read,write}
 * are #defined in sox_i.h */
int lsx_rawstart(sox_format_t * ft, sox_bool default_rate,
                 sox_bool default_channels, sox_bool default_length,
                 sox_encoding_t encoding, unsigned size)
{
  if (default_rate && ft->signal.rate == 0) {
    lsx_warn("`%s': sample rate not specified; trying 8kHz", ft->filename);
    ft->signal.rate = 8000;
  }

  if (default_channels && ft->signal.channels == 0) {
    lsx_warn("`%s': # channels not specified; trying mono", ft->filename);
    ft->signal.channels = 1;
  }

  if (encoding != SOX_ENCODING_UNKNOWN) {
    if (ft->mode == 'r' && ft->encoding.encoding != SOX_ENCODING_UNKNOWN &&
        ft->encoding.encoding != encoding)
      lsx_report("`%s': Format options overriding file-type encoding",
                 ft->filename);
    else
      ft->encoding.encoding = encoding;
  }

  if (size != 0) {
    if (ft->mode == 'r' && ft->encoding.bits_per_sample != 0 &&
        ft->encoding.bits_per_sample != size)
      lsx_report("`%s': Format options overriding file-type sample-size",
                 ft->filename);
    else
      ft->encoding.bits_per_sample = size;
  }

  if (!ft->signal.length && ft->mode == 'r' && default_length &&
      ft->encoding.bits_per_sample)
    ft->signal.length =
        div_bits(lsx_filelength(ft), ft->encoding.bits_per_sample);

  return SOX_SUCCESS;
}

#define READ_SAMPLES_FUNC(type, size, sign, ctype, uctype, cast) \
  static size_t sox_read_ ## sign ## type ## _samples( \
      sox_format_t * ft, sox_sample_t *buf, size_t len) \
  { \
    size_t n, nread; \
    SOX_SAMPLE_LOCALS; \
    ctype *data = lsx_malloc(sizeof(ctype) * len); \
    LSX_USE_VAR(sox_macro_temp_sample), LSX_USE_VAR(sox_macro_temp_double); \
    nread = lsx_read_ ## type ## _buf(ft, (uctype *)data, len); \
    for (n = 0; n < nread; n++) \
      *buf++ = cast(data[n], ft->clips); \
    free(data); \
    return nread; \
  }

READ_SAMPLES_FUNC(b, 1, u, uint8_t, uint8_t, SOX_UNSIGNED_8BIT_TO_SAMPLE)
READ_SAMPLES_FUNC(b, 1, s, int8_t, uint8_t, SOX_SIGNED_8BIT_TO_SAMPLE)
READ_SAMPLES_FUNC(b, 1, ulaw, uint8_t, uint8_t, SOX_ULAW_BYTE_TO_SAMPLE)
READ_SAMPLES_FUNC(b, 1, alaw, uint8_t, uint8_t, SOX_ALAW_BYTE_TO_SAMPLE)
READ_SAMPLES_FUNC(w, 2, u, uint16_t, uint16_t, SOX_UNSIGNED_16BIT_TO_SAMPLE)
READ_SAMPLES_FUNC(w, 2, s, int16_t, uint16_t, SOX_SIGNED_16BIT_TO_SAMPLE)
READ_SAMPLES_FUNC(3, 3, u, sox_uint24_t, sox_uint24_t, SOX_UNSIGNED_24BIT_TO_SAMPLE)
READ_SAMPLES_FUNC(3, 3, s, sox_int24_t, sox_uint24_t, SOX_SIGNED_24BIT_TO_SAMPLE)
READ_SAMPLES_FUNC(dw, 4, u, uint32_t, uint32_t, SOX_UNSIGNED_32BIT_TO_SAMPLE)
READ_SAMPLES_FUNC(dw, 4, s, int32_t, uint32_t, SOX_SIGNED_32BIT_TO_SAMPLE)
READ_SAMPLES_FUNC(f, sizeof(float), su, float, float, SOX_FLOAT_32BIT_TO_SAMPLE)
READ_SAMPLES_FUNC(df, sizeof(double), su, double, double, SOX_FLOAT_64BIT_TO_SAMPLE)

#define WRITE_SAMPLES_FUNC(type, size, sign, ctype, uctype, cast) \
  static size_t sox_write_ ## sign ## type ## _samples( \
      sox_format_t * ft, sox_sample_t const * buf, size_t len) \
  { \
    SOX_SAMPLE_LOCALS; \
    size_t n, nwritten; \
    ctype *data = lsx_malloc(sizeof(ctype) * len); \
    LSX_USE_VAR(sox_macro_temp_sample), LSX_USE_VAR(sox_macro_temp_double); \
    for (n = 0; n < len; n++) \
      data[n] = cast(buf[n], ft->clips); \
    nwritten = lsx_write_ ## type ## _buf(ft, (uctype *)data, len); \
    free(data); \
    return nwritten; \
  }


WRITE_SAMPLES_FUNC(b, 1, u, uint8_t, uint8_t, SOX_SAMPLE_TO_UNSIGNED_8BIT) 
WRITE_SAMPLES_FUNC(b, 1, s, int8_t, uint8_t, SOX_SAMPLE_TO_SIGNED_8BIT)
WRITE_SAMPLES_FUNC(b, 1, ulaw, uint8_t, uint8_t, SOX_SAMPLE_TO_ULAW_BYTE) 
WRITE_SAMPLES_FUNC(b, 1, alaw, uint8_t, uint8_t, SOX_SAMPLE_TO_ALAW_BYTE)
WRITE_SAMPLES_FUNC(w, 2, u, uint16_t, uint16_t, SOX_SAMPLE_TO_UNSIGNED_16BIT) 
WRITE_SAMPLES_FUNC(w, 2, s, int16_t, uint16_t, SOX_SAMPLE_TO_SIGNED_16BIT)
WRITE_SAMPLES_FUNC(3, 3, u, sox_uint24_t, sox_uint24_t, SOX_SAMPLE_TO_UNSIGNED_24BIT) 
WRITE_SAMPLES_FUNC(3, 3, s, sox_int24_t, sox_uint24_t, SOX_SAMPLE_TO_SIGNED_24BIT)
WRITE_SAMPLES_FUNC(dw, 4, u, uint32_t, uint32_t, SOX_SAMPLE_TO_UNSIGNED_32BIT) 
WRITE_SAMPLES_FUNC(dw, 4, s, int32_t, uint32_t, SOX_SAMPLE_TO_SIGNED_32BIT)
WRITE_SAMPLES_FUNC(f, sizeof(float), su, float, float, SOX_SAMPLE_TO_FLOAT_32BIT) 
WRITE_SAMPLES_FUNC(df, sizeof (double), su, double, double, SOX_SAMPLE_TO_FLOAT_64BIT)

#define GET_FORMAT(type) \
static ft_##type##_fn * type##_fn(sox_format_t * ft) { \
  switch (ft->encoding.bits_per_sample) { \
    case 8: \
      switch (ft->encoding.encoding) { \
        case SOX_ENCODING_SIGN2: return sox_##type##_sb_samples; \
        case SOX_ENCODING_UNSIGNED: return sox_##type##_ub_samples; \
        case SOX_ENCODING_ULAW: return sox_##type##_ulawb_samples; \
        case SOX_ENCODING_ALAW: return sox_##type##_alawb_samples; \
        default: break; } \
      break; \
    case 16: \
      switch (ft->encoding.encoding) { \
        case SOX_ENCODING_SIGN2: return sox_##type##_sw_samples; \
        case SOX_ENCODING_UNSIGNED: return sox_##type##_uw_samples; \
        default: break; } \
      break; \
    case 24: \
      switch (ft->encoding.encoding) { \
        case SOX_ENCODING_SIGN2:    return sox_##type##_s3_samples; \
        case SOX_ENCODING_UNSIGNED: return sox_##type##_u3_samples; \
        default: break; } \
      break; \
    case 32: \
      switch (ft->encoding.encoding) { \
        case SOX_ENCODING_SIGN2: return sox_##type##_sdw_samples; \
        case SOX_ENCODING_UNSIGNED: return sox_##type##_udw_samples; \
        case SOX_ENCODING_FLOAT: return sox_##type##_suf_samples; \
        default: break; } \
      break; \
    case 64: \
      switch (ft->encoding.encoding) { \
        case SOX_ENCODING_FLOAT: return sox_##type##_sudf_samples; \
        default: break; } \
      break; \
    default: \
      lsx_fail_errno(ft, SOX_EFMT, "this handler does not support this data size"); \
      return NULL; } \
  lsx_fail_errno(ft, SOX_EFMT, "this encoding is not supported for this data size"); \
  return NULL; }

typedef size_t(ft_read_fn)
  (sox_format_t * ft, sox_sample_t * buf, size_t len);

GET_FORMAT(read)

/* Read a stream of some type into SoX's internal buffer format. */
size_t lsx_rawread(sox_format_t * ft, sox_sample_t * buf, size_t nsamp)
{
  ft_read_fn * read_buf = read_fn(ft);

  if (read_buf && nsamp)
    return read_buf(ft, buf, nsamp);
  return 0;
}

typedef size_t(ft_write_fn)
  (sox_format_t * ft, sox_sample_t const * buf, size_t len);

GET_FORMAT(write)

/* Writes SoX's internal buffer format to buffer of various data types. */
size_t lsx_rawwrite(
    sox_format_t * ft, sox_sample_t const * buf, size_t nsamp)
{
  ft_write_fn * write_buf = write_fn(ft);

  if (write_buf && nsamp)
    return write_buf(ft, buf, nsamp);
  return 0;
}