ac3_bit_allocate.c

vlc stand 0.1.99 ist sehr einfach

        return;
    }

    for (i = 0; i < p_ac3dec->bsi.nfchans; i++) {
        start = 0;
        end = p_ac3dec->audblk.endmant[i] ;
        fgain = fastgain[p_ac3dec->audblk.fgaincod[i]];
        snroffset = (((p_ac3dec->audblk.csnroffst - 15) << 4) + p_ac3dec->audblk.fsnroffst[i]) << 2 ;
        fastleak = 0;
        slowleak = 0;

        ba_compute_psd (start, end, p_ac3dec->audblk.fbw_exp[i], psd, bndpsd);

        ba_compute_excitation (start, end , fgain, fastleak, slowleak, 0,
                               bndpsd, excite);

        ba_compute_mask (start, end, p_ac3dec->syncinfo.fscod,
                         p_ac3dec->audblk.deltbae[i],
                         p_ac3dec->audblk.deltnseg[i],
                         p_ac3dec->audblk.deltoffst[i],
                         p_ac3dec->audblk.deltba[i],
                         p_ac3dec->audblk.deltlen[i], excite, mask);

        ba_compute_bap (start, end, snroffset, psd, mask,
                        p_ac3dec->audblk.fbw_bap[i]);
    }

    if (p_ac3dec->audblk.cplinu) {
        start = p_ac3dec->audblk.cplstrtmant;
        end = p_ac3dec->audblk.cplendmant;
        fgain = fastgain[p_ac3dec->audblk.cplfgaincod];
        snroffset = (((p_ac3dec->audblk.csnroffst - 15) << 4) + p_ac3dec->audblk.cplfsnroffst) << 2 ;
        fastleak = (p_ac3dec->audblk.cplfleak << 8) + 768;
        slowleak = (p_ac3dec->audblk.cplsleak << 8) + 768;

        ba_compute_psd (start, end, p_ac3dec->audblk.cpl_exp, psd, bndpsd);

        ba_compute_excitation (start, end , fgain, fastleak, slowleak, 0,
                               bndpsd, excite);

        ba_compute_mask (start, end, p_ac3dec->syncinfo.fscod,
                         p_ac3dec->audblk.cpldeltbae,
                         p_ac3dec->audblk.cpldeltnseg,
                         p_ac3dec->audblk.cpldeltoffst,
                         p_ac3dec->audblk.cpldeltba,
                         p_ac3dec->audblk.cpldeltlen, excite, mask);

        ba_compute_bap (start, end, snroffset, psd, mask,
                        p_ac3dec->audblk.cpl_bap);
    }

    if (p_ac3dec->bsi.lfeon) {
        start = 0;
        end = 7;
        fgain = fastgain[p_ac3dec->audblk.lfefgaincod];
        snroffset = (((p_ac3dec->audblk.csnroffst - 15) << 4) + p_ac3dec->audblk.lfefsnroffst) << 2 ;
        fastleak = 0;
        slowleak = 0;

        ba_compute_psd (start, end, p_ac3dec->audblk.lfe_exp, psd, bndpsd);

        ba_compute_excitation (start, end , fgain, fastleak, slowleak, 1,
                               bndpsd, excite);

        ba_compute_mask (start, end, p_ac3dec->syncinfo.fscod, 2, 0, 0, 0, 0,
                         excite, mask);

        ba_compute_bap (start, end, snroffset, psd, mask,
                        p_ac3dec->audblk.lfe_bap);
    }
}


static void ba_compute_psd (s16 start, s16 end, s16 exps[], s16 psd[],
                            s16 bndpsd[])
{
    int bin,i,j,k;
    s16 lastbin = 0;

    /* Map the exponents into dBs */
    for (bin=start; bin<end; bin++) {
        psd[bin] = (3072 - (exps[bin] << 7));
    }

    /* Integrate the psd function over each bit allocation band */
    j = start;
    k = masktab[start];

    do {
        lastbin = min(bndtab[k] + bndsz[k], end);
        bndpsd[k] = psd[j];
        j++;

        for (i = j; i < lastbin; i++) {
            bndpsd[k] = logadd(bndpsd[k], psd[j]);
            j++;
        }

        k++;
    } while (end > lastbin);
}

