/* libSoX Sun format with header (SunOS 4.1; see /usr/demo/SOUND).
 * Copyright 1991, 1992, 1993 Guido van Rossum And Sundry Contributors.
 *
 * This source code is freely redistributable and may be used for
 * any purpose.  This copyright notice must be maintained.
 * Guido van Rossum And Sundry Contributors are not responsible for
 * the consequences of using this software.
 *
 * October 7, 1998 - cbagwell@sprynet.com
 *   G.723 was using incorrect # of bits.  Corrected to 3 and 5 bits.
 *
 * NeXT uses this format also, but has more format codes defined.
 * DEC uses a slight variation and swaps bytes.
 * We support only the common formats, plus
 * CCITT G.721 (32 kbit/s) and G.723 (24/40 kbit/s),
 * courtesy of Sun's public domain implementation.
 */

#include "sox_i.h"
#include "g72x.h"
#include <string.h>

/* Magic numbers used in Sun and NeXT audio files */
static struct {char str[4]; sox_bool reverse_bytes; char const * desc;} id[] = {
  {"\x2e\x73\x6e\x64", MACHINE_IS_LITTLEENDIAN, "big-endian `.snd'"},
  {"\x64\x6e\x73\x2e", MACHINE_IS_BIGENDIAN   , "little-endian `.snd'"},
  {"\x00\x64\x73\x2e", MACHINE_IS_BIGENDIAN   , "little-endian `\\0ds.' (for DEC)"},
  {"\x2e\x73\x64\x00", MACHINE_IS_LITTLEENDIAN, "big-endian `\\0ds.'"},
  {"    ", 0, NULL}
};
#define FIXED_HDR     24
#define SUN_UNSPEC    ~0u         /* Unspecified data size (this is legal) */

typedef enum {
  Unspecified, Mulaw_8, Linear_8, Linear_16, Linear_24, Linear_32, Float,
  Double, Indirect, Nested, Dsp_core, Dsp_data_8, Dsp_data_16, Dsp_data_24,
  Dsp_data_32, Unknown, Display, Mulaw_squelch, Emphasized, Compressed,
  Compressed_emphasized, Dsp_commands, Dsp_commands_samples, Adpcm_g721,
  Adpcm_g722, Adpcm_g723_3, Adpcm_g723_5, Alaw_8, Unknown_other} ft_encoding_t;
static char const * const str[] = {
  "Unspecified", "8-bit mu-law", "8-bit signed linear", "16-bit signed linear",
  "24-bit signed linear", "32-bit signed linear", "Floating-point",
  "Double precision float", "Fragmented sampled data", "Unknown", "DSP program",
  "8-bit fixed-point", "16-bit fixed-point", "24-bit fixed-point",
  "32-bit fixed-point", "Unknown", "Non-audio data", "Mu-law squelch",
  "16-bit linear with emphasis", "16-bit linear with compression",
  "16-bit linear with emphasis and compression", "Music Kit DSP commands",
  "Music Kit DSP samples", "4-bit G.721 ADPCM", "G.722 ADPCM",
  "3-bit G.723 ADPCM", "5-bit G.723 ADPCM", "8-bit a-law", "Unknown"};

static ft_encoding_t ft_enc(unsigned size, sox_encoding_t encoding)
{
  if (encoding == SOX_ENCODING_ULAW  && size ==  8) return Mulaw_8;
  if (encoding == SOX_ENCODING_ALAW  && size ==  8) return Alaw_8;
  if (encoding == SOX_ENCODING_SIGN2 && size ==  8) return Linear_8;
  if (encoding == SOX_ENCODING_SIGN2 && size == 16) return Linear_16;
  if (encoding == SOX_ENCODING_SIGN2 && size == 24) return Linear_24;
  if (encoding == SOX_ENCODING_SIGN2 && size == 32) return Linear_32;
  if (encoding == SOX_ENCODING_FLOAT && size == 32) return Float;
  if (encoding == SOX_ENCODING_FLOAT && size == 64) return Double;
  return Unspecified;
}

