Mercurial > audlegacy-plugins
changeset 56:56c88eee9802 trunk
[svn] - experimental ALAC plugin -- don't use this, it crashes
| author | nenolod |
|---|---|
| date | Sat, 30 Sep 2006 19:26:34 -0700 |
| parents | 4423278dc9ae |
| children | 96901271d2e2 |
| files | ChangeLog src/alac/Makefile src/alac/alac.c src/alac/decomp.h src/alac/demux.c src/alac/demux.h src/alac/plugin.c src/alac/stream.c src/alac/stream.h |
| diffstat | 9 files changed, 2330 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- a/ChangeLog Sat Sep 30 18:32:24 2006 -0700 +++ b/ChangeLog Sat Sep 30 19:26:34 2006 -0700 @@ -1,3 +1,11 @@ +2006-10-01 01:32:24 +0000 William Pitcock <nenolod@nenolod.net> + revision [110] + - alac support will be a seperate plugin + + trunk/src/aac/Makefile | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + + 2006-09-27 04:01:02 +0000 William Pitcock <nenolod@nenolod.net> revision [108] - merge ALAC decoder into mp4 plugin buildsystem (todo: hook into the ALAC decoder, e.g. if mp4 decoding fails)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alac/Makefile Sat Sep 30 19:26:34 2006 -0700 @@ -0,0 +1,14 @@ +include ../../mk/rules.mk +include ../../mk/init.mk + +OBJECTIVE_LIBS = libalac$(SHARED_SUFFIX) + +LIBDIR = $(plugindir)/$(INPUT_PLUGIN_DIR) + +SOURCES = alac.c demux.c plugin.c stream.c + +OBJECTS = ${SOURCES:.c=.o} + +CFLAGS += $(PICFLAGS) $(GTK_CFLAGS) -I../../intl -I../.. -I../.. + +include ../../mk/objective.mk
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alac/alac.c Sat Sep 30 19:26:34 2006 -0700 @@ -0,0 +1,1055 @@ +/* + * ALAC (Apple Lossless Audio Codec) decoder + * Copyright (c) 2005 David Hammerton + * All rights reserved. + * + * This is the actual decoder. + * + * http://crazney.net/programs/itunes/alac.html + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + */ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdint.h> + +#include "decomp.h" + +#define _Swap32(v) do { \ + v = (((v) & 0x000000FF) << 0x18) | \ + (((v) & 0x0000FF00) << 0x08) | \ + (((v) & 0x00FF0000) >> 0x08) | \ + (((v) & 0xFF000000) >> 0x18); } while(0) + +#define _Swap16(v) do { \ + v = (((v) & 0x00FF) << 0x08) | \ + (((v) & 0xFF00) >> 0x08); } while (0) + + +struct alac_file +{ + unsigned char *input_buffer; + int input_buffer_bitaccumulator; /* used so we can do arbitary + bit reads */ + + int samplesize; + int numchannels; + int bytespersample; + + + /* buffers */ + int32_t *predicterror_buffer_a; + int32_t *predicterror_buffer_b; + + int32_t *outputsamples_buffer_a; + int32_t *outputsamples_buffer_b; + + + /* stuff from setinfo */ + uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */ /* max samples per frame? */ + uint8_t setinfo_7a; /* 0x00 */ + uint8_t setinfo_sample_size; /* 0x10 */ + uint8_t setinfo_rice_historymult; /* 0x28 */ + uint8_t setinfo_rice_initialhistory; /* 0x0a */ + uint8_t setinfo_rice_kmodifier; /* 0x0e */ + uint8_t setinfo_7f; /* 0x02 */ + uint16_t setinfo_80; /* 0x00ff */ + uint32_t setinfo_82; /* 0x000020e7 */ /* max sample size?? */ + uint32_t setinfo_86; /* 0x00069fe4 */ /* bit rate (avarge)?? */ + uint32_t setinfo_8a_rate; /* 0x0000ac44 */ + /* end setinfo stuff */ + +}; + + +static void allocate_buffers(alac_file *alac) +{ + alac->predicterror_buffer_a = malloc(alac->setinfo_max_samples_per_frame * 4); + alac->predicterror_buffer_b = malloc(alac->setinfo_max_samples_per_frame * 4); + + alac->outputsamples_buffer_a = malloc(alac->setinfo_max_samples_per_frame * 4); + alac->outputsamples_buffer_b = malloc(alac->setinfo_max_samples_per_frame * 4); +} + +void alac_set_info(alac_file *alac, char *inputbuffer) +{ + char *ptr = inputbuffer; + ptr += 4; /* size */ + ptr += 4; /* frma */ + ptr += 4; /* alac */ + ptr += 4; /* size */ + ptr += 4; /* alac */ + + ptr += 4; /* 0 ? */ + + alac->setinfo_max_samples_per_frame = *(uint32_t*)ptr; /* buffer size / 2 ? */ +#ifndef WORDS_BIGENDIAN + _Swap32(alac->setinfo_max_samples_per_frame); +#endif + ptr += 4; + alac->setinfo_7a = *(uint8_t*)ptr; + ptr += 1; + alac->setinfo_sample_size = *(uint8_t*)ptr; + ptr += 1; + alac->setinfo_rice_historymult = *(uint8_t*)ptr; + ptr += 1; + alac->setinfo_rice_initialhistory = *(uint8_t*)ptr; + ptr += 1; + alac->setinfo_rice_kmodifier = *(uint8_t*)ptr; + ptr += 1; + alac->setinfo_7f = *(uint8_t*)ptr; + ptr += 1; + alac->setinfo_80 = *(uint16_t*)ptr; +#ifndef WORDS_BIGENDIAN + _Swap16(alac->setinfo_80); +#endif + ptr += 2; + alac->setinfo_82 = *(uint32_t*)ptr; +#ifndef WORDS_BIGENDIAN + _Swap32(alac->setinfo_82); +#endif + ptr += 4; + alac->setinfo_86 = *(uint32_t*)ptr; +#ifndef WORDS_BIGENDIAN + _Swap32(alac->setinfo_86); +#endif + ptr += 4; + alac->setinfo_8a_rate = *(uint32_t*)ptr; +#ifndef WORDS_BIGENDIAN + _Swap32(alac->setinfo_8a_rate); +#endif + ptr += 4; + + allocate_buffers(alac); + +} + +/* stream reading */ + +/* supports reading 1 to 16 bits, in big endian format */ +static uint32_t readbits_16(alac_file *alac, int bits) +{ + uint32_t result; + int new_accumulator; + + result = (alac->input_buffer[0] << 16) | + (alac->input_buffer[1] << 8) | + (alac->input_buffer[2]); + + /* shift left by the number of bits we've already read, + * so that the top 'n' bits of the 24 bits we read will + * be the return bits */ + result = result << alac->input_buffer_bitaccumulator; + + result = result & 0x00ffffff; + + /* and then only want the top 'n' bits from that, where + * n is 'bits' */ + result = result >> (24 - bits); + + new_accumulator = (alac->input_buffer_bitaccumulator + bits); + + /* increase the buffer pointer if we've read over n bytes. */ + alac->input_buffer += (new_accumulator >> 3); + + /* and the remainder goes back into the bit accumulator */ + alac->input_buffer_bitaccumulator = (new_accumulator & 7); + + return result; +} + +/* supports reading 1 to 32 bits, in big endian format */ +static uint32_t readbits(alac_file *alac, int bits) +{ + int32_t result = 0; + + if (bits > 16) + { + bits -= 16; + result = readbits_16(alac, 16) << bits; + } + + result |= readbits_16(alac, bits); + + return result; +} + +/* reads a single bit */ +static int readbit(alac_file *alac) +{ + int result; + int new_accumulator; + + result = alac->input_buffer[0]; + + result = result << alac->input_buffer_bitaccumulator; + + result = result >> 7 & 1; + + new_accumulator = (alac->input_buffer_bitaccumulator + 1); + + alac->input_buffer += (new_accumulator / 8); + + alac->input_buffer_bitaccumulator = (new_accumulator % 8); + + return result; +} + +static void unreadbits(alac_file *alac, int bits) +{ + int new_accumulator = (alac->input_buffer_bitaccumulator - bits); + + alac->input_buffer += (new_accumulator >> 3); + + alac->input_buffer_bitaccumulator = (new_accumulator & 7); + if (alac->input_buffer_bitaccumulator < 0) + alac->input_buffer_bitaccumulator *= -1; +} + +/* various implementations of count_leading_zero: + * the first one is the original one, the simplest and most + * obvious for what it's doing. never use this. + * then there are the asm ones. fill in as necessary + * and finally an unrolled and optimised c version + * to fall back to + */ +#if 0 +/* hideously inefficient. could use a bitmask search, + * alternatively bsr on x86, + */ +static int count_leading_zeros(int32_t input) +{ + int i = 0; + while (!(0x80000000 & input) && i < 32) + { + i++; + input = input << 1; + } + return i; +} +#elif defined(__GNUC__) && (defined(_X86) || defined(__i386) || defined(i386)) +/* for some reason the unrolled version (below) is + * actually faster than this. yay intel! + */ +static int count_leading_zeros(int input) +{ + int output = 0; + if (!input) return 32; + asm("bsr %1, %0\n" + : "=r" (output) + : "r" (input)); + return (0x1f - output); +} +#elif defined(_MSC_VER) && defined(_M_IX86) +static int count_leading_zeros(int input) +{ + int output = 0; + if (!input) return 32; + __asm + { + mov eax, input; + mov edx, 0x1f; + bsr ecx, eax; + sub edx, ecx; + mov output, edx; + } + return output; +} +#else +#warning using generic count leading zeroes. You may wish to write one for your CPU / compiler +static int count_leading_zeros(int input) +{ + int output = 0; + int curbyte = 0; + + curbyte = input >> 24; + if (curbyte) goto found; + output += 8; + + curbyte = input >> 16; + if (curbyte & 0xff) goto found; + output += 8; + + curbyte = input >> 8; + if (curbyte & 0xff) goto found; + output += 8; + + curbyte = input; + if (curbyte & 0xff) goto found; + output += 8; + + return output; + +found: + if (!(curbyte & 0xf0)) + { + output += 4; + } + else + curbyte >>= 4; + + if (curbyte & 0x8) + return output; + if (curbyte & 0x4) + return output + 1; + if (curbyte & 0x2) + return output + 2; + if (curbyte & 0x1) + return output + 3; + + /* shouldn't get here: */ + return output + 4; +} +#endif + +void basterdised_rice_decompress(alac_file *alac, + int32_t *output_buffer, + int output_size, + int readsamplesize, /* arg_10 */ + int rice_initialhistory, /* arg424->b */ + int rice_kmodifier, /* arg424->d */ + int rice_historymult, /* arg424->c */ + int rice_kmodifier_mask /* arg424->e */ + ) +{ + int output_count; + unsigned int history = rice_initialhistory; + int sign_modifier = 0; + + for (output_count = 0; output_count < output_size; output_count++) + { + int32_t x = 0; + int32_t x_modified; + int32_t final_val; + + /* read x - number of 1s before 0 represent the rice */ + while (x <= 8 && readbit(alac)) + { + x++; + } + + + if (x > 8) /* RICE THRESHOLD */ + { /* use alternative encoding */ + int32_t value; + + value = readbits(alac, readsamplesize); + + /* mask value to readsamplesize size */ + if (readsamplesize != 32) + value &= (0xffffffff >> (32 - readsamplesize)); + + x = value; + } + else + { /* standard rice encoding */ + int extrabits; + int k; /* size of extra bits */ + + /* read k, that is bits as is */ + k = 31 - rice_kmodifier - count_leading_zeros((history >> 9) + 3); + + if (k < 0) k += rice_kmodifier; + else k = rice_kmodifier; + + if (k != 1) + { + extrabits = readbits(alac, k); + + /* multiply x by 2^k - 1, as part of their strange algorithm */ + x = (x << k) - x; + + if (extrabits > 1) + { + x += extrabits - 1; + } + else unreadbits(alac, 1); + } + } + + x_modified = sign_modifier + x; + final_val = (x_modified + 1) / 2; + if (x_modified & 1) final_val *= -1; + + output_buffer[output_count] = final_val; + + sign_modifier = 0; + + /* now update the history */ + history += (x_modified * rice_historymult) + - ((history * rice_historymult) >> 9); + + if (x_modified > 0xffff) + history = 0xffff; + + /* special case: there may be compressed blocks of 0 */ + if ((history < 128) && (output_count+1 < output_size)) + { + int block_size; + + sign_modifier = 1; + + x = 0; + while (x <= 8 && readbit(alac)) + { + x++; + } + + if (x > 8) + { + block_size = readbits(alac, 16); + block_size &= 0xffff; + } + else + { + int k; + int extrabits; + + k = count_leading_zeros(history) + ((history + 16) >> 6 /* / 64 */) - 24; + + extrabits = readbits(alac, k); + + block_size = (((1 << k) - 1) & rice_kmodifier_mask) * x + + extrabits - 1; + + if (extrabits < 2) + { + x = 1 - extrabits; + block_size += x; + unreadbits(alac, 1); + } + } + + if (block_size > 0) + { + memset(&output_buffer[output_count+1], 0, block_size * 4); + output_count += block_size; + + } + + if (block_size > 0xffff) + sign_modifier = 0; + + history = 0; + } + } +} + +#define SIGN_EXTENDED32(val, bits) ((val << (32 - bits)) >> (32 - bits)) + +#define SIGN_ONLY(v) \ + ((v < 0) ? (-1) : \ + ((v > 0) ? (1) : \ + (0))) + +static void predictor_decompress_fir_adapt(int32_t *error_buffer, + int32_t *buffer_out, + int output_size, + int readsamplesize, + int16_t *predictor_coef_table, + int predictor_coef_num, + int predictor_quantitization) +{ + int i; + + /* first sample always copies */ + *buffer_out = *error_buffer; + + if (!predictor_coef_num) + { + if (output_size <= 1) return; + memcpy(buffer_out+1, error_buffer+1, (output_size-1) * 4); + return; + } + + if (predictor_coef_num == 0x1f) /* 11111 - max value of predictor_coef_num */ + { /* second-best case scenario for fir decompression, + * error describes a small difference from the previous sample only + */ + if (output_size <= 1) return; + for (i = 0; i < output_size - 1; i++) + { + int32_t prev_value; + int32_t error_value; + + prev_value = buffer_out[i]; + error_value = error_buffer[i+1]; + buffer_out[i+1] = SIGN_EXTENDED32((prev_value + error_value), readsamplesize); + } + return; + } + + /* read warm-up samples */ + if (predictor_coef_num > 0) + { + int i; + for (i = 0; i < predictor_coef_num; i++) + { + int32_t val; + + val = buffer_out[i] + error_buffer[i+1]; + + val = SIGN_EXTENDED32(val, readsamplesize); + + buffer_out[i+1] = val; + } + } + +#if 0 + /* 4 and 8 are very common cases (the only ones i've seen). these + * should be unrolled and optimised + */ + if (predictor_coef_num == 4) + { + /* FIXME: optimised general case */ + return; + } + + if (predictor_coef_table == 8) + { + /* FIXME: optimised general case */ + return; + } +#endif + + + /* general case */ + if (predictor_coef_num > 0) + { + for (i = predictor_coef_num + 1; + i < output_size; + i++) + { + int j; + int sum = 0; + int outval; + int error_val = error_buffer[i]; + + for (j = 0; j < predictor_coef_num; j++) + { + sum += (buffer_out[predictor_coef_num-j] - buffer_out[0]) * + predictor_coef_table[j]; + } + + outval = (1 << (predictor_quantitization-1)) + sum; + outval = outval >> predictor_quantitization; + outval = outval + buffer_out[0] + error_val; + outval = SIGN_EXTENDED32(outval, readsamplesize); + + buffer_out[predictor_coef_num+1] = outval; + + if (error_val > 0) + { + int predictor_num = predictor_coef_num - 1; + + while (predictor_num >= 0 && error_val > 0) + { + int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num]; + int sign = SIGN_ONLY(val); + + predictor_coef_table[predictor_num] -= sign; + + val *= sign; /* absolute value */ + + error_val -= ((val >> predictor_quantitization) * + (predictor_coef_num - predictor_num)); + + predictor_num--; + } + } + else if (error_val < 0) + { + int predictor_num = predictor_coef_num - 1; + + while (predictor_num >= 0 && error_val < 0) + { + int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num]; + int sign = - SIGN_ONLY(val); + + predictor_coef_table[predictor_num] -= sign; + + val *= sign; /* neg value */ + + error_val -= ((val >> predictor_quantitization) * + (predictor_coef_num - predictor_num)); + + predictor_num--; + } + } + + buffer_out++; + } + } +} + +void deinterlace_16(int32_t *buffer_a, int32_t *buffer_b, + int16_t *buffer_out, + int numchannels, int numsamples, + uint8_t interlacing_shift, + uint8_t interlacing_leftweight) +{ + int i; + if (numsamples <= 0) return; + + /* weighted interlacing */ + if (interlacing_leftweight) + { + for (i = 0; i < numsamples; i++) + { + int32_t difference, midright; + int16_t left; + int16_t right; + + midright = buffer_a[i]; + difference = buffer_b[i]; + + + right = midright - ((difference * interlacing_leftweight) >> interlacing_shift); + left = right + difference; + + /* output is always little endian */ +#ifdef WORDS_BIGENDIAN + _Swap16(left); + _Swap16(right); +#endif + + buffer_out[i*numchannels] = left; + buffer_out[i*numchannels + 1] = right; + } + + return; + } + + /* otherwise basic interlacing took place */ + for (i = 0; i < numsamples; i++) + { + int16_t left, right; + + left = buffer_a[i]; + right = buffer_b[i]; + + /* output is always little endian */ +#ifdef WORDS_BIGENDIAN + _Swap16(left); + _Swap16(right); +#endif + + buffer_out[i*numchannels] = left; + buffer_out[i*numchannels + 1] = right; + } +} + +void decode_frame(alac_file *alac, + unsigned char *inbuffer, + void *outbuffer, int *outputsize) +{ + int channels; + int32_t outputsamples = alac->setinfo_max_samples_per_frame; + + /* setup the stream */ + alac->input_buffer = inbuffer; + alac->input_buffer_bitaccumulator = 0; + + channels = readbits(alac, 3); + + *outputsize = outputsamples * alac->bytespersample; + + switch(channels) + { + case 0: /* 1 channel */ + { + int hassize; + int isnotcompressed; + int readsamplesize; + + int wasted_bytes; + int ricemodifier; + + + /* 2^result = something to do with output waiting. + * perhaps matters if we read > 1 frame in a pass? + */ + readbits(alac, 4); + + readbits(alac, 12); /* unknown, skip 12 bits */ + + hassize = readbits(alac, 1); /* the output sample size is stored soon */ + + wasted_bytes = readbits(alac, 2); /* unknown ? */ + + isnotcompressed = readbits(alac, 1); /* whether the frame is compressed */ + + if (hassize) + { + /* now read the number of samples, + * as a 32bit integer */ + outputsamples = readbits(alac, 32); + *outputsize = outputsamples * alac->bytespersample; + } + + readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8); + + if (!isnotcompressed) + { /* so it is compressed */ + int16_t predictor_coef_table[32]; + int predictor_coef_num; + int prediction_type; + int prediction_quantitization; + int i; + + /* skip 16 bits, not sure what they are. seem to be used in + * two channel case */ + readbits(alac, 8); + readbits(alac, 8); + + prediction_type = readbits(alac, 4); + prediction_quantitization = readbits(alac, 4); + + ricemodifier = readbits(alac, 3); + predictor_coef_num = readbits(alac, 5); + + /* read the predictor table */ + for (i = 0; i < predictor_coef_num; i++) + { + predictor_coef_table[i] = (int16_t)readbits(alac, 16); + } + + if (wasted_bytes) + { + /* these bytes seem to have something to do with + * > 2 channel files. + */ + fprintf(stderr, "FIXME: unimplemented, unhandling of wasted_bytes\n"); + } + + basterdised_rice_decompress(alac, + alac->predicterror_buffer_a, + outputsamples, + readsamplesize, + alac->setinfo_rice_initialhistory, + alac->setinfo_rice_kmodifier, + ricemodifier * alac->setinfo_rice_historymult / 4, + (1 << alac->setinfo_rice_kmodifier) - 1); + + if (prediction_type == 0) + { /* adaptive fir */ + predictor_decompress_fir_adapt(alac->predicterror_buffer_a, + alac->outputsamples_buffer_a, + outputsamples, + readsamplesize, + predictor_coef_table, + predictor_coef_num, + prediction_quantitization); + } + else + { + fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type); + /* i think the only other prediction type (or perhaps this is just a + * boolean?) runs adaptive fir twice.. like: + * predictor_decompress_fir_adapt(predictor_error, tempout, ...) + * predictor_decompress_fir_adapt(predictor_error, outputsamples ...) + * little strange.. + */ + } + + } + else + { /* not compressed, easy case */ + if (readsamplesize <= 16) + { + int i; + for (i = 0; i < outputsamples; i++) + { + int32_t audiobits = readbits(alac, readsamplesize); + + audiobits = SIGN_EXTENDED32(audiobits, readsamplesize); + + alac->outputsamples_buffer_a[i] = audiobits; + } + } + else + { + int i; + for (i = 0; i < outputsamples; i++) + { + int32_t audiobits; + + audiobits = readbits(alac, 16); + /* special case of sign extension.. + * as we'll be ORing the low 16bits into this */ + audiobits = audiobits << 16; + audiobits = audiobits >> (32 - readsamplesize); + + audiobits |= readbits(alac, readsamplesize - 16); + + alac->outputsamples_buffer_a[i] = audiobits; + } + } + /* wasted_bytes = 0; // unused */ + } + + switch(alac->setinfo_sample_size) + { + case 16: + { + int i; + for (i = 0; i < outputsamples; i++) + { + int16_t sample = alac->outputsamples_buffer_a[i]; +#ifdef WORDS_BIGENDIAN + _Swap16(sample); +#endif + ((int16_t*)outbuffer)[i * alac->numchannels] = sample; + } + break; + } + case 20: + case 24: + case 32: + fprintf(stderr, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size); + break; + default: + break; + } + break; + } + case 1: /* 2 channels */ + { + int hassize; + int isnotcompressed; + int readsamplesize; + + int wasted_bytes; + + uint8_t interlacing_shift; + uint8_t interlacing_leftweight; + + /* 2^result = something to do with output waiting. + * perhaps matters if we read > 1 frame in a pass? + */ + readbits(alac, 4); + + readbits(alac, 12); /* unknown, skip 12 bits */ + + hassize = readbits(alac, 1); /* the output sample size is stored soon */ + + wasted_bytes = readbits(alac, 2); /* unknown ? */ + + isnotcompressed = readbits(alac, 1); /* whether the frame is compressed */ + + if (hassize) + { + /* now read the number of samples, + * as a 32bit integer */ + outputsamples = readbits(alac, 32); + *outputsize = outputsamples * alac->bytespersample; + } + + readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8) + 1; + + if (!isnotcompressed) + { /* compressed */ + int16_t predictor_coef_table_a[32]; + int predictor_coef_num_a; + int prediction_type_a; + int prediction_quantitization_a; + int ricemodifier_a; + + int16_t predictor_coef_table_b[32]; + int predictor_coef_num_b; + int prediction_type_b; + int prediction_quantitization_b; + int ricemodifier_b; + + int i; + + interlacing_shift = readbits(alac, 8); + interlacing_leftweight = readbits(alac, 8); + + /******** channel 1 ***********/ + prediction_type_a = readbits(alac, 4); + prediction_quantitization_a = readbits(alac, 4); + + ricemodifier_a = readbits(alac, 3); + predictor_coef_num_a = readbits(alac, 5); + + /* read the predictor table */ + for (i = 0; i < predictor_coef_num_a; i++) + { + predictor_coef_table_a[i] = (int16_t)readbits(alac, 16); + } + + /******** channel 2 *********/ + prediction_type_b = readbits(alac, 4); + prediction_quantitization_b = readbits(alac, 4); + + ricemodifier_b = readbits(alac, 3); + predictor_coef_num_b = readbits(alac, 5); + + /* read the predictor table */ + for (i = 0; i < predictor_coef_num_b; i++) + { + predictor_coef_table_b[i] = (int16_t)readbits(alac, 16); + } + + /*********************/ + if (wasted_bytes) + { /* see mono case */ + fprintf(stderr, "FIXME: unimplemented, unhandling of wasted_bytes\n"); + } + + /* channel 1 */ + basterdised_rice_decompress(alac, + alac->predicterror_buffer_a, + outputsamples, + readsamplesize, + alac->setinfo_rice_initialhistory, + alac->setinfo_rice_kmodifier, + ricemodifier_a * alac->setinfo_rice_historymult / 4, + (1 << alac->setinfo_rice_kmodifier) - 1); + + if (prediction_type_a == 0) + { /* adaptive fir */ + predictor_decompress_fir_adapt(alac->predicterror_buffer_a, + alac->outputsamples_buffer_a, + outputsamples, + readsamplesize, + predictor_coef_table_a, + predictor_coef_num_a, + prediction_quantitization_a); + } + else + { /* see mono case */ + fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type_a); + } + + /* channel 2 */ + basterdised_rice_decompress(alac, + alac->predicterror_buffer_b, + outputsamples, + readsamplesize, + alac->setinfo_rice_initialhistory, + alac->setinfo_rice_kmodifier, + ricemodifier_b * alac->setinfo_rice_historymult / 4, + (1 << alac->setinfo_rice_kmodifier) - 1); + + if (prediction_type_b == 0) + { /* adaptive fir */ + predictor_decompress_fir_adapt(alac->predicterror_buffer_b, + alac->outputsamples_buffer_b, + outputsamples, + readsamplesize, + predictor_coef_table_b, + predictor_coef_num_b, + prediction_quantitization_b); + } + else + { + fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type_b); + } + } + else + { /* not compressed, easy case */ + if (alac->setinfo_sample_size <= 16) + { + int i; + for (i = 0; i < outputsamples; i++) + { + int32_t audiobits_a, audiobits_b; + + audiobits_a = readbits(alac, alac->setinfo_sample_size); + audiobits_b = readbits(alac, alac->setinfo_sample_size); + + audiobits_a = SIGN_EXTENDED32(audiobits_a, alac->setinfo_sample_size); + audiobits_b = SIGN_EXTENDED32(audiobits_b, alac->setinfo_sample_size); + + alac->outputsamples_buffer_a[i] = audiobits_a; + alac->outputsamples_buffer_b[i] = audiobits_b; + } + } + else + { + int i; + for (i = 0; i < outputsamples; i++) + { + int32_t audiobits_a, audiobits_b; + + audiobits_a = readbits(alac, 16); + audiobits_a = audiobits_a << 16; + audiobits_a = audiobits_a >> (32 - alac->setinfo_sample_size); + audiobits_a |= readbits(alac, alac->setinfo_sample_size - 16); + + audiobits_b = readbits(alac, 16); + audiobits_b = audiobits_b << 16; + audiobits_b = audiobits_b >> (32 - alac->setinfo_sample_size); + audiobits_b |= readbits(alac, alac->setinfo_sample_size - 16); + + alac->outputsamples_buffer_a[i] = audiobits_a; + alac->outputsamples_buffer_b[i] = audiobits_b; + } + } + /* wasted_bytes = 0; */ + interlacing_shift = 0; + interlacing_leftweight = 0; + } + + switch(alac->setinfo_sample_size) + { + case 16: + { + deinterlace_16(alac->outputsamples_buffer_a, + alac->outputsamples_buffer_b, + (int16_t*)outbuffer, + alac->numchannels, + outputsamples, + interlacing_shift, + interlacing_leftweight); + break; + } + case 20: + case 24: + case 32: + fprintf(stderr, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size); + break; + default: + break; + } + + break; + } + } +} + +alac_file *create_alac(int samplesize, int numchannels) +{ + alac_file *newfile = malloc(sizeof(alac_file)); + + newfile->samplesize = samplesize; + newfile->numchannels = numchannels; + newfile->bytespersample = (samplesize / 8) * numchannels; + + return newfile; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alac/decomp.h Sat Sep 30 19:26:34 2006 -0700 @@ -0,0 +1,13 @@ +#ifndef __ALAC__DECOMP_H +#define __ALAC__DECOMP_H + +typedef struct alac_file alac_file; + +alac_file *create_alac(int samplesize, int numchannels); +void decode_frame(alac_file *alac, + unsigned char *inbuffer, + void *outbuffer, int *outputsize); +void alac_set_info(alac_file *alac, char *inputbuffer); + +#endif /* __ALAC__DECOMP_H */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alac/demux.c Sat Sep 30 19:26:34 2006 -0700 @@ -0,0 +1,693 @@ +/* + * ALAC (Apple Lossless Audio Codec) decoder + * Copyright (c) 2005 David Hammerton + * All rights reserved. + * + * This is the quicktime container demuxer. + * + * http://crazney.net/programs/itunes/alac.html + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + */ + + +#include <string.h> +#include <stdio.h> +#include <stdint.h> +#include <stdlib.h> + +#include "stream.h" +#include "demux.h" + +typedef struct +{ + stream_t *stream; + demux_res_t *res; + long saved_mdat_pos; +} qtmovie_t; + + +/* chunk handlers */ +static void read_chunk_ftyp(qtmovie_t *qtmovie, size_t chunk_len) +{ + fourcc_t type; + uint32_t minor_ver; + size_t size_remaining = chunk_len - 8; /* FIXME: can't hardcode 8, size may be 64bit */ + + type = stream_read_uint32(qtmovie->stream); + size_remaining-=4; + if (type != MAKEFOURCC('M','4','A',' ')) + { + fprintf(stderr, "not M4A file\n"); + return; + } + minor_ver = stream_read_uint32(qtmovie->stream); + size_remaining-=4; + + /* compatible brands */ + while (size_remaining) + { + /* unused */ + /*fourcc_t cbrand =*/ stream_read_uint32(qtmovie->stream); + size_remaining-=4; + } +} + +static void read_chunk_tkhd(qtmovie_t *qtmovie, size_t chunk_len) +{ + /* don't need anything from here atm, skip */ + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + stream_skip(qtmovie->stream, size_remaining); +} + +static void read_chunk_mdhd(qtmovie_t *qtmovie, size_t chunk_len) +{ + /* don't need anything from here atm, skip */ + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + stream_skip(qtmovie->stream, size_remaining); +} + +static void read_chunk_edts(qtmovie_t *qtmovie, size_t chunk_len) +{ + /* don't need anything from here atm, skip */ + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + stream_skip(qtmovie->stream, size_remaining); +} + +static void read_chunk_elst(qtmovie_t *qtmovie, size_t chunk_len) +{ + /* don't need anything from here atm, skip */ + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + stream_skip(qtmovie->stream, size_remaining); +} + +/* media handler inside mdia */ +static void read_chunk_hdlr(qtmovie_t *qtmovie, size_t chunk_len) +{ + fourcc_t comptype, compsubtype; + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + int strlen; + char str[256] = {0}; + + /* version */ + stream_read_uint8(qtmovie->stream); + size_remaining -= 1; + /* flags */ + stream_read_uint8(qtmovie->stream); + stream_read_uint8(qtmovie->stream); + stream_read_uint8(qtmovie->stream); + size_remaining -= 3; + + /* component type */ + comptype = stream_read_uint32(qtmovie->stream); + compsubtype = stream_read_uint32(qtmovie->stream); + size_remaining -= 8; + + /* component manufacturer */ + stream_read_uint32(qtmovie->stream); + size_remaining -= 4; + + /* flags */ + stream_read_uint32(qtmovie->stream); + stream_read_uint32(qtmovie->stream); + size_remaining -= 8; + + /* name */ + strlen = stream_read_uint8(qtmovie->stream); + stream_read(qtmovie->stream, strlen, str); + size_remaining -= 1 + strlen; + + if (size_remaining) + { + stream_skip(qtmovie->stream, size_remaining); + } + +} + +static void read_chunk_stsd(qtmovie_t *qtmovie, size_t chunk_len) +{ + unsigned int i; + uint32_t numentries; + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + /* version */ + stream_read_uint8(qtmovie->stream); + size_remaining -= 1; + /* flags */ + stream_read_uint8(qtmovie->stream); + stream_read_uint8(qtmovie->stream); + stream_read_uint8(qtmovie->stream); + size_remaining -= 3; + + numentries = stream_read_uint32(qtmovie->stream); + size_remaining -= 4; + + if (numentries != 1) + { + fprintf(stderr, "only expecting one entry in sample description atom!\n"); + return; + } + + for (i = 0; i < numentries; i++) + { + uint32_t entry_size; + uint16_t version; + + uint32_t entry_remaining; + + entry_size = stream_read_uint32(qtmovie->stream); + qtmovie->res->format = stream_read_uint32(qtmovie->stream); + entry_remaining = entry_size; + entry_remaining -= 8; + + /* sound info: */ + + stream_skip(qtmovie->stream, 6); /* reserved */ + entry_remaining -= 6; + + version = stream_read_uint16(qtmovie->stream); + if (version != 1) + fprintf(stderr, "unknown version??\n"); + entry_remaining -= 2; + + /* revision level */ + stream_read_uint16(qtmovie->stream); + /* vendor */ + stream_read_uint32(qtmovie->stream); + entry_remaining -= 6; + + /* EH?? spec doesn't say theres an extra 16 bits here.. but there is! */ + stream_read_uint16(qtmovie->stream); + entry_remaining -= 2; + + qtmovie->res->num_channels = stream_read_uint16(qtmovie->stream); + + qtmovie->res->sample_size = stream_read_uint16(qtmovie->stream); + entry_remaining -= 4; + + /* compression id */ + stream_read_uint16(qtmovie->stream); + /* packet size */ + stream_read_uint16(qtmovie->stream); + entry_remaining -= 4; + + /* sample rate - 32bit fixed point = 16bit?? */ + qtmovie->res->sample_rate = stream_read_uint16(qtmovie->stream); + entry_remaining -= 2; + + /* skip 2 */ + stream_skip(qtmovie->stream, 2); + entry_remaining -= 2; + + /* remaining is codec data */ + +#if 0 + qtmovie->res->codecdata_len = stream_read_uint32(qtmovie->stream); + if (qtmovie->res->codecdata_len != entry_remaining) + fprintf(stderr, "perhaps not? %i vs %i\n", + qtmovie->res->codecdata_len, entry_remaining); + entry_remaining -= 4; + stream_read_uint32(qtmovie->stream); /* 'alac' */ + entry_remaining -= 4; + + qtmovie->res->codecdata = malloc(qtmovie->res->codecdata_len - 8); + + stream_read(qtmovie->stream, + entry_remaining, + qtmovie->res->codecdata); + entry_remaining = 0; + +#else + /* 12 = audio format atom, 8 = padding */ + qtmovie->res->codecdata_len = entry_remaining + 12 + 8; + qtmovie->res->codecdata = malloc(qtmovie->res->codecdata_len); + memset(qtmovie->res->codecdata, 0, qtmovie->res->codecdata_len); + /* audio format atom */ + ((unsigned int*)qtmovie->res->codecdata)[0] = 0x0c000000; + ((unsigned int*)qtmovie->res->codecdata)[1] = MAKEFOURCC('a','m','r','f'); + ((unsigned int*)qtmovie->res->codecdata)[2] = MAKEFOURCC('c','a','l','a'); + + stream_read(qtmovie->stream, + entry_remaining, + ((char*)qtmovie->res->codecdata) + 12); + entry_remaining -= entry_remaining; + +#endif + if (entry_remaining) + stream_skip(qtmovie->stream, entry_remaining); + + if (qtmovie->res->format != MAKEFOURCC('a','l','a','c')) + { + fprintf(stderr, "expecting 'alac' data format, got %c%c%c%c\n", + SPLITFOURCC(qtmovie->res->format)); + return; + } + } +} + +static void read_chunk_stts(qtmovie_t *qtmovie, size_t chunk_len) +{ + unsigned int i; + uint32_t numentries; + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + /* version */ + stream_read_uint8(qtmovie->stream); + size_remaining -= 1; + /* flags */ + stream_read_uint8(qtmovie->stream); + stream_read_uint8(qtmovie->stream); + stream_read_uint8(qtmovie->stream); + size_remaining -= 3; + + numentries = stream_read_uint32(qtmovie->stream); + size_remaining -= 4; + + qtmovie->res->num_time_to_samples = numentries; + qtmovie->res->time_to_sample = malloc(numentries * sizeof(*qtmovie->res->time_to_sample)); + + for (i = 0; i < numentries; i++) + { + qtmovie->res->time_to_sample[i].sample_count = stream_read_uint32(qtmovie->stream); + qtmovie->res->time_to_sample[i].sample_duration = stream_read_uint32(qtmovie->stream); + size_remaining -= 8; + } + + if (size_remaining) + { + fprintf(stderr, "ehm, size remianing?\n"); + stream_skip(qtmovie->stream, size_remaining); + } +} + +static void read_chunk_stsz(qtmovie_t *qtmovie, size_t chunk_len) +{ + unsigned int i; + uint32_t numentries; + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + /* version */ + stream_read_uint8(qtmovie->stream); + size_remaining -= 1; + /* flags */ + stream_read_uint8(qtmovie->stream); + stream_read_uint8(qtmovie->stream); + stream_read_uint8(qtmovie->stream); + size_remaining -= 3; + + /* default sample size */ + if (stream_read_uint32(qtmovie->stream) != 0) + { + fprintf(stderr, "i was expecting variable samples sizes\n"); + stream_read_uint32(qtmovie->stream); + size_remaining -= 4; + return; + } + size_remaining -= 4; + + numentries = stream_read_uint32(qtmovie->stream); + size_remaining -= 4; + + qtmovie->res->num_sample_byte_sizes = numentries; + qtmovie->res->sample_byte_size = malloc(numentries * sizeof(*qtmovie->res->sample_byte_size)); + + for (i = 0; i < numentries; i++) + { + qtmovie->res->sample_byte_size[i] = stream_read_uint32(qtmovie->stream); + size_remaining -= 4; + } + + if (size_remaining) + { + fprintf(stderr, "ehm, size remianing?\n"); + stream_skip(qtmovie->stream, size_remaining); + } +} + +static void read_chunk_stbl(qtmovie_t *qtmovie, size_t chunk_len) +{ + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + while (size_remaining) + { + size_t sub_chunk_len; + fourcc_t sub_chunk_id; + + sub_chunk_len = stream_read_uint32(qtmovie->stream); + if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining) + { + fprintf(stderr, "strange size for chunk inside stbl (%i) (remaining: %i)\n", + sub_chunk_len, size_remaining); + return; + } + + sub_chunk_id = stream_read_uint32(qtmovie->stream); + + switch (sub_chunk_id) + { + case MAKEFOURCC('s','t','s','d'): + read_chunk_stsd(qtmovie, sub_chunk_len); + break; + case MAKEFOURCC('s','t','t','s'): + read_chunk_stts(qtmovie, sub_chunk_len); + break; + case MAKEFOURCC('s','t','s','z'): + read_chunk_stsz(qtmovie, sub_chunk_len); + break; + case MAKEFOURCC('s','t','s','c'): + case MAKEFOURCC('s','t','c','o'): + /* skip these, no indexing for us! */ + stream_skip(qtmovie->stream, sub_chunk_len - 8); + break; + default: + fprintf(stderr, "(stbl) unknown chunk id: %c%c%c%c\n", + SPLITFOURCC(sub_chunk_id)); + return; + } + + size_remaining -= sub_chunk_len; + } +} + +static void read_chunk_minf(qtmovie_t *qtmovie, size_t chunk_len) +{ + size_t dinf_size, stbl_size; + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + /**** SOUND HEADER CHUNK ****/ + if (stream_read_uint32(qtmovie->stream) != 16) + { + fprintf(stderr, "unexpected size in media info\n"); + return; + } + if (stream_read_uint32(qtmovie->stream) != MAKEFOURCC('s','m','h','d')) + { + fprintf(stderr, "not a sound header! can't handle this.\n"); + return; + } + /* now skip the rest */ + stream_skip(qtmovie->stream, 16 - 8); + size_remaining -= 16; + /****/ + + /**** DINF CHUNK ****/ + dinf_size = stream_read_uint32(qtmovie->stream); + if (stream_read_uint32(qtmovie->stream) != MAKEFOURCC('d','i','n','f')) + { + fprintf(stderr, "expected dinf, didn't get it.\n"); + return; + } + /* skip it */ + stream_skip(qtmovie->stream, dinf_size - 8); + size_remaining -= dinf_size; + /****/ + + + /**** SAMPLE TABLE ****/ + stbl_size = stream_read_uint32(qtmovie->stream); + if (stream_read_uint32(qtmovie->stream) != MAKEFOURCC('s','t','b','l')) + { + fprintf(stderr, "expected stbl, didn't get it.\n"); + return; + } + read_chunk_stbl(qtmovie, stbl_size); + size_remaining -= stbl_size; + + if (size_remaining) + { + fprintf(stderr, "oops\n"); + stream_skip(qtmovie->stream, size_remaining); + } +} + +static void read_chunk_mdia(qtmovie_t *qtmovie, size_t chunk_len) +{ + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + while (size_remaining) + { + size_t sub_chunk_len; + fourcc_t sub_chunk_id; + + sub_chunk_len = stream_read_uint32(qtmovie->stream); + if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining) + { + fprintf(stderr, "strange size for chunk inside mdia\n"); + return; + } + + sub_chunk_id = stream_read_uint32(qtmovie->stream); + + switch (sub_chunk_id) + { + case MAKEFOURCC('m','d','h','d'): + read_chunk_mdhd(qtmovie, sub_chunk_len); + break; + case MAKEFOURCC('h','d','l','r'): + read_chunk_hdlr(qtmovie, sub_chunk_len); + break; + case MAKEFOURCC('m','i','n','f'): + read_chunk_minf(qtmovie, sub_chunk_len); + break; + default: + fprintf(stderr, "(mdia) unknown chunk id: %c%c%c%c\n", + SPLITFOURCC(sub_chunk_id)); + return; + } + + size_remaining -= sub_chunk_len; + } +} + +/* 'trak' - a movie track - contains other atoms */ +static void read_chunk_trak(qtmovie_t *qtmovie, size_t chunk_len) +{ + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + while (size_remaining) + { + size_t sub_chunk_len; + fourcc_t sub_chunk_id; + + sub_chunk_len = stream_read_uint32(qtmovie->stream); + if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining) + { + fprintf(stderr, "strange size for chunk inside trak\n"); + return; + } + + sub_chunk_id = stream_read_uint32(qtmovie->stream); + + switch (sub_chunk_id) + { + case MAKEFOURCC('t','k','h','d'): + read_chunk_tkhd(qtmovie, sub_chunk_len); + break; + case MAKEFOURCC('m','d','i','a'): + read_chunk_mdia(qtmovie, sub_chunk_len); + break; + case MAKEFOURCC('e','d','t','s'): + read_chunk_edts(qtmovie, sub_chunk_len); + break; + default: + fprintf(stderr, "(trak) unknown chunk id: %c%c%c%c\n", + SPLITFOURCC(sub_chunk_id)); + return; + } + + size_remaining -= sub_chunk_len; + } +} + +/* 'mvhd' movie header atom */ +static void read_chunk_mvhd(qtmovie_t *qtmovie, size_t chunk_len) +{ + /* don't need anything from here atm, skip */ + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + stream_skip(qtmovie->stream, size_remaining); +} + +/* 'udta' user data.. contains tag info */ +static void read_chunk_udta(qtmovie_t *qtmovie, size_t chunk_len) +{ + /* don't need anything from here atm, skip */ + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + stream_skip(qtmovie->stream, size_remaining); +} + +/* 'moov' movie atom - contains other atoms */ +static void read_chunk_moov(qtmovie_t *qtmovie, size_t chunk_len) +{ + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + while (size_remaining) + { + size_t sub_chunk_len; + fourcc_t sub_chunk_id; + + sub_chunk_len = stream_read_uint32(qtmovie->stream); + if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining) + { + fprintf(stderr, "strange size for chunk inside moov\n"); + return; + } + + sub_chunk_id = stream_read_uint32(qtmovie->stream); + + switch (sub_chunk_id) + { + case MAKEFOURCC('m','v','h','d'): + read_chunk_mvhd(qtmovie, sub_chunk_len); + break; + case MAKEFOURCC('t','r','a','k'): + read_chunk_trak(qtmovie, sub_chunk_len); + break; + case MAKEFOURCC('u','d','t','a'): + read_chunk_udta(qtmovie, sub_chunk_len); + break; + case MAKEFOURCC('e','l','s','t'): + read_chunk_elst(qtmovie, sub_chunk_len); + break; + default: + fprintf(stderr, "(moov) unknown chunk id: %c%c%c%c\n", + SPLITFOURCC(sub_chunk_id)); + return; + } + + size_remaining -= sub_chunk_len; + } +} + +static void read_chunk_mdat(qtmovie_t *qtmovie, size_t chunk_len, int skip_mdat) +{ + size_t size_remaining = chunk_len - 8; /* FIXME WRONG */ + + qtmovie->res->mdat_len = (uint32_t)size_remaining; + if (skip_mdat) + { + qtmovie->saved_mdat_pos = stream_tell(qtmovie->stream); + stream_skip(qtmovie->stream, size_remaining); + } +#if 0 + qtmovie->res->mdat = malloc(size_remaining); + + stream_read(qtmovie->stream, size_remaining, qtmovie->res->mdat); +#endif +} + +static int set_saved_mdat(qtmovie_t *qtmovie) +{ + if (qtmovie->saved_mdat_pos == -1) + { + fprintf(stderr, "stream contains mdat before moov but is not seekable\n"); + return 0; + } + + if (stream_setpos(qtmovie->stream, qtmovie->saved_mdat_pos)) + { + fprintf(stderr, "error while seeking stream to mdat pos\n"); + return 0; + } + + return 1; +} + +int qtmovie_read(stream_t *file, demux_res_t *demux_res) +{ + int found_moov = 0; + int found_mdat = 0; + qtmovie_t *qtmovie; + + qtmovie = (qtmovie_t*)malloc(sizeof(qtmovie_t)); + + /* construct the stream */ + qtmovie->stream = file; + + qtmovie->res = demux_res; + + memset(demux_res, 0, sizeof(demux_res_t)); + + /* read the chunks */ + while (1) + { + size_t chunk_len; + fourcc_t chunk_id; + + chunk_len = stream_read_uint32(qtmovie->stream); + if (stream_eof(qtmovie->stream)) + { + return 0; + } + + if (chunk_len == 1) + { + fprintf(stderr, "need 64bit support\n"); + return 0; + } + chunk_id = stream_read_uint32(qtmovie->stream); + + switch (chunk_id) + { + case MAKEFOURCC('f','t','y','p'): + read_chunk_ftyp(qtmovie, chunk_len); + break; + case MAKEFOURCC('m','o','o','v'): + read_chunk_moov(qtmovie, chunk_len); + if (found_mdat) + { + return set_saved_mdat(qtmovie); + } + found_moov = 1; + break; + /* if we hit mdat before we've found moov, record the position + * and move on. We can then come back to mdat later. + * This presumes the stream supports seeking backwards. + */ + case MAKEFOURCC('m','d','a','t'): + read_chunk_mdat(qtmovie, chunk_len, !found_moov); + if (found_moov) + return 1; + found_mdat = 1; + break; + + /* these following atoms can be skipped !!!! */ + case MAKEFOURCC('f','r','e','e'): + stream_skip(qtmovie->stream, chunk_len - 8); /* FIXME not 8 */ + break; + default: + fprintf(stderr, "(top) unknown chunk id: %c%c%c%c\n", + SPLITFOURCC(chunk_id)); + return 0; + } + + } + return 0; +} + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alac/demux.h Sat Sep 30 19:26:34 2006 -0700 @@ -0,0 +1,55 @@ +#ifndef DEMUX_H +#define DEMUX_H + +#include <stdint.h> +#include "stream.h" + +typedef uint32_t fourcc_t; + +typedef struct +{ + uint16_t num_channels; + uint16_t sample_size; + uint32_t sample_rate; + fourcc_t format; + void *buf; + + struct { + uint32_t sample_count; + uint32_t sample_duration; + } *time_to_sample; + uint32_t num_time_to_samples; + + uint32_t *sample_byte_size; + uint32_t num_sample_byte_sizes; + + uint32_t codecdata_len; + void *codecdata; + + uint32_t mdat_len; +#if 0 + void *mdat; +#endif +} demux_res_t; + +int qtmovie_read(stream_t *stream, demux_res_t *demux_res); + +#ifndef MAKEFOURCC +#define MAKEFOURCC(ch0, ch1, ch2, ch3) ( \ + ( (int32_t)(char)(ch0) << 24 ) | \ + ( (int32_t)(char)(ch1) << 16 ) | \ + ( (int32_t)(char)(ch2) << 8 ) | \ + ( (int32_t)(char)(ch3) ) ) +#endif + +#ifndef SLPITFOURCC +/* splits it into ch0, ch1, ch2, ch3 - use for printf's */ +#define SPLITFOURCC(code) \ + (char)((int32_t)code >> 24), \ + (char)((int32_t)code >> 16), \ + (char)((int32_t)code >> 8), \ + (char)code +#endif + +#endif /* DEMUX_H */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alac/plugin.c Sat Sep 30 19:26:34 2006 -0700 @@ -0,0 +1,275 @@ +/* + * Copyright (c) 2005 David Hammerton + * All rights reserved. + * + * Adapted from example program by William Pitcock <nenolod@atheme.org> + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <ctype.h> +#include <stdio.h> +#include <stdint.h> +#include <stdlib.h> +#include <errno.h> +#include <string.h> + +#include <audacious/plugin.h> +#include <audacious/output.h> +#include <audacious/vfs.h> + +#include "demux.h" +#include "decomp.h" +#include "stream.h" + +alac_file *alac = NULL; + +static VFSFile *input_file = NULL; +static int input_opened = 0; +static stream_t *input_stream; + +static int write_wav_format = 0; +static int verbose = 0; + +gpointer decode_thread(void *args); +static GThread *playback_thread; + +static void alac_init(void) +{ + /* empty */ +} + +gboolean is_our_file(char *filename) +{ + demux_res_t demux_res; + input_file = vfs_fopen(filename, "rb"); +#ifdef WORDS_BIGENDIAN + input_stream = stream_create_file(input_file, 1); +#else + input_stream = stream_create_file(input_file, 0); +#endif + if (!input_stream) + { + fprintf(stderr, "failed to create input stream from file\n"); + vfs_fclose(input_file); + return FALSE; + } + + /* if qtmovie_read returns successfully, the stream is up to + * the movie data, which can be used directly by the decoder */ + if (!qtmovie_read(input_stream, &demux_res)) + { + fprintf(stderr, "failed to load the QuickTime movie headers\n"); + stream_destroy(input_stream); + vfs_fclose(input_file); + return FALSE; + } + + stream_destroy(input_stream); + vfs_fclose(input_file); + + return TRUE; +} + +static void play_file(char *filename) +{ + playback_thread = g_thread_create(decode_thread, filename, TRUE, NULL); +} + +static void stop(void) +{ + g_thread_join(playback_thread); + output_close_audio(); +} + +static void seek(gint time) +{ + /* unimplemented */ +} + +InputPlugin alac_ip = { + NULL, + NULL, + "Apple Lossless Plugin", /* Description */ + alac_init, + NULL, + NULL, + is_our_file, + NULL, + play_file, + stop, + output_pause, + seek, + NULL, + get_output_time, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, /* file_info_box */ + NULL +}; + +static int get_sample_info(demux_res_t *demux_res, uint32_t samplenum, + uint32_t *sample_duration, + uint32_t *sample_byte_size) +{ + unsigned int duration_index_accum = 0; + unsigned int duration_cur_index = 0; + + if (samplenum >= demux_res->num_sample_byte_sizes) + { + fprintf(stderr, "sample %i does not exist\n", samplenum); + return 0; + } + + if (!demux_res->num_time_to_samples) + { + fprintf(stderr, "no time to samples\n"); + return 0; + } + while ((demux_res->time_to_sample[duration_cur_index].sample_count + duration_index_accum) + <= samplenum) + { + duration_index_accum += demux_res->time_to_sample[duration_cur_index].sample_count; + duration_cur_index++; + if (duration_cur_index >= demux_res->num_time_to_samples) + { + fprintf(stderr, "sample %i does not have a duration\n", samplenum); + return 0; + } + } + + *sample_duration = demux_res->time_to_sample[duration_cur_index].sample_duration; + *sample_byte_size = demux_res->sample_byte_size[samplenum]; + + return 1; +} + +static void GetBuffer(demux_res_t *demux_res) +{ + unsigned long destBufferSize = 1024*16; /* 16kb buffer = 4096 frames = 1 alac sample */ + void *pDestBuffer = malloc(destBufferSize); + int bytes_read = 0; + + unsigned int buffer_size = 1024*64; + void *buffer; + + unsigned int i; + + buffer = malloc(buffer_size); + + for (i = 0; i < demux_res->num_sample_byte_sizes; i++) + { + uint32_t sample_duration; + uint32_t sample_byte_size; + + int outputBytes; + + /* just get one sample for now */ + if (!get_sample_info(demux_res, i, + &sample_duration, &sample_byte_size)) + { + fprintf(stderr, "sample failed\n"); + return; + } + + if (buffer_size < sample_byte_size) + { + fprintf(stderr, "sorry buffer too small! (is %i want %i)\n", + buffer_size, + sample_byte_size); + return; + } + + stream_read(input_stream, sample_byte_size, + buffer); + + /* now fetch */ + outputBytes = destBufferSize; + decode_frame(alac, buffer, pDestBuffer, &outputBytes); + + /* write */ + bytes_read += outputBytes; + + if (verbose) + fprintf(stderr, "read %i bytes. total: %i\n", outputBytes, bytes_read); + + produce_audio(get_written_time(), FMT_S16_LE, demux_res->num_channels, outputBytes, pDestBuffer, NULL); + } + if (verbose) + fprintf(stderr, "done reading, read %i frames\n", i); +} + +static void init_sound_converter(demux_res_t *demux_res) +{ + alac = create_alac(demux_res->sample_size, demux_res->num_channels); + + alac_set_info(alac, demux_res->codecdata); +} + +gpointer decode_thread(void *args) +{ + demux_res_t demux_res; + unsigned int output_size, i; + + input_file = vfs_fopen((char *) args, "rb"); +#ifdef WORDS_BIGENDIAN + input_stream = stream_create_file(input_file, 1); +#else + input_stream = stream_create_file(input_file, 0); +#endif + if (!input_stream) + { + fprintf(stderr, "failed to create input stream from file\n"); + return 0; + } + + /* if qtmovie_read returns successfully, the stream is up to + * the movie data, which can be used directly by the decoder */ + if (!qtmovie_read(input_stream, &demux_res)) + { + fprintf(stderr, "failed to load the QuickTime movie headers\n"); + return 0; + } + + /* initialise the sound converter */ + init_sound_converter(&demux_res); + + /* will convert the entire buffer */ + GetBuffer(&demux_res); + + stream_destroy(input_stream); + + if (input_opened) + vfs_fclose(input_file); + + return NULL; +} + +InputPlugin *get_iplugin_info(void) +{ + return &alac_ip; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alac/stream.c Sat Sep 30 19:26:34 2006 -0700 @@ -0,0 +1,181 @@ +/* + * ALAC (Apple Lossless Audio Codec) decoder + * Copyright (c) 2005 David Hammerton + * All rights reserved. + * + * Basic stream reading + * + * http://crazney.net/programs/itunes/alac.html + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + */ + + +#include <stdio.h> +#include <stdint.h> +#include <stdlib.h> +#include <errno.h> + +#include <audacious/plugin.h> +#include <audacious/vfs.h> + +#include "stream.h" + +#define _Swap32(v) do { \ + v = (((v) & 0x000000FF) << 0x18) | \ + (((v) & 0x0000FF00) << 0x08) | \ + (((v) & 0x00FF0000) >> 0x08) | \ + (((v) & 0xFF000000) >> 0x18); } while(0) + +#define _Swap16(v) do { \ + v = (((v) & 0x00FF) << 0x08) | \ + (((v) & 0xFF00) >> 0x08); } while (0) + +#ifdef WORDS_BIGENDIAN +int host_bigendian = 1; +#else +int host_bigendian = 0; +#endif + +struct stream_tTAG { + VFSFile *f; + int bigendian; + int eof; +}; + +void stream_read(stream_t *stream, size_t size, void *buf) +{ + size_t ret; + + ret = vfs_fread(buf, 4, size >> 2, stream->f) * 4; + ret += vfs_fread((char*)buf + ret, 1, size - ret, stream->f); + + if (ret == 0 && size != 0) stream->eof = 1; +} + +int32_t stream_read_int32(stream_t *stream) +{ + int32_t v; + stream_read(stream, 4, &v); + if ((stream->bigendian && !host_bigendian) || + (!stream->bigendian && host_bigendian)) + { + _Swap32(v); + } + return v; +} + +uint32_t stream_read_uint32(stream_t *stream) +{ + uint32_t v; + stream_read(stream, 4, &v); + if ((stream->bigendian && !host_bigendian) || + (!stream->bigendian && host_bigendian)) + { + _Swap32(v); + } + return v; +} + +int16_t stream_read_int16(stream_t *stream) +{ + int16_t v; + stream_read(stream, 2, &v); + if ((stream->bigendian && !host_bigendian) || + (!stream->bigendian && host_bigendian)) + { + _Swap16(v); + } + return v; +} + +uint16_t stream_read_uint16(stream_t *stream) +{ + uint16_t v; + stream_read(stream, 2, &v); + if ((stream->bigendian && !host_bigendian) || + (!stream->bigendian && host_bigendian)) + { + _Swap16(v); + } + return v; +} + +int8_t stream_read_int8(stream_t *stream) +{ + int8_t v; + stream_read(stream, 1, &v); + return v; +} + +uint8_t stream_read_uint8(stream_t *stream) +{ + uint8_t v; + stream_read(stream, 1, &v); + return v; +} + + +void stream_skip(stream_t *stream, size_t skip) +{ + if (vfs_fseek(stream->f, (long)skip, SEEK_CUR) == 0) return; + if (errno == ESPIPE) + { + char *buffer = malloc(skip); + stream_read(stream, skip, buffer); + free(buffer); + } +} + +int stream_eof(stream_t *stream) +{ + return stream->eof; +} + +long stream_tell(stream_t *stream) +{ + return vfs_ftell(stream->f); /* returns -1 on error */ +} + +int stream_setpos(stream_t *stream, long pos) +{ + return vfs_fseek(stream->f, pos, SEEK_SET); +} + +stream_t *stream_create_file(VFSFile *file, + int bigendian) +{ + stream_t *new_stream; + + new_stream = (stream_t*)malloc(sizeof(stream_t)); + new_stream->f = file; + new_stream->bigendian = bigendian; + new_stream->eof = 0; + + return new_stream; +} + +void stream_destroy(stream_t *stream) +{ + free(stream); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alac/stream.h Sat Sep 30 19:26:34 2006 -0700 @@ -0,0 +1,36 @@ +#ifndef STREAM_H +#define STREAM_H + +/* stream.h */ + +#include <stdint.h> + +#include <audacious/plugin.h> +#include <audacious/vfs.h> + +typedef struct stream_tTAG stream_t; + +void stream_read(stream_t *stream, size_t len, void *buf); + +int32_t stream_read_int32(stream_t *stream); +uint32_t stream_read_uint32(stream_t *stream); + +int16_t stream_read_int16(stream_t *stream); +uint16_t stream_read_uint16(stream_t *stream); + +int8_t stream_read_int8(stream_t *stream); +uint8_t stream_read_uint8(stream_t *stream); + +void stream_skip(stream_t *stream, size_t skip); + +int stream_eof(stream_t *stream); + +long stream_tell(stream_t *stream); +int stream_setpos(stream_t *stream, long pos); + +stream_t *stream_create_file(VFSFile *file, + int bigendian); +void stream_destroy(stream_t *stream); + +#endif /* STREAM_H */ +