static void ba_compute_excitation (s16 start, s16 end,s16 fgain, s16 fastleak,
                                   s16 slowleak, s16 is_lfe, s16 bndpsd[],
                                   s16 excite[])
{
    int bin;
    s16 bndstrt;
    s16 bndend;
    s16 lowcomp = 0;
    s16 begin = 0;

    /* Compute excitation function */
    bndstrt = masktab[start];
    bndend = masktab[end - 1] + 1;

    if (bndstrt == 0) { /* For fbw and lfe channels */
        lowcomp = calc_lowcomp(lowcomp, bndpsd[0], bndpsd[1], 0);
        excite[0] = bndpsd[0] - fgain - lowcomp;
        lowcomp = calc_lowcomp(lowcomp, bndpsd[1], bndpsd[2], 1);
        excite[1] = bndpsd[1] - fgain - lowcomp;
        begin = 7 ;

        /* Note: Do not call calc_lowcomp() for the last band of the lfe channel, (bin = 6) */
        for (bin = 2; bin < 7; bin++) {
            if (!(is_lfe && (bin == 6)))
                lowcomp = calc_lowcomp (lowcomp, bndpsd[bin], bndpsd[bin+1], bin);
            fastleak = bndpsd[bin] - fgain;
            slowleak = bndpsd[bin] - sgain;
            excite[bin] = fastleak - lowcomp;

            if (!(is_lfe && (bin == 6))) {
                if (bndpsd[bin] <= bndpsd[bin+1]) {
                    begin = bin + 1 ;
                    break;
                }
            }
        }

        for (bin = begin; bin < min(bndend, 22); bin++) {
            if (!(is_lfe && (bin == 6)))
                lowcomp = calc_lowcomp (lowcomp, bndpsd[bin], bndpsd[bin+1], bin);
            fastleak -= fdecay ;
            fastleak = max(fastleak, bndpsd[bin] - fgain);
            slowleak -= sdecay ;
            slowleak = max(slowleak, bndpsd[bin] - sgain);
            excite[bin] = max(fastleak - lowcomp, slowleak);
        }
        begin = 22;
    } else { /* For coupling channel */
        begin = bndstrt;
    }

    for (bin = begin; bin < bndend; bin++) {
        fastleak -= fdecay;
        fastleak = max(fastleak, bndpsd[bin] - fgain);
        slowleak -= sdecay;
        slowleak = max(slowleak, bndpsd[bin] - sgain);
        excite[bin] = max(fastleak, slowleak) ;
    }
}

static void ba_compute_mask (s16 start, s16 end, u16 fscod, u16 deltbae,
                             u16 deltnseg, u16 deltoffst[], u16 deltba[],
                             u16 deltlen[], s16 excite[], s16 mask[])
{
    int bin,k;
    s16 bndstrt;
    s16 bndend;
    s16 delta;

    bndstrt = masktab[start];
    bndend = masktab[end - 1] + 1;

    /* Compute the masking curve */
    for (bin = bndstrt; bin < bndend; bin++) {
        if (bndpsd[bin] < dbknee) {
            excite[bin] += ((dbknee - bndpsd[bin]) >> 2);
        }
        mask[bin] = max(excite[bin], hth[fscod][bin]);
    }

    /* Perform delta bit modulation if necessary */
    if ((deltbae == DELTA_BIT_REUSE) || (deltbae == DELTA_BIT_NEW)) {
        s16 band = 0;
        s16 seg = 0;

        for (seg = 0; seg < deltnseg+1; seg++) {
            band += deltoffst[seg];
            if (deltba[seg] >= 4) {
                delta = (deltba[seg] - 3) << 7;
            } else {
                delta = (deltba[seg] - 4) << 7;
            }
            for (k = 0; k < deltlen[seg]; k++) {
                mask[band] += delta;
                band++;
            }
        }
    }
}

static void ba_compute_bap (s16 start, s16 end, s16 snroffset, s16 psd[],
                            s16 mask[], s16 bap[])
{
    int i,j,k;
    s16 lastbin = 0;
    s16 address = 0;

    /* Compute the bit allocation pointer for each bin */
    i = start;
    j = masktab[start];

    do {
        lastbin = min(bndtab[j] + bndsz[j], end);
        mask[j] -= snroffset;
        mask[j] -= floor;

        if (mask[j] < 0)
            mask[j] = 0;

        mask[j] &= 0x1fe0;
        mask[j] += floor;
        for (k = i; k < lastbin; k++) {
            address = (psd[i] - mask[j]) >> 5;
            address = min(63, max(0, address));
            bap[i] = baptab[address];
            i++;
        }
        j++;
    } while (end > lastbin);
}