ac3_parse.c

vlc stand 0.1.99 ist sehr einfach

    DumpBits (&(p_ac3dec->bit_stream), 1);

    /* Get the original bit */
    NeedBits (&(p_ac3dec->bit_stream), 1);
    p_ac3dec->bsi.origbs = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
    DumpBits (&(p_ac3dec->bit_stream), 1);

    /* Does timecode one exist? */
    NeedBits (&(p_ac3dec->bit_stream), 1);
    p_ac3dec->bsi.timecod1e = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
    DumpBits (&(p_ac3dec->bit_stream), 1);

    if (p_ac3dec->bsi.timecod1e) {
        NeedBits (&(p_ac3dec->bit_stream), 14);
        p_ac3dec->bsi.timecod1 = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 14));
        DumpBits (&(p_ac3dec->bit_stream), 14);
    }

    /* Does timecode two exist? */
    NeedBits (&(p_ac3dec->bit_stream), 1);
    p_ac3dec->bsi.timecod2e = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
    DumpBits (&(p_ac3dec->bit_stream), 1);

    if (p_ac3dec->bsi.timecod2e) {
        NeedBits (&(p_ac3dec->bit_stream), 14);
        p_ac3dec->bsi.timecod2 = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 14));
        DumpBits (&(p_ac3dec->bit_stream), 14);
    }

    /* Does addition info exist? */
    NeedBits (&(p_ac3dec->bit_stream), 1);
    p_ac3dec->bsi.addbsie = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
    DumpBits (&(p_ac3dec->bit_stream), 1);

    if (p_ac3dec->bsi.addbsie) {
        /* Get how much info is there */
        NeedBits (&(p_ac3dec->bit_stream), 6);
        p_ac3dec->bsi.addbsil = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 6));
        DumpBits (&(p_ac3dec->bit_stream), 6);

        /* Get the additional info */
        for (i=0;i<(p_ac3dec->bsi.addbsil + 1);i++) {
            NeedBits (&(p_ac3dec->bit_stream), 8);
            p_ac3dec->bsi.addbsi[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 8));
            DumpBits (&(p_ac3dec->bit_stream), 8);
        }
    }

    return 0;
}

