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