hashirama/uvg266
1
0
Fork 0
mirror of https://github.com/ultravideo/uvg266.git synced 2024-11-27 11:24:05 +00:00
Code Issues Actions Projects Releases Wiki Activity

Refactor: cabac.c renaming.

Browse source
This commit is contained in:
Ari Koivula 2013-09-19 11:05:42 +03:00
parent 627762dcd8
commit f4833ba931
2 changed files with 99 additions and 99 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

184
src/cabac.c
View file

@ -57,7 +57,7 @@ const uint8_t g_auc_lpst_table[64][4] =
{ 6, 8, 9, 11}, { 6, 7, 9, 10}, { 6, 7, 8, 9}, { 2, 2, 2, 2} { 6, 8, 9, 11}, { 6, 7, 9, 10}, { 6, 7, 8, 9}, { 2, 2, 2, 2}
}; };
const uint8_t g_aucRenormTable[32] = { 6, 5, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, const uint8_t g_auc_renorm_table[32] = { 6, 5, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
@ -66,13 +66,13 @@ uint8_t g_next_state[128][2];
cabac_data cabac; cabac_data cabac;
void ctx_init(cabac_ctx* ctx, uint32_t qp, uint32_t initValue ) void ctx_init(cabac_ctx* ctx, uint32_t qp, uint32_t init_value )
{ {
int slope = (initValue>>4)*5 - 45; int slope = (init_value>>4)*5 - 45;
int offset = ((initValue&15)<<3)-16; int offset = ((init_value&15)<<3)-16;
int initState = MIN( MAX( 1, ( ( ( slope * (int)qp ) >> 4 ) + offset ) ), 126 ); int init_state = MIN( MAX( 1, ( ( ( slope * (int)qp ) >> 4 ) + offset ) ), 126 );
uint8_t mpState = (initState >= 64 )?1:0; uint8_t mp_state = (init_state >= 64 )?1:0;
ctx->uc_state = ( (mpState? (initState - 64):(63 - initState)) <<1) + mpState; ctx->uc_state = ( (mp_state? (init_state - 64):(63 - init_state)) <<1) + mp_state;
ctx->bins_coded = 0; ctx->bins_coded = 0;
} }
@ -97,47 +97,47 @@ void cabac_init(cabac_data* data)
{ {
data->frac_bits = 0; data->frac_bits = 0;
data->bin_count_increment = 0; data->bin_count_increment = 0;
data->ui_bins_coded = 0; data->bins_coded = 0;
ctx_build_next_state_table(); ctx_build_next_state_table();
} }
void cabac_start(cabac_data* data) void cabac_start(cabac_data* data)
{ {
data->ui_low = 0; data->low = 0;
data->ui_range = 510; data->range = 510;
data->bits_left = 23; data->bits_left = 23;
data->num_buffered_bytes = 0; data->num_buffered_bytes = 0;
data->buffered_ryte = 0xff; data->buffered_byte = 0xff;
} }
void cabac_encode_bin(cabac_data* data, uint32_t binValue ) void cabac_encode_bin(cabac_data* data, uint32_t bin_value )
{ {
uint32_t uiLPS; uint32_t lps;
//printf("\tdecodeBin m_uiRange %d uivalue %d\n", data->uiRange, data->uiLow); //printf("\tdecodeBin m_uiRange %d uivalue %d\n", data->uiRange, data->uiLow);
data->ui_bins_coded += data->bin_count_increment; data->bins_coded += data->bin_count_increment;
data->ctx->bins_coded = 1; data->ctx->bins_coded = 1;
uiLPS = g_auc_lpst_table[ CTX_STATE(data->ctx) ][ ( data->ui_range >> 6 ) & 3 ]; lps = g_auc_lpst_table[ CTX_STATE(data->ctx) ][ ( data->range >> 6 ) & 3 ];
data->ui_range -= uiLPS; data->range -= lps;
#ifdef _DEBUG #ifdef _DEBUG
//printf("\tencodeBin m_uiRange %d uiLPS %d m_uiValue %d ", data->uiRange,uiLPS,data->uiLow); //printf("\tencodeBin m_uiRange %d uiLPS %d m_uiValue %d ", data->uiRange,uiLPS,data->uiLow);
#endif #endif
//Not the Most Probable Symbol? //Not the Most Probable Symbol?
if( binValue != CTX_MPS(data->ctx) ) if( bin_value != CTX_MPS(data->ctx) )
{ {
int numBits = g_aucRenormTable[ uiLPS >> 3 ]; int num_bits = g_auc_renorm_table[ lps >> 3 ];
data->ui_low = ( data->ui_low + data->ui_range ) << numBits; data->low = ( data->low + data->range ) << num_bits;
data->ui_range = uiLPS << numBits; data->range = lps << num_bits;
ctx_update_LPS(data->ctx); ctx_update_LPS(data->ctx);
data->bits_left -= numBits; data->bits_left -= num_bits;
} }
else else
{ {
ctx_update_MPS(data->ctx); ctx_update_MPS(data->ctx);
if ( data->ui_range >= 256 ) if ( data->range >= 256 )
{ {
#ifdef _DEBUG #ifdef _DEBUG
//printf("enduiValue %d \n",data->uiLow); //printf("enduiValue %d \n",data->uiLow);
@ -145,8 +145,8 @@ void cabac_encode_bin(cabac_data* data, uint32_t binValue )
return; return;
} }
data->ui_low <<= 1; data->low <<= 1;
data->ui_range <<= 1; data->range <<= 1;
data->bits_left--; data->bits_left--;
} }
@ -161,11 +161,11 @@ void cabac_encode_bin(cabac_data* data, uint32_t binValue )
void cabac_write(cabac_data* data) void cabac_write(cabac_data* data)
{ {
uint32_t leadByte = data->ui_low >> (24 - data->bits_left); uint32_t lead_byte = data->low >> (24 - data->bits_left);
data->bits_left += 8; data->bits_left += 8;
data->ui_low &= 0xffffffffu >> data->bits_left; data->low &= 0xffffffffu >> data->bits_left;
if ( leadByte == 0xff ) if ( lead_byte == 0xff )
{ {
data->num_buffered_bytes++; data->num_buffered_bytes++;
} }
@ -173,9 +173,9 @@ void cabac_write(cabac_data* data)
{ {
if ( data->num_buffered_bytes > 0 ) if ( data->num_buffered_bytes > 0 )
{ {
uint32_t carry = leadByte >> 8; uint32_t carry = lead_byte >> 8;
uint32_t byte = data->buffered_ryte + carry; uint32_t byte = data->buffered_byte + carry;
data->buffered_ryte = leadByte & 0xff; data->buffered_byte = lead_byte & 0xff;
bitstream_put(data->stream,byte,8); bitstream_put(data->stream,byte,8);
byte = ( 0xff + carry ) & 0xff; byte = ( 0xff + carry ) & 0xff;
@ -188,28 +188,28 @@ void cabac_write(cabac_data* data)
else else
{ {
data->num_buffered_bytes = 1; data->num_buffered_bytes = 1;
data->buffered_ryte = leadByte; data->buffered_byte = lead_byte;
} }
} }
} }
void cabac_finish(cabac_data* data) void cabac_finish(cabac_data* data)
{ {
if ( data->ui_low >> ( 32 - data->bits_left ) ) if ( data->low >> ( 32 - data->bits_left ) )
{ {
bitstream_put(data->stream,data->buffered_ryte + 1, 8 ); bitstream_put(data->stream,data->buffered_byte + 1, 8 );
while ( data->num_buffered_bytes > 1 ) while ( data->num_buffered_bytes > 1 )
{ {
bitstream_put(data->stream,0, 8 ); bitstream_put(data->stream,0, 8 );
data->num_buffered_bytes--; data->num_buffered_bytes--;
} }
data->ui_low -= 1 << ( 32 - data->bits_left ); data->low -= 1 << ( 32 - data->bits_left );
} }
else else
{ {
if ( data->num_buffered_bytes > 0 ) if ( data->num_buffered_bytes > 0 )
{ {
bitstream_put(data->stream,data->buffered_ryte, 8 ); bitstream_put(data->stream,data->buffered_byte, 8 );
} }
while ( data->num_buffered_bytes > 1 ) while ( data->num_buffered_bytes > 1 )
{ {
@ -217,35 +217,35 @@ void cabac_finish(cabac_data* data)
data->num_buffered_bytes--; data->num_buffered_bytes--;
} }
} }
bitstream_put(data->stream, data->ui_low >> 8, 24 - data->bits_left ); bitstream_put(data->stream, data->low >> 8, 24 - data->bits_left );
} }
/*! /*!
\brief Encode terminating bin \brief Encode terminating bin
\param binValue bin value \param binValue bin value
*/ */
void cabac_encode_bin_trm(cabac_data* data, uint8_t binValue ) void cabac_encode_bin_trm(cabac_data* data, uint8_t bin_value )
{ {
#ifdef _DEBUG #ifdef _DEBUG
//printf("\tencodeBinTrm m_uiRange %d uivalue %d\n", data->uiRange, data->uiLow); //printf("\tencodeBinTrm m_uiRange %d uivalue %d\n", data->uiRange, data->uiLow);
#endif #endif
data->ui_bins_coded += data->bin_count_increment; data->bins_coded += data->bin_count_increment;
data->ui_range -= 2; data->range -= 2;
if( binValue ) if( bin_value )
{ {
data->ui_low += data->ui_range; data->low += data->range;
data->ui_low <<= 7; data->low <<= 7;
data->ui_range = 2 << 7; data->range = 2 << 7;
data->bits_left -= 7; data->bits_left -= 7;
} }
else if ( data->ui_range >= 256 ) else if ( data->range >= 256 )
{ {
return; return;
} }
else else
{ {
data->ui_low <<= 1; data->low <<= 1;
data->ui_range <<= 1; data->range <<= 1;
data->bits_left--; data->bits_left--;
} }
@ -264,13 +264,13 @@ void cabac_flush(cabac_data* data)
cabac_start(data); cabac_start(data);
} }
void cabac_encode_bin_ep(cabac_data* data, uint32_t binValue ) void cabac_encode_bin_ep(cabac_data* data, uint32_t bin_value )
{ {
data->ui_bins_coded += data->bin_count_increment; data->bins_coded += data->bin_count_increment;
data->ui_low <<= 1; data->low <<= 1;
if( binValue ) if( bin_value )
{ {
data->ui_low += data->ui_range; data->low += data->range;
} }
data->bits_left--; data->bits_left--;
@ -280,18 +280,18 @@ void cabac_encode_bin_ep(cabac_data* data, uint32_t binValue )
} }
} }
void cabac_encode_bins_ep(cabac_data* data, uint32_t binValues, int numBins ) void cabac_encode_bins_ep(cabac_data* data, uint32_t bin_values, int num_bins )
{ {
uint32_t pattern; uint32_t pattern;
data->ui_bins_coded += numBins & -data->bin_count_increment; data->bins_coded += num_bins & -data->bin_count_increment;
while ( numBins > 8 ) while ( num_bins > 8 )
{ {
numBins -= 8; num_bins -= 8;
pattern = binValues >> numBins; pattern = bin_values >> num_bins;
data->ui_low <<= 8; data->low <<= 8;
data->ui_low += data->ui_range * pattern; data->low += data->range * pattern;
binValues -= pattern << numBins; bin_values -= pattern << num_bins;
data->bits_left -= 8; data->bits_left -= 8;
if(data->bits_left < 12) if(data->bits_left < 12)
@ -300,9 +300,9 @@ void cabac_encode_bins_ep(cabac_data* data, uint32_t binValues, int numBins )
} }
} }
data->ui_low <<= numBins; data->low <<= num_bins;
data->ui_low += data->ui_range * binValues; data->low += data->range * bin_values;
data->bits_left -= numBins; data->bits_left -= num_bins;
if(data->bits_left < 12) if(data->bits_left < 12)
{ {
@ -318,73 +318,73 @@ void cabac_encode_bins_ep(cabac_data* data, uint32_t binValues, int numBins )
\param ruiGoRiceParam reference to Rice parameter \param ruiGoRiceParam reference to Rice parameter
\returns Void \returns Void
*/ */
void cabac_write_coeff_remain(cabac_data* cabac,uint32_t symbol, uint32_t rParam ) void cabac_write_coeff_remain(cabac_data* cabac, uint32_t symbol, uint32_t r_param )
{ {
int32_t codeNumber = symbol; int32_t code_number = symbol;
uint32_t length; uint32_t length;
if (codeNumber < (3 << rParam)) if (code_number < (3 << r_param))
{ {
length = codeNumber>>rParam; length = code_number>>r_param;
cabac_encode_bins_ep(cabac, (1<<(length+1))-2 , length+1); cabac_encode_bins_ep(cabac, (1<<(length+1))-2 , length+1);
cabac_encode_bins_ep(cabac,(codeNumber%(1<<rParam)),rParam); cabac_encode_bins_ep(cabac,(code_number%(1<<r_param)),r_param);
} }
else else
{ {
length = rParam; length = r_param;
codeNumber = codeNumber - ( 3 << rParam); code_number = code_number - ( 3 << r_param);
while (codeNumber >= (1<<length)) while (code_number >= (1<<length))
{ {
codeNumber -= (1<<(length++)); code_number -= (1<<(length++));
} }
cabac_encode_bins_ep(cabac,(1<<(3+length+1-rParam))-2,3+length+1-rParam); cabac_encode_bins_ep(cabac,(1<<(3+length+1-r_param))-2,3+length+1-r_param);
cabac_encode_bins_ep(cabac,codeNumber,length); cabac_encode_bins_ep(cabac,code_number,length);
} }
} }
void cabac_write_unary_max_symbol(cabac_data* data,cabac_ctx* ctx, uint32_t uiSymbol,int32_t iOffset, uint32_t uiMaxSymbol) void cabac_write_unary_max_symbol(cabac_data* data,cabac_ctx* ctx, uint32_t symbol,int32_t offset, uint32_t max_symbol)
{ {
int8_t bCodeLast = ( uiMaxSymbol > uiSymbol ); int8_t code_last = ( max_symbol > symbol );
if (!uiMaxSymbol) if (!max_symbol)
return; return;
data->ctx = &ctx[0]; data->ctx = &ctx[0];
cabac_encode_bin(data, uiSymbol ? 1 : 0); cabac_encode_bin(data, symbol ? 1 : 0);
if (!uiSymbol) if (!symbol)
return; return;
while( --uiSymbol ) while( --symbol )
{ {
data->ctx = &ctx[iOffset]; data->ctx = &ctx[offset];
cabac_encode_bin(data, 1); cabac_encode_bin(data, 1);
} }
if( bCodeLast ) if( code_last )
{ {
data->ctx = &ctx[iOffset]; data->ctx = &ctx[offset];
cabac_encode_bin(data, 0); cabac_encode_bin(data, 0);
} }
return; return;
} }
void cabac_write_ep_ex_golomb(cabac_data* data, uint32_t uiSymbol, uint32_t uiCount ) void cabac_write_ep_ex_golomb(cabac_data* data, uint32_t symbol, uint32_t count )
{ {
uint32_t bins = 0; uint32_t bins = 0;
int32_t numBins = 0; int32_t num_bins = 0;
while( uiSymbol >= (uint32_t)(1<<uiCount) ) while( symbol >= (uint32_t)(1<<count) )
{ {
bins = 2 * bins + 1; bins = 2 * bins + 1;
numBins++; num_bins++;
uiSymbol -= 1 << uiCount; symbol -= 1 << count;
uiCount ++; count ++;
} }
bins = 2 * bins + 0; bins = 2 * bins + 0;
numBins++; num_bins++;
bins = (bins << uiCount) | uiSymbol; bins = (bins << count) | symbol;
numBins += uiCount; num_bins += count;
cabac_encode_bins_ep(data, bins, numBins); cabac_encode_bins_ep(data, bins, num_bins);
} }

14
src/cabac.h
View file

@ -22,7 +22,7 @@ extern const uint8_t g_auc_next_state_lps[ 128 ];
extern uint8_t g_next_state[128][2]; extern uint8_t g_next_state[128][2];
extern const uint8_t g_auc_lpst_table[64][4]; extern const uint8_t g_auc_lpst_table[64][4];
extern const uint8_t g_aucRenormTable[32]; extern const uint8_t g_auc_renorm_table[32];
typedef struct typedef struct
{ {
@ -44,16 +44,16 @@ void ctx_update(cabac_ctx* ctx, int val );
typedef struct typedef struct
{ {
cabac_ctx *ctx; cabac_ctx *ctx;
uint32_t ui_low; uint32_t low;
uint32_t ui_range; uint32_t range;
uint32_t buffered_ryte; uint32_t buffered_byte;
int32_t num_buffered_bytes; int32_t num_buffered_bytes;
int32_t bits_left; int32_t bits_left;
uint32_t ui_bins_coded; uint32_t bins_coded;
int32_t bin_count_increment; int32_t bin_count_increment;
uint64_t frac_bits; uint64_t frac_bits;
bitstream* stream; bitstream *stream;
} cabac_data; } cabac_data;
extern cabac_data cabac; extern cabac_data cabac;