Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

CABAC

Browse Source 
note, this is just the CABAC (de)coder not complete h264-cabac support

Originally committed as revision 1915 to svn://svn.ffmpeg.org/ffmpeg/trunk
pull/126/head
Michael Niedermayer 22 years ago
parent 8e7284ba91
commit d592f67fb6
2 changed files with 411 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 179
      libavcodec/cabac.c
  2. 232
      libavcodec/cabac.h

179
libavcodec/cabac.c
Unescape View File

@ -0,0 +1,179 @@
/*
* H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
/**
* @file cabac.c
* Context Adaptive Binary Arithmetic Coder.
*/
#include <string.h>
#include "common.h"
#include "cabac.h"
const uint8_t ff_h264_lps_range[64][4]= {
{128,176,208,240}, {128,167,197,227}, {128,158,187,216}, {123,150,178,205},
{116,142,169,195}, {111,135,160,185}, {105,128,152,175}, {100,122,144,166},
{ 95,116,137,158}, { 90,110,130,150}, { 85,104,123,142}, { 81, 99,117,135},
{ 77, 94,111,128}, { 73, 89,105,122}, { 69, 85,100,116}, { 66, 80, 95,110},
{ 62, 76, 90,104}, { 59, 72, 86, 99}, { 56, 69, 81, 94}, { 53, 65, 77, 89},
{ 51, 62, 73, 85}, { 48, 59, 69, 80}, { 46, 56, 66, 76}, { 43, 53, 63, 72},
{ 41, 50, 59, 69}, { 39, 48, 56, 65}, { 37, 45, 54, 62}, { 35, 43, 51, 59},
{ 33, 41, 48, 56}, { 32, 39, 46, 53}, { 30, 37, 43, 50}, { 29, 35, 41, 48},
{ 27, 33, 39, 45}, { 26, 31, 37, 43}, { 24, 30, 35, 41}, { 23, 28, 33, 39},
{ 22, 27, 32, 37}, { 21, 26, 30, 35}, { 20, 24, 29, 33}, { 19, 23, 27, 31},
{ 18, 22, 26, 30}, { 17, 21, 25, 28}, { 16, 20, 23, 27}, { 15, 19, 22, 25},
{ 14, 18, 21, 24}, { 14, 17, 20, 23}, { 13, 16, 19, 22}, { 12, 15, 18, 21},
{ 12, 14, 17, 20}, { 11, 14, 16, 19}, { 11, 13, 15, 18}, { 10, 12, 15, 17},
{ 10, 12, 14, 16}, { 9, 11, 13, 15}, { 9, 11, 12, 14}, { 8, 10, 12, 14},
{ 8, 9, 11, 13}, { 7, 9, 11, 12}, { 7, 9, 10, 12}, { 7, 8, 10, 11},
{ 6, 8, 9, 11}, { 6, 7, 9, 10}, { 6, 7, 8, 9}, { 2, 2, 2, 2},
};
const uint8_t ff_h264_mps_state[64]= {
1, 2, 3, 4, 5, 6, 7, 8,
9,10,11,12,13,14,15,16,
17,18,19,20,21,22,23,24,
25,26,27,28,29,30,31,32,
33,34,35,36,37,38,39,40,
41,42,43,44,45,46,47,48,
49,50,51,52,53,54,55,56,
57,58,59,60,61,62,62,63,
};
const uint8_t ff_h264_lps_state[64]= {
0, 0, 1, 2, 2, 4, 4, 5,
6, 7, 8, 9, 9,11,11,12,
13,13,15,15,16,16,18,18,
19,19,21,21,22,22,23,24,
24,25,26,26,27,27,28,29,
29,30,30,30,31,32,32,33,
33,33,34,34,35,35,35,36,
36,36,37,37,37,38,38,63,
};
/**
*
* @param buf_size size of buf in bits
*/
void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size){
init_put_bits(&c->pb, buf, buf_size, NULL, NULL);
c->low= 0;
c->range= 0x1FE;
c->outstanding_count= 0;
#ifdef STRICT_LIMITS
c->sym_count =0;
#endif
c->pb.bit_left++; //avoids firstBitFlag
}
/**
*
* @param buf_size size of buf in bits
*/
void ff_init_cabac_decoder(CABACContext *c, uint8_t *buf, int buf_size){
c->bytestream= buf;
c->low= *c->bytestream++;
c->low= (c->low<<9) + ((*c->bytestream++)<<1);
c->range= 0x1FE00;
c->bits_left= 7;
}
void ff_init_cabac_states(CABACContext *c, uint8_t const (*lps_range)[4],
uint8_t const *mps_state, uint8_t const *lps_state, int state_count){
int i, j;
for(i=0; i<state_count; i++){
for(j=0; j<4; j++){ //FIXME check if this is worth the 1 shift we save
c->lps_range[2*i+0][j]=
c->lps_range[2*i+1][j]= lps_range[i][j];
}
c->mps_state[2*i+0]= 2*mps_state[i];
c->mps_state[2*i+1]= 2*mps_state[i]+1;
if(lps_state[i]){
c->lps_state[2*i+0]= 2*lps_state[i];
c->lps_state[2*i+1]= 2*lps_state[i]+1;
}else{
c->lps_state[2*i+0]= 1;
c->lps_state[2*i+1]= 0;
}
}
}
#if 0 //selftest
#define SIZE 10240
int main(){
CABACContext c;
uint8_t b[9*SIZE];
uint8_t bit[9*SIZE];
int i;
uint8_t state= 0;
ff_init_cabac_encoder(&c, b, SIZE);
ff_init_cabac_states(&c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
for(i=0; i<SIZE; i++){
bit[i]= (random()%7)&1;
}
for(i=0; i<SIZE; i++){
START_TIMER
put_cabac_bypass(&c, bit[i]);
STOP_TIMER("put_cabac_bypass")
}
for(i=0; i<SIZE; i++){
START_TIMER
put_cabac(&c, &state, bit[i]);
STOP_TIMER("put_cabac")
}
put_cabac_terminate(&c, 1);
ff_init_cabac_decoder(&c, b, SIZE);
state=0;
for(i=0; i<SIZE; i++){
START_TIMER
if( bit[i] != get_cabac_bypass(&c) )
printf("CABAC bypass failure at %d\n", i);
STOP_TIMER("get_cabac_bypass")
}
for(i=0; i<SIZE; i++){
START_TIMER
if( bit[i] != get_cabac(&c, &state) )
printf("CABAC failure at %d\n", i);
STOP_TIMER("get_cabac")
}
if(!get_cabac_terminate(&c))
printf("where's the Terminator?\n");
return 0;
}
#endif

232
libavcodec/cabac.h
Unescape View File

@ -0,0 +1,232 @@
/*
* H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
/**
* @file cabac.h
* Context Adaptive Binary Arithmetic Coder.
*/
#undef NDEBUG
#include <assert.h>
typedef struct CABACContext{
int low;
int range;
int outstanding_count;
#ifdef STRICT_LIMITS
int symCount;
#endif
uint8_t lps_range[2*64][4]; ///< rangeTabLPS
uint8_t lps_state[2*64]; ///< transIdxLPS
uint8_t mps_state[2*64]; ///< transIdxMPS
uint8_t *bytestream;
int bits_left; ///<
PutBitContext pb;
}CABACContext;
const uint8_t ff_h264_lps_range[64][4];
const uint8_t ff_h264_mps_state[64];
const uint8_t ff_h264_lps_state[64];
void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size);
void ff_init_cabac_decoder(CABACContext *c, uint8_t *buf, int buf_size);
void ff_init_cabac_states(CABACContext *c, uint8_t const (*lps_range)[4],
uint8_t const *mps_state, uint8_t const *lps_state, int state_count);
static inline void put_cabac_bit(CABACContext *c, int b){
put_bits(&c->pb, 1, b);
for(;c->outstanding_count; c->outstanding_count--){
put_bits(&c->pb, 1, 1-b);
}
}
static inline void renorm_cabac_encoder(CABACContext *c){
while(c->range < 0x100){
//FIXME optimize
if(c->low<0x100){
put_cabac_bit(c, 0);
}else if(c->low<0x200){
c->outstanding_count++;
c->low -= 0x100;
}else{
put_cabac_bit(c, 1);
c->low -= 0x200;
}
c->range+= c->range;
c->low += c->low;
}
}
static inline void put_cabac(CABACContext *c, uint8_t * const state, int bit){
int RangeLPS= c->lps_range[*state][((c->range)>>6)&3];
if(bit == ((*state)&1)){
c->range -= RangeLPS;
*state= c->mps_state[*state];
}else{
c->low += c->range - RangeLPS;
c->range = RangeLPS;
*state= c->lps_state[*state];
}
renorm_cabac_encoder(c);
#ifdef STRICT_LIMITS
c->symCount++;
#endif
}
static inline void put_cabac_static(CABACContext *c, int RangeLPS, int bit){
assert(c->range > RangeLPS);
if(!bit){
c->range -= RangeLPS;
}else{
c->low += c->range - RangeLPS;
c->range = RangeLPS;
}
renorm_cabac_encoder(c);
#ifdef STRICT_LIMITS
c->symCount++;
#endif
}
static inline void put_cabac_bypass(CABACContext *c, int bit){
c->low += c->low;
if(bit){
c->low += c->range;
}
//FIXME optimize
if(c->low<0x200){
put_cabac_bit(c, 0);
}else if(c->low<0x400){
c->outstanding_count++;
c->low -= 0x200;
}else{
put_cabac_bit(c, 1);
c->low -= 0x400;
}
#ifdef STRICT_LIMITS
c->symCount++;
#endif
}
static inline void put_cabac_terminate(CABACContext *c, int bit){
c->range -= 2;
if(!bit){
renorm_cabac_encoder(c);
}else{
c->low += c->range;
c->range= 2;
renorm_cabac_encoder(c);
assert(c->low <= 0x1FF);
put_cabac_bit(c, c->low>>9);
put_bits(&c->pb, 2, ((c->low>>7)&3)|1);
flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong
}
#ifdef STRICT_LIMITS
c->symCount++;
#endif
}
static inline void renorm_cabac_decoder(CABACContext *c){
while(c->range < 0x10000){
c->range+= c->range;
c->low+= c->low;
if(--c->bits_left == 0){
c->low+= *c->bytestream++;
c->bits_left= 8;
}
}
}
static inline int get_cabac(CABACContext *c, uint8_t * const state){
int RangeLPS= c->lps_range[*state][((c->range)>>14)&3]<<8;
int bit;
c->range -= RangeLPS;
if(c->low < c->range){
bit= (*state)&1;
*state= c->mps_state[*state];
}else{
bit= ((*state)&1)^1;
c->low -= c->range;
c->range = RangeLPS;
*state= c->lps_state[*state];
}
renorm_cabac_decoder(c);
return bit;
}
static inline int get_cabac_static(CABACContext *c, int RangeLPS){
int bit;
c->range -= RangeLPS;
if(c->low < c->range){
bit= 0;
}else{
bit= 1;
c->low -= c->range;
c->range = RangeLPS;
}
renorm_cabac_decoder(c);
return bit;
}
static inline int get_cabac_bypass(CABACContext *c){
c->low += c->low;
if(--c->bits_left == 0){
c->low+= *c->bytestream++;
c->bits_left= 8;
}
if(c->low < c->range){
return 0;
}else{
c->low -= c->range;
return 1;
}
}
static inline int get_cabac_terminate(CABACContext *c){
c->range -= 2<<8;
if(c->low < c->range){
renorm_cabac_decoder(c);
return 0;
}else{
return 1;
}
}
Write Preview
Loading…
Cancel
Save