| /* 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 "third_party/sox/src/src/sox_i.h" |
| #include "third_party/sox/src/src/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; |
| } |