Mercurial > libavcodec.hg

changeset 2338:37516ec97cd6 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
switch ffv1 from CABAC to the range coder
author michael
date Sun, 31 Oct 2004 10:08:50 +0000
parents 841a111be02c
children b7bb00973f99
files ffv1.c
diffstat 1 files changed, 57 insertions(+), 51 deletions(-) [+]
line wrap: on
line diff
--- a/ffv1.c	Sun Oct 31 02:51:39 2004 +0000
+++ b/ffv1.c	Sun Oct 31 10:08:50 2004 +0000
@@ -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 FFV1Context{
     AVCodecContext *avctx;
-    CABACContext c;
+    RangeCoder c;
     GetBitContext gb;
     PutBitContext pb;
     int version;
@@ -221,35 +221,35 @@
 /**
  * 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 @@
         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 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 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_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 @@
     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 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_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;
-    
+    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);
+
     *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 @@
     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 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 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_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_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 @@
     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 @@
         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 @@
     *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;