PeerStreamer

OBJS-$(CONFIG_VP6_DECODER)             += vp6.o vp56.o vp56data.o vp3dsp.o huffman.o

OBJS-$(CONFIG_VP6A_DECODER)            += vp6.o vp56.o vp56data.o vp3dsp.o huffman.o

OBJS-$(CONFIG_VP6F_DECODER)            += vp6.o vp56.o vp56data.o vp3dsp.o huffman.o

                        coeff = vp56_coeff_bias[idx+5];

    /* huffman decoding */

    int use_huffman;

    GetBitContext gb;

    VLC dccv_vlc[2];

    VLC runv_vlc[2];

    VLC ract_vlc[2][3][6];

    unsigned int nb_null[2][2];       /* number of consecutive NULL DC/AC */

const uint8_t vp56_coeff_bias[] = { 0, 1, 2, 3, 4, 5, 7, 11, 19, 35, 67 };

#include "huffman.h"

static void vp6_parse_coeff(vp56_context_t *s);

static void vp6_parse_coeff_huffman(vp56_context_t *s);

    s->use_huffman = vp56_rac_get(c);

    s->parse_coeff = vp6_parse_coeff;

        buf      += coeff_offset;

        buf_size -= coeff_offset;

        if (s->use_huffman) {

            s->parse_coeff = vp6_parse_coeff_huffman;

            init_get_bits(&s->gb, buf, buf_size);

        } else {

            vp56_init_range_decoder(&s->cc, buf, buf_size);

            s->ccp = &s->cc;

        }

static int vp6_huff_cmp(const void *va, const void *vb)

{

    const Node *a = va, *b = vb;

    return a->count >= b->count;

}

static void vp6_build_huff_tree(vp56_context_t *s, uint8_t coeff_model[],

                                const uint8_t *map, unsigned size, VLC *vlc)

{

    Node nodes[2*size], *tmp = &nodes[size];

    int a, b, i;

    /* first compute probabilities from model */

    tmp[0].count = 256;

    for (i=0; i<size-1; i++) {

        a = tmp[i].count *        coeff_model[i]  >> 8;

        b = tmp[i].count * (255 - coeff_model[i]) >> 8;

        nodes[map[2*i  ]].count = a + !a;

        nodes[map[2*i+1]].count = b + !b;

    }

    /* then build the huffman tree accodring to probabilities */

    ff_huff_build_tree(s->avctx, vlc, size, nodes, vp6_huff_cmp, 1);

}

    if (s->use_huffman) {

        for (pt=0; pt<2; pt++) {

            vp6_build_huff_tree(s, model->coeff_dccv[pt],

                                vp6_huff_coeff_map, 12, &s->dccv_vlc[pt]);

            vp6_build_huff_tree(s, model->coeff_runv[pt],

                                vp6_huff_run_map, 9, &s->runv_vlc[pt]);

            for (ct=0; ct<3; ct++)

                for (cg = 0; cg < 6; cg++)

                    vp6_build_huff_tree(s, model->coeff_ract[pt][ct][cg],

                                        vp6_huff_coeff_map, 12,

                                        &s->ract_vlc[pt][ct][cg]);

        }

        memset(s->nb_null, 0, sizeof(s->nb_null));

    } else {

    }

/**

 * Read number of consecutive blocks with null DC or AC.

 * This value is < 74.

 */

static unsigned vp6_get_nb_null(vp56_context_t *s)

{

    unsigned val = get_bits(&s->gb, 2);

    if (val == 2)

        val += get_bits(&s->gb, 2);

    else if (val == 3) {

        val = get_bits1(&s->gb) << 2;

        val = 6+val + get_bits(&s->gb, 2+val);

    }

    return val;

}

static void vp6_parse_coeff_huffman(vp56_context_t *s)

{

    vp56_model_t *model = s->modelp;

    uint8_t *permute = s->scantable.permutated;

    VLC *vlc_coeff;

    int coeff, sign, coeff_idx;

    int b, cg, idx;

    int pt = 0;    /* plane type (0 for Y, 1 for U or V) */

    for (b=0; b<6; b++) {

        int ct = 0;    /* code type */

        if (b > 3) pt = 1;

        vlc_coeff = &s->dccv_vlc[pt];

        for (coeff_idx=0; coeff_idx<64; ) {

            int run = 1;

            if (coeff_idx<2 && s->nb_null[coeff_idx][pt]) {

                s->nb_null[coeff_idx][pt]--;

                if (coeff_idx)

                    break;

            } else {

                coeff = get_vlc2(&s->gb, vlc_coeff->table, 9, 3);

                if (coeff == 0) {

                    if (coeff_idx) {

                        int pt = (coeff_idx >= 6);

                        run += get_vlc2(&s->gb, s->runv_vlc[pt].table, 9, 3);

                        if (run >= 9)

                            run += get_bits(&s->gb, 6);

                    } else

                        s->nb_null[0][pt] = vp6_get_nb_null(s);

                    ct = 0;

                } else if (coeff == 11) {  /* end of block */

                    if (coeff_idx == 1)    /* first AC coeff ? */

                        s->nb_null[1][pt] = vp6_get_nb_null(s);

                    break;

                } else {

                    int coeff2 = vp56_coeff_bias[coeff];

                    if (coeff > 4)

                        coeff2 += get_bits(&s->gb, coeff <= 9 ? coeff - 4 : 11);

                    ct = 1 + (coeff2 > 1);

                    sign = get_bits1(&s->gb);

                    coeff2 = (coeff2 ^ -sign) + sign;

                    if (coeff_idx)

                        coeff2 *= s->dequant_ac;

                    idx = model->coeff_index_to_pos[coeff_idx];

                    s->block_coeff[b][permute[idx]] = coeff2;

                }

            }

            coeff_idx+=run;

            cg = FFMIN(vp6_coeff_groups[coeff_idx], 3);

            vlc_coeff = &s->ract_vlc[pt][ct][cg];

        }

    }

}

                        coeff = vp56_coeff_bias[idx+5];

static const uint8_t vp6_huff_coeff_map[] = {

    13, 14, 11, 0, 1, 15, 16, 18, 2, 17, 3, 4, 19, 20, 5, 6, 21, 22, 7, 8, 9, 10

};

static const uint8_t vp6_huff_run_map[] = {

    10, 13, 11, 12, 0, 1, 2, 3, 14, 8, 15, 16, 4, 5, 6, 7

};