static sox_encoding_t sox_enc(uint32_t ft_encoding, unsigned * size)
{
  switch (ft_encoding) {
    case Mulaw_8     : *size =  8; return SOX_ENCODING_ULAW;
    case Alaw_8      : *size =  8; return SOX_ENCODING_ALAW;
    case Linear_8    : *size =  8; return SOX_ENCODING_SIGN2;
    case Linear_16   : *size = 16; return SOX_ENCODING_SIGN2;
    case Linear_24   : *size = 24; return SOX_ENCODING_SIGN2;
    case Linear_32   : *size = 32; return SOX_ENCODING_SIGN2;
    case Float       : *size = 32; return SOX_ENCODING_FLOAT;
    case Double      : *size = 64; return SOX_ENCODING_FLOAT;
    case Adpcm_g721  : *size =  4; return SOX_ENCODING_G721; /* read-only */
    case Adpcm_g723_3: *size =  3; return SOX_ENCODING_G723; /* read-only */
    case Adpcm_g723_5: *size =  5; return SOX_ENCODING_G723; /* read-only */
    default:                       return SOX_ENCODING_UNKNOWN;
  }
}

typedef struct {        /* For G72x decoding: */
  struct g72x_state state;
  int (*dec_routine)(int i, int out_coding, struct g72x_state *state_ptr);
  unsigned int in_buffer;
  int in_bits;
} priv_t;

/*
 * Unpack input codes and pass them back as bytes.
 * Returns 1 if there is residual input, returns -1 if eof, else returns 0.
 * (Adapted from Sun's decode.c.)
 */
static int unpack_input(sox_format_t * ft, unsigned char *code)
{
  priv_t * p = (priv_t *) ft->priv;
  unsigned char           in_byte;

  if (p->in_bits < (int)ft->encoding.bits_per_sample) {
    if (lsx_read_b_buf(ft, &in_byte, (size_t) 1) != 1) {
      *code = 0;
      return -1;
    }
    p->in_buffer |= (in_byte << p->in_bits);
    p->in_bits += 8;
  }
  *code = p->in_buffer & ((1 << ft->encoding.bits_per_sample) - 1);
  p->in_buffer >>= ft->encoding.bits_per_sample;
  p->in_bits -= ft->encoding.bits_per_sample;
  return p->in_bits > 0;
}

static size_t dec_read(sox_format_t *ft, sox_sample_t *buf, size_t samp)
{
  priv_t * p = (priv_t *)ft->priv;
  unsigned char code;
  size_t done;

  for (done = 0; samp > 0 && unpack_input(ft, &code) >= 0; ++done, --samp)
    *buf++ = SOX_SIGNED_16BIT_TO_SAMPLE(
        (*p->dec_routine)(code, AUDIO_ENCODING_LINEAR, &p->state),);
  return done;
}

