synfig-core/tags/synfig_0_61_04/synfig-core/src/modules/mod_libavcodec/libavcodec/ffv1.c

   1 /*
   2  * FFV1 codec for libavcodec
   3  *
   4  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 /**
  23  * @file ffv1.c
  24  * FF Video Codec 1 (a experimental lossless codec)
  25  */
  26
  27 #include "common.h"
  28 #include "avcodec.h"
  29 #include "dsputil.h"
  30 #include "cabac.h"
  31 #include "golomb.h"
  32
  33 #define MAX_PLANES 4
  34 #define CONTEXT_SIZE 32
  35
  36 static const int8_t quant3[256]={
  37  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  38  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  39  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  40  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  41  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  42  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  43  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  44  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  45 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  46 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  47 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  48 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  49 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  50 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  51 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  52 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
  53 };
  54 static const int8_t quant5[256]={
  55  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  56  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  57  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  58  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  59  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  60  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  61  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  62  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  63 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  64 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  65 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  66 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  67 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  68 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  69 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  70 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
  71 };
  72 static const int8_t quant7[256]={
  73  0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  74  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  75  2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
  76  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  77  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  78  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  79  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  80  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  81 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  82 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  83 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  84 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  85 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  86 -3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
  87 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  88 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
  89 };
  90 static const int8_t quant9[256]={
  91  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  92  3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  93  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  94  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  95  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  96  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  97  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  98  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  99 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 100 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 101 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 102 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 103 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 104 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 105 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
 106 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
 107 };
 108 static const int8_t quant11[256]={
 109  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
 110  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 111  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 112  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 113  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 114  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 115  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 116  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 117 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 118 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 119 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 120 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 121 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 122 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
 123 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 124 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
 125 };
 126 static const int8_t quant13[256]={
 127  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
 128  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 129  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 130  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 131  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 132  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 133  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 134  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 135 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 136 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 137 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 138 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 139 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
 140 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 141 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 142 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
 143 };
 144
 145 static const uint8_t log2_run[32]={
 146  0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
 147  4, 4, 5, 5, 6, 6, 7, 7,
 148  8, 9,10,11,12,13,14,15,
 149 };
 150
 151 typedef struct VlcState{
 152     int16_t drift;
 153     uint16_t error_sum;
 154     int8_t bias;
 155     uint8_t count;
 156 } VlcState;
 157
 158 typedef struct PlaneContext{
 159     int context_count;
 160     uint8_t (*state)[CONTEXT_SIZE];
 161     VlcState *vlc_state;
 162     uint8_t interlace_bit_state[2];
 163 } PlaneContext;
 164
 165 typedef struct FFV1Context{
 166     AVCodecContext *avctx;
 167     CABACContext c;
 168     GetBitContext gb;
 169     PutBitContext pb;
 170     int version;
 171     int width, height;
 172     int chroma_h_shift, chroma_v_shift;
 173     int flags;
 174     int picture_number;
 175     AVFrame picture;
 176     int plane_count;
 177     int ac;                              ///< 1-> CABAC 0-> golomb rice
 178     PlaneContext plane[MAX_PLANES];
 179     int16_t quant_table[5][256];
 180
 181     DSPContext dsp;
 182 }FFV1Context;
 183
 184 static inline int predict(uint8_t *src, uint8_t *last){
 185     const int LT= last[-1];
 186     const int  T= last[ 0];
 187     const int L =  src[-1];
 188
 189     return mid_pred(L, L + T - LT, T);
 190 }
 191
 192 static inline int get_context(FFV1Context *f, uint8_t *src, uint8_t *last, uint8_t *last2){
 193     const int LT= last[-1];
 194     const int  T= last[ 0];
 195     const int RT= last[ 1];
 196     const int L =  src[-1];
 197
 198     if(f->quant_table[3][127]){
 199         const int TT= last2[0];
 200         const int LL=  src[-2];
 201         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
 202               +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
 203     }else
 204         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
 205 }
 206
 207 /**
 208  * put
 209  */
 210 static inline void put_symbol(CABACContext *c, uint8_t *state, int v, int is_signed, int max_exp){
 211     int i;
 212
 213     if(v){
 214         const int a= ABS(v);
 215         const int e= av_log2(a);
 216
 217         put_cabac(c, state+0, 0);
 218
 219         for(i=0; i<e; i++){
 220             put_cabac(c, state+1+i, 1);  //1..8
 221         }
 222
 223         if(e<max_exp){
 224             put_cabac(c, state+1+i, 0);      //1..8
 225
 226             for(i=e-1; i>=0; i--){
 227                 put_cabac(c, state+16+e+i, (a>>i)&1); //17..29
 228             }
 229             if(is_signed)
 230                 put_cabac(c, state+9 + e, v < 0); //9..16
 231         }
 232     }else{
 233         put_cabac(c, state+0, 1);
 234     }
 235 }
 236
 237 static inline int get_symbol(CABACContext *c, uint8_t *state, int is_signed, int max_exp){
 238     if(get_cabac(c, state+0))
 239         return 0;
 240     else{
 241         int i, e;
 242
 243         for(e=0; e<max_exp; e++){
 244             int a= 1<<e;
 245
 246             if(get_cabac(c, state + 1 + e)==0){ // 1..8
 247                 for(i=e-1; i>=0; i--){
 248                     a += get_cabac(c, state+16+e+i)<<i; //17..29
 249                 }
 250
 251                 if(is_signed && get_cabac(c, state+9 + e)) //9..16
 252                     return -a;
 253                 else
 254                     return a;
 255             }
 256         }
 257         return -(1<<e);
 258     }
 259 }
 260
 261 static inline void update_vlc_state(VlcState * const state, const int v){
 262     int drift= state->drift;
 263     int count= state->count;
 264     state->error_sum += ABS(v);
 265     drift += v;
 266
 267     if(count == 128){ //FIXME variable
 268         count >>= 1;
 269         drift >>= 1;
 270         state->error_sum >>= 1;
 271     }
 272     count++;
 273
 274     if(drift <= -count){
 275         if(state->bias > -128) state->bias--;
 276
 277         drift += count;
 278         if(drift <= -count)
 279             drift= -count + 1;
 280     }else if(drift > 0){
 281         if(state->bias <  127) state->bias++;
 282
 283         drift -= count;
 284         if(drift > 0)
 285             drift= 0;
 286     }
 287
 288     state->drift= drift;
 289     state->count= count;
 290 }
 291
 292 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v){
 293     int i, k, code;
 294 //printf("final: %d ", v);
 295     v = (int8_t)(v - state->bias);
 296
 297     i= state->count;
 298     k=0;
 299     while(i < state->error_sum){ //FIXME optimize
 300         k++;
 301         i += i;
 302     }
 303
 304     assert(k<=8);
 305
 306 #if 0 // JPEG LS
 307     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
 308     else                                         code= v;
 309 #else
 310      code= v ^ ((2*state->drift + state->count)>>31);
 311 #endif
 312
 313     code = -2*code-1;
 314     code^= (code>>31);
 315 //printf("v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code, state->bias, state->error_sum, state->drift, state->count, k);
 316     set_ur_golomb(pb, code, k, 12, 8);
 317
 318     update_vlc_state(state, v);
 319 }
 320
 321 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state){
 322     int k, i, v, ret;
 323
 324     i= state->count;
 325     k=0;
 326     while(i < state->error_sum){ //FIXME optimize
 327         k++;
 328         i += i;
 329     }
 330
 331     assert(k<=8);
 332
 333     v= get_ur_golomb(gb, k, 12, 8);
 334 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
 335
 336     v++;
 337     if(v&1) v=  (v>>1);
 338     else    v= -(v>>1);
 339
 340 #if 0 // JPEG LS
 341     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
 342 #else
 343      v ^= ((2*state->drift + state->count)>>31);
 344 #endif
 345
 346     ret= (int8_t)(v + state->bias);
 347
 348     update_vlc_state(state, v);
 349 //printf("final: %d\n", ret);
 350     return ret;
 351 }
 352
 353
 354
 355 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 356     PlaneContext * const p= &s->plane[plane_index];
 357     CABACContext * const c= &s->c;
 358     int x,y;
 359     uint8_t sample_buffer[2][w+6];
 360     uint8_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
 361     int run_index=0;
 362
 363     memset(sample_buffer, 0, sizeof(sample_buffer));
 364
 365     for(y=0; y<h; y++){
 366         uint8_t *temp= sample[0]; //FIXME try a normal buffer
 367         int run_count=0;
 368         int run_mode=0;
 369
 370         sample[0]= sample[1];
 371         sample[1]= temp;
 372
 373         sample[1][-1]= sample[0][0  ];
 374         sample[0][ w]= sample[0][w-1];
 375
 376         for(x=0; x<w; x++){
 377             uint8_t *temp_src= src + x + stride*y;
 378             int diff, context;
 379
 380             context= get_context(s, sample[1]+x, sample[0]+x, sample[1]+x);
 381             diff= temp_src[0] - predict(sample[1]+x, sample[0]+x);
 382
 383             if(context < 0){
 384                 context = -context;
 385                 diff= -diff;
 386             }
 387
 388             diff= (int8_t)diff;
 389
 390             if(s->ac){
 391                 put_symbol(c, p->state[context], diff, 1, 7);
 392             }else{
 393                 if(context == 0) run_mode=1;
 394
 395                 if(run_mode){
 396
 397                     if(diff){
 398                         while(run_count >= 1<<log2_run[run_index]){
 399                             run_count -= 1<<log2_run[run_index];
 400                             run_index++;
 401                             put_bits(&s->pb, 1, 1);
 402                         }
 403
 404                         put_bits(&s->pb, 1 + log2_run[run_index], run_count);
 405                         if(run_index) run_index--;
 406                         run_count=0;
 407                         run_mode=0;
 408                         if(diff>0) diff--;
 409                     }else{
 410                         run_count++;
 411                     }
 412                 }
 413
 414 //                printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, (int)get_bit_count(&s->pb));
 415
 416                 if(run_mode == 0)
 417                     put_vlc_symbol(&s->pb, &p->vlc_state[context], diff);
 418             }
 419
 420             sample[1][x]= temp_src[0];
 421         }
 422         if(run_mode){
 423             while(run_count >= 1<<log2_run[run_index]){
 424                 run_count -= 1<<log2_run[run_index];
 425                 run_index++;
 426                 put_bits(&s->pb, 1, 1);
 427             }
 428
 429             if(run_count)
 430                 put_bits(&s->pb, 1, 1);
 431         }
 432     }
 433 }
 434
 435 static void write_quant_table(CABACContext *c, int16_t *quant_table){
 436     int last=0;
 437     int i;
 438     uint8_t state[CONTEXT_SIZE]={0};
 439
 440     for(i=1; i<128 ; i++){
 441         if(quant_table[i] != quant_table[i-1]){
 442             put_symbol(c, state, i-last-1, 0, 7);
 443             last= i;
 444         }
 445     }
 446     put_symbol(c, state, i-last-1, 0, 7);
 447 }
 448
 449 static void write_header(FFV1Context *f){
 450     uint8_t state[CONTEXT_SIZE]={0};
 451     int i;
 452     CABACContext * const c= &f->c;
 453
 454     put_symbol(c, state, f->version, 0, 7);
 455     put_symbol(c, state, f->avctx->coder_type, 0, 7);
 456     put_symbol(c, state, 0, 0, 7); //YUV cs type
 457     put_cabac(c, state, 1); //chroma planes
 458         put_symbol(c, state, f->chroma_h_shift, 0, 7);
 459         put_symbol(c, state, f->chroma_v_shift, 0, 7);
 460     put_cabac(c, state, 0); //no transparency plane
 461
 462     for(i=0; i<5; i++)
 463         write_quant_table(c, f->quant_table[i]);
 464 }
 465
 466 static int common_init(AVCodecContext *avctx){
 467     FFV1Context *s = avctx->priv_data;
 468     int width, height;
 469
 470     s->avctx= avctx;
 471     s->flags= avctx->flags;
 472
 473     dsputil_init(&s->dsp, avctx);
 474
 475     width= s->width= avctx->width;
 476     height= s->height= avctx->height;
 477
 478     assert(width && height);
 479
 480     return 0;
 481 }
 482
 483 static int encode_init(AVCodecContext *avctx)
 484 {
 485     FFV1Context *s = avctx->priv_data;
 486     int i;
 487
 488     common_init(avctx);
 489
 490     s->version=0;
 491     s->ac= avctx->coder_type;
 492
 493     s->plane_count=2;
 494     for(i=0; i<256; i++){
 495         s->quant_table[0][i]=           quant11[i];
 496         s->quant_table[1][i]=        11*quant11[i];
 497         if(avctx->context_model==0){
 498             s->quant_table[2][i]=     11*11*quant11[i];
 499             s->quant_table[3][i]=
 500             s->quant_table[4][i]=0;
 501         }else{
 502             s->quant_table[2][i]=     11*11*quant5 [i];
 503             s->quant_table[3][i]=   5*11*11*quant5 [i];
 504             s->quant_table[4][i]= 5*5*11*11*quant5 [i];
 505         }
 506     }
 507
 508     for(i=0; i<s->plane_count; i++){
 509         PlaneContext * const p= &s->plane[i];
 510
 511         if(avctx->context_model==0){
 512             p->context_count= (11*11*11+1)/2;
 513         }else{
 514             p->context_count= (11*11*5*5*5+1)/2;
 515         }
 516
 517         if(s->ac){
 518             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 519         }else{
 520             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 521         }
 522     }
 523
 524     avctx->coded_frame= &s->picture;
 525     switch(avctx->pix_fmt){
 526     case PIX_FMT_YUV444P:
 527     case PIX_FMT_YUV422P:
 528     case PIX_FMT_YUV420P:
 529     case PIX_FMT_YUV411P:
 530     case PIX_FMT_YUV410P:
 531         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 532         break;
 533     default:
 534         fprintf(stderr, "format not supported\n");
 535         return -1;
 536     }
 537
 538
 539     s->picture_number=0;
 540
 541     return 0;
 542 }
 543
 544
 545 static void clear_state(FFV1Context *f){
 546     int i, j;
 547
 548     for(i=0; i<f->plane_count; i++){
 549         PlaneContext *p= &f->plane[i];
 550
 551         p->interlace_bit_state[0]= 0;
 552         p->interlace_bit_state[1]= 0;
 553
 554         for(j=0; j<p->context_count; j++){
 555             if(f->ac){
 556                 memset(p->state[j], 0, sizeof(uint8_t)*CONTEXT_SIZE);
 557                 p->state[j][7] = 2*62;
 558             }else{
 559                 p->vlc_state[j].drift= 0;
 560                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
 561                 p->vlc_state[j].bias= 0;
 562                 p->vlc_state[j].count= 1;
 563             }
 564         }
 565     }
 566 }
 567
 568 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 569     FFV1Context *f = avctx->priv_data;
 570     CABACContext * const c= &f->c;
 571     AVFrame *pict = data;
 572     const int width= f->width;
 573     const int height= f->height;
 574     AVFrame * const p= &f->picture;
 575     int used_count= 0;
 576
 577     if(avctx->strict_std_compliance >= 0){
 578         printf("this codec is under development, files encoded with it wont be decodeable with future versions!!!\n"
 579                "use vstrict=-1 to use it anyway\n");
 580         return -1;
 581     }
 582
 583     ff_init_cabac_encoder(c, buf, buf_size);
 584     ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
 585
 586     *p = *pict;
 587     p->pict_type= FF_I_TYPE;
 588
 589     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
 590         put_cabac_bypass(c, 1);
 591         p->key_frame= 1;
 592         write_header(f);
 593         clear_state(f);
 594     }else{
 595         put_cabac_bypass(c, 0);
 596         p->key_frame= 0;
 597     }
 598
 599     if(!f->ac){
 600         used_count += put_cabac_terminate(c, 1);
 601 //printf("pos=%d\n", used_count);
 602         init_put_bits(&f->pb, buf + used_count, buf_size - used_count, NULL, NULL);
 603     }
 604
 605     if(1){
 606         const int chroma_width = -((-width )>>f->chroma_h_shift);
 607         const int chroma_height= -((-height)>>f->chroma_v_shift);
 608
 609         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
 610
 611         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
 612         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
 613     }
 614     emms_c();
 615
 616     f->picture_number++;
 617
 618     if(f->ac){
 619         return put_cabac_terminate(c, 1);
 620     }else{
 621         flush_put_bits(&f->pb); //nicer padding FIXME
 622         return used_count + (get_bit_count(&f->pb)+7)/8;
 623     }
 624 }
 625
 626 static void common_end(FFV1Context *s){
 627     int i;
 628
 629     for(i=0; i<s->plane_count; i++){
 630         PlaneContext *p= &s->plane[i];
 631
 632         av_freep(&p->state);
 633     }
 634 }
 635
 636 static int encode_end(AVCodecContext *avctx)
 637 {
 638     FFV1Context *s = avctx->priv_data;
 639
 640     common_end(s);
 641
 642     return 0;
 643 }
 644
 645 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 646     PlaneContext * const p= &s->plane[plane_index];
 647     CABACContext * const c= &s->c;
 648     int x,y;
 649     uint8_t sample_buffer[2][w+6];
 650     uint8_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
 651     int run_index=0;
 652
 653     memset(sample_buffer, 0, sizeof(sample_buffer));
 654
 655     for(y=0; y<h; y++){
 656         uint8_t *temp= sample[0]; //FIXME try a normal buffer
 657         int run_count=0;
 658         int run_mode=0;
 659
 660         sample[0]= sample[1];
 661         sample[1]= temp;
 662
 663         sample[1][-1]= sample[0][0  ];
 664         sample[0][ w]= sample[0][w-1];
 665
 666         for(x=0; x<w; x++){
 667             uint8_t *temp_src= src + x + stride*y;
 668             int diff, context, sign;
 669
 670             context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
 671             if(context < 0){
 672                 context= -context;
 673                 sign=1;
 674             }else
 675                 sign=0;
 676
 677
 678             if(s->ac)
 679                 diff= get_symbol(c, p->state[context], 1, 7);
 680             else{
 681                 if(context == 0 && run_mode==0) run_mode=1;
 682
 683                 if(run_mode){
 684                     if(run_count==0 && run_mode==1){
 685                         if(get_bits1(&s->gb)){
 686                             run_count = 1<<log2_run[run_index];
 687                             if(x + run_count <= w) run_index++;
 688                         }else{
 689                             if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
 690                             else run_count=0;
 691                             if(run_index) run_index--;
 692                             run_mode=2;
 693                         }
 694                     }
 695                     run_count--;
 696                     if(run_count < 0){
 697                         run_mode=0;
 698                         run_count=0;
 699                         diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);
 700                         if(diff>=0) diff++;
 701                     }else
 702                         diff=0;
 703                 }else
 704                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);
 705
 706 //                printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, get_bits_count(&s->gb));
 707             }
 708
 709             if(sign) diff= (int8_t)(-diff); //FIXME remove cast
 710
 711             sample[1][x]=
 712             temp_src[0] = predict(sample[1] + x, sample[0] + x) + diff;
 713
 714             assert(diff>= -128 && diff <= 127);
 715         }
 716     }
 717 }
 718
 719 static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
 720     int v;
 721     int i=0;
 722     uint8_t state[CONTEXT_SIZE]={0};
 723
 724     for(v=0; i<128 ; v++){
 725         int len= get_symbol(c, state, 0, 7) + 1;
 726
 727         if(len + i > 128) return -1;
 728
 729         while(len--){
 730             quant_table[i] = scale*v;
 731             i++;
 732 //printf("%2d ",v);
 733 //if(i%16==0) printf("\n");
 734         }
 735     }
 736
 737     for(i=1; i<128; i++){
 738         quant_table[256-i]= -quant_table[i];
 739     }
 740     quant_table[128]= -quant_table[127];
 741
 742     return 2*v - 1;
 743 }
 744
 745 static int read_header(FFV1Context *f){
 746     uint8_t state[CONTEXT_SIZE]={0};
 747     int i, context_count;
 748     CABACContext * const c= &f->c;
 749
 750     f->version= get_symbol(c, state, 0, 7);
 751     f->ac= f->avctx->coder_type= get_symbol(c, state, 0, 7);
 752     get_symbol(c, state, 0, 7); //YUV cs type
 753     get_cabac(c, state); //no chroma = false
 754     f->chroma_h_shift= get_symbol(c, state, 0, 7);
 755     f->chroma_v_shift= get_symbol(c, state, 0, 7);
 756     get_cabac(c, state); //transparency plane
 757     f->plane_count= 2;
 758
 759     switch(16*f->chroma_h_shift + f->chroma_v_shift){
 760     case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
 761     case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
 762     case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
 763     case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
 764     case 0x33: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
 765     default:
 766         fprintf(stderr, "format not supported\n");
 767         return -1;
 768     }
 769 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
 770
 771     context_count=1;
 772     for(i=0; i<5; i++){
 773         context_count*= read_quant_table(c, f->quant_table[i], context_count);
 774         if(context_count < 0){
 775             printf("read_quant_table error\n");
 776             return -1;
 777         }
 778     }
 779     context_count= (context_count+1)/2;
 780
 781     for(i=0; i<f->plane_count; i++){
 782         PlaneContext * const p= &f->plane[i];
 783
 784         p->context_count= context_count;
 785
 786         if(f->ac){
 787             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 788         }else{
 789             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 790         }
 791     }
 792
 793     return 0;
 794 }
 795
 796 static int decode_init(AVCodecContext *avctx)
 797 {
 798 //    FFV1Context *s = avctx->priv_data;
 799
 800     common_init(avctx);
 801
 802 #if 0
 803     switch(s->bitstream_bpp){
 804     case 12:
 805         avctx->pix_fmt = PIX_FMT_YUV420P;
 806         break;
 807     case 16:
 808         avctx->pix_fmt = PIX_FMT_YUV422P;
 809         break;
 810     case 24:
 811     case 32:
 812         if(s->bgr32){
 813             avctx->pix_fmt = PIX_FMT_RGBA32;
 814         }else{
 815             avctx->pix_fmt = PIX_FMT_BGR24;
 816         }
 817         break;
 818     default:
 819         assert(0);
 820     }
 821 #endif
 822
 823     return 0;
 824 }
 825
 826 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
 827     FFV1Context *f = avctx->priv_data;
 828     CABACContext * const c= &f->c;
 829     const int width= f->width;
 830     const int height= f->height;
 831     AVFrame * const p= &f->picture;
 832     int bytes_read;
 833
 834     AVFrame *picture = data;
 835
 836     *data_size = 0;
 837
 838     /* no supplementary picture */
 839     if (buf_size == 0)
 840         return 0;
 841
 842     ff_init_cabac_decoder(c, buf, buf_size);
 843     ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
 844
 845     p->pict_type= FF_I_TYPE; //FIXME I vs. P
 846     if(get_cabac_bypass(c)){
 847         p->key_frame= 1;
 848         read_header(f);
 849         clear_state(f);
 850     }else{
 851         p->key_frame= 0;
 852     }
 853
 854     p->reference= 0;
 855     if(avctx->get_buffer(avctx, p) < 0){
 856         fprintf(stderr, "get_buffer() failed\n");
 857         return -1;
 858     }
 859
 860     if(avctx->debug&FF_DEBUG_PICT_INFO)
 861         printf("keyframe:%d coder:%d\n", p->key_frame, f->ac);
 862
 863     if(!f->ac){
 864         bytes_read = get_cabac_terminate(c);
 865         if(bytes_read ==0) printf("error at end of AC stream\n");
 866 //printf("pos=%d\n", bytes_read);
 867         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
 868     } else {
 869         bytes_read = 0; /* avoid warning */
 870     }
 871
 872     if(1){
 873         const int chroma_width = -((-width )>>f->chroma_h_shift);
 874         const int chroma_height= -((-height)>>f->chroma_v_shift);
 875         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
 876
 877         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
 878         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
 879     }
 880
 881     emms_c();
 882
 883     f->picture_number++;
 884
 885     *picture= *p;
 886
 887     avctx->release_buffer(avctx, p); //FIXME
 888
 889     *data_size = sizeof(AVFrame);
 890
 891     if(f->ac){
 892         bytes_read= get_cabac_terminate(c);
 893         if(bytes_read ==0) printf("error at end of frame\n");
 894     }else{
 895         bytes_read+= (get_bits_count(&f->gb)+7)/8;
 896     }
 897
 898     return bytes_read;
 899 }
 900
 901 static int decode_end(AVCodecContext *avctx)
 902 {
 903     FFV1Context *s = avctx->priv_data;
 904     int i;
 905
 906     if(avctx->get_buffer == avcodec_default_get_buffer){
 907         for(i=0; i<4; i++){
 908             av_freep(&s->picture.base[i]);
 909             s->picture.data[i]= NULL;
 910         }
 911         av_freep(&s->picture.opaque);
 912     }
 913
 914     return 0;
 915 }
 916
 917 AVCodec ffv1_decoder = {
 918     "ffv1",
 919     CODEC_TYPE_VIDEO,
 920     CODEC_ID_FFV1,
 921     sizeof(FFV1Context),
 922     decode_init,
 923     NULL,
 924     decode_end,
 925     decode_frame,
 926     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
 927     NULL
 928 };
 929
 930 #ifdef CONFIG_ENCODERS
 931 AVCodec ffv1_encoder = {
 932     "ffv1",
 933     CODEC_TYPE_VIDEO,
 934     CODEC_ID_FFV1,
 935     sizeof(FFV1Context),
 936     encode_init,
 937     encode_frame,
 938     encode_end,
 939 };
 940 #endif