Mercurial > libavcodec.hg
comparison alac.c @ 11077:c5f2e2abb70e libavcodec
Add ALAC 24 bps decoding support.
author | jai_menon |
---|---|
date | Thu, 04 Feb 2010 16:21:26 +0000 |
parents | 0dce4fe6e6f3 |
children | 5380ea3dcba9 |
comparison
equal
deleted
inserted
replaced
11076:4a95670ed5f1 | 11077:c5f2e2abb70e |
---|---|
75 /* buffers */ | 75 /* buffers */ |
76 int32_t *predicterror_buffer[MAX_CHANNELS]; | 76 int32_t *predicterror_buffer[MAX_CHANNELS]; |
77 | 77 |
78 int32_t *outputsamples_buffer[MAX_CHANNELS]; | 78 int32_t *outputsamples_buffer[MAX_CHANNELS]; |
79 | 79 |
80 int32_t *wasted_bits_buffer[MAX_CHANNELS]; | |
81 | |
80 /* stuff from setinfo */ | 82 /* stuff from setinfo */ |
81 uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */ /* max samples per frame? */ | 83 uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */ /* max samples per frame? */ |
82 uint8_t setinfo_sample_size; /* 0x10 */ | 84 uint8_t setinfo_sample_size; /* 0x10 */ |
83 uint8_t setinfo_rice_historymult; /* 0x28 */ | 85 uint8_t setinfo_rice_historymult; /* 0x28 */ |
84 uint8_t setinfo_rice_initialhistory; /* 0x0a */ | 86 uint8_t setinfo_rice_initialhistory; /* 0x0a */ |
85 uint8_t setinfo_rice_kmodifier; /* 0x0e */ | 87 uint8_t setinfo_rice_kmodifier; /* 0x0e */ |
86 /* end setinfo stuff */ | 88 /* end setinfo stuff */ |
87 | 89 |
90 int wasted_bits; | |
88 } ALACContext; | 91 } ALACContext; |
89 | 92 |
90 static void allocate_buffers(ALACContext *alac) | 93 static void allocate_buffers(ALACContext *alac) |
91 { | 94 { |
92 int chan; | 95 int chan; |
94 alac->predicterror_buffer[chan] = | 97 alac->predicterror_buffer[chan] = |
95 av_malloc(alac->setinfo_max_samples_per_frame * 4); | 98 av_malloc(alac->setinfo_max_samples_per_frame * 4); |
96 | 99 |
97 alac->outputsamples_buffer[chan] = | 100 alac->outputsamples_buffer[chan] = |
98 av_malloc(alac->setinfo_max_samples_per_frame * 4); | 101 av_malloc(alac->setinfo_max_samples_per_frame * 4); |
102 | |
103 alac->wasted_bits_buffer[chan] = av_malloc(alac->setinfo_max_samples_per_frame * 4); | |
99 } | 104 } |
100 } | 105 } |
101 | 106 |
102 static int alac_set_info(ALACContext *alac) | 107 static int alac_set_info(ALACContext *alac) |
103 { | 108 { |
396 buffer_out[i*numchannels] = left; | 401 buffer_out[i*numchannels] = left; |
397 buffer_out[i*numchannels + 1] = right; | 402 buffer_out[i*numchannels + 1] = right; |
398 } | 403 } |
399 } | 404 } |
400 | 405 |
406 static void decorrelate_stereo_24(int32_t *buffer[MAX_CHANNELS], | |
407 int32_t *buffer_out, | |
408 int32_t *wasted_bits_buffer[MAX_CHANNELS], | |
409 int wasted_bits, | |
410 int numchannels, int numsamples, | |
411 uint8_t interlacing_shift, | |
412 uint8_t interlacing_leftweight) | |
413 { | |
414 int i; | |
415 | |
416 if (numsamples <= 0) | |
417 return; | |
418 | |
419 /* weighted interlacing */ | |
420 if (interlacing_leftweight) { | |
421 for (i = 0; i < numsamples; i++) { | |
422 int32_t a, b; | |
423 | |
424 a = buffer[0][i]; | |
425 b = buffer[1][i]; | |
426 | |
427 a -= (b * interlacing_leftweight) >> interlacing_shift; | |
428 b += a; | |
429 | |
430 if (wasted_bits) { | |
431 b = (b << wasted_bits) | wasted_bits_buffer[0][i]; | |
432 a = (a << wasted_bits) | wasted_bits_buffer[1][i]; | |
433 } | |
434 | |
435 buffer_out[i * numchannels] = b << 8; | |
436 buffer_out[i * numchannels + 1] = a << 8; | |
437 } | |
438 } else { | |
439 for (i = 0; i < numsamples; i++) { | |
440 int32_t left, right; | |
441 | |
442 left = buffer[0][i]; | |
443 right = buffer[1][i]; | |
444 | |
445 if (wasted_bits) { | |
446 left = (left << wasted_bits) | wasted_bits_buffer[0][i]; | |
447 right = (right << wasted_bits) | wasted_bits_buffer[1][i]; | |
448 } | |
449 | |
450 buffer_out[i * numchannels] = left << 8; | |
451 buffer_out[i * numchannels + 1] = right << 8; | |
452 } | |
453 } | |
454 } | |
455 | |
401 static int alac_decode_frame(AVCodecContext *avctx, | 456 static int alac_decode_frame(AVCodecContext *avctx, |
402 void *outbuffer, int *outputsize, | 457 void *outbuffer, int *outputsize, |
403 AVPacket *avpkt) | 458 AVPacket *avpkt) |
404 { | 459 { |
405 const uint8_t *inbuffer = avpkt->data; | 460 const uint8_t *inbuffer = avpkt->data; |
408 | 463 |
409 int channels; | 464 int channels; |
410 unsigned int outputsamples; | 465 unsigned int outputsamples; |
411 int hassize; | 466 int hassize; |
412 unsigned int readsamplesize; | 467 unsigned int readsamplesize; |
413 int wasted_bytes; | |
414 int isnotcompressed; | 468 int isnotcompressed; |
415 uint8_t interlacing_shift; | 469 uint8_t interlacing_shift; |
416 uint8_t interlacing_leftweight; | 470 uint8_t interlacing_leftweight; |
417 | 471 |
418 /* short-circuit null buffers */ | 472 /* short-circuit null buffers */ |
450 skip_bits(&alac->gb, 12); /* unknown, skip 12 bits */ | 504 skip_bits(&alac->gb, 12); /* unknown, skip 12 bits */ |
451 | 505 |
452 /* the output sample size is stored soon */ | 506 /* the output sample size is stored soon */ |
453 hassize = get_bits1(&alac->gb); | 507 hassize = get_bits1(&alac->gb); |
454 | 508 |
455 wasted_bytes = get_bits(&alac->gb, 2); /* unknown ? */ | 509 alac->wasted_bits = get_bits(&alac->gb, 2) << 3; |
456 | 510 |
457 /* whether the frame is compressed */ | 511 /* whether the frame is compressed */ |
458 isnotcompressed = get_bits1(&alac->gb); | 512 isnotcompressed = get_bits1(&alac->gb); |
459 | 513 |
460 if (hassize) { | 514 if (hassize) { |
465 return -1; | 519 return -1; |
466 } | 520 } |
467 } else | 521 } else |
468 outputsamples = alac->setinfo_max_samples_per_frame; | 522 outputsamples = alac->setinfo_max_samples_per_frame; |
469 | 523 |
524 switch (alac->setinfo_sample_size) { | |
525 case 16: avctx->sample_fmt = SAMPLE_FMT_S16; | |
526 alac->bytespersample = channels << 1; | |
527 break; | |
528 case 24: avctx->sample_fmt = SAMPLE_FMT_S32; | |
529 alac->bytespersample = channels << 2; | |
530 break; | |
531 default: av_log(avctx, AV_LOG_ERROR, "Sample depth %d is not supported.\n", | |
532 alac->setinfo_sample_size); | |
533 return -1; | |
534 } | |
535 | |
470 if(outputsamples > *outputsize / alac->bytespersample){ | 536 if(outputsamples > *outputsize / alac->bytespersample){ |
471 av_log(avctx, AV_LOG_ERROR, "sample buffer too small\n"); | 537 av_log(avctx, AV_LOG_ERROR, "sample buffer too small\n"); |
472 return -1; | 538 return -1; |
473 } | 539 } |
474 | 540 |
475 *outputsize = outputsamples * alac->bytespersample; | 541 *outputsize = outputsamples * alac->bytespersample; |
476 readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8) + channels - 1; | 542 readsamplesize = alac->setinfo_sample_size - (alac->wasted_bits) + channels - 1; |
477 if (readsamplesize > MIN_CACHE_BITS) { | 543 if (readsamplesize > MIN_CACHE_BITS) { |
478 av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize); | 544 av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize); |
479 return -1; | 545 return -1; |
480 } | 546 } |
481 | 547 |
501 /* read the predictor table */ | 567 /* read the predictor table */ |
502 for (i = 0; i < predictor_coef_num[chan]; i++) | 568 for (i = 0; i < predictor_coef_num[chan]; i++) |
503 predictor_coef_table[chan][i] = (int16_t)get_bits(&alac->gb, 16); | 569 predictor_coef_table[chan][i] = (int16_t)get_bits(&alac->gb, 16); |
504 } | 570 } |
505 | 571 |
506 if (wasted_bytes) | 572 if (alac->wasted_bits) { |
507 av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of wasted_bytes\n"); | 573 int i, ch; |
508 | 574 for (i = 0; i < outputsamples; i++) { |
575 for (ch = 0; ch < channels; ch++) | |
576 alac->wasted_bits_buffer[ch][i] = get_bits(&alac->gb, alac->wasted_bits); | |
577 } | |
578 } | |
509 for (chan = 0; chan < channels; chan++) { | 579 for (chan = 0; chan < channels; chan++) { |
510 bastardized_rice_decompress(alac, | 580 bastardized_rice_decompress(alac, |
511 alac->predicterror_buffer[chan], | 581 alac->predicterror_buffer[chan], |
512 outputsamples, | 582 outputsamples, |
513 readsamplesize, | 583 readsamplesize, |
536 } | 606 } |
537 } | 607 } |
538 } else { | 608 } else { |
539 /* not compressed, easy case */ | 609 /* not compressed, easy case */ |
540 int i, chan; | 610 int i, chan; |
611 if (alac->setinfo_sample_size <= 16) { | |
541 for (i = 0; i < outputsamples; i++) | 612 for (i = 0; i < outputsamples; i++) |
542 for (chan = 0; chan < channels; chan++) { | 613 for (chan = 0; chan < channels; chan++) { |
543 int32_t audiobits; | 614 int32_t audiobits; |
544 | 615 |
545 audiobits = get_sbits_long(&alac->gb, alac->setinfo_sample_size); | 616 audiobits = get_sbits_long(&alac->gb, alac->setinfo_sample_size); |
546 | 617 |
547 alac->outputsamples_buffer[chan][i] = audiobits; | 618 alac->outputsamples_buffer[chan][i] = audiobits; |
548 } | 619 } |
549 /* wasted_bytes = 0; */ | 620 } else { |
621 for (i = 0; i < outputsamples; i++) { | |
622 for (chan = 0; chan < channels; chan++) { | |
623 alac->outputsamples_buffer[chan][i] = get_bits(&alac->gb, | |
624 alac->setinfo_sample_size); | |
625 alac->outputsamples_buffer[chan][i] = sign_extend(alac->outputsamples_buffer[chan][i], | |
626 alac->setinfo_sample_size); | |
627 } | |
628 } | |
629 } | |
630 alac->wasted_bits = 0; | |
550 interlacing_shift = 0; | 631 interlacing_shift = 0; |
551 interlacing_leftweight = 0; | 632 interlacing_leftweight = 0; |
552 } | 633 } |
553 if (get_bits(&alac->gb, 3) != 7) | 634 if (get_bits(&alac->gb, 3) != 7) |
554 av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n"); | 635 av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n"); |
568 int16_t sample = alac->outputsamples_buffer[0][i]; | 649 int16_t sample = alac->outputsamples_buffer[0][i]; |
569 ((int16_t*)outbuffer)[i * alac->numchannels] = sample; | 650 ((int16_t*)outbuffer)[i * alac->numchannels] = sample; |
570 } | 651 } |
571 } | 652 } |
572 break; | 653 break; |
573 case 20: | |
574 case 24: | 654 case 24: |
575 // It is not clear if there exist any encoder that creates 24 bit ALAC | 655 if (channels == 2) { |
576 // files. iTunes convert 24 bit raw files to 16 bit before encoding. | 656 decorrelate_stereo_24(alac->outputsamples_buffer, |
577 case 32: | 657 outbuffer, |
578 av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size); | 658 alac->wasted_bits_buffer, |
579 break; | 659 alac->wasted_bits, |
580 default: | 660 alac->numchannels, |
661 outputsamples, | |
662 interlacing_shift, | |
663 interlacing_leftweight); | |
664 } else { | |
665 int i; | |
666 for (i = 0; i < outputsamples; i++) | |
667 ((int32_t *)outbuffer)[i] = alac->outputsamples_buffer[0][i] << 8; | |
668 } | |
581 break; | 669 break; |
582 } | 670 } |
583 | 671 |
584 if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8) | 672 if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8) |
585 av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb)); | 673 av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb)); |
592 ALACContext *alac = avctx->priv_data; | 680 ALACContext *alac = avctx->priv_data; |
593 alac->avctx = avctx; | 681 alac->avctx = avctx; |
594 alac->context_initialized = 0; | 682 alac->context_initialized = 0; |
595 | 683 |
596 alac->numchannels = alac->avctx->channels; | 684 alac->numchannels = alac->avctx->channels; |
597 alac->bytespersample = 2 * alac->numchannels; | |
598 avctx->sample_fmt = SAMPLE_FMT_S16; | |
599 | 685 |
600 return 0; | 686 return 0; |
601 } | 687 } |
602 | 688 |
603 static av_cold int alac_decode_close(AVCodecContext *avctx) | 689 static av_cold int alac_decode_close(AVCodecContext *avctx) |
606 | 692 |
607 int chan; | 693 int chan; |
608 for (chan = 0; chan < MAX_CHANNELS; chan++) { | 694 for (chan = 0; chan < MAX_CHANNELS; chan++) { |
609 av_free(alac->predicterror_buffer[chan]); | 695 av_free(alac->predicterror_buffer[chan]); |
610 av_free(alac->outputsamples_buffer[chan]); | 696 av_free(alac->outputsamples_buffer[chan]); |
697 av_freep(&alac->wasted_bits_buffer[chan]); | |
611 } | 698 } |
612 | 699 |
613 return 0; | 700 return 0; |
614 } | 701 } |
615 | 702 |