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