switch ffv1 from CABAC to the range coder

Originally committed as revision 3658 to svn://svn.ffmpeg.org/ffmpeg/trunk

1 files changed, 57 insertions, 51 deletions

diff --git a/libavcodec/ffv1.c b/libavcodec/ffv1.c
index af57faa5fa..c7eb2281fa 100644
--- a/libavcodec/ffv1.c
+++ b/libavcodec/ffv1.c
@@ -27,7 +27,7 @@
 #include "common.h"
 #include "avcodec.h"
 #include "dsputil.h"
-#include "cabac.h"
+#include "rangecoder.h"
 #include "golomb.h"
 
 #define MAX_PLANES 4
@@ -164,7 +164,7 @@ typedef struct PlaneContext{
 
 typedef struct FFV1Context{
     AVCodecContext *avctx;
-    CABACContext c;
+    RangeCoder c;
     GetBitContext gb;
     PutBitContext pb;
     int version;
@@ -221,35 +221,35 @@ static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *l
 /**
  * put 
  */
-static inline void put_symbol(CABACContext *c, uint8_t *state, int v, int is_signed, int max_exp){
+static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed, int max_exp){
     int i;
 
     if(v){
         const int a= ABS(v);
         const int e= av_log2(a);
 
-        put_cabac(c, state+0, 0);
+        put_rac(c, state+0, 0);
         
         for(i=0; i<e; i++){
-            put_cabac(c, state+1+i, 1);  //1..8
+            put_rac(c, state+1+i, 1);  //1..8
         }
 
         if(e<max_exp){
-            put_cabac(c, state+1+i, 0);      //1..8
+            put_rac(c, state+1+i, 0);      //1..8
 
             for(i=e-1; i>=0; i--){
-                put_cabac(c, state+16+e+i, (a>>i)&1); //17..29
+                put_rac(c, state+16+e+i, (a>>i)&1); //17..29
             }
             if(is_signed)
-                put_cabac(c, state+9 + e, v < 0); //9..16
+                put_rac(c, state+9 + e, v < 0); //9..16
         }
     }else{
-        put_cabac(c, state+0, 1);
+        put_rac(c, state+0, 1);
     }
 }
 
-static inline int get_symbol(CABACContext *c, uint8_t *state, int is_signed, int max_exp){
-    if(get_cabac(c, state+0))
+static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed, int max_exp){
+    if(get_rac(c, state+0))
         return 0;
     else{
         int i, e;
@@ -257,12 +257,12 @@ static inline int get_symbol(CABACContext *c, uint8_t *state, int is_signed, int
         for(e=0; e<max_exp; e++){ 
             int a= 1<<e;
 
-            if(get_cabac(c, state + 1 + e)==0){ // 1..8
+            if(get_rac(c, state + 1 + e)==0){ // 1..8
                 for(i=e-1; i>=0; i--){
-                    a += get_cabac(c, state+16+e+i)<<i; //17..29
+                    a += get_rac(c, state+16+e+i)<<i; //17..29
                 }
 
-                if(is_signed && get_cabac(c, state+9 + e)) //9..16
+                if(is_signed && get_rac(c, state+9 + e)) //9..16
                     return -a;
                 else
                     return a;
@@ -360,7 +360,7 @@ static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int
 
 static inline void encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
     PlaneContext * const p= &s->plane[plane_index];
-    CABACContext * const c= &s->c;
+    RangeCoder * const c= &s->c;
     int x;
     int run_index= s->run_index;
     int run_count=0;
@@ -484,10 +484,11 @@ static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int st
     }
 }
 
-static void write_quant_table(CABACContext *c, int16_t *quant_table){
+static void write_quant_table(RangeCoder *c, int16_t *quant_table){
     int last=0;
     int i;
-    uint8_t state[CONTEXT_SIZE]={0};
+    uint8_t state[CONTEXT_SIZE];
+    memset(state, 128, sizeof(state));
 
     for(i=1; i<128 ; i++){
         if(quant_table[i] != quant_table[i-1]){
@@ -499,17 +500,19 @@ static void write_quant_table(CABACContext *c, int16_t *quant_table){
 }
 
 static void write_header(FFV1Context *f){
-    uint8_t state[CONTEXT_SIZE]={0};
+    uint8_t state[CONTEXT_SIZE];
     int i;
-    CABACContext * const c= &f->c;
+    RangeCoder * const c= &f->c;
 
+    memset(state, 128, sizeof(state));
+    
     put_symbol(c, state, f->version, 0, 7);
     put_symbol(c, state, f->avctx->coder_type, 0, 7);
     put_symbol(c, state, f->colorspace, 0, 7); //YUV cs type 
-    put_cabac(c, state, 1); //chroma planes
+    put_rac(c, state, 1); //chroma planes
         put_symbol(c, state, f->chroma_h_shift, 0, 7);
         put_symbol(c, state, f->chroma_v_shift, 0, 7);
-    put_cabac(c, state, 0); //no transparency plane
+    put_rac(c, state, 0); //no transparency plane
 
     for(i=0; i<5; i++)
         write_quant_table(c, f->quant_table[i]);
@@ -609,13 +612,13 @@ static void clear_state(FFV1Context *f){
     for(i=0; i<f->plane_count; i++){
         PlaneContext *p= &f->plane[i];
 
-        p->interlace_bit_state[0]= 0;
-        p->interlace_bit_state[1]= 0;
+        p->interlace_bit_state[0]= 128;
+        p->interlace_bit_state[1]= 128;
         
         for(j=0; j<p->context_count; j++){
             if(f->ac){
-                memset(p->state[j], 0, sizeof(uint8_t)*CONTEXT_SIZE);
-                p->state[j][7] = 2*62;
+                memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
+                p->state[j][7] = 256-8;
             }else{
                 p->vlc_state[j].drift= 0;
                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
@@ -628,33 +631,33 @@ static void clear_state(FFV1Context *f){
 
 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
     FFV1Context *f = avctx->priv_data;
-    CABACContext * const c= &f->c;
+    RangeCoder * const c= &f->c;
     AVFrame *pict = data;
     const int width= f->width;
     const int height= f->height;
     AVFrame * const p= &f->picture;
     int used_count= 0;
+    uint8_t keystate=128;
+
+    ff_init_range_encoder(c, buf, buf_size);
+//    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
+    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 
-    ff_init_cabac_encoder(c, buf, buf_size);
-    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
-    c->lps_state[2] = 1;
-    c->lps_state[3] = 0;
-    
     *p = *pict;
     p->pict_type= FF_I_TYPE;
     
     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
-        put_cabac_bypass(c, 1);
+        put_rac(c, &keystate, 1);
         p->key_frame= 1;
         write_header(f);
         clear_state(f);
     }else{
-        put_cabac_bypass(c, 0);
+        put_rac(c, &keystate, 0);
         p->key_frame= 0;
     }
 
     if(!f->ac){
-        used_count += put_cabac_terminate(c, 1);
+        used_count += ff_rac_terminate(c);
 //printf("pos=%d\n", used_count);
         init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
     }
@@ -675,7 +678,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,
     f->picture_number++;
 
     if(f->ac){
-        return put_cabac_terminate(c, 1);
+        return ff_rac_terminate(c);
     }else{
         flush_put_bits(&f->pb); //nicer padding FIXME
         return used_count + (put_bits_count(&f->pb)+7)/8;
@@ -703,7 +706,7 @@ static int encode_end(AVCodecContext *avctx)
 
 static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
     PlaneContext * const p= &s->plane[plane_index];
-    CABACContext * const c= &s->c;
+    RangeCoder * const c= &s->c;
     int x;
     int run_count=0;
     int run_mode=0;
@@ -827,10 +830,12 @@ static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int st
     }
 }
 
-static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
+static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
     int v;
     int i=0;
-    uint8_t state[CONTEXT_SIZE]={0};
+    uint8_t state[CONTEXT_SIZE];
+
+    memset(state, 128, sizeof(state));
 
     for(v=0; i<128 ; v++){
         int len= get_symbol(c, state, 0, 7) + 1;
@@ -854,17 +859,19 @@ static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
 }
 
 static int read_header(FFV1Context *f){
-    uint8_t state[CONTEXT_SIZE]={0};
+    uint8_t state[CONTEXT_SIZE];
     int i, context_count;
-    CABACContext * const c= &f->c;
+    RangeCoder * const c= &f->c;
     
+    memset(state, 128, sizeof(state));
+
     f->version= get_symbol(c, state, 0, 7);
     f->ac= f->avctx->coder_type= get_symbol(c, state, 0, 7);
     f->colorspace= get_symbol(c, state, 0, 7); //YUV cs type
-    get_cabac(c, state); //no chroma = false
+    get_rac(c, state); //no chroma = false
     f->chroma_h_shift= get_symbol(c, state, 0, 7);
     f->chroma_v_shift= get_symbol(c, state, 0, 7);
-    get_cabac(c, state); //transparency plane
+    get_rac(c, state); //transparency plane
     f->plane_count= 2;
 
     if(f->colorspace==0){
@@ -927,11 +934,12 @@ static int decode_init(AVCodecContext *avctx)
 
 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
     FFV1Context *f = avctx->priv_data;
-    CABACContext * const c= &f->c;
+    RangeCoder * const c= &f->c;
     const int width= f->width;
     const int height= f->height;
     AVFrame * const p= &f->picture;
     int bytes_read;
+    uint8_t keystate= 128;
 
     AVFrame *picture = data;
 
@@ -939,14 +947,12 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8
     if (buf_size == 0)
         return 0;
 
-    ff_init_cabac_decoder(c, buf, buf_size);
-    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
-    c->lps_state[2] = 1;
-    c->lps_state[3] = 0;
+    ff_init_range_decoder(c, buf, buf_size);
+    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 
 
     p->pict_type= FF_I_TYPE; //FIXME I vs. P
-    if(get_cabac_bypass(c)){
+    if(get_rac(c, &keystate)){
         p->key_frame= 1;
         read_header(f);
         clear_state(f);
@@ -964,8 +970,8 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8
         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
     
     if(!f->ac){
-        bytes_read = get_cabac_terminate(c);
-        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n");
+        bytes_read = c->bytestream - c->bytestream_start - 1;
+        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
 //printf("pos=%d\n", bytes_read);
         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
     } else {
@@ -994,7 +1000,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8
     *data_size = sizeof(AVFrame);
     
     if(f->ac){
-        bytes_read= get_cabac_terminate(c);
+        bytes_read= c->bytestream - c->bytestream_start - 1;
         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
     }else{
         bytes_read+= (get_bits_count(&f->gb)+7)/8;