remove au.c

app/src/main/cpp/sox/CmakeLists.txt

@@ -87,7 +87,6 @@ set(formats_srcs
         adpcms.h
         adpcms.c
         al-fmt.c
-        au.c
         avr.c
         cdr.c
         cvsd.h

app/src/main/cpp/sox/au.c

@@ -1,237 +0,0 @@
-/* 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;
-}

app/src/main/cpp/sox/formats.h

@@ -20,7 +20,7 @@
 //  FORMAT(aifc)
 //  FORMAT(aiff)
   FORMAT(al)
-  FORMAT(au)
+//  FORMAT(au)
   FORMAT(avr)
   FORMAT(cdr)
   FORMAT(cvsd)