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