00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00055 #include "avcodec.h"
00056 #include "get_bits.h"
00057 #include "bytestream.h"
00058 #include "unary.h"
00059 #include "mathops.h"
00060
00061 #define ALAC_EXTRADATA_SIZE 36
00062 #define MAX_CHANNELS 2
00063
00064 typedef struct {
00065
00066 AVCodecContext *avctx;
00067 GetBitContext gb;
00068
00069
00070 int context_initialized;
00071
00072 int numchannels;
00073 int bytespersample;
00074
00075
00076 int32_t *predicterror_buffer[MAX_CHANNELS];
00077
00078 int32_t *outputsamples_buffer[MAX_CHANNELS];
00079
00080 int32_t *wasted_bits_buffer[MAX_CHANNELS];
00081
00082
00083 uint32_t setinfo_max_samples_per_frame;
00084 uint8_t setinfo_sample_size;
00085 uint8_t setinfo_rice_historymult;
00086 uint8_t setinfo_rice_initialhistory;
00087 uint8_t setinfo_rice_kmodifier;
00088
00089
00090 int wasted_bits;
00091 } ALACContext;
00092
00093 static void allocate_buffers(ALACContext *alac)
00094 {
00095 int chan;
00096 for (chan = 0; chan < MAX_CHANNELS; chan++) {
00097 alac->predicterror_buffer[chan] =
00098 av_malloc(alac->setinfo_max_samples_per_frame * 4);
00099
00100 alac->outputsamples_buffer[chan] =
00101 av_malloc(alac->setinfo_max_samples_per_frame * 4);
00102
00103 alac->wasted_bits_buffer[chan] = av_malloc(alac->setinfo_max_samples_per_frame * 4);
00104 }
00105 }
00106
00107 static int alac_set_info(ALACContext *alac)
00108 {
00109 const unsigned char *ptr = alac->avctx->extradata;
00110
00111 ptr += 4;
00112 ptr += 4;
00113 ptr += 4;
00114
00115 if(AV_RB32(ptr) >= UINT_MAX/4){
00116 av_log(alac->avctx, AV_LOG_ERROR, "setinfo_max_samples_per_frame too large\n");
00117 return -1;
00118 }
00119
00120
00121 alac->setinfo_max_samples_per_frame = bytestream_get_be32(&ptr);
00122 ptr++;
00123 alac->setinfo_sample_size = *ptr++;
00124 if (alac->setinfo_sample_size > 32) {
00125 av_log(alac->avctx, AV_LOG_ERROR, "setinfo_sample_size too large\n");
00126 return -1;
00127 }
00128 alac->setinfo_rice_historymult = *ptr++;
00129 alac->setinfo_rice_initialhistory = *ptr++;
00130 alac->setinfo_rice_kmodifier = *ptr++;
00131 ptr++;
00132 bytestream_get_be16(&ptr);
00133 bytestream_get_be32(&ptr);
00134 bytestream_get_be32(&ptr);
00135 bytestream_get_be32(&ptr);
00136
00137 allocate_buffers(alac);
00138
00139 return 0;
00140 }
00141
00142 static inline int decode_scalar(GetBitContext *gb, int k, int limit, int readsamplesize){
00143
00144 int x = get_unary_0_9(gb);
00145
00146 if (x > 8) {
00147
00148 x = get_bits(gb, readsamplesize);
00149 } else {
00150 if (k >= limit)
00151 k = limit;
00152
00153 if (k != 1) {
00154 int extrabits = show_bits(gb, k);
00155
00156
00157 x = (x << k) - x;
00158
00159 if (extrabits > 1) {
00160 x += extrabits - 1;
00161 skip_bits(gb, k);
00162 } else
00163 skip_bits(gb, k - 1);
00164 }
00165 }
00166 return x;
00167 }
00168
00169 static void bastardized_rice_decompress(ALACContext *alac,
00170 int32_t *output_buffer,
00171 int output_size,
00172 int readsamplesize,
00173 int rice_initialhistory,
00174 int rice_kmodifier,
00175 int rice_historymult,
00176 int rice_kmodifier_mask
00177 )
00178 {
00179 int output_count;
00180 unsigned int history = rice_initialhistory;
00181 int sign_modifier = 0;
00182
00183 for (output_count = 0; output_count < output_size; output_count++) {
00184 int32_t x;
00185 int32_t x_modified;
00186 int32_t final_val;
00187
00188
00189 int k;
00190
00191
00192 k = av_log2((history >> 9) + 3);
00193 x= decode_scalar(&alac->gb, k, rice_kmodifier, readsamplesize);
00194
00195 x_modified = sign_modifier + x;
00196 final_val = (x_modified + 1) / 2;
00197 if (x_modified & 1) final_val *= -1;
00198
00199 output_buffer[output_count] = final_val;
00200
00201 sign_modifier = 0;
00202
00203
00204 history += x_modified * rice_historymult
00205 - ((history * rice_historymult) >> 9);
00206
00207 if (x_modified > 0xffff)
00208 history = 0xffff;
00209
00210
00211 if ((history < 128) && (output_count+1 < output_size)) {
00212 int k;
00213 unsigned int block_size;
00214
00215 sign_modifier = 1;
00216
00217 k = 7 - av_log2(history) + ((history + 16) >> 6 );
00218
00219 block_size= decode_scalar(&alac->gb, k, rice_kmodifier, 16);
00220
00221 if (block_size > 0) {
00222 if(block_size >= output_size - output_count){
00223 av_log(alac->avctx, AV_LOG_ERROR, "invalid zero block size of %d %d %d\n", block_size, output_size, output_count);
00224 block_size= output_size - output_count - 1;
00225 }
00226 memset(&output_buffer[output_count+1], 0, block_size * 4);
00227 output_count += block_size;
00228 }
00229
00230 if (block_size > 0xffff)
00231 sign_modifier = 0;
00232
00233 history = 0;
00234 }
00235 }
00236 }
00237
00238 static inline int sign_only(int v)
00239 {
00240 return v ? FFSIGN(v) : 0;
00241 }
00242
00243 static void predictor_decompress_fir_adapt(int32_t *error_buffer,
00244 int32_t *buffer_out,
00245 int output_size,
00246 int readsamplesize,
00247 int16_t *predictor_coef_table,
00248 int predictor_coef_num,
00249 int predictor_quantitization)
00250 {
00251 int i;
00252
00253
00254 *buffer_out = *error_buffer;
00255
00256 if (!predictor_coef_num) {
00257 if (output_size <= 1)
00258 return;
00259
00260 memcpy(buffer_out+1, error_buffer+1, (output_size-1) * 4);
00261 return;
00262 }
00263
00264 if (predictor_coef_num == 0x1f) {
00265
00266
00267
00268 if (output_size <= 1)
00269 return;
00270 for (i = 0; i < output_size - 1; i++) {
00271 int32_t prev_value;
00272 int32_t error_value;
00273
00274 prev_value = buffer_out[i];
00275 error_value = error_buffer[i+1];
00276 buffer_out[i+1] =
00277 sign_extend((prev_value + error_value), readsamplesize);
00278 }
00279 return;
00280 }
00281
00282
00283 if (predictor_coef_num > 0)
00284 for (i = 0; i < predictor_coef_num; i++) {
00285 int32_t val;
00286
00287 val = buffer_out[i] + error_buffer[i+1];
00288 val = sign_extend(val, readsamplesize);
00289 buffer_out[i+1] = val;
00290 }
00291
00292 #if 0
00293
00294
00295
00296 if (predictor_coef_num == 4) {
00297
00298 return;
00299 }
00300
00301 if (predictor_coef_table == 8) {
00302
00303 return;
00304 }
00305 #endif
00306
00307
00308 if (predictor_coef_num > 0) {
00309 for (i = predictor_coef_num + 1; i < output_size; i++) {
00310 int j;
00311 int sum = 0;
00312 int outval;
00313 int error_val = error_buffer[i];
00314
00315 for (j = 0; j < predictor_coef_num; j++) {
00316 sum += (buffer_out[predictor_coef_num-j] - buffer_out[0]) *
00317 predictor_coef_table[j];
00318 }
00319
00320 outval = (1 << (predictor_quantitization-1)) + sum;
00321 outval = outval >> predictor_quantitization;
00322 outval = outval + buffer_out[0] + error_val;
00323 outval = sign_extend(outval, readsamplesize);
00324
00325 buffer_out[predictor_coef_num+1] = outval;
00326
00327 if (error_val > 0) {
00328 int predictor_num = predictor_coef_num - 1;
00329
00330 while (predictor_num >= 0 && error_val > 0) {
00331 int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num];
00332 int sign = sign_only(val);
00333
00334 predictor_coef_table[predictor_num] -= sign;
00335
00336 val *= sign;
00337
00338 error_val -= ((val >> predictor_quantitization) *
00339 (predictor_coef_num - predictor_num));
00340
00341 predictor_num--;
00342 }
00343 } else if (error_val < 0) {
00344 int predictor_num = predictor_coef_num - 1;
00345
00346 while (predictor_num >= 0 && error_val < 0) {
00347 int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num];
00348 int sign = - sign_only(val);
00349
00350 predictor_coef_table[predictor_num] -= sign;
00351
00352 val *= sign;
00353
00354 error_val -= ((val >> predictor_quantitization) *
00355 (predictor_coef_num - predictor_num));
00356
00357 predictor_num--;
00358 }
00359 }
00360
00361 buffer_out++;
00362 }
00363 }
00364 }
00365
00366 static void reconstruct_stereo_16(int32_t *buffer[MAX_CHANNELS],
00367 int16_t *buffer_out,
00368 int numchannels, int numsamples,
00369 uint8_t interlacing_shift,
00370 uint8_t interlacing_leftweight)
00371 {
00372 int i;
00373 if (numsamples <= 0)
00374 return;
00375
00376
00377 if (interlacing_leftweight) {
00378 for (i = 0; i < numsamples; i++) {
00379 int32_t a, b;
00380
00381 a = buffer[0][i];
00382 b = buffer[1][i];
00383
00384 a -= (b * interlacing_leftweight) >> interlacing_shift;
00385 b += a;
00386
00387 buffer_out[i*numchannels] = b;
00388 buffer_out[i*numchannels + 1] = a;
00389 }
00390
00391 return;
00392 }
00393
00394
00395 for (i = 0; i < numsamples; i++) {
00396 int16_t left, right;
00397
00398 left = buffer[0][i];
00399 right = buffer[1][i];
00400
00401 buffer_out[i*numchannels] = left;
00402 buffer_out[i*numchannels + 1] = right;
00403 }
00404 }
00405
00406 static void decorrelate_stereo_24(int32_t *buffer[MAX_CHANNELS],
00407 int32_t *buffer_out,
00408 int32_t *wasted_bits_buffer[MAX_CHANNELS],
00409 int wasted_bits,
00410 int numchannels, int numsamples,
00411 uint8_t interlacing_shift,
00412 uint8_t interlacing_leftweight)
00413 {
00414 int i;
00415
00416 if (numsamples <= 0)
00417 return;
00418
00419
00420 if (interlacing_leftweight) {
00421 for (i = 0; i < numsamples; i++) {
00422 int32_t a, b;
00423
00424 a = buffer[0][i];
00425 b = buffer[1][i];
00426
00427 a -= (b * interlacing_leftweight) >> interlacing_shift;
00428 b += a;
00429
00430 if (wasted_bits) {
00431 b = (b << wasted_bits) | wasted_bits_buffer[0][i];
00432 a = (a << wasted_bits) | wasted_bits_buffer[1][i];
00433 }
00434
00435 buffer_out[i * numchannels] = b << 8;
00436 buffer_out[i * numchannels + 1] = a << 8;
00437 }
00438 } else {
00439 for (i = 0; i < numsamples; i++) {
00440 int32_t left, right;
00441
00442 left = buffer[0][i];
00443 right = buffer[1][i];
00444
00445 if (wasted_bits) {
00446 left = (left << wasted_bits) | wasted_bits_buffer[0][i];
00447 right = (right << wasted_bits) | wasted_bits_buffer[1][i];
00448 }
00449
00450 buffer_out[i * numchannels] = left << 8;
00451 buffer_out[i * numchannels + 1] = right << 8;
00452 }
00453 }
00454 }
00455
00456 static int alac_decode_frame(AVCodecContext *avctx,
00457 void *outbuffer, int *outputsize,
00458 AVPacket *avpkt)
00459 {
00460 const uint8_t *inbuffer = avpkt->data;
00461 int input_buffer_size = avpkt->size;
00462 ALACContext *alac = avctx->priv_data;
00463
00464 int channels;
00465 unsigned int outputsamples;
00466 int hassize;
00467 unsigned int readsamplesize;
00468 int isnotcompressed;
00469 uint8_t interlacing_shift;
00470 uint8_t interlacing_leftweight;
00471
00472
00473 if (!inbuffer || !input_buffer_size)
00474 return input_buffer_size;
00475
00476
00477 if (!alac->context_initialized) {
00478 if (alac->avctx->extradata_size != ALAC_EXTRADATA_SIZE) {
00479 av_log(avctx, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",
00480 ALAC_EXTRADATA_SIZE);
00481 return input_buffer_size;
00482 }
00483 if (alac_set_info(alac)) {
00484 av_log(avctx, AV_LOG_ERROR, "alac: set_info failed\n");
00485 return input_buffer_size;
00486 }
00487 alac->context_initialized = 1;
00488 }
00489
00490 init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);
00491
00492 channels = get_bits(&alac->gb, 3) + 1;
00493 if (channels > MAX_CHANNELS) {
00494 av_log(avctx, AV_LOG_ERROR, "channels > %d not supported\n",
00495 MAX_CHANNELS);
00496 return input_buffer_size;
00497 }
00498
00499
00500
00501
00502 skip_bits(&alac->gb, 4);
00503
00504 skip_bits(&alac->gb, 12);
00505
00506
00507 hassize = get_bits1(&alac->gb);
00508
00509 alac->wasted_bits = get_bits(&alac->gb, 2) << 3;
00510
00511
00512 isnotcompressed = get_bits1(&alac->gb);
00513
00514 if (hassize) {
00515
00516 outputsamples = get_bits_long(&alac->gb, 32);
00517 if(outputsamples > alac->setinfo_max_samples_per_frame){
00518 av_log(avctx, AV_LOG_ERROR, "outputsamples %d > %d\n", outputsamples, alac->setinfo_max_samples_per_frame);
00519 return -1;
00520 }
00521 } else
00522 outputsamples = alac->setinfo_max_samples_per_frame;
00523
00524 switch (alac->setinfo_sample_size) {
00525 case 16: avctx->sample_fmt = SAMPLE_FMT_S16;
00526 alac->bytespersample = channels << 1;
00527 break;
00528 case 24: avctx->sample_fmt = SAMPLE_FMT_S32;
00529 alac->bytespersample = channels << 2;
00530 break;
00531 default: av_log(avctx, AV_LOG_ERROR, "Sample depth %d is not supported.\n",
00532 alac->setinfo_sample_size);
00533 return -1;
00534 }
00535
00536 if(outputsamples > *outputsize / alac->bytespersample){
00537 av_log(avctx, AV_LOG_ERROR, "sample buffer too small\n");
00538 return -1;
00539 }
00540
00541 *outputsize = outputsamples * alac->bytespersample;
00542 readsamplesize = alac->setinfo_sample_size - (alac->wasted_bits) + channels - 1;
00543 if (readsamplesize > MIN_CACHE_BITS) {
00544 av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize);
00545 return -1;
00546 }
00547
00548 if (!isnotcompressed) {
00549
00550 int16_t predictor_coef_table[channels][32];
00551 int predictor_coef_num[channels];
00552 int prediction_type[channels];
00553 int prediction_quantitization[channels];
00554 int ricemodifier[channels];
00555 int i, chan;
00556
00557 interlacing_shift = get_bits(&alac->gb, 8);
00558 interlacing_leftweight = get_bits(&alac->gb, 8);
00559
00560 for (chan = 0; chan < channels; chan++) {
00561 prediction_type[chan] = get_bits(&alac->gb, 4);
00562 prediction_quantitization[chan] = get_bits(&alac->gb, 4);
00563
00564 ricemodifier[chan] = get_bits(&alac->gb, 3);
00565 predictor_coef_num[chan] = get_bits(&alac->gb, 5);
00566
00567
00568 for (i = 0; i < predictor_coef_num[chan]; i++)
00569 predictor_coef_table[chan][i] = (int16_t)get_bits(&alac->gb, 16);
00570 }
00571
00572 if (alac->wasted_bits) {
00573 int i, ch;
00574 for (i = 0; i < outputsamples; i++) {
00575 for (ch = 0; ch < channels; ch++)
00576 alac->wasted_bits_buffer[ch][i] = get_bits(&alac->gb, alac->wasted_bits);
00577 }
00578 }
00579 for (chan = 0; chan < channels; chan++) {
00580 bastardized_rice_decompress(alac,
00581 alac->predicterror_buffer[chan],
00582 outputsamples,
00583 readsamplesize,
00584 alac->setinfo_rice_initialhistory,
00585 alac->setinfo_rice_kmodifier,
00586 ricemodifier[chan] * alac->setinfo_rice_historymult / 4,
00587 (1 << alac->setinfo_rice_kmodifier) - 1);
00588
00589 if (prediction_type[chan] == 0) {
00590
00591 predictor_decompress_fir_adapt(alac->predicterror_buffer[chan],
00592 alac->outputsamples_buffer[chan],
00593 outputsamples,
00594 readsamplesize,
00595 predictor_coef_table[chan],
00596 predictor_coef_num[chan],
00597 prediction_quantitization[chan]);
00598 } else {
00599 av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type[chan]);
00600
00601
00602
00603
00604
00605
00606 }
00607 }
00608 } else {
00609
00610 int i, chan;
00611 if (alac->setinfo_sample_size <= 16) {
00612 for (i = 0; i < outputsamples; i++)
00613 for (chan = 0; chan < channels; chan++) {
00614 int32_t audiobits;
00615
00616 audiobits = get_sbits_long(&alac->gb, alac->setinfo_sample_size);
00617
00618 alac->outputsamples_buffer[chan][i] = audiobits;
00619 }
00620 } else {
00621 for (i = 0; i < outputsamples; i++) {
00622 for (chan = 0; chan < channels; chan++) {
00623 alac->outputsamples_buffer[chan][i] = get_bits(&alac->gb,
00624 alac->setinfo_sample_size);
00625 alac->outputsamples_buffer[chan][i] = sign_extend(alac->outputsamples_buffer[chan][i],
00626 alac->setinfo_sample_size);
00627 }
00628 }
00629 }
00630 alac->wasted_bits = 0;
00631 interlacing_shift = 0;
00632 interlacing_leftweight = 0;
00633 }
00634 if (get_bits(&alac->gb, 3) != 7)
00635 av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n");
00636
00637 switch(alac->setinfo_sample_size) {
00638 case 16:
00639 if (channels == 2) {
00640 reconstruct_stereo_16(alac->outputsamples_buffer,
00641 (int16_t*)outbuffer,
00642 alac->numchannels,
00643 outputsamples,
00644 interlacing_shift,
00645 interlacing_leftweight);
00646 } else {
00647 int i;
00648 for (i = 0; i < outputsamples; i++) {
00649 ((int16_t*)outbuffer)[i] = alac->outputsamples_buffer[0][i];
00650 }
00651 }
00652 break;
00653 case 24:
00654 if (channels == 2) {
00655 decorrelate_stereo_24(alac->outputsamples_buffer,
00656 outbuffer,
00657 alac->wasted_bits_buffer,
00658 alac->wasted_bits,
00659 alac->numchannels,
00660 outputsamples,
00661 interlacing_shift,
00662 interlacing_leftweight);
00663 } else {
00664 int i;
00665 for (i = 0; i < outputsamples; i++)
00666 ((int32_t *)outbuffer)[i] = alac->outputsamples_buffer[0][i] << 8;
00667 }
00668 break;
00669 }
00670
00671 if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8)
00672 av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb));
00673
00674 return input_buffer_size;
00675 }
00676
00677 static av_cold int alac_decode_init(AVCodecContext * avctx)
00678 {
00679 ALACContext *alac = avctx->priv_data;
00680 alac->avctx = avctx;
00681 alac->context_initialized = 0;
00682
00683 alac->numchannels = alac->avctx->channels;
00684
00685 return 0;
00686 }
00687
00688 static av_cold int alac_decode_close(AVCodecContext *avctx)
00689 {
00690 ALACContext *alac = avctx->priv_data;
00691
00692 int chan;
00693 for (chan = 0; chan < MAX_CHANNELS; chan++) {
00694 av_freep(&alac->predicterror_buffer[chan]);
00695 av_freep(&alac->outputsamples_buffer[chan]);
00696 av_freep(&alac->wasted_bits_buffer[chan]);
00697 }
00698
00699 return 0;
00700 }
00701
00702 AVCodec alac_decoder = {
00703 "alac",
00704 AVMEDIA_TYPE_AUDIO,
00705 CODEC_ID_ALAC,
00706 sizeof(ALACContext),
00707 alac_decode_init,
00708 NULL,
00709 alac_decode_close,
00710 alac_decode_frame,
00711 .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
00712 };