cabac.c

在dsp上实现h.264编解码

    FIX8(0.0273), FIX8(0.0288), FIX8(0.0303), FIX8(0.0320),
    FIX8(0.0337), FIX8(0.0355), FIX8(0.0375), FIX8(0.0395),
    FIX8(0.0416), FIX8(0.0439), FIX8(0.0463), FIX8(0.0488),
    FIX8(0.0515), FIX8(0.0543), FIX8(0.0572), FIX8(0.0604),
    FIX8(0.0637), FIX8(0.0671), FIX8(0.0708), FIX8(0.0747),
    FIX8(0.0788), FIX8(0.0832), FIX8(0.0878), FIX8(0.0926),
    FIX8(0.0977), FIX8(0.1032), FIX8(0.1089), FIX8(0.1149),
    FIX8(0.1214), FIX8(0.1282), FIX8(0.1353), FIX8(0.1429),
    FIX8(0.1510), FIX8(0.1596), FIX8(0.1686), FIX8(0.1782),
    FIX8(0.1884), FIX8(0.1992), FIX8(0.2107), FIX8(0.2229),
    FIX8(0.2358), FIX8(0.2496), FIX8(0.2642), FIX8(0.2798),
    FIX8(0.2964), FIX8(0.3142), FIX8(0.3331), FIX8(0.3532),
    FIX8(0.3748), FIX8(0.3979), FIX8(0.4226), FIX8(0.4491),
    FIX8(0.4776), FIX8(0.5082), FIX8(0.5412), FIX8(0.5768),
    FIX8(0.6152), FIX8(0.6568), FIX8(0.7020), FIX8(0.7513),
    FIX8(0.8050), FIX8(0.8638), FIX8(0.9285), FIX8(1.0000),
    FIX8(1.0000), FIX8(1.0752), FIX8(1.1504), FIX8(1.2256),
    FIX8(1.3008), FIX8(1.3759), FIX8(1.4511), FIX8(1.5263),
    FIX8(1.6015), FIX8(1.6767), FIX8(1.7519), FIX8(1.8271),
    FIX8(1.9023), FIX8(1.9775), FIX8(2.0527), FIX8(2.1278),
    FIX8(2.2030), FIX8(2.2782), FIX8(2.3534), FIX8(2.4286),
    FIX8(2.5038), FIX8(2.5790), FIX8(2.6542), FIX8(2.7294),
    FIX8(2.8046), FIX8(2.8797), FIX8(2.9549), FIX8(3.0301),
    FIX8(3.1053), FIX8(3.1805), FIX8(3.2557), FIX8(3.3309),
    FIX8(3.4061), FIX8(3.4813), FIX8(3.5565), FIX8(3.6316),
    FIX8(3.7068), FIX8(3.7820), FIX8(3.8572), FIX8(3.9324),
    FIX8(4.0076), FIX8(4.0828), FIX8(4.1580), FIX8(4.2332),
    FIX8(4.3083), FIX8(4.3836), FIX8(4.4588), FIX8(4.5339),
    FIX8(4.6091), FIX8(4.6843), FIX8(4.7595), FIX8(4.8347),
    FIX8(4.9099), FIX8(4.9851), FIX8(5.0602), FIX8(5.1354),
    FIX8(5.2106), FIX8(5.2859), FIX8(5.3610), FIX8(5.4362),
    FIX8(5.5114), FIX8(5.5866), FIX8(5.6618), FIX8(5.7370)
};


/*****************************************************************************
 *
 *****************************************************************************/
void SHU264_cabac_context_init( SHU264_cabac_t *cb, int i_slice_type, int i_qp, int i_model )
{
    const int (*cabac_context_init)[460][2];
    int i;

    if( i_slice_type == SLICE_TYPE_I )
    {
        cabac_context_init = &SHU264_cabac_context_init_I;
    }
    else
    {
        cabac_context_init = &SHU264_cabac_context_init_PB[i_model];
    }

    for( i = 0; i < 436; i++ )
    {
        cb->state[i] = SHU264_clip3( (((*cabac_context_init)[i][0] * i_qp) >> 4) + (*cabac_context_init)[i][1], 1, 126 );
    }
}

/*****************************************************************************
 *
 *****************************************************************************/
void SHU264_cabac_decode_init( SHU264_cabac_t *cb, bs_t *s )
{
    cb->i_range = 0x01fe;
    cb->i_low   = bs_read( s, 9 );
    cb->s       = s;
}

static inline void SHU264_cabac_decode_renorm( SHU264_cabac_t *cb )
{
    while( cb->i_range < 0x0100 )
    {
        cb->i_range <<= 1;
        cb->i_low   = ( cb->i_low << 1 )|bs_read( cb->s, 1 );
    }
}

