dec_cavlc.c

经过开源的H.264压缩算法代码

        table = coeff1_1;
        code = (code >> 8) - 4;
    }
    else if (code >= 128)
    {
        table = coeff1_2;
        code = (code >> 5) - 4;
    }
    else if (code >= 64)
    {
        table = coeff1_3;
        code = (code >> 3) - 8;
    }
    else if (code >= 32)
    {
        table = coeff1_4;
        code = (code >> 2) - 8;
    }
    else if (code >= 16)
    {
        table = coeff1_5;
        code = (code >> 1) - 8;
    }
    else
    {
        table = coeff1_6;
    }

    *trailing_ones = table[code].trailing_ones;
    *total_coff = table[code].total_coeff;
    eg_read_skip(t->bs, table[code].len);
}

/* 2 > nC >= 0 */
void
T264dec_mb_read_coff_token_t0(T264_t* t, uint8_t* trailing_ones, uint8_t* total_coff)
{
    int32_t code;
    const vlc_coeff_token_t* table;

    code = eg_show(t->bs, 16);
    if (code >= 8192)
    {
        table = coeff0_5;
        code >>= 13;
    }
    else if (code >= 4096)
    {
        table = coeff0_4;
        code = (code >> 10) - 4;
    }
    else if (code >= 1024)
    {
        table = coeff0_3;
        code = (code >> 8) - 4;
    }
    else if (code >= 128)
    {
        table = coeff0_2;
        code = (code >> 5) - 4;
    }
    else if (code >= 64)
    {
        table = coeff0_1;
        code = (code >> 3) - 8;
    }
    else
    {
        table = coeff0_0;
    }

    *trailing_ones = table[code].trailing_ones;
    *total_coff = table[code].total_coeff;
    eg_read_skip(t->bs, table[code].len);
}

uint8_t
T264dec_mb_read_level_prefix(T264_t* t)
{
    uint8_t prefix;
    int32_t code;

    code = eg_show(t->bs, 16);
    if (code >= 4096)
    {
        prefix = prefix_table0[code >> 12];
    }
    else if (code >= 256)
    {
        prefix = prefix_table1[code >> 8];
    }
    else if (code >= 16)
    {
        prefix = prefix_table2[code >> 4];
    }
    else
    {
        prefix = prefix_table3[code];
    }

    eg_read_skip(t->bs, prefix + 1);

    return prefix;
}

uint8_t
T264dec_mb_read_total_zero1(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 9);
    if (code >= 32)
    {
        code >>= 4;
        total_zero = total_zero_table1_1[code].num;
        eg_read_skip(t->bs, total_zero_table1_1[code].len);
    }
    else
    {
        total_zero = total_zero_table1_0[code].num;
        eg_read_skip(t->bs, total_zero_table1_0[code].len);
    }

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero2(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 6);
    if (code >= 8)
    {
        code >>= 2;
        total_zero = total_zero_table2_1[code].num;
        eg_read_skip(t->bs, total_zero_table2_1[code].len);
    }
    else
    {
        total_zero = total_zero_table2_0[code].num;
        eg_read_skip(t->bs, total_zero_table2_0[code].len);
    }

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero3(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 6);
    if (code >= 8)
    {
        code >>= 2;
        total_zero = total_zero_table3_1[code].num;
        eg_read_skip(t->bs, total_zero_table3_1[code].len);
    }
    else
    {
        total_zero = total_zero_table3_0[code].num;
        eg_read_skip(t->bs, total_zero_table3_0[code].len);
    }

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero6(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 6);
    if (code >= 8)
    {
        code >>= 3;
        total_zero = total_zero_table6_1[code].num;
        eg_read_skip(t->bs, total_zero_table6_1[code].len);
    }
    else
    {
        total_zero = total_zero_table6_0[code].num;
        eg_read_skip(t->bs, total_zero_table6_0[code].len);
    }

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero7(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 6);
    if (code >= 8)
    {
        code >>= 3;
        total_zero = total_zero_table7_1[code].num;
        eg_read_skip(t->bs, total_zero_table7_1[code].len);
    }
    else
    {
        total_zero = total_zero_table7_0[code].num;
        eg_read_skip(t->bs, total_zero_table7_0[code].len);
    }

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero8(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 6);
    if (code >= 8)
    {
        code >>= 3;
        total_zero = total_zero_table8_1[code].num;
        eg_read_skip(t->bs, total_zero_table8_1[code].len);
    }
    else
    {
        total_zero = total_zero_table8_0[code].num;
        eg_read_skip(t->bs, total_zero_table8_0[code].len);
    }

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero9(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 6);
    if (code >= 8)
    {
        code >>= 3;
        total_zero = total_zero_table9_1[code].num;
        eg_read_skip(t->bs, total_zero_table9_1[code].len);
    }
    else
    {
        total_zero = total_zero_table9_0[code].num;
        eg_read_skip(t->bs, total_zero_table9_0[code].len);
    }

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero4(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 5);
    if (code >= 16)
    {
        code = (code >> 2) - 4;
        total_zero = total_zero_table4_1[code].num;
        eg_read_skip(t->bs, total_zero_table4_1[code].len);
    }
    else
    {
        total_zero = total_zero_table4_0[code].num;
        eg_read_skip(t->bs, total_zero_table4_0[code].len);
    }

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero5(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 5);
    if (code >= 16)
    {
        code = (code >> 2) - 4;
        total_zero = total_zero_table5_1[code].num;
        eg_read_skip(t->bs, total_zero_table5_1[code].len);
    }
    else
    {
        total_zero = total_zero_table5_0[code].num;
        eg_read_skip(t->bs, total_zero_table5_0[code].len);
    }

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero10(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 5);
    if (code >= 4)
    {
        code >>= 2;
        total_zero = total_zero_table10_1[code].num;
        eg_read_skip(t->bs, total_zero_table10_1[code].len);
    }
    else
    {
        total_zero = total_zero_table10_0[code].num;
        eg_read_skip(t->bs, total_zero_table10_0[code].len);
    }

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero11(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 4);
    total_zero = total_zero_table11_0[code].num;
    eg_read_skip(t->bs, total_zero_table11_0[code].len);

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero12(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 4);
    total_zero = total_zero_table12_0[code].num;
    eg_read_skip(t->bs, total_zero_table12_0[code].len);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero13(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 3);
    total_zero = total_zero_table13_0[code].num;
    eg_read_skip(t->bs, total_zero_table13_0[code].len);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero14(T264_t* t)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 2);
    total_zero = total_zero_table14_0[code].num;
    eg_read_skip(t->bs, total_zero_table14_0[code].len);

    return total_zero;
}