/* More pain inducing parsing */
int parse_audblk (ac3dec_t * p_ac3dec, int blknum)
{
    int i, j;

    for (i=0; i < p_ac3dec->bsi.nfchans; i++) {
        /* Is this channel an interleaved 256 + 256 block ? */
        NeedBits (&(p_ac3dec->bit_stream), 1);
        p_ac3dec->audblk.blksw[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
        DumpBits (&(p_ac3dec->bit_stream), 1);
    }

    for (i=0; i < p_ac3dec->bsi.nfchans; i++) {
        /* Should we dither this channel? */
        NeedBits (&(p_ac3dec->bit_stream), 1);
        p_ac3dec->audblk.dithflag[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
        DumpBits (&(p_ac3dec->bit_stream), 1);
    }

    /* Does dynamic range control exist? */
    NeedBits (&(p_ac3dec->bit_stream), 1);
    p_ac3dec->audblk.dynrnge = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
    DumpBits (&(p_ac3dec->bit_stream), 1);
    if (p_ac3dec->audblk.dynrnge) {
        /* Get dynamic range info */
        NeedBits (&(p_ac3dec->bit_stream), 8);
        p_ac3dec->audblk.dynrng = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 8));
        DumpBits (&(p_ac3dec->bit_stream), 8);
    }

    /* If we're in dual mono mode then get the second channel DR info */
    if (p_ac3dec->bsi.acmod == 0) {
        /* Does dynamic range control two exist? */
        NeedBits (&(p_ac3dec->bit_stream), 1);
        p_ac3dec->audblk.dynrng2e = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
        DumpBits (&(p_ac3dec->bit_stream), 1);
        if (p_ac3dec->audblk.dynrng2e) {
            /* Get dynamic range info */
            NeedBits (&(p_ac3dec->bit_stream), 8);
            p_ac3dec->audblk.dynrng2 = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 8));
            DumpBits (&(p_ac3dec->bit_stream), 8);
        }
    }

    /* Does coupling strategy exist? */
    NeedBits (&(p_ac3dec->bit_stream), 1);
    p_ac3dec->audblk.cplstre = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
    DumpBits (&(p_ac3dec->bit_stream), 1);

    if ((!blknum) && (!p_ac3dec->audblk.cplstre))
	return 1;

    if (p_ac3dec->audblk.cplstre) {
        /* Is coupling turned on? */
        NeedBits (&(p_ac3dec->bit_stream), 1);
        p_ac3dec->audblk.cplinu = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
        DumpBits (&(p_ac3dec->bit_stream), 1);
        if (p_ac3dec->audblk.cplinu) {
	    int nb_coupled_channels;

	    nb_coupled_channels = 0;
            for (i=0; i < p_ac3dec->bsi.nfchans; i++) {
                NeedBits (&(p_ac3dec->bit_stream), 1);
                p_ac3dec->audblk.chincpl[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
                DumpBits (&(p_ac3dec->bit_stream), 1);
		if (p_ac3dec->audblk.chincpl[i])
		    nb_coupled_channels++;
            }
	    if (nb_coupled_channels < 2)
		return 1;

            if (p_ac3dec->bsi.acmod == 0x2) {
                NeedBits (&(p_ac3dec->bit_stream), 1);
                p_ac3dec->audblk.phsflginu = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
                DumpBits (&(p_ac3dec->bit_stream), 1);
            }
            NeedBits (&(p_ac3dec->bit_stream), 4);
            p_ac3dec->audblk.cplbegf = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 4));
            DumpBits (&(p_ac3dec->bit_stream), 4);
            NeedBits (&(p_ac3dec->bit_stream), 4);
            p_ac3dec->audblk.cplendf = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 4));
            DumpBits (&(p_ac3dec->bit_stream), 4);

	    if (p_ac3dec->audblk.cplbegf > p_ac3dec->audblk.cplendf + 2)
		return 1;

            p_ac3dec->audblk.ncplsubnd = (p_ac3dec->audblk.cplendf + 2) - p_ac3dec->audblk.cplbegf + 1;

            /* Calculate the start and end bins of the coupling channel */
            p_ac3dec->audblk.cplstrtmant = (p_ac3dec->audblk.cplbegf * 12) + 37 ;
            p_ac3dec->audblk.cplendmant = ((p_ac3dec->audblk.cplendf + 3) * 12) + 37;

            /* The number of combined subbands is ncplsubnd minus each combined
             * band */
            p_ac3dec->audblk.ncplbnd = p_ac3dec->audblk.ncplsubnd;

            for (i=1; i< p_ac3dec->audblk.ncplsubnd; i++) {
                NeedBits (&(p_ac3dec->bit_stream), 1);
                p_ac3dec->audblk.cplbndstrc[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
                DumpBits (&(p_ac3dec->bit_stream), 1);
                p_ac3dec->audblk.ncplbnd -= p_ac3dec->audblk.cplbndstrc[i];
            }
        }
    }

    if (p_ac3dec->audblk.cplinu) {
        /* Loop through all the channels and get their coupling co-ords */
        for (i=0; i < p_ac3dec->bsi.nfchans;i++) {
            if (!p_ac3dec->audblk.chincpl[i])
                continue;

            /* Is there new coupling co-ordinate info? */
            NeedBits (&(p_ac3dec->bit_stream), 1);
            p_ac3dec->audblk.cplcoe[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
            DumpBits (&(p_ac3dec->bit_stream), 1);

	    if ((!blknum) && (!p_ac3dec->audblk.cplcoe[i]))
		return 1;

            if (p_ac3dec->audblk.cplcoe[i]) {
                NeedBits (&(p_ac3dec->bit_stream), 2);
                p_ac3dec->audblk.mstrcplco[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 2));
                DumpBits (&(p_ac3dec->bit_stream), 2);
                for (j=0;j < p_ac3dec->audblk.ncplbnd; j++) {
                    NeedBits (&(p_ac3dec->bit_stream), 4);
                    p_ac3dec->audblk.cplcoexp[i][j] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 4));
                    DumpBits (&(p_ac3dec->bit_stream), 4);
                    NeedBits (&(p_ac3dec->bit_stream), 4);
                    p_ac3dec->audblk.cplcomant[i][j] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 4));
                    DumpBits (&(p_ac3dec->bit_stream), 4);
                }
            }
        }

        /* If we're in dual mono mode, there's going to be some phase info */
        if ((p_ac3dec->bsi.acmod == 0x2) && p_ac3dec->audblk.phsflginu &&
	   (p_ac3dec->audblk.cplcoe[0] || p_ac3dec->audblk.cplcoe[1])) {
            for (j=0; j < p_ac3dec->audblk.ncplbnd; j++) {
                NeedBits (&(p_ac3dec->bit_stream), 1);
                p_ac3dec->audblk.phsflg[j] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
                DumpBits (&(p_ac3dec->bit_stream), 1);
            }

        }
    }

    /* If we're in dual mono mode, there may be a rematrix strategy */
    if (p_ac3dec->bsi.acmod == 0x2) {
        NeedBits (&(p_ac3dec->bit_stream), 1);
        p_ac3dec->audblk.rematstr = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
        DumpBits (&(p_ac3dec->bit_stream), 1);

	if ((!blknum) && (!p_ac3dec->audblk.rematstr))
	    return 1;

        if (p_ac3dec->audblk.rematstr) {
            if (p_ac3dec->audblk.cplinu == 0) {
                for (i = 0; i < 4; i++) {
                    NeedBits (&(p_ac3dec->bit_stream), 1);
                    p_ac3dec->audblk.rematflg[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
                    DumpBits (&(p_ac3dec->bit_stream), 1);
                }
            }
            if ((p_ac3dec->audblk.cplbegf > 2) && p_ac3dec->audblk.cplinu) {
                for (i = 0; i < 4; i++) {
                    NeedBits (&(p_ac3dec->bit_stream), 1);
                    p_ac3dec->audblk.rematflg[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
                    DumpBits (&(p_ac3dec->bit_stream), 1);
                }
            }
            if ((p_ac3dec->audblk.cplbegf <= 2) && p_ac3dec->audblk.cplinu) {
                for (i = 0; i < 3; i++) {
                    NeedBits (&(p_ac3dec->bit_stream), 1);
                    p_ac3dec->audblk.rematflg[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
                    DumpBits (&(p_ac3dec->bit_stream), 1);
                }
            }
            if ((p_ac3dec->audblk.cplbegf == 0) && p_ac3dec->audblk.cplinu)
                for (i = 0; i < 2; i++) {
                    NeedBits (&(p_ac3dec->bit_stream), 1);
                    p_ac3dec->audblk.rematflg[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
                    DumpBits (&(p_ac3dec->bit_stream), 1);
                }
        }
    }

    if (p_ac3dec->audblk.cplinu)
    {
        /* Get the coupling channel exponent strategy */
        NeedBits (&(p_ac3dec->bit_stream), 2);
        p_ac3dec->audblk.cplexpstr = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 2));
        DumpBits (&(p_ac3dec->bit_stream), 2);

	if ((!blknum) && (p_ac3dec->audblk.cplexpstr == EXP_REUSE))
	    return 1;

        if (p_ac3dec->audblk.cplexpstr==0)
            p_ac3dec->audblk.ncplgrps = 0;
        else
            p_ac3dec->audblk.ncplgrps = (p_ac3dec->audblk.cplendmant - p_ac3dec->audblk.cplstrtmant) /
		(3 << (p_ac3dec->audblk.cplexpstr-1));

    }

    for (i = 0; i < p_ac3dec->bsi.nfchans; i++) {
        NeedBits (&(p_ac3dec->bit_stream), 2);
        p_ac3dec->audblk.chexpstr[i] = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 2));
        DumpBits (&(p_ac3dec->bit_stream), 2);

	if ((!blknum) && (p_ac3dec->audblk.chexpstr[i] == EXP_REUSE))
	    return 1;
    }

    /* Get the exponent strategy for lfe channel */
    if (p_ac3dec->bsi.lfeon) {
        NeedBits (&(p_ac3dec->bit_stream), 1);
        p_ac3dec->audblk.lfeexpstr = (u16)(p_ac3dec->bit_stream.buffer >> (32 - 1));
        DumpBits (&(p_ac3dec->bit_stream), 1);