int  SHU264_cabac_decode_decision( SHU264_cabac_t *cb, int i_ctx )
{
    int i_state = cb->state[i_ctx];
    int i_range_lps = SHU264_cabac_range_lps[i_state][(cb->i_range>>6)&0x03];

    int val = (i_state >> 6);

    cb->i_range -= i_range_lps;

    if( cb->i_low >= cb->i_range )
    {
        val ^= 1;

        cb->i_low -= cb->i_range;
        cb->i_range= i_range_lps;
    }

    cb->state[i_ctx] = SHU264_cabac_transition[val][i_state];

    SHU264_cabac_decode_renorm( cb );

    return val;
}
int  SHU264_cabac_decode_bypass( SHU264_cabac_t *cb )
{
    cb->i_low = (cb->i_low << 1)|bs_read( cb->s, 1 );

    if( cb->i_low >= cb->i_range )
    {
        cb->i_low -= cb->i_range;
        return 1;
    }
    return 0;
}
int  SHU264_cabac_decode_terminal( SHU264_cabac_t *cb )
{
    if( cb->i_low >= cb->i_range - 2 )
    {
        return 1;
    }

    cb->i_range -= 2;
    SHU264_cabac_decode_renorm( cb );
    return 0;
}

/*****************************************************************************
 *
 *****************************************************************************/
void SHU264_cabac_encode_init( SHU264_cabac_t *cb, bs_t *s )
{
    cb->i_low   = 0;
    cb->i_range = 0x01FE;
    cb->i_bits_outstanding = 0;
    cb->s = s;
    s->i_left++; // the first bit will be shifted away and not written
}

static inline void SHU264_cabac_putbit( SHU264_cabac_t *cb, int b )
{
    bs_write1( cb->s, b );

    if( cb->i_bits_outstanding > 0 )
    {
        while( cb->i_bits_outstanding > 32 )
        {
            bs_write1( cb->s, 1-b );
            cb->i_bits_outstanding--;
        }
        bs_write( cb->s, cb->i_bits_outstanding, (1-b)*(~0) );
        cb->i_bits_outstanding = 0;
    }
}

static inline void SHU264_cabac_encode_renorm( SHU264_cabac_t *cb )
{
    /* RenormE */
    while( cb->i_range < 0x100 )
    {
        if( cb->i_low < 0x100 )
        {
            SHU264_cabac_putbit( cb, 0 );
        }
        else if( cb->i_low >= 0x200 )
        {
            cb->i_low -= 0x200;
            SHU264_cabac_putbit( cb, 1 );
        }
        else
        {
            cb->i_low -= 0x100;
            cb->i_bits_outstanding++;
        }

        cb->i_range <<= 1;
        cb->i_low   <<= 1;
    }
}

void SHU264_cabac_encode_decision( SHU264_cabac_t *cb, int i_ctx, int b )
{
    int i_state = cb->state[i_ctx];
    int i_range_lps = SHU264_cabac_range_lps[i_state][(cb->i_range>>6)&0x03];

    cb->i_range -= i_range_lps;

    if( b != (i_state >> 6) )
    {
        cb->i_low += cb->i_range;
        cb->i_range = i_range_lps;
    }

    cb->state[i_ctx] = SHU264_cabac_transition[b][i_state];

    SHU264_cabac_encode_renorm( cb );
}

void SHU264_cabac_encode_bypass( SHU264_cabac_t *cb, int b )
{
    cb->i_low <<= 1;
    cb->i_low += b * cb->i_range;

    if( cb->i_low >= 0x400 )
    {
        SHU264_cabac_putbit( cb, 1 );
        cb->i_low -= 0x400;
    }
    else if( cb->i_low < 0x200 )
    {
        SHU264_cabac_putbit( cb, 0 );
    }
    else
    {
        cb->i_low -= 0x200;
        cb->i_bits_outstanding++;
    }
}

void SHU264_cabac_encode_terminal( SHU264_cabac_t *cb, int b )
{
    cb->i_range -= 2;
    if( b )
    {
        cb->i_low += cb->i_range;
        cb->i_range = 2;
    }
    SHU264_cabac_encode_renorm( cb );
}

void SHU264_cabac_encode_flush( SHU264_cabac_t *cb )
{
    SHU264_cabac_putbit( cb, (cb->i_low >> 9)&0x01 );
    bs_write1( cb->s, (cb->i_low >> 8)&0x01 );

    /* check that */
    bs_write1( cb->s, 0x01 );
    bs_align_0( cb->s );
}

/*****************************************************************************
 *
 *****************************************************************************/
void SHU264_cabac_size_decision( SHU264_cabac_t *cb, int i_ctx, int b )
{
    int i_state = cb->state[i_ctx];
    cb->state[i_ctx] = SHU264_cabac_transition[b][i_state];
    cb->f8_bits_encoded += SHU264_cabac_entropy[ b ? 127 - i_state : i_state ];
}

int SHU264_cabac_size_decision2( uint8_t *state, int b )
{
    int i_state = *state;
    *state = SHU264_cabac_transition[b][i_state];
    return SHU264_cabac_entropy[ b ? 127 - i_state : i_state ];
}

int SHU264_cabac_size_decision_noup( uint8_t *state, int b )
{
    return SHU264_cabac_entropy[ b ? 127 - *state : *state ];
}