Mercurial > libavcodec.hg

comparison ac3dec.c @ 5335:8ecef197b08e libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
use shared ac3 bit allocation function
author jbr
date Sun, 15 Jul 2007 13:53:42 +0000
parents d406baea3275
children cc3f5a28aa2a
comparison
equal deleted inserted replaced
5334:d406baea3275 5335:8ecef197b08e
159 int ncplbnd; //number of coupling bands 159 int ncplbnd; //number of coupling bands
160 int ncplsubnd; //number of coupling sub bands 160 int ncplsubnd; //number of coupling sub bands
161 int cplstrtmant; //coupling start mantissa 161 int cplstrtmant; //coupling start mantissa
162 int cplendmant; //coupling end mantissa 162 int cplendmant; //coupling end mantissa
163 int endmant[5]; //channel end mantissas 163 int endmant[5]; //channel end mantissas
164 AC3BitAllocParameters bit_alloc_params; ///< bit allocation parameters
164 165
165 uint8_t dcplexps[256]; //decoded coupling exponents 166 uint8_t dcplexps[256]; //decoded coupling exponents
166 uint8_t dexps[5][256]; //decoded fbw channel exponents 167 uint8_t dexps[5][256]; //decoded fbw channel exponents
167 uint8_t dlfeexps[256]; //decoded lfe channel exponents 168 uint8_t dlfeexps[256]; //decoded lfe channel exponents
168 uint8_t cplbap[256]; //coupling bit allocation pointers 169 uint8_t cplbap[256]; //coupling bit allocation pointers
547 } 548 }
548 549
549 return 0; 550 return 0;
550 } 551 }
551 552
552 /*********** HELPER FUNCTIONS FOR BIT ALLOCATION ***********/
553 static inline int logadd(int a, int b)
554 {
555 int c = a - b;
556 int address;
557
558 address = FFMIN((FFABS(c) >> 1), 255);
559
560 if (c >= 0)
561 return (a + ff_ac3_latab[address]);
562 else
563 return (b + ff_ac3_latab[address]);
564 }
565
566 static inline int calc_lowcomp(int a, int b0, int b1, int bin)
567 {
568 if (bin < 7) {
569 if ((b0 + 256) == b1)
570 a = 384;
571 else if (b0 > b1)
572 a = FFMAX(0, (a - 64));
573 }
574 else if (bin < 20) {
575 if ((b0 + 256) == b1)
576 a = 320;
577 else if (b0 > b1)
578 a = FFMAX(0, (a - 64));
579 }
580 else
581 a = FFMAX(0, (a - 128));
582
583 return a;
584 }
585 /*********** END HELPER FUNCTIONS FOR BIT ALLOCATION ***********/
586
587 /* Performs bit allocation. 553 /* Performs bit allocation.
588 * This function performs bit allocation for the requested chanenl. 554 * This function performs bit allocation for the requested chanenl.
589 */ 555 */
590 static void do_bit_allocation(AC3DecodeContext *ctx, int chnl) 556 static void do_bit_allocation(AC3DecodeContext *ctx, int chnl)
591 { 557 {
592 int16_t psd[256], bndpsd[50], excite[50], mask[50], delta; 558 int fgain, snroffset;
593 int sdecay, fdecay, sgain, dbknee, floor;
594 int lowcomp = 0, fgain = 0, snroffset = 0, fastleak = 0, slowleak = 0, do_delta = 0;
595 int start = 0, end = 0, bin = 0, i = 0, j = 0, k = 0, lastbin = 0, bndstrt = 0;
596 int bndend = 0, begin = 0, deltnseg = 0, band = 0, seg = 0, address = 0;
597 int fscod = ctx->fscod;
598 uint8_t *deltoffst = 0, *deltlen = 0, *deltba = 0;
599 uint8_t *exps = 0, *bap = 0;
600
601 /* initialization */
602 sdecay = ff_sdecaytab[ctx->sdcycod];
603 fdecay = ff_fdecaytab[ctx->fdcycod];
604 sgain = ff_sgaintab[ctx->sgaincod];
605 dbknee = ff_dbkneetab[ctx->dbpbcod];
606 floor = ff_floortab[ctx->floorcod];
607 559
608 if (chnl == 5) { 560 if (chnl == 5) {
609 start = ctx->cplstrtmant;
610 end = ctx->cplendmant;
611 fgain = ff_fgaintab[ctx->cplfgaincod]; 561 fgain = ff_fgaintab[ctx->cplfgaincod];
612 snroffset = (((ctx->csnroffst - 15) << 4) + ctx->cplfsnroffst) << 2; 562 snroffset = (((ctx->csnroffst - 15) << 4) + ctx->cplfsnroffst) << 2;
613 fastleak = (ctx->cplfleak << 8) + 768; 563 ac3_parametric_bit_allocation(&ctx->bit_alloc_params, ctx->cplbap,
614 slowleak = (ctx->cplsleak << 8) + 768; 564 ctx->dcplexps, ctx->cplstrtmant,
615 exps = ctx->dcplexps; 565 ctx->cplendmant, snroffset, fgain, 0,
616 bap = ctx->cplbap; 566 ctx->cpldeltbae, ctx->cpldeltnseg,
617 if (ctx->cpldeltbae == DBA_NEW || ctx->deltbae == DBA_REUSE) { 567 ctx->cpldeltoffst, ctx->cpldeltlen,
618 do_delta = 1; 568 ctx->cpldeltba);
619 deltnseg = ctx->cpldeltnseg;
620 deltoffst = ctx->cpldeltoffst;
621 deltlen = ctx->cpldeltlen;
622 deltba = ctx->cpldeltba;
623 }
624 } 569 }
625 else if (chnl == 6) { 570 else if (chnl == 6) {
626 start = 0;
627 end = 7;
628 lowcomp = 0;
629 fastleak = 0;
630 slowleak = 0;
631 fgain = ff_fgaintab[ctx->lfefgaincod]; 571 fgain = ff_fgaintab[ctx->lfefgaincod];
632 snroffset = (((ctx->csnroffst - 15) << 4) + ctx->lfefsnroffst) << 2; 572 snroffset = (((ctx->csnroffst - 15) << 4) + ctx->lfefsnroffst) << 2;
633 exps = ctx->dlfeexps; 573 ac3_parametric_bit_allocation(&ctx->bit_alloc_params, ctx->lfebap,
634 bap = ctx->lfebap; 574 ctx->dlfeexps, 0, 7, snroffset, fgain, 1,
575 DBA_NONE, 0, NULL, NULL, NULL);
635 } 576 }
636 else { 577 else {
637 start = 0;
638 end = ctx->endmant[chnl];
639 lowcomp = 0;
640 fastleak = 0;
641 slowleak = 0;
642 fgain = ff_fgaintab[ctx->fgaincod[chnl]]; 578 fgain = ff_fgaintab[ctx->fgaincod[chnl]];
643 snroffset = (((ctx->csnroffst - 15) << 4) + ctx->fsnroffst[chnl]) << 2; 579 snroffset = (((ctx->csnroffst - 15) << 4) + ctx->fsnroffst[chnl]) << 2;
644 exps = ctx->dexps[chnl]; 580 ac3_parametric_bit_allocation(&ctx->bit_alloc_params, ctx->bap[chnl],
645 bap = ctx->bap[chnl]; 581 ctx->dexps[chnl], 0, ctx->endmant[chnl],
646 if (ctx->deltbae[chnl] == DBA_NEW || ctx->deltbae[chnl] == DBA_REUSE) { 582 snroffset, fgain, 0, ctx->deltbae[chnl],
647 do_delta = 1; 583 ctx->deltnseg[chnl], ctx->deltoffst[chnl],
648 deltnseg = ctx->deltnseg[chnl]; 584 ctx->deltlen[chnl], ctx->deltba[chnl]);
649 deltoffst = ctx->deltoffst[chnl]; 585 }
650 deltlen = ctx->deltlen[chnl];
651 deltba = ctx->deltba[chnl];
652 }
653 }
654
655 for (bin = start; bin < end; bin++) /* exponent mapping into psd */
656 psd[bin] = psdtab[exps[bin]];
657
658 /* psd integration */
659 j = start;
660 k = masktab[start];
661 do {
662 lastbin = FFMIN((bndtab[k] + ff_ac3_bndsz[k]), end);
663 bndpsd[k] = psd[j];
664 j++;
665 for (i = j; i < lastbin; i++) {
666 bndpsd[k] = logadd(bndpsd[k], psd[j]);
667 j++;
668 }
669 k++;
670 } while (end > lastbin);
671
672 /* compute the excite function */
673 bndstrt = masktab[start];
674 bndend = masktab[end - 1] + 1;
675 if (bndstrt == 0) {
676 lowcomp = calc_lowcomp(lowcomp, bndpsd[0], bndpsd[1], 0);
677 excite[0] = bndpsd[0] - fgain - lowcomp;
678 lowcomp = calc_lowcomp(lowcomp, bndpsd[1], bndpsd[2], 1);
679 excite[1] = bndpsd[1] - fgain - lowcomp;
680 begin = 7;
681 for (bin = 2; bin < 7; bin++) {
682 if ((bndend != 7) || (bin != 6))
683 lowcomp = calc_lowcomp(lowcomp, bndpsd[bin], bndpsd[bin + 1], bin);
684 fastleak = bndpsd[bin] - fgain;
685 slowleak = bndpsd[bin] - sgain;
686 excite[bin] = fastleak - lowcomp;
687 if ((bndend != 7) || (bin != 6))
688 if (bndpsd[bin] <= bndpsd[bin + 1]) {
689 begin = bin + 1;
690 break;
691 }
692 }
693 for (bin = begin; bin < FFMIN(bndend, 22); bin++) {
694 if ((bndend != 7) || (bin != 6))
695 lowcomp = calc_lowcomp(lowcomp, bndpsd[bin], bndpsd[bin + 1], bin);
696 fastleak -= fdecay;
697 fastleak = FFMAX(fastleak, (bndpsd[bin] - fgain));
698 slowleak -= sdecay;
699 slowleak = FFMAX(slowleak, (bndpsd[bin] - sgain));
700 excite[bin] = FFMAX((fastleak - lowcomp), slowleak);
701 }
702 begin = 22;
703 }
704 else {
705 begin = bndstrt;
706 }
707 for (bin = begin; bin < bndend; bin++) {
708 fastleak -= fdecay;
709 fastleak = FFMAX(fastleak, (bndpsd[bin] - fgain));
710 slowleak -= sdecay;
711 slowleak = FFMAX(slowleak, (bndpsd[bin] - sgain));
712 excite[bin] = FFMAX(fastleak, slowleak);
713 }
714
715 /* compute the masking curve */
716 for (bin = bndstrt; bin < bndend; bin++) {
717 if (bndpsd[bin] < dbknee)
718 excite[bin] += ((dbknee - bndpsd[bin]) >> 2);
719 mask[bin] = FFMAX(excite[bin], ff_ac3_hth[bin][fscod]);
720 }
721
722 /* apply the delta bit allocation */
723 if (do_delta) {
724 band = 0;
725 for (seg = 0; seg < deltnseg + 1; seg++) {
726 band += deltoffst[seg];
727 if (deltba[seg] >= 4)
728 delta = (deltba[seg] - 3) << 7;
729 else
730 delta = (deltba[seg] - 4) << 7;
731 for (k = 0; k < deltlen[seg]; k++) {
732 mask[band] += delta;
733 band++;
734 }
735 }
736 }
737
738 /*compute the bit allocation */
739 i = start;
740 j = masktab[start];
741 do {
742 lastbin = FFMIN((bndtab[j] + ff_ac3_bndsz[j]), end);
743 mask[j] -= snroffset;
744 mask[j] -= floor;
745 if (mask[j] < 0)
746 mask[j] = 0;
747 mask[j] &= 0x1fe0;
748 mask[j] += floor;
749 for (k = i; k < lastbin; k++) {
750 address = (psd[i] - mask[j]) >> 5;
751 address = FFMIN(63, (FFMAX(0, address)));
752 bap[i] = ff_ac3_baptab[address];
753 i++;
754 }
755 j++;
756 } while (end > lastbin);
757 } 586 }
758 587
759 /* Check if snroffsets are zero. */ 588 /* Check if snroffsets are zero. */
760 static int is_snr_offsets_zero(AC3DecodeContext *ctx) 589 static int is_snr_offsets_zero(AC3DecodeContext *ctx)
761 { 590 {
1854 memset(ctx->cplbap, 0, sizeof (ctx->cplbap)); 1683 memset(ctx->cplbap, 0, sizeof (ctx->cplbap));
1855 memset(ctx->lfebap, 0, sizeof (ctx->lfebap)); 1684 memset(ctx->lfebap, 0, sizeof (ctx->lfebap));
1856 for (i = 0; i < nfchans; i++) 1685 for (i = 0; i < nfchans; i++)
1857 memset(ctx->bap[i], 0, sizeof(ctx->bap[i])); 1686 memset(ctx->bap[i], 0, sizeof(ctx->bap[i]));
1858 } else { 1687 } else {
1688 /* set bit allocation parameters */
1689 ctx->bit_alloc_params.fscod = ctx->fscod;
1690 ctx->bit_alloc_params.halfratecod = 0;
1691 ctx->bit_alloc_params.sdecay = ff_sdecaytab[ctx->sdcycod];
1692 ctx->bit_alloc_params.fdecay = ff_fdecaytab[ctx->fdcycod];
1693 ctx->bit_alloc_params.sgain = ff_sgaintab[ctx->sgaincod];
1694 ctx->bit_alloc_params.dbknee = ff_dbkneetab[ctx->dbpbcod];
1695 ctx->bit_alloc_params.floor = ff_floortab[ctx->floorcod];
1696 ctx->bit_alloc_params.cplfleak = ctx->cplfleak;
1697 ctx->bit_alloc_params.cplsleak = ctx->cplsleak;
1698
1859 if (ctx->chincpl && (bit_alloc_flags & 64)) 1699 if (ctx->chincpl && (bit_alloc_flags & 64))
1860 do_bit_allocation(ctx, 5); 1700 do_bit_allocation(ctx, 5);
1861 for (i = 0; i < nfchans; i++) 1701 for (i = 0; i < nfchans; i++)
1862 if ((bit_alloc_flags >> i) & 1) 1702 if ((bit_alloc_flags >> i) & 1)
1863 do_bit_allocation(ctx, i); 1703 do_bit_allocation(ctx, i);