static int startread(sox_format_t * ft)
{
  priv_t * p = (priv_t *) ft->priv;
  char     magic[4];     /* These 6 variables represent a Sun sound */
  uint32_t hdr_size;     /* header on disk.  The uint32_t are written as */
  uint32_t data_size;    /* big-endians.  At least extra bytes (totalling */
  uint32_t ft_encoding;  /* hdr_size - FIXED_HDR) are an "info" field of */
  uint32_t rate;         /* unspecified nature, usually a string.  By */
  uint32_t channels;     /* convention the header size is a multiple of 4. */
  unsigned i, bits_per_sample;
  sox_encoding_t encoding;

  if (lsx_readchars(ft, magic, sizeof(magic)))
    return SOX_EOF;

  for (i = 0; id[i].desc && memcmp(magic, id[i].str, sizeof(magic)); ++i);
  if (!id[i].desc) {
    lsx_fail_errno(ft, SOX_EHDR, "au: can't find Sun/NeXT/DEC identifier");
    return SOX_EOF;
  }
  lsx_report("found %s identifier", id[i].desc);
  ft->encoding.reverse_bytes = id[i].reverse_bytes;

  if (lsx_readdw(ft, &hdr_size) ||
      lsx_readdw(ft, &data_size) ||   /* Can be SUN_UNSPEC */
      lsx_readdw(ft, &ft_encoding) ||
      lsx_readdw(ft, &rate) ||
      lsx_readdw(ft, &channels))
    return SOX_EOF;

  if (hdr_size < FIXED_HDR) {
    lsx_fail_errno(ft, SOX_EHDR, "header size %u is too small", hdr_size);
    return SOX_EOF;
  }
  if (hdr_size < FIXED_HDR + 4)
    lsx_warn("header size %u is too small", hdr_size);

  if (!(encoding = sox_enc(ft_encoding, &bits_per_sample))) {
    int n = min(ft_encoding, Unknown_other);
    lsx_fail_errno(ft, SOX_EFMT, "unsupported encoding `%s' (%#x)", str[n], ft_encoding);
    return SOX_EOF;
  }

  switch (ft_encoding) {
    case Adpcm_g721  : p->dec_routine = g721_decoder   ; break;
    case Adpcm_g723_3: p->dec_routine = g723_24_decoder; break;
    case Adpcm_g723_5: p->dec_routine = g723_40_decoder; break;
  }
  if (p->dec_routine) {
    g72x_init_state(&p->state);
    ft->handler.seek = NULL;
    ft->handler.read = dec_read;
  }

  if (hdr_size > FIXED_HDR) {
    size_t info_size = hdr_size - FIXED_HDR;
    char * buf = lsx_calloc(1, info_size + 1); /* +1 ensures null-terminated */
    if (lsx_readchars(ft, buf, info_size) != SOX_SUCCESS) {
      free(buf);
      return SOX_EOF;
    }
    sox_append_comments(&ft->oob.comments, buf);
    free(buf);
  }
  if (data_size == SUN_UNSPEC)
    data_size = SOX_UNSPEC;
  return lsx_check_read_params(ft, channels, (sox_rate_t)rate, encoding,
      bits_per_sample, div_bits(data_size, bits_per_sample), sox_true);
}

static int write_header(sox_format_t * ft)
{
  char * comment  = lsx_cat_comments(ft->oob.comments);
  size_t len      = strlen(comment) + 1;     /* Write out null-terminated */
  size_t info_len = max(4, (len + 3) & ~3u); /* Minimum & multiple of 4 bytes */
  int i = ft->encoding.reverse_bytes == MACHINE_IS_BIGENDIAN? 2 : 0;
  uint64_t size64 = ft->olength ? ft->olength : ft->signal.length;
  unsigned size = size64 == SOX_UNSPEC
      ? SUN_UNSPEC
      : size64*(ft->encoding.bits_per_sample >> 3) > UINT_MAX
      ? SUN_UNSPEC
      : (unsigned)(size64*(ft->encoding.bits_per_sample >> 3));
  sox_bool error = sox_false
  ||lsx_writechars(ft, id[i].str, sizeof(id[i].str))
  ||lsx_writedw(ft, FIXED_HDR + (unsigned)info_len)
  ||lsx_writedw(ft, size)
  ||lsx_writedw(ft, ft_enc(ft->encoding.bits_per_sample, ft->encoding.encoding))
  ||lsx_writedw(ft, (unsigned)(ft->signal.rate + .5))
  ||lsx_writedw(ft, ft->signal.channels)
  ||lsx_writechars(ft, comment, len)
  ||lsx_padbytes(ft, info_len - len);
  free(comment);
  return error? SOX_EOF: SOX_SUCCESS;
}

LSX_FORMAT_HANDLER(au)
{
  static char const * const names[] = {"au", "snd", NULL};
  static unsigned const write_encodings[] = {
    SOX_ENCODING_ULAW, 8, 0,
    SOX_ENCODING_ALAW, 8, 0,
    SOX_ENCODING_SIGN2, 8, 16, 24, 32, 0,
    SOX_ENCODING_FLOAT, 32, 64, 0,
    0};
  static sox_format_handler_t const handler = {SOX_LIB_VERSION_CODE,
    "PCM file format used widely on Sun systems",
    names, SOX_FILE_BIG_END | SOX_FILE_REWIND,
    startread, lsx_rawread, NULL,
    write_header, lsx_rawwrite, NULL,
    lsx_rawseek, write_encodings, NULL, sizeof(priv_t)
  };
  return &handler;
}