git.sesse.net Git - ffmpeg/blob - libavcodec/ffv1.c

   1 /*
   2  * FFV1 codec for libavcodec
   3  *
   4  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file
  25  * FF Video Codec 1 (a lossless codec)
  26  */
  27
  28 #include "avcodec.h"
  29 #include "get_bits.h"
  30 #include "put_bits.h"
  31 #include "dsputil.h"
  32 #include "rangecoder.h"
  33 #include "golomb.h"
  34 #include "mathops.h"
  35 #include "libavutil/avassert.h"
  36
  37 #define MAX_PLANES 4
  38 #define CONTEXT_SIZE 32
  39
  40 #define MAX_QUANT_TABLES 8
  41 #define MAX_CONTEXT_INPUTS 5
  42
  43 extern const uint8_t ff_log2_run[41];
  44
  45 static const int8_t quant5_10bit[256]={
  46  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  50  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  51  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  52  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  53  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  54 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  55 -2,-2,-2,-2,-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,-1,
  59 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  60 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  61 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
  62 };
  63
  64 static const int8_t quant5[256]={
  65  0, 1, 1, 1, 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, 2, 2, 2,
  71  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  72  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  73 -2,-2,-2,-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,-2,-2,-2,-2,-2,-2,-2,-2,
  76 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  77 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  78 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  79 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  80 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
  81 };
  82
  83 static const int8_t quant9_10bit[256]={
  84  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
  85  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
  86  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  87  3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
  88  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  89  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  90  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  91  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  92 -4,-4,-4,-4,-4,-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,-3,-3,-3,-3,-3,-3,-3,
  97 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  98 -3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  99 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
 100 };
 101
 102 static const int8_t quant11[256]={
 103  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 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, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 106  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 107  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 108  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 109  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 110  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 111 -5,-5,-5,-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,-4,-4,
 117 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 118 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
 119 };
 120
 121 static const uint8_t ver2_state[256]= {
 122    0,  10,  10,  10,  10,  16,  16,  16,  28,  16,  16,  29,  42,  49,  20,  49,
 123   59,  25,  26,  26,  27,  31,  33,  33,  33,  34,  34,  37,  67,  38,  39,  39,
 124   40,  40,  41,  79,  43,  44,  45,  45,  48,  48,  64,  50,  51,  52,  88,  52,
 125   53,  74,  55,  57,  58,  58,  74,  60, 101,  61,  62,  84,  66,  66,  68,  69,
 126   87,  82,  71,  97,  73,  73,  82,  75, 111,  77,  94,  78,  87,  81,  83,  97,
 127   85,  83,  94,  86,  99,  89,  90,  99, 111,  92,  93, 134,  95,  98, 105,  98,
 128  105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
 129  115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
 130  165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
 131  147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
 132  172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
 133  175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
 134  197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
 135  209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
 136  226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
 137  241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
 138 };
 139
 140 typedef struct VlcState{
 141     int16_t drift;
 142     uint16_t error_sum;
 143     int8_t bias;
 144     uint8_t count;
 145 } VlcState;
 146
 147 typedef struct PlaneContext{
 148     int16_t quant_table[MAX_CONTEXT_INPUTS][256];
 149     int quant_table_index;
 150     int context_count;
 151     uint8_t (*state)[CONTEXT_SIZE];
 152     VlcState *vlc_state;
 153     uint8_t interlace_bit_state[2];
 154 } PlaneContext;
 155
 156 #define MAX_SLICES 256
 157
 158 typedef struct FFV1Context{
 159     AVCodecContext *avctx;
 160     RangeCoder c;
 161     GetBitContext gb;
 162     PutBitContext pb;
 163     uint64_t rc_stat[256][2];
 164     uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
 165     int version;
 166     int width, height;
 167     int chroma_h_shift, chroma_v_shift;
 168     int flags;
 169     int picture_number;
 170     AVFrame picture;
 171     int plane_count;
 172     int ac;                              ///< 1=range coder <-> 0=golomb rice
 173     PlaneContext plane[MAX_PLANES];
 174     int16_t quant_table[MAX_CONTEXT_INPUTS][256];
 175     int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
 176     int context_count[MAX_QUANT_TABLES];
 177     uint8_t state_transition[256];
 178     uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
 179     int run_index;
 180     int colorspace;
 181     int16_t *sample_buffer;
 182     int gob_count;
 183     int packed_at_lsb;
 184
 185     int quant_table_count;
 186
 187     DSPContext dsp;
 188
 189     struct FFV1Context *slice_context[MAX_SLICES];
 190     int slice_count;
 191     int num_v_slices;
 192     int num_h_slices;
 193     int slice_width;
 194     int slice_height;
 195     int slice_x;
 196     int slice_y;
 197 }FFV1Context;
 198
 199 static av_always_inline int fold(int diff, int bits){
 200     if(bits==8)
 201         diff= (int8_t)diff;
 202     else{
 203         diff+= 1<<(bits-1);
 204         diff&=(1<<bits)-1;
 205         diff-= 1<<(bits-1);
 206     }
 207
 208     return diff;
 209 }
 210
 211 static inline int predict(int16_t *src, int16_t *last)
 212 {
 213     const int LT= last[-1];
 214     const int  T= last[ 0];
 215     const int L =  src[-1];
 216
 217     return mid_pred(L, L + T - LT, T);
 218 }
 219
 220 static inline int get_context(PlaneContext *p, int16_t *src,
 221                               int16_t *last, int16_t *last2)
 222 {
 223     const int LT= last[-1];
 224     const int  T= last[ 0];
 225     const int RT= last[ 1];
 226     const int L =  src[-1];
 227
 228     if(p->quant_table[3][127]){
 229         const int TT= last2[0];
 230         const int LL=  src[-2];
 231         return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
 232               +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
 233     }else
 234         return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
 235 }
 236
 237 static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
 238     int i,j,k,m;
 239     double l2tab[256];
 240
 241     for(i=1; i<256; i++)
 242         l2tab[i]= log2(i/256.0);
 243
 244     for(i=0; i<256; i++){
 245         double best_len[256];
 246         double p= i/256.0;
 247
 248         for(j=0; j<256; j++)
 249             best_len[j]= 1<<30;
 250
 251         for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
 252             double occ[256]={0};
 253             double len=0;
 254             occ[j]=1.0;
 255             for(k=0; k<256; k++){
 256                 double newocc[256]={0};
 257                 for(m=0; m<256; m++){
 258                     if(occ[m]){
 259                         len -=occ[m]*(     p *l2tab[    m]
 260                                       + (1-p)*l2tab[256-m]);
 261                     }
 262                 }
 263                 if(len < best_len[k]){
 264                     best_len[k]= len;
 265                     best_state[i][k]= j;
 266                 }
 267                 for(m=0; m<256; m++){
 268                     if(occ[m]){
 269                         newocc[    one_state[    m]] += occ[m]*   p ;
 270                         newocc[256-one_state[256-m]] += occ[m]*(1-p);
 271                     }
 272                 }
 273                 memcpy(occ, newocc, sizeof(occ));
 274             }
 275         }
 276     }
 277 }
 278
 279 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2]){
 280     int i;
 281
 282 #define put_rac(C,S,B) \
 283 do{\
 284     if(rc_stat){\
 285     rc_stat[*(S)][B]++;\
 286         rc_stat2[(S)-state][B]++;\
 287     }\
 288     put_rac(C,S,B);\
 289 }while(0)
 290
 291     if(v){
 292         const int a= FFABS(v);
 293         const int e= av_log2(a);
 294         put_rac(c, state+0, 0);
 295         if(e<=9){
 296             for(i=0; i<e; i++){
 297                 put_rac(c, state+1+i, 1);  //1..10
 298             }
 299             put_rac(c, state+1+i, 0);
 300
 301             for(i=e-1; i>=0; i--){
 302                 put_rac(c, state+22+i, (a>>i)&1); //22..31
 303             }
 304
 305             if(is_signed)
 306                 put_rac(c, state+11 + e, v < 0); //11..21
 307         }else{
 308             for(i=0; i<e; i++){
 309                 put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
 310             }
 311             put_rac(c, state+1+9, 0);
 312
 313             for(i=e-1; i>=0; i--){
 314                 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
 315             }
 316
 317             if(is_signed)
 318                 put_rac(c, state+11 + 10, v < 0); //11..21
 319         }
 320     }else{
 321         put_rac(c, state+0, 1);
 322     }
 323 #undef put_rac
 324 }
 325
 326 static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
 327     put_symbol_inline(c, state, v, is_signed, NULL, NULL);
 328 }
 329
 330 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
 331     if(get_rac(c, state+0))
 332         return 0;
 333     else{
 334         int i, e, a;
 335         e= 0;
 336         while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
 337             e++;
 338         }
 339
 340         a= 1;
 341         for(i=e-1; i>=0; i--){
 342             a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
 343         }
 344
 345         e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
 346         return (a^e)-e;
 347     }
 348 }
 349
 350 static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
 351     return get_symbol_inline(c, state, is_signed);
 352 }
 353
 354 static inline void update_vlc_state(VlcState * const state, const int v){
 355     int drift= state->drift;
 356     int count= state->count;
 357     state->error_sum += FFABS(v);
 358     drift += v;
 359
 360     if(count == 128){ //FIXME variable
 361         count >>= 1;
 362         drift >>= 1;
 363         state->error_sum >>= 1;
 364     }
 365     count++;
 366
 367     if(drift <= -count){
 368         if(state->bias > -128) state->bias--;
 369
 370         drift += count;
 371         if(drift <= -count)
 372             drift= -count + 1;
 373     }else if(drift > 0){
 374         if(state->bias <  127) state->bias++;
 375
 376         drift -= count;
 377         if(drift > 0)
 378             drift= 0;
 379     }
 380
 381     state->drift= drift;
 382     state->count= count;
 383 }
 384
 385 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
 386     int i, k, code;
 387 //printf("final: %d ", v);
 388     v = fold(v - state->bias, bits);
 389
 390     i= state->count;
 391     k=0;
 392     while(i < state->error_sum){ //FIXME optimize
 393         k++;
 394         i += i;
 395     }
 396
 397     assert(k<=8);
 398
 399 #if 0 // JPEG LS
 400     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
 401     else                                         code= v;
 402 #else
 403      code= v ^ ((2*state->drift + state->count)>>31);
 404 #endif
 405
 406 //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);
 407     set_sr_golomb(pb, code, k, 12, bits);
 408
 409     update_vlc_state(state, v);
 410 }
 411
 412 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
 413     int k, i, v, ret;
 414
 415     i= state->count;
 416     k=0;
 417     while(i < state->error_sum){ //FIXME optimize
 418         k++;
 419         i += i;
 420     }
 421
 422     assert(k<=8);
 423
 424     v= get_sr_golomb(gb, k, 12, bits);
 425 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
 426
 427 #if 0 // JPEG LS
 428     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
 429 #else
 430      v ^= ((2*state->drift + state->count)>>31);
 431 #endif
 432
 433     ret= fold(v + state->bias, bits);
 434
 435     update_vlc_state(state, v);
 436 //printf("final: %d\n", ret);
 437     return ret;
 438 }
 439
 440 #if CONFIG_FFV1_ENCODER
 441 static av_always_inline int encode_line(FFV1Context *s, int w,
 442                                         int16_t *sample[2],
 443                                         int plane_index, int bits)
 444 {
 445     PlaneContext * const p= &s->plane[plane_index];
 446     RangeCoder * const c= &s->c;
 447     int x;
 448     int run_index= s->run_index;
 449     int run_count=0;
 450     int run_mode=0;
 451
 452     if(s->ac){
 453         if(c->bytestream_end - c->bytestream < w*20){
 454             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 455             return -1;
 456         }
 457     }else{
 458         if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
 459             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 460             return -1;
 461         }
 462     }
 463
 464     for(x=0; x<w; x++){
 465         int diff, context;
 466
 467         context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
 468         diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
 469
 470         if(context < 0){
 471             context = -context;
 472             diff= -diff;
 473         }
 474
 475         diff= fold(diff, bits);
 476
 477         if(s->ac){
 478             if(s->flags & CODEC_FLAG_PASS1){
 479                 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
 480             }else{
 481                 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
 482             }
 483         }else{
 484             if(context == 0) run_mode=1;
 485
 486             if(run_mode){
 487
 488                 if(diff){
 489                     while(run_count >= 1<<ff_log2_run[run_index]){
 490                         run_count -= 1<<ff_log2_run[run_index];
 491                         run_index++;
 492                         put_bits(&s->pb, 1, 1);
 493                     }
 494
 495                     put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
 496                     if(run_index) run_index--;
 497                     run_count=0;
 498                     run_mode=0;
 499                     if(diff>0) diff--;
 500                 }else{
 501                     run_count++;
 502                 }
 503             }
 504
 505 //            printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, (int)put_bits_count(&s->pb));
 506
 507             if(run_mode == 0)
 508                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
 509         }
 510     }
 511     if(run_mode){
 512         while(run_count >= 1<<ff_log2_run[run_index]){
 513             run_count -= 1<<ff_log2_run[run_index];
 514             run_index++;
 515             put_bits(&s->pb, 1, 1);
 516         }
 517
 518         if(run_count)
 519             put_bits(&s->pb, 1, 1);
 520     }
 521     s->run_index= run_index;
 522
 523     return 0;
 524 }
 525
 526 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 527     int x,y,i;
 528     const int ring_size= s->avctx->context_model ? 3 : 2;
 529     int16_t *sample[3];
 530     s->run_index=0;
 531
 532     memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
 533
 534     for(y=0; y<h; y++){
 535         for(i=0; i<ring_size; i++)
 536             sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
 537
 538         sample[0][-1]= sample[1][0  ];
 539         sample[1][ w]= sample[1][w-1];
 540 //{START_TIMER
 541         if(s->avctx->bits_per_raw_sample<=8){
 542             for(x=0; x<w; x++){
 543                 sample[0][x]= src[x + stride*y];
 544             }
 545             encode_line(s, w, sample, plane_index, 8);
 546         }else{
 547             if(s->packed_at_lsb){
 548                 for(x=0; x<w; x++){
 549                     sample[0][x]= ((uint16_t*)(src + stride*y))[x];
 550                 }
 551             }else{
 552                 for(x=0; x<w; x++){
 553                     sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
 554                 }
 555             }
 556             encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
 557         }
 558 //STOP_TIMER("encode line")}
 559     }
 560 }
 561
 562 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 563     int x, y, p, i;
 564     const int ring_size= s->avctx->context_model ? 3 : 2;
 565     int16_t *sample[3][3];
 566     s->run_index=0;
 567
 568     memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
 569
 570     for(y=0; y<h; y++){
 571         for(i=0; i<ring_size; i++)
 572             for(p=0; p<3; p++)
 573                 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
 574
 575         for(x=0; x<w; x++){
 576             int v= src[x + stride*y];
 577             int b= v&0xFF;
 578             int g= (v>>8)&0xFF;
 579             int r= (v>>16)&0xFF;
 580
 581             b -= g;
 582             r -= g;
 583             g += (b + r)>>2;
 584             b += 0x100;
 585             r += 0x100;
 586
 587 //            assert(g>=0 && b>=0 && r>=0);
 588 //            assert(g<256 && b<512 && r<512);
 589             sample[0][0][x]= g;
 590             sample[1][0][x]= b;
 591             sample[2][0][x]= r;
 592         }
 593         for(p=0; p<3; p++){
 594             sample[p][0][-1]= sample[p][1][0  ];
 595             sample[p][1][ w]= sample[p][1][w-1];
 596             encode_line(s, w, sample[p], FFMIN(p, 1), 9);
 597         }
 598     }
 599 }
 600
 601 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
 602     int last=0;
 603     int i;
 604     uint8_t state[CONTEXT_SIZE];
 605     memset(state, 128, sizeof(state));
 606
 607     for(i=1; i<128 ; i++){
 608         if(quant_table[i] != quant_table[i-1]){
 609             put_symbol(c, state, i-last-1, 0);
 610             last= i;
 611         }
 612     }
 613     put_symbol(c, state, i-last-1, 0);
 614 }
 615
 616 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
 617     int i;
 618     for(i=0; i<5; i++)
 619         write_quant_table(c, quant_table[i]);
 620 }
 621
 622 static void write_header(FFV1Context *f){
 623     uint8_t state[CONTEXT_SIZE];
 624     int i, j;
 625     RangeCoder * const c= &f->slice_context[0]->c;
 626
 627     memset(state, 128, sizeof(state));
 628
 629     if(f->version < 2){
 630         put_symbol(c, state, f->version, 0);
 631         put_symbol(c, state, f->ac, 0);
 632         if(f->ac>1){
 633             for(i=1; i<256; i++){
 634                 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 635             }
 636         }
 637         put_symbol(c, state, f->colorspace, 0); //YUV cs type
 638         if(f->version>0)
 639             put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
 640         put_rac(c, state, 1); //chroma planes
 641             put_symbol(c, state, f->chroma_h_shift, 0);
 642             put_symbol(c, state, f->chroma_v_shift, 0);
 643         put_rac(c, state, 0); //no transparency plane
 644
 645         write_quant_tables(c, f->quant_table);
 646     }else{
 647         put_symbol(c, state, f->slice_count, 0);
 648         for(i=0; i<f->slice_count; i++){
 649             FFV1Context *fs= f->slice_context[i];
 650             put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
 651             put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
 652             put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
 653             put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
 654             for(j=0; j<f->plane_count; j++){
 655                 put_symbol(c, state, f->plane[j].quant_table_index, 0);
 656                 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
 657             }
 658         }
 659     }
 660 }
 661 #endif /* CONFIG_FFV1_ENCODER */
 662
 663 static av_cold int common_init(AVCodecContext *avctx){
 664     FFV1Context *s = avctx->priv_data;
 665
 666     s->avctx= avctx;
 667     s->flags= avctx->flags;
 668
 669     avcodec_get_frame_defaults(&s->picture);
 670
 671     dsputil_init(&s->dsp, avctx);
 672
 673     s->width = avctx->width;
 674     s->height= avctx->height;
 675
 676     assert(s->width && s->height);
 677     //defaults
 678     s->num_h_slices=1;
 679     s->num_v_slices=1;
 680
 681
 682     return 0;
 683 }
 684
 685 static int init_slice_state(FFV1Context *f){
 686     int i, j;
 687
 688     for(i=0; i<f->slice_count; i++){
 689         FFV1Context *fs= f->slice_context[i];
 690         for(j=0; j<f->plane_count; j++){
 691             PlaneContext * const p= &fs->plane[j];
 692
 693             if(fs->ac){
 694                 if(!p->    state) p->    state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 695                 if(!p->    state)
 696                     return AVERROR(ENOMEM);
 697             }else{
 698                 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 699                 if(!p->vlc_state)
 700                     return AVERROR(ENOMEM);
 701             }
 702         }
 703
 704         if (fs->ac>1){
 705             //FIXME only redo if state_transition changed
 706             for(j=1; j<256; j++){
 707                 fs->c.one_state [    j]= fs->state_transition[j];
 708                 fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
 709             }
 710         }
 711     }
 712
 713     return 0;
 714 }
 715
 716 static av_cold int init_slice_contexts(FFV1Context *f){
 717     int i;
 718
 719     f->slice_count= f->num_h_slices * f->num_v_slices;
 720
 721     for(i=0; i<f->slice_count; i++){
 722         FFV1Context *fs= av_mallocz(sizeof(*fs));
 723         int sx= i % f->num_h_slices;
 724         int sy= i / f->num_h_slices;
 725         int sxs= f->avctx->width * sx    / f->num_h_slices;
 726         int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
 727         int sys= f->avctx->height* sy    / f->num_v_slices;
 728         int sye= f->avctx->height*(sy+1) / f->num_v_slices;
 729         f->slice_context[i]= fs;
 730         memcpy(fs, f, sizeof(*fs));
 731         memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
 732
 733         fs->slice_width = sxe - sxs;
 734         fs->slice_height= sye - sys;
 735         fs->slice_x     = sxs;
 736         fs->slice_y     = sys;
 737
 738         fs->sample_buffer = av_malloc(9 * (fs->width+6) * sizeof(*fs->sample_buffer));
 739         if (!fs->sample_buffer)
 740             return AVERROR(ENOMEM);
 741     }
 742     return 0;
 743 }
 744
 745 static int allocate_initial_states(FFV1Context *f){
 746     int i;
 747
 748     for(i=0; i<f->quant_table_count; i++){
 749         f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
 750         if(!f->initial_states[i])
 751             return AVERROR(ENOMEM);
 752         memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
 753     }
 754     return 0;
 755 }
 756
 757 #if CONFIG_FFV1_ENCODER
 758 static int write_extra_header(FFV1Context *f){
 759     RangeCoder * const c= &f->c;
 760     uint8_t state[CONTEXT_SIZE];
 761     int i, j, k;
 762     uint8_t state2[32][CONTEXT_SIZE];
 763
 764     memset(state2, 128, sizeof(state2));
 765     memset(state, 128, sizeof(state));
 766
 767     f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
 768     ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
 769     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 770
 771     put_symbol(c, state, f->version, 0);
 772     put_symbol(c, state, f->ac, 0);
 773     if(f->ac>1){
 774         for(i=1; i<256; i++){
 775             put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 776         }
 777     }
 778     put_symbol(c, state, f->colorspace, 0); //YUV cs type
 779     put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
 780     put_rac(c, state, 1); //chroma planes
 781         put_symbol(c, state, f->chroma_h_shift, 0);
 782         put_symbol(c, state, f->chroma_v_shift, 0);
 783     put_rac(c, state, 0); //no transparency plane
 784     put_symbol(c, state, f->num_h_slices-1, 0);
 785     put_symbol(c, state, f->num_v_slices-1, 0);
 786
 787     put_symbol(c, state, f->quant_table_count, 0);
 788     for(i=0; i<f->quant_table_count; i++)
 789         write_quant_tables(c, f->quant_tables[i]);
 790
 791     for(i=0; i<f->quant_table_count; i++){
 792         for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
 793             if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
 794                 break;
 795         if(j<f->context_count[i]*CONTEXT_SIZE){
 796             put_rac(c, state, 1);
 797             for(j=0; j<f->context_count[i]; j++){
 798                 for(k=0; k<CONTEXT_SIZE; k++){
 799                     int pred= j ? f->initial_states[i][j-1][k] : 128;
 800                     put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
 801                 }
 802             }
 803         }else{
 804             put_rac(c, state, 0);
 805         }
 806     }
 807
 808     f->avctx->extradata_size= ff_rac_terminate(c);
 809
 810     return 0;
 811 }
 812
 813 static int sort_stt(FFV1Context *s, uint8_t stt[256]){
 814     int i,i2,changed,print=0;
 815
 816     do{
 817         changed=0;
 818         for(i=12; i<244; i++){
 819             for(i2=i+1; i2<245 && i2<i+4; i2++){
 820 #define COST(old, new) \
 821     s->rc_stat[old][0]*-log2((256-(new))/256.0)\
 822    +s->rc_stat[old][1]*-log2(     (new) /256.0)
 823
 824 #define COST2(old, new) \
 825     COST(old, new)\
 826    +COST(256-(old), 256-(new))
 827
 828                 double size0= COST2(i, i ) + COST2(i2, i2);
 829                 double sizeX= COST2(i, i2) + COST2(i2, i );
 830                 if(sizeX < size0 && i!=128 && i2!=128){
 831                     int j;
 832                     FFSWAP(int, stt[    i], stt[    i2]);
 833                     FFSWAP(int, s->rc_stat[i    ][0],s->rc_stat[    i2][0]);
 834                     FFSWAP(int, s->rc_stat[i    ][1],s->rc_stat[    i2][1]);
 835                     if(i != 256-i2){
 836                         FFSWAP(int, stt[256-i], stt[256-i2]);
 837                         FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
 838                         FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
 839                     }
 840                     for(j=1; j<256; j++){
 841                         if     (stt[j] == i ) stt[j] = i2;
 842                         else if(stt[j] == i2) stt[j] = i ;
 843                         if(i != 256-i2){
 844                             if     (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
 845                             else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
 846                         }
 847                     }
 848                     print=changed=1;
 849                 }
 850             }
 851         }
 852     }while(changed);
 853     return print;
 854 }
 855
 856 static av_cold int encode_init(AVCodecContext *avctx)
 857 {
 858     FFV1Context *s = avctx->priv_data;
 859     int i, j, k, m;
 860
 861     common_init(avctx);
 862
 863     s->version=0;
 864     s->ac= avctx->coder_type ? 2:0;
 865
 866     if(s->ac>1)
 867         for(i=1; i<256; i++)
 868             s->state_transition[i]=ver2_state[i];
 869
 870     s->plane_count=2;
 871     for(i=0; i<256; i++){
 872         s->quant_table_count=2;
 873         if(avctx->bits_per_raw_sample <=8){
 874             s->quant_tables[0][0][i]=           quant11[i];
 875             s->quant_tables[0][1][i]=        11*quant11[i];
 876             s->quant_tables[0][2][i]=     11*11*quant11[i];
 877             s->quant_tables[1][0][i]=           quant11[i];
 878             s->quant_tables[1][1][i]=        11*quant11[i];
 879             s->quant_tables[1][2][i]=     11*11*quant5 [i];
 880             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
 881             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
 882         }else{
 883             s->quant_tables[0][0][i]=           quant9_10bit[i];
 884             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
 885             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
 886             s->quant_tables[1][0][i]=           quant9_10bit[i];
 887             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
 888             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
 889             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
 890             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
 891         }
 892     }
 893     s->context_count[0]= (11*11*11+1)/2;
 894     s->context_count[1]= (11*11*5*5*5+1)/2;
 895     memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
 896
 897     for(i=0; i<s->plane_count; i++){
 898         PlaneContext * const p= &s->plane[i];
 899
 900         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 901         p->quant_table_index= avctx->context_model;
 902         p->context_count= s->context_count[p->quant_table_index];
 903     }
 904
 905     if(allocate_initial_states(s) < 0)
 906         return AVERROR(ENOMEM);
 907
 908     avctx->coded_frame= &s->picture;
 909     switch(avctx->pix_fmt){
 910     case PIX_FMT_YUV420P9:
 911     case PIX_FMT_YUV420P10:
 912     case PIX_FMT_YUV422P10:
 913         s->packed_at_lsb = 1;
 914     case PIX_FMT_YUV444P16:
 915     case PIX_FMT_YUV422P16:
 916     case PIX_FMT_YUV420P16:
 917         if(avctx->bits_per_raw_sample <=8){
 918             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 919             return -1;
 920         }
 921         if(!s->ac){
 922             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
 923             return -1;
 924         }
 925         s->version= FFMAX(s->version, 1);
 926     case PIX_FMT_YUV444P:
 927     case PIX_FMT_YUV422P:
 928     case PIX_FMT_YUV420P:
 929     case PIX_FMT_YUV411P:
 930     case PIX_FMT_YUV410P:
 931         s->colorspace= 0;
 932         break;
 933     case PIX_FMT_RGB32:
 934         s->colorspace= 1;
 935         break;
 936     default:
 937         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 938         return -1;
 939     }
 940     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 941
 942     s->picture_number=0;
 943
 944     if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
 945         for(i=0; i<s->quant_table_count; i++){
 946             s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
 947             if(!s->rc_stat2[i])
 948                 return AVERROR(ENOMEM);
 949         }
 950     }
 951     if(avctx->stats_in){
 952         char *p= avctx->stats_in;
 953         uint8_t best_state[256][256];
 954         int gob_count=0;
 955         char *next;
 956
 957         av_assert0(s->version>=2);
 958
 959         for(;;){
 960             for(j=0; j<256; j++){
 961                 for(i=0; i<2; i++){
 962                     s->rc_stat[j][i]= strtol(p, &next, 0);
 963                     if(next==p){
 964                         av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
 965                         return -1;
 966                     }
 967                     p=next;
 968                 }
 969             }
 970             for(i=0; i<s->quant_table_count; i++){
 971                 for(j=0; j<s->context_count[i]; j++){
 972                     for(k=0; k<32; k++){
 973                         for(m=0; m<2; m++){
 974                             s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
 975                             if(next==p){
 976                                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
 977                                 return -1;
 978                             }
 979                             p=next;
 980                         }
 981                     }
 982                 }
 983             }
 984             gob_count= strtol(p, &next, 0);
 985             if(next==p || gob_count <0){
 986                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
 987                 return -1;
 988             }
 989             p=next;
 990             while(*p=='\n' || *p==' ') p++;
 991             if(p[0]==0) break;
 992         }
 993         sort_stt(s, s->state_transition);
 994
 995         find_best_state(best_state, s->state_transition);
 996
 997         for(i=0; i<s->quant_table_count; i++){
 998             for(j=0; j<s->context_count[i]; j++){
 999                 for(k=0; k<32; k++){
1000                     double p= 128;
1001                     if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
1002                         p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
1003                     }
1004                     s->initial_states[i][j][k]= best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1])/gob_count, 0, 255)];
1005                 }
1006             }
1007         }
1008     }
1009
1010     if(s->version>1){
1011         s->num_h_slices=2;
1012         s->num_v_slices=2;
1013         write_extra_header(s);
1014     }
1015
1016     if(init_slice_contexts(s) < 0)
1017         return -1;
1018     if(init_slice_state(s) < 0)
1019         return -1;
1020
1021 #define STATS_OUT_SIZE 1024*1024*6
1022     if(avctx->flags & CODEC_FLAG_PASS1){
1023         avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1024         for(i=0; i<s->quant_table_count; i++){
1025             for(j=0; j<s->slice_count; j++){
1026                 FFV1Context *sf= s->slice_context[j];
1027                 av_assert0(!sf->rc_stat2[i]);
1028                 sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1029                 if(!sf->rc_stat2[i])
1030                     return AVERROR(ENOMEM);
1031             }
1032         }
1033     }
1034
1035     return 0;
1036 }
1037 #endif /* CONFIG_FFV1_ENCODER */
1038
1039
1040 static void clear_state(FFV1Context *f){
1041     int i, si, j;
1042
1043     for(si=0; si<f->slice_count; si++){
1044         FFV1Context *fs= f->slice_context[si];
1045         for(i=0; i<f->plane_count; i++){
1046             PlaneContext *p= &fs->plane[i];
1047
1048             p->interlace_bit_state[0]= 128;
1049             p->interlace_bit_state[1]= 128;
1050
1051             if(fs->ac){
1052                 if(f->initial_states[p->quant_table_index]){
1053                     memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1054                 }else
1055                 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1056             }else{
1057             for(j=0; j<p->context_count; j++){
1058                     p->vlc_state[j].drift= 0;
1059                     p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1060                     p->vlc_state[j].bias= 0;
1061                     p->vlc_state[j].count= 1;
1062             }
1063             }
1064         }
1065     }
1066 }
1067
1068 #if CONFIG_FFV1_ENCODER
1069 static int encode_slice(AVCodecContext *c, void *arg){
1070     FFV1Context *fs= *(void**)arg;
1071     FFV1Context *f= fs->avctx->priv_data;
1072     int width = fs->slice_width;
1073     int height= fs->slice_height;
1074     int x= fs->slice_x;
1075     int y= fs->slice_y;
1076     AVFrame * const p= &f->picture;
1077     const int ps= (c->bits_per_raw_sample>8)+1;
1078
1079     if(f->colorspace==0){
1080         const int chroma_width = -((-width )>>f->chroma_h_shift);
1081         const int chroma_height= -((-height)>>f->chroma_v_shift);
1082         const int cx= x>>f->chroma_h_shift;
1083         const int cy= y>>f->chroma_v_shift;
1084
1085         encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1086
1087         encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1088         encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1089     }else{
1090         encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1091     }
1092     emms_c();
1093
1094     return 0;
1095 }
1096
1097 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1098     FFV1Context *f = avctx->priv_data;
1099     RangeCoder * const c= &f->slice_context[0]->c;
1100     AVFrame *pict = data;
1101     AVFrame * const p= &f->picture;
1102     int used_count= 0;
1103     uint8_t keystate=128;
1104     uint8_t *buf_p;
1105     int i;
1106
1107     ff_init_range_encoder(c, buf, buf_size);
1108     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1109
1110     *p = *pict;
1111     p->pict_type= AV_PICTURE_TYPE_I;
1112
1113     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1114         put_rac(c, &keystate, 1);
1115         p->key_frame= 1;
1116         f->gob_count++;
1117         write_header(f);
1118         clear_state(f);
1119     }else{
1120         put_rac(c, &keystate, 0);
1121         p->key_frame= 0;
1122     }
1123
1124     if(!f->ac){
1125         used_count += ff_rac_terminate(c);
1126 //printf("pos=%d\n", used_count);
1127         init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1128     }else if (f->ac>1){
1129         int i;
1130         for(i=1; i<256; i++){
1131             c->one_state[i]= f->state_transition[i];
1132             c->zero_state[256-i]= 256-c->one_state[i];
1133         }
1134     }
1135
1136     for(i=1; i<f->slice_count; i++){
1137         FFV1Context *fs= f->slice_context[i];
1138         uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1139         int len= buf_size/f->slice_count;
1140
1141         if(fs->ac){
1142             ff_init_range_encoder(&fs->c, start, len);
1143         }else{
1144             init_put_bits(&fs->pb, start, len);
1145         }
1146     }
1147     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1148
1149     buf_p=buf;
1150     for(i=0; i<f->slice_count; i++){
1151         FFV1Context *fs= f->slice_context[i];
1152         int bytes;
1153
1154         if(fs->ac){
1155             uint8_t state=128;
1156             put_rac(&fs->c, &state, 0);
1157             bytes= ff_rac_terminate(&fs->c);
1158         }else{
1159             flush_put_bits(&fs->pb); //nicer padding FIXME
1160             bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1161             used_count= 0;
1162         }
1163         if(i>0){
1164             av_assert0(bytes < buf_size/f->slice_count);
1165             memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1166             av_assert0(bytes < (1<<24));
1167             AV_WB24(buf_p+bytes, bytes);
1168             bytes+=3;
1169         }
1170         buf_p += bytes;
1171     }
1172
1173     if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1174         int j, k, m;
1175         char *p= avctx->stats_out;
1176         char *end= p + STATS_OUT_SIZE;
1177
1178         memset(f->rc_stat, 0, sizeof(f->rc_stat));
1179         for(i=0; i<f->quant_table_count; i++)
1180             memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1181
1182         for(j=0; j<f->slice_count; j++){
1183             FFV1Context *fs= f->slice_context[j];
1184             for(i=0; i<256; i++){
1185                 f->rc_stat[i][0] += fs->rc_stat[i][0];
1186                 f->rc_stat[i][1] += fs->rc_stat[i][1];
1187             }
1188             for(i=0; i<f->quant_table_count; i++){
1189                 for(k=0; k<f->context_count[i]; k++){
1190                     for(m=0; m<32; m++){
1191                         f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1192                         f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1193                     }
1194                 }
1195             }
1196         }
1197
1198         for(j=0; j<256; j++){
1199             snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1200             p+= strlen(p);
1201         }
1202         snprintf(p, end-p, "\n");
1203
1204         for(i=0; i<f->quant_table_count; i++){
1205             for(j=0; j<f->context_count[i]; j++){
1206                 for(m=0; m<32; m++){
1207                     snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1208                     p+= strlen(p);
1209                 }
1210             }
1211         }
1212         snprintf(p, end-p, "%d\n", f->gob_count);
1213     } else if(avctx->flags&CODEC_FLAG_PASS1)
1214         avctx->stats_out[0] = '\0';
1215
1216     f->picture_number++;
1217     return buf_p-buf;
1218 }
1219 #endif /* CONFIG_FFV1_ENCODER */
1220
1221 static av_cold int common_end(AVCodecContext *avctx){
1222     FFV1Context *s = avctx->priv_data;
1223     int i, j;
1224
1225     if (avctx->codec->decode && s->picture.data[0])
1226         avctx->release_buffer(avctx, &s->picture);
1227
1228     for(j=0; j<s->slice_count; j++){
1229         FFV1Context *fs= s->slice_context[j];
1230         for(i=0; i<s->plane_count; i++){
1231             PlaneContext *p= &fs->plane[i];
1232
1233             av_freep(&p->state);
1234             av_freep(&p->vlc_state);
1235         }
1236         av_freep(&fs->sample_buffer);
1237     }
1238
1239     av_freep(&avctx->stats_out);
1240     for(j=0; j<s->quant_table_count; j++){
1241         av_freep(&s->initial_states[j]);
1242         for(i=0; i<s->slice_count; i++){
1243             FFV1Context *sf= s->slice_context[i];
1244             av_freep(&sf->rc_stat2[j]);
1245         }
1246         av_freep(&s->rc_stat2[j]);
1247     }
1248
1249     for(i=0; i<s->slice_count; i++){
1250         av_freep(&s->slice_context[i]);
1251     }
1252
1253     return 0;
1254 }
1255
1256 static av_always_inline void decode_line(FFV1Context *s, int w,
1257                                          int16_t *sample[2],
1258                                          int plane_index, int bits)
1259 {
1260     PlaneContext * const p= &s->plane[plane_index];
1261     RangeCoder * const c= &s->c;
1262     int x;
1263     int run_count=0;
1264     int run_mode=0;
1265     int run_index= s->run_index;
1266
1267     for(x=0; x<w; x++){
1268         int diff, context, sign;
1269
1270         context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1271         if(context < 0){
1272             context= -context;
1273             sign=1;
1274         }else
1275             sign=0;
1276
1277         av_assert2(context < p->context_count);
1278
1279         if(s->ac){
1280             diff= get_symbol_inline(c, p->state[context], 1);
1281         }else{
1282             if(context == 0 && run_mode==0) run_mode=1;
1283
1284             if(run_mode){
1285                 if(run_count==0 && run_mode==1){
1286                     if(get_bits1(&s->gb)){
1287                         run_count = 1<<ff_log2_run[run_index];
1288                         if(x + run_count <= w) run_index++;
1289                     }else{
1290                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1291                         else run_count=0;
1292                         if(run_index) run_index--;
1293                         run_mode=2;
1294                     }
1295                 }
1296                 run_count--;
1297                 if(run_count < 0){
1298                     run_mode=0;
1299                     run_count=0;
1300                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1301                     if(diff>=0) diff++;
1302                 }else
1303                     diff=0;
1304             }else
1305                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1306
1307 //            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));
1308         }
1309
1310         if(sign) diff= -diff;
1311
1312         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1313     }
1314     s->run_index= run_index;
1315 }
1316
1317 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1318     int x, y;
1319     int16_t *sample[2];
1320     sample[0]=s->sample_buffer    +3;
1321     sample[1]=s->sample_buffer+w+6+3;
1322
1323     s->run_index=0;
1324
1325     memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1326
1327     for(y=0; y<h; y++){
1328         int16_t *temp = sample[0]; //FIXME try a normal buffer
1329
1330         sample[0]= sample[1];
1331         sample[1]= temp;
1332
1333         sample[1][-1]= sample[0][0  ];
1334         sample[0][ w]= sample[0][w-1];
1335
1336 //{START_TIMER
1337         if(s->avctx->bits_per_raw_sample <= 8){
1338             decode_line(s, w, sample, plane_index, 8);
1339             for(x=0; x<w; x++){
1340                 src[x + stride*y]= sample[1][x];
1341             }
1342         }else{
1343             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1344             if(s->packed_at_lsb){
1345                 for(x=0; x<w; x++){
1346                     ((uint16_t*)(src + stride*y))[x]= sample[1][x];
1347                 }
1348             }else{
1349                 for(x=0; x<w; x++){
1350                     ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1351                 }
1352             }
1353         }
1354 //STOP_TIMER("decode-line")}
1355     }
1356 }
1357
1358 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1359     int x, y, p;
1360     int16_t *sample[3][2];
1361     for(x=0; x<3; x++){
1362         sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1363         sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1364     }
1365
1366     s->run_index=0;
1367
1368     memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1369
1370     for(y=0; y<h; y++){
1371         for(p=0; p<3; p++){
1372             int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1373
1374             sample[p][0]= sample[p][1];
1375             sample[p][1]= temp;
1376
1377             sample[p][1][-1]= sample[p][0][0  ];
1378             sample[p][0][ w]= sample[p][0][w-1];
1379             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1380         }
1381         for(x=0; x<w; x++){
1382             int g= sample[0][1][x];
1383             int b= sample[1][1][x];
1384             int r= sample[2][1][x];
1385
1386 //            assert(g>=0 && b>=0 && r>=0);
1387 //            assert(g<256 && b<512 && r<512);
1388
1389             b -= 0x100;
1390             r -= 0x100;
1391             g -= (b + r)>>2;
1392             b += g;
1393             r += g;
1394
1395             src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1396         }
1397     }
1398 }
1399
1400 static int decode_slice(AVCodecContext *c, void *arg){
1401     FFV1Context *fs= *(void**)arg;
1402     FFV1Context *f= fs->avctx->priv_data;
1403     int width = fs->slice_width;
1404     int height= fs->slice_height;
1405     int x= fs->slice_x;
1406     int y= fs->slice_y;
1407     const int ps= (c->bits_per_raw_sample>8)+1;
1408     AVFrame * const p= &f->picture;
1409
1410     av_assert1(width && height);
1411     if(f->colorspace==0){
1412         const int chroma_width = -((-width )>>f->chroma_h_shift);
1413         const int chroma_height= -((-height)>>f->chroma_v_shift);
1414         const int cx= x>>f->chroma_h_shift;
1415         const int cy= y>>f->chroma_v_shift;
1416         decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1417
1418         decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1419         decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1420     }else{
1421         decode_rgb_frame(fs, (uint32_t*)p->data[0] + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1422     }
1423
1424     emms_c();
1425
1426     return 0;
1427 }
1428
1429 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1430     int v;
1431     int i=0;
1432     uint8_t state[CONTEXT_SIZE];
1433
1434     memset(state, 128, sizeof(state));
1435
1436     for(v=0; i<128 ; v++){
1437         int len= get_symbol(c, state, 0) + 1;
1438
1439         if(len + i > 128) return -1;
1440
1441         while(len--){
1442             quant_table[i] = scale*v;
1443             i++;
1444 //printf("%2d ",v);
1445 //if(i%16==0) printf("\n");
1446         }
1447     }
1448
1449     for(i=1; i<128; i++){
1450         quant_table[256-i]= -quant_table[i];
1451     }
1452     quant_table[128]= -quant_table[127];
1453
1454     return 2*v - 1;
1455 }
1456
1457 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1458     int i;
1459     int context_count=1;
1460
1461     for(i=0; i<5; i++){
1462         context_count*= read_quant_table(c, quant_table[i], context_count);
1463         if(context_count > 32768U){
1464             return -1;
1465         }
1466     }
1467     return (context_count+1)/2;
1468 }
1469
1470 static int read_extra_header(FFV1Context *f){
1471     RangeCoder * const c= &f->c;
1472     uint8_t state[CONTEXT_SIZE];
1473     int i, j, k;
1474     uint8_t state2[32][CONTEXT_SIZE];
1475
1476     memset(state2, 128, sizeof(state2));
1477     memset(state, 128, sizeof(state));
1478
1479     ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1480     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1481
1482     f->version= get_symbol(c, state, 0);
1483     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1484     if(f->ac>1){
1485         for(i=1; i<256; i++){
1486             f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1487         }
1488     }
1489     f->colorspace= get_symbol(c, state, 0); //YUV cs type
1490     f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1491     get_rac(c, state); //no chroma = false
1492     f->chroma_h_shift= get_symbol(c, state, 0);
1493     f->chroma_v_shift= get_symbol(c, state, 0);
1494     get_rac(c, state); //transparency plane
1495     f->plane_count= 2;
1496     f->num_h_slices= 1 + get_symbol(c, state, 0);
1497     f->num_v_slices= 1 + get_symbol(c, state, 0);
1498     if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1499         av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1500         return -1;
1501     }
1502
1503     f->quant_table_count= get_symbol(c, state, 0);
1504     if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1505         return -1;
1506     for(i=0; i<f->quant_table_count; i++){
1507         if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1508             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1509             return -1;
1510         }
1511     }
1512
1513     if(allocate_initial_states(f) < 0)
1514         return AVERROR(ENOMEM);
1515
1516     for(i=0; i<f->quant_table_count; i++){
1517         if(get_rac(c, state)){
1518             for(j=0; j<f->context_count[i]; j++){
1519                 for(k=0; k<CONTEXT_SIZE; k++){
1520                     int pred= j ? f->initial_states[i][j-1][k] : 128;
1521                     f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1522                 }
1523             }
1524         }
1525     }
1526
1527     return 0;
1528 }
1529
1530 static int read_header(FFV1Context *f){
1531     uint8_t state[CONTEXT_SIZE];
1532     int i, j, context_count;
1533     RangeCoder * const c= &f->slice_context[0]->c;
1534
1535     memset(state, 128, sizeof(state));
1536
1537     if(f->version < 2){
1538         f->version= get_symbol(c, state, 0);
1539         f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1540         if(f->ac>1){
1541             for(i=1; i<256; i++){
1542                 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1543             }
1544         }
1545         f->colorspace= get_symbol(c, state, 0); //YUV cs type
1546         if(f->version>0)
1547             f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1548         get_rac(c, state); //no chroma = false
1549         f->chroma_h_shift= get_symbol(c, state, 0);
1550         f->chroma_v_shift= get_symbol(c, state, 0);
1551         get_rac(c, state); //transparency plane
1552         f->plane_count= 2;
1553     }
1554
1555     if(f->colorspace==0){
1556         if(f->avctx->bits_per_raw_sample<=8){
1557             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1558             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1559             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1560             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1561             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1562             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1563             default:
1564                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1565                 return -1;
1566             }
1567         }else if(f->avctx->bits_per_raw_sample==9) {
1568             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1569             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1570             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1571             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P9 ; f->packed_at_lsb=1; break;
1572             default:
1573                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1574                 return -1;
1575             }
1576         }else if(f->avctx->bits_per_raw_sample==10) {
1577             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1578             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1579             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P10; f->packed_at_lsb=1; break;
1580             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P10; f->packed_at_lsb=1; break;
1581             default:
1582                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1583                 return -1;
1584             }
1585         }else {
1586             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1587             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1588             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1589             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1590             default:
1591                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1592                 return -1;
1593             }
1594         }
1595     }else if(f->colorspace==1){
1596         if(f->chroma_h_shift || f->chroma_v_shift){
1597             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1598             return -1;
1599         }
1600         f->avctx->pix_fmt= PIX_FMT_RGB32;
1601     }else{
1602         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1603         return -1;
1604     }
1605
1606 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1607     if(f->version < 2){
1608         context_count= read_quant_tables(c, f->quant_table);
1609         if(context_count < 0){
1610                 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1611                 return -1;
1612         }
1613     }else{
1614         f->slice_count= get_symbol(c, state, 0);
1615         if(f->slice_count > (unsigned)MAX_SLICES)
1616             return -1;
1617     }
1618
1619     for(j=0; j<f->slice_count; j++){
1620         FFV1Context *fs= f->slice_context[j];
1621         fs->ac= f->ac;
1622         fs->packed_at_lsb= f->packed_at_lsb;
1623
1624         if(f->version >= 2){
1625             fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1626             fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1627             fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1628             fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1629
1630             fs->slice_x /= f->num_h_slices;
1631             fs->slice_y /= f->num_v_slices;
1632             fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1633             fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1634             if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1635                 return -1;
1636             if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1637                 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1638                 return -1;
1639         }
1640
1641         for(i=0; i<f->plane_count; i++){
1642             PlaneContext * const p= &fs->plane[i];
1643
1644             if(f->version >= 2){
1645                 int idx=get_symbol(c, state, 0);
1646                 if(idx > (unsigned)f->quant_table_count){
1647                     av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1648                     return -1;
1649                 }
1650                 p->quant_table_index= idx;
1651                 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1652                 context_count= f->context_count[idx];
1653             }else{
1654                 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1655             }
1656
1657             if(p->context_count < context_count){
1658                 av_freep(&p->state);
1659                 av_freep(&p->vlc_state);
1660             }
1661             p->context_count= context_count;
1662         }
1663     }
1664
1665     return 0;
1666 }
1667
1668 static av_cold int decode_init(AVCodecContext *avctx)
1669 {
1670     FFV1Context *f = avctx->priv_data;
1671
1672     common_init(avctx);
1673
1674     if(avctx->extradata && read_extra_header(f) < 0)
1675         return -1;
1676
1677     if(init_slice_contexts(f) < 0)
1678         return -1;
1679
1680     return 0;
1681 }
1682
1683 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1684     const uint8_t *buf = avpkt->data;
1685     int buf_size = avpkt->size;
1686     FFV1Context *f = avctx->priv_data;
1687     RangeCoder * const c= &f->slice_context[0]->c;
1688     AVFrame * const p= &f->picture;
1689     int bytes_read, i;
1690     uint8_t keystate= 128;
1691     const uint8_t *buf_p;
1692
1693     AVFrame *picture = data;
1694
1695     /* release previously stored data */
1696     if (p->data[0])
1697         avctx->release_buffer(avctx, p);
1698
1699     ff_init_range_decoder(c, buf, buf_size);
1700     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1701
1702
1703     p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1704     if(get_rac(c, &keystate)){
1705         p->key_frame= 1;
1706         if(read_header(f) < 0)
1707             return -1;
1708         if(init_slice_state(f) < 0)
1709             return -1;
1710
1711         clear_state(f);
1712     }else{
1713         p->key_frame= 0;
1714     }
1715     if(f->ac>1){
1716         int i;
1717         for(i=1; i<256; i++){
1718             c->one_state[i]= f->state_transition[i];
1719             c->zero_state[256-i]= 256-c->one_state[i];
1720         }
1721     }
1722
1723     p->reference= 0;
1724     if(avctx->get_buffer(avctx, p) < 0){
1725         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1726         return -1;
1727     }
1728
1729     if(avctx->debug&FF_DEBUG_PICT_INFO)
1730         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1731
1732     if(!f->ac){
1733         bytes_read = c->bytestream - c->bytestream_start - 1;
1734         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1735 //printf("pos=%d\n", bytes_read);
1736         init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1737     } else {
1738         bytes_read = 0; /* avoid warning */
1739     }
1740
1741     buf_p= buf + buf_size;
1742     for(i=f->slice_count-1; i>0; i--){
1743         FFV1Context *fs= f->slice_context[i];
1744         int v= AV_RB24(buf_p-3)+3;
1745         if(buf_p - buf <= v){
1746             av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1747             return -1;
1748         }
1749         buf_p -= v;
1750         if(fs->ac){
1751             ff_init_range_decoder(&fs->c, buf_p, v);
1752         }else{
1753             init_get_bits(&fs->gb, buf_p, v * 8);
1754         }
1755     }
1756
1757     avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1758     f->picture_number++;
1759
1760     *picture= *p;
1761     *data_size = sizeof(AVFrame);
1762
1763     return buf_size;
1764 }
1765
1766 AVCodec ff_ffv1_decoder = {
1767     .name           = "ffv1",
1768     .type           = AVMEDIA_TYPE_VIDEO,
1769     .id             = CODEC_ID_FFV1,
1770     .priv_data_size = sizeof(FFV1Context),
1771     .init           = decode_init,
1772     .close          = common_end,
1773     .decode         = decode_frame,
1774     .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
1775     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1776 };
1777
1778 #if CONFIG_FFV1_ENCODER
1779 AVCodec ff_ffv1_encoder = {
1780     .name           = "ffv1",
1781     .type           = AVMEDIA_TYPE_VIDEO,
1782     .id             = CODEC_ID_FFV1,
1783     .priv_data_size = sizeof(FFV1Context),
1784     .init           = encode_init,
1785     .encode         = encode_frame,
1786     .close          = common_end,
1787     .capabilities = CODEC_CAP_SLICE_THREADS,
1788     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_NONE},
1789     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1790 };
1791 #endif