*/
/**
- * @file alac.c
+ * @file libavcodec/alac.c
* ALAC (Apple Lossless Audio Codec) decoder
* @author 2005 David Hammerton
*
#include "avcodec.h"
-#include "bitstream.h"
+#include "get_bits.h"
#include "bytestream.h"
#include "unary.h"
+#include "mathops.h"
#define ALAC_EXTRADATA_SIZE 36
#define MAX_CHANNELS 2
* set this to 1 */
int context_initialized;
- int samplesize;
int numchannels;
int bytespersample;
/* 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 (average)?? */
- uint32_t setinfo_8a_rate; /* 0x0000ac44 */
/* end setinfo stuff */
} ALACContext;
/* buffer size / 2 ? */
alac->setinfo_max_samples_per_frame = bytestream_get_be32(&ptr);
- alac->setinfo_7a = *ptr++;
+ ptr++; /* ??? */
alac->setinfo_sample_size = *ptr++;
+ if (alac->setinfo_sample_size > 32) {
+ av_log(alac->avctx, AV_LOG_ERROR, "setinfo_sample_size too large\n");
+ return -1;
+ }
alac->setinfo_rice_historymult = *ptr++;
alac->setinfo_rice_initialhistory = *ptr++;
alac->setinfo_rice_kmodifier = *ptr++;
- /* channels? */
- alac->setinfo_7f = *ptr++;
- alac->setinfo_80 = bytestream_get_be16(&ptr);
- /* max coded frame size */
- alac->setinfo_82 = bytestream_get_be32(&ptr);
- /* bitrate ? */
- alac->setinfo_86 = bytestream_get_be32(&ptr);
- /* samplerate */
- alac->setinfo_8a_rate = bytestream_get_be32(&ptr);
+ ptr++; /* channels? */
+ bytestream_get_be16(&ptr); /* ??? */
+ bytestream_get_be32(&ptr); /* max coded frame size */
+ bytestream_get_be32(&ptr); /* bitrate ? */
+ bytestream_get_be32(&ptr); /* samplerate */
allocate_buffers(alac);
return 0;
}
-static inline int count_leading_zeros(int32_t input)
-{
- return 31-av_log2(input);
-}
-
+static inline int decode_scalar(GetBitContext *gb, int k, int limit, int readsamplesize){
+ /* read x - number of 1s before 0 represent the rice */
+ int x = get_unary_0_9(gb);
-static inline int decode_postfix(GetBitContext *gb, int x, int k, int limit){
- if (k >= limit)
- k = limit;
+ if (x > 8) { /* RICE THRESHOLD */
+ /* use alternative encoding */
+ x = get_bits(gb, readsamplesize);
+ } else {
+ if (k >= limit)
+ k = limit;
- if (k != 1) {
- int extrabits = show_bits(gb, k);
+ if (k != 1) {
+ int extrabits = show_bits(gb, k);
- /* multiply x by 2^k - 1, as part of their strange algorithm */
- x = (x << k) - x;
+ /* multiply x by 2^k - 1, as part of their strange algorithm */
+ x = (x << k) - x;
- if (extrabits > 1) {
- x += extrabits - 1;
- skip_bits(gb, k);
- } else
- skip_bits(gb, k - 1);
+ if (extrabits > 1) {
+ x += extrabits - 1;
+ skip_bits(gb, k);
+ } else
+ skip_bits(gb, k - 1);
+ }
}
return x;
}
int32_t x_modified;
int32_t final_val;
- /* read x - number of 1s before 0 represent the rice */
- x = get_unary_0_9(&alac->gb);
-
- if (x > 8) { /* RICE THRESHOLD */
- /* use alternative encoding */
- x = get_bits(&alac->gb, readsamplesize);
- } else {
- /* standard rice encoding */
- int k; /* size of extra bits */
+ /* standard rice encoding */
+ int k; /* size of extra bits */
- /* read k, that is bits as is */
- k = 31 - count_leading_zeros((history >> 9) + 3);
- x= decode_postfix(&alac->gb, x, k, rice_kmodifier);
- }
+ /* read k, that is bits as is */
+ k = av_log2((history >> 9) + 3);
+ x= decode_scalar(&alac->gb, k, rice_kmodifier, readsamplesize);
x_modified = sign_modifier + x;
final_val = (x_modified + 1) / 2;
/* special case: there may be compressed blocks of 0 */
if ((history < 128) && (output_count+1 < output_size)) {
- int block_size;
+ int k;
+ unsigned int block_size;
sign_modifier = 1;
- x = get_unary_0_9(&alac->gb);
-
- if (x > 8) {
- block_size = get_bits(&alac->gb, 16);
- } else {
- int k;
-
- k = count_leading_zeros(history) + ((history + 16) >> 6 /* / 64 */) - 24;
+ k = 7 - av_log2(history) + ((history + 16) >> 6 /* / 64 */);
- block_size= decode_postfix(&alac->gb, x, k, rice_kmodifier);
- }
+ block_size= decode_scalar(&alac->gb, k, rice_kmodifier, 16);
if (block_size > 0) {
+ if(block_size >= output_size - output_count){
+ av_log(alac->avctx, AV_LOG_ERROR, "invalid zero block size of %d %d %d\n", block_size, output_size, output_count);
+ block_size= output_size - output_count - 1;
+ }
memset(&output_buffer[output_count+1], 0, block_size * 4);
output_count += block_size;
}
}
}
-static inline int32_t extend_sign32(int32_t val, int bits)
-{
- return (val << (32 - bits)) >> (32 - bits);
-}
-
static inline int sign_only(int v)
{
return v ? FFSIGN(v) : 0;
prev_value = buffer_out[i];
error_value = error_buffer[i+1];
buffer_out[i+1] =
- extend_sign32((prev_value + error_value), readsamplesize);
+ sign_extend((prev_value + error_value), readsamplesize);
}
return;
}
int32_t val;
val = buffer_out[i] + error_buffer[i+1];
- val = extend_sign32(val, readsamplesize);
+ val = sign_extend(val, readsamplesize);
buffer_out[i+1] = val;
}
outval = (1 << (predictor_quantitization-1)) + sum;
outval = outval >> predictor_quantitization;
outval = outval + buffer_out[0] + error_val;
- outval = extend_sign32(outval, readsamplesize);
+ outval = sign_extend(outval, readsamplesize);
buffer_out[predictor_coef_num+1] = outval;
static int alac_decode_frame(AVCodecContext *avctx,
void *outbuffer, int *outputsize,
- const uint8_t *inbuffer, int input_buffer_size)
+ AVPacket *avpkt)
{
+ const uint8_t *inbuffer = avpkt->data;
+ int input_buffer_size = avpkt->size;
ALACContext *alac = avctx->priv_data;
int channels;
- int32_t outputsamples;
+ unsigned int outputsamples;
int hassize;
- int readsamplesize;
+ unsigned int readsamplesize;
int wasted_bytes;
int isnotcompressed;
uint8_t interlacing_shift;
if (hassize) {
/* now read the number of samples as a 32bit integer */
- outputsamples = get_bits(&alac->gb, 32);
+ outputsamples = get_bits_long(&alac->gb, 32);
+ if(outputsamples > alac->setinfo_max_samples_per_frame){
+ av_log(avctx, AV_LOG_ERROR, "outputsamples %d > %d\n", outputsamples, alac->setinfo_max_samples_per_frame);
+ return -1;
+ }
} else
outputsamples = alac->setinfo_max_samples_per_frame;
+ if(outputsamples > *outputsize / alac->bytespersample){
+ av_log(avctx, AV_LOG_ERROR, "sample buffer too small\n");
+ return -1;
+ }
+
*outputsize = outputsamples * alac->bytespersample;
readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8) + channels - 1;
+ if (readsamplesize > MIN_CACHE_BITS) {
+ av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize);
+ return -1;
+ }
if (!isnotcompressed) {
/* so it is compressed */
}
} else {
/* not compressed, easy case */
- if (alac->setinfo_sample_size <= 16) {
- int i, chan;
- for (chan = 0; chan < channels; chan++)
- for (i = 0; i < outputsamples; i++) {
- int32_t audiobits;
+ int i, chan;
+ for (i = 0; i < outputsamples; i++)
+ for (chan = 0; chan < channels; chan++) {
+ int32_t audiobits;
- audiobits = get_bits(&alac->gb, alac->setinfo_sample_size);
- audiobits = extend_sign32(audiobits, readsamplesize);
+ audiobits = get_sbits_long(&alac->gb, alac->setinfo_sample_size);
- alac->outputsamples_buffer[chan][i] = audiobits;
- }
- } else {
- int i, chan;
- for (chan = 0; chan < channels; chan++)
- for (i = 0; i < outputsamples; i++) {
- int32_t audiobits;
-
- audiobits = get_bits(&alac->gb, 16);
- /* special case of sign extension..
- * as we'll be ORing the low 16bits into this */
- audiobits = audiobits << 16;
- audiobits = audiobits >> (32 - alac->setinfo_sample_size);
- audiobits |= get_bits(&alac->gb, alac->setinfo_sample_size - 16);
-
- alac->outputsamples_buffer[chan][i] = audiobits;
- }
- }
+ alac->outputsamples_buffer[chan][i] = audiobits;
+ }
/* wasted_bytes = 0; */
interlacing_shift = 0;
interlacing_leftweight = 0;
}
+ if (get_bits(&alac->gb, 3) != 7)
+ av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n");
switch(alac->setinfo_sample_size) {
case 16:
break;
}
+ if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8)
+ av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb));
+
return input_buffer_size;
}
alac->avctx = avctx;
alac->context_initialized = 0;
- alac->samplesize = alac->avctx->bits_per_sample;
alac->numchannels = alac->avctx->channels;
- alac->bytespersample = (alac->samplesize / 8) * alac->numchannels;
+ alac->bytespersample = 2 * alac->numchannels;
+ avctx->sample_fmt = SAMPLE_FMT_S16;
return 0;
}
NULL,
alac_decode_close,
alac_decode_frame,
+ .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
};