uint8_t
T264dec_mb_read_total_zero15(T264_t* t)
{
    return eg_read_direct1(t->bs);
}

uint8_t
T264dec_mb_read_total_zero_chroma(T264_t* t, uint8_t total_coeff)
{
    uint8_t total_zero;
    int32_t code;

    code = eg_show(t->bs, 3);
    total_zero = total_zero_table_chroma[total_coeff - 1][code].num;
    eg_read_skip(t->bs, total_zero_table_chroma[total_coeff - 1][code].len);

    assert(total_zero != 255);

    return total_zero;
}

uint8_t
T264dec_mb_read_run_before(T264_t* t, uint8_t zero_left)
{
    int32_t code;
    uint8_t run_before;

    assert(zero_left != 255);

    code = eg_show(t->bs, 3);
    if (zero_left <= 6)
    {
        run_before = run_before_table_0[zero_left - 1][code].num;
        eg_read_skip(t->bs, run_before_table_0[zero_left - 1][code].len);
    }
    else
    {
        eg_read_skip(t->bs, 3);
        if (code > 0)
        {
            run_before = run_before_table_0[6][code].num;
        }
        else
        {
            code = eg_show(t->bs, 4);
            if (code > 0)
            {
                run_before = run_before_table_1[code];
                eg_read_skip(t->bs, run_before - 6);
            }
            else
            {
                eg_read_skip(t->bs, 4);
                code = eg_show(t->bs, 4);
                run_before = run_before_table_2[code];
                eg_read_skip(t->bs, run_before - 10);
            }
        }
    }

    assert(run_before >= 0 && run_before <= 14);

    return run_before;
}

void
T264dec_mb_read_cavlc_residual(T264_t* t, int32_t idx, int16_t* z, int32_t count)
{
    uint8_t trailing_ones, total_coeff;
    int32_t i, j;
    int32_t zero_left = 0;
    int16_t level[16];
    uint8_t run[16];
    int32_t x, y;

    if(idx == BLOCK_INDEX_CHROMA_DC)
    {
        T264dec_mb_read_coff_token_t4(t, &trailing_ones, &total_coeff);
    }
    else
    {
        /* T264_mb_predict_non_zero_code return 0 <-> (16+16+1)>>1 = 16 */
        int32_t nC = 0;
        typedef void (*T264dec_mb_read_coff_token_t)(T264_t* t, uint8_t* trailing_ones, uint8_t* total_coff);
        static const T264dec_mb_read_coff_token_t read_coeff[17] = 
        {
            T264dec_mb_read_coff_token_t0, T264dec_mb_read_coff_token_t0,
            T264dec_mb_read_coff_token_t1, T264dec_mb_read_coff_token_t1,