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, unsigned char *buf, int buf_size, void *data){
1139     FFV1Context *f = avctx->priv_data;
1140     RangeCoder * const c= &f->slice_context[0]->c;
1141     AVFrame *pict = data;
1142     AVFrame * const p= &f->picture;
1143     int used_count= 0;
1144     uint8_t keystate=128;
1145     uint8_t *buf_p;
1146     int i;
1147
1148     ff_init_range_encoder(c, buf, buf_size);
1149     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1150
1151     *p = *pict;
1152     p->pict_type= AV_PICTURE_TYPE_I;
1153
1154     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1155         put_rac(c, &keystate, 1);
1156         p->key_frame= 1;
1157         f->gob_count++;
1158         write_header(f);
1159         clear_state(f);
1160     }else{
1161         put_rac(c, &keystate, 0);
1162         p->key_frame= 0;
1163     }
1164
1165     if(!f->ac){
1166         used_count += ff_rac_terminate(c);
1167 //printf("pos=%d\n", used_count);
1168         init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1169     }else if (f->ac>1){
1170         int i;
1171         for(i=1; i<256; i++){
1172             c->one_state[i]= f->state_transition[i];
1173             c->zero_state[256-i]= 256-c->one_state[i];
1174         }
1175     }
1176
1177     for(i=1; i<f->slice_count; i++){
1178         FFV1Context *fs= f->slice_context[i];
1179         uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1180         int len= buf_size/f->slice_count;
1181
1182         if(fs->ac){
1183             ff_init_range_encoder(&fs->c, start, len);
1184         }else{
1185             init_put_bits(&fs->pb, start, len);
1186         }
1187     }
1188     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1189
1190     buf_p=buf;
1191     for(i=0; i<f->slice_count; i++){
1192         FFV1Context *fs= f->slice_context[i];
1193         int bytes;
1194
1195         if(fs->ac){
1196             uint8_t state=128;
1197             put_rac(&fs->c, &state, 0);
1198             bytes= ff_rac_terminate(&fs->c);
1199         }else{
1200             flush_put_bits(&fs->pb); //nicer padding FIXME
1201             bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1202             used_count= 0;
1203         }
1204         if(i>0){
1205             av_assert0(bytes < buf_size/f->slice_count);
1206             memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1207             av_assert0(bytes < (1<<24));
1208             AV_WB24(buf_p+bytes, bytes);
1209             bytes+=3;
1210         }
1211         buf_p += bytes;
1212     }
1213
1214     if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1215         int j, k, m;
1216         char *p= avctx->stats_out;
1217         char *end= p + STATS_OUT_SIZE;
1218
1219         memset(f->rc_stat, 0, sizeof(f->rc_stat));
1220         for(i=0; i<f->quant_table_count; i++)
1221             memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1222
1223         for(j=0; j<f->slice_count; j++){
1224             FFV1Context *fs= f->slice_context[j];
1225             for(i=0; i<256; i++){
1226                 f->rc_stat[i][0] += fs->rc_stat[i][0];
1227                 f->rc_stat[i][1] += fs->rc_stat[i][1];
1228             }
1229             for(i=0; i<f->quant_table_count; i++){
1230                 for(k=0; k<f->context_count[i]; k++){
1231                     for(m=0; m<32; m++){
1232                         f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1233                         f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1234                     }
1235                 }
1236             }
1237         }
1238
1239         for(j=0; j<256; j++){
1240             snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1241             p+= strlen(p);
1242         }
1243         snprintf(p, end-p, "\n");
1244
1245         for(i=0; i<f->quant_table_count; i++){
1246             for(j=0; j<f->context_count[i]; j++){
1247                 for(m=0; m<32; m++){
1248                     snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1249                     p+= strlen(p);
1250                 }
1251             }
1252         }
1253         snprintf(p, end-p, "%d\n", f->gob_count);
1254     } else if(avctx->flags&CODEC_FLAG_PASS1)
1255         avctx->stats_out[0] = '\0';
1256
1257     f->picture_number++;
1258     return buf_p-buf;
1259 }
1260 #endif /* CONFIG_FFV1_ENCODER */
1261
1262 static av_cold int common_end(AVCodecContext *avctx){
1263     FFV1Context *s = avctx->priv_data;
1264     int i, j;
1265
1266     if (avctx->codec->decode && s->picture.data[0])
1267         avctx->release_buffer(avctx, &s->picture);
1268
1269     for(j=0; j<s->slice_count; j++){
1270         FFV1Context *fs= s->slice_context[j];
1271         for(i=0; i<s->plane_count; i++){
1272             PlaneContext *p= &fs->plane[i];
1273
1274             av_freep(&p->state);
1275             av_freep(&p->vlc_state);
1276         }
1277         av_freep(&fs->sample_buffer);
1278     }
1279
1280     av_freep(&avctx->stats_out);
1281     for(j=0; j<s->quant_table_count; j++){
1282         av_freep(&s->initial_states[j]);
1283         for(i=0; i<s->slice_count; i++){
1284             FFV1Context *sf= s->slice_context[i];
1285             av_freep(&sf->rc_stat2[j]);
1286         }
1287         av_freep(&s->rc_stat2[j]);
1288     }
1289
1290     for(i=0; i<s->slice_count; i++){
1291         av_freep(&s->slice_context[i]);
1292     }
1293
1294     return 0;
1295 }
1296
1297 static av_always_inline void decode_line(FFV1Context *s, int w,
1298                                          int16_t *sample[2],
1299                                          int plane_index, int bits)
1300 {
1301     PlaneContext * const p= &s->plane[plane_index];
1302     RangeCoder * const c= &s->c;
1303     int x;
1304     int run_count=0;
1305     int run_mode=0;
1306     int run_index= s->run_index;
1307
1308     for(x=0; x<w; x++){
1309         int diff, context, sign;
1310
1311         context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1312         if(context < 0){
1313             context= -context;
1314             sign=1;
1315         }else
1316             sign=0;
1317
1318         av_assert2(context < p->context_count);
1319
1320         if(s->ac){
1321             diff= get_symbol_inline(c, p->state[context], 1);
1322         }else{
1323             if(context == 0 && run_mode==0) run_mode=1;
1324
1325             if(run_mode){
1326                 if(run_count==0 && run_mode==1){
1327                     if(get_bits1(&s->gb)){
1328                         run_count = 1<<ff_log2_run[run_index];
1329                         if(x + run_count <= w) run_index++;
1330                     }else{
1331                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1332                         else run_count=0;
1333                         if(run_index) run_index--;
1334                         run_mode=2;
1335                     }
1336                 }
1337                 run_count--;
1338                 if(run_count < 0){
1339                     run_mode=0;
1340                     run_count=0;
1341                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1342                     if(diff>=0) diff++;
1343                 }else
1344                     diff=0;
1345             }else
1346                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1347
1348 //            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));
1349         }
1350
1351         if(sign) diff= -diff;
1352
1353         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1354     }
1355     s->run_index= run_index;
1356 }
1357
1358 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1359     int x, y;
1360     int16_t *sample[2];
1361     sample[0]=s->sample_buffer    +3;
1362     sample[1]=s->sample_buffer+w+6+3;
1363
1364     s->run_index=0;
1365
1366     memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1367
1368     for(y=0; y<h; y++){
1369         int16_t *temp = sample[0]; //FIXME try a normal buffer
1370
1371         sample[0]= sample[1];
1372         sample[1]= temp;
1373
1374         sample[1][-1]= sample[0][0  ];
1375         sample[0][ w]= sample[0][w-1];
1376
1377 //{START_TIMER
1378         if(s->avctx->bits_per_raw_sample <= 8){
1379             decode_line(s, w, sample, plane_index, 8);
1380             for(x=0; x<w; x++){
1381                 src[x + stride*y]= sample[1][x];
1382             }
1383         }else{
1384             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1385             if(s->packed_at_lsb){
1386                 for(x=0; x<w; x++){
1387                     ((uint16_t*)(src + stride*y))[x]= sample[1][x];
1388                 }
1389             }else{
1390                 for(x=0; x<w; x++){
1391                     ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1392                 }
1393             }
1394         }
1395 //STOP_TIMER("decode-line")}
1396     }
1397 }
1398
1399 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1400     int x, y, p;
1401     int16_t *sample[4][2];
1402     for(x=0; x<4; x++){
1403         sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1404         sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1405     }
1406
1407     s->run_index=0;
1408
1409     memset(s->sample_buffer, 0, 8*(w+6)*sizeof(*s->sample_buffer));
1410
1411     for(y=0; y<h; y++){
1412         for(p=0; p<3 + s->transparency; p++){
1413             int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1414
1415             sample[p][0]= sample[p][1];
1416             sample[p][1]= temp;
1417
1418             sample[p][1][-1]= sample[p][0][0  ];
1419             sample[p][0][ w]= sample[p][0][w-1];
1420             decode_line(s, w, sample[p], (p+1)/2, 9);
1421         }
1422         for(x=0; x<w; x++){
1423             int g= sample[0][1][x];
1424             int b= sample[1][1][x];
1425             int r= sample[2][1][x];
1426             int a= sample[3][1][x];
1427
1428 //            assert(g>=0 && b>=0 && r>=0);
1429 //            assert(g<256 && b<512 && r<512);
1430
1431             b -= 0x100;
1432             r -= 0x100;
1433             g -= (b + r)>>2;
1434             b += g;
1435             r += g;
1436
1437             src[x + stride*y]= b + (g<<8) + (r<<16) + (a<<24);
1438         }
1439     }
1440 }
1441
1442 static int decode_slice(AVCodecContext *c, void *arg){
1443     FFV1Context *fs= *(void**)arg;
1444     FFV1Context *f= fs->avctx->priv_data;
1445     int width = fs->slice_width;
1446     int height= fs->slice_height;
1447     int x= fs->slice_x;
1448     int y= fs->slice_y;
1449     const int ps= (c->bits_per_raw_sample>8)+1;
1450     AVFrame * const p= &f->picture;
1451
1452     av_assert1(width && height);
1453     if(f->colorspace==0){
1454         const int chroma_width = -((-width )>>f->chroma_h_shift);
1455         const int chroma_height= -((-height)>>f->chroma_v_shift);
1456         const int cx= x>>f->chroma_h_shift;
1457         const int cy= y>>f->chroma_v_shift;
1458         decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1459
1460         if (f->chroma_planes){
1461             decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1462             decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1463         }
1464         if (fs->transparency)
1465             decode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1466     }else{
1467         decode_rgb_frame(fs, (uint32_t*)p->data[0] + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1468     }
1469
1470     emms_c();
1471
1472     return 0;
1473 }
1474
1475 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1476     int v;
1477     int i=0;
1478     uint8_t state[CONTEXT_SIZE];
1479
1480     memset(state, 128, sizeof(state));
1481
1482     for(v=0; i<128 ; v++){
1483         int len= get_symbol(c, state, 0) + 1;
1484
1485         if(len + i > 128) return -1;
1486
1487         while(len--){
1488             quant_table[i] = scale*v;
1489             i++;
1490 //printf("%2d ",v);
1491 //if(i%16==0) printf("\n");
1492         }
1493     }
1494
1495     for(i=1; i<128; i++){
1496         quant_table[256-i]= -quant_table[i];
1497     }
1498     quant_table[128]= -quant_table[127];
1499
1500     return 2*v - 1;
1501 }
1502
1503 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1504     int i;
1505     int context_count=1;
1506
1507     for(i=0; i<5; i++){
1508         context_count*= read_quant_table(c, quant_table[i], context_count);
1509         if(context_count > 32768U){
1510             return -1;
1511         }
1512     }
1513     return (context_count+1)/2;
1514 }
1515
1516 static int read_extra_header(FFV1Context *f){
1517     RangeCoder * const c= &f->c;
1518     uint8_t state[CONTEXT_SIZE];
1519     int i, j, k;
1520     uint8_t state2[32][CONTEXT_SIZE];
1521
1522     memset(state2, 128, sizeof(state2));
1523     memset(state, 128, sizeof(state));
1524
1525     ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1526     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1527
1528     f->version= get_symbol(c, state, 0);
1529     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1530     if(f->ac>1){
1531         for(i=1; i<256; i++){
1532             f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1533         }
1534     }
1535     f->colorspace= get_symbol(c, state, 0); //YUV cs type
1536     f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1537     get_rac(c, state); //no chroma = false
1538     f->chroma_h_shift= get_symbol(c, state, 0);
1539     f->chroma_v_shift= get_symbol(c, state, 0);
1540     f->transparency= get_rac(c, state);
1541     f->plane_count= 2 + f->transparency;
1542     f->num_h_slices= 1 + get_symbol(c, state, 0);
1543     f->num_v_slices= 1 + get_symbol(c, state, 0);
1544     if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1545         av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1546         return -1;
1547     }
1548
1549     f->quant_table_count= get_symbol(c, state, 0);
1550     if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1551         return -1;
1552     for(i=0; i<f->quant_table_count; i++){
1553         if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1554             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1555             return -1;
1556         }
1557     }
1558
1559     if(allocate_initial_states(f) < 0)
1560         return AVERROR(ENOMEM);
1561
1562     for(i=0; i<f->quant_table_count; i++){
1563         if(get_rac(c, state)){
1564             for(j=0; j<f->context_count[i]; j++){
1565                 for(k=0; k<CONTEXT_SIZE; k++){
1566                     int pred= j ? f->initial_states[i][j-1][k] : 128;
1567                     f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1568                 }
1569             }
1570         }
1571     }
1572
1573     return 0;
1574 }
1575
1576 static int read_header(FFV1Context *f){
1577     uint8_t state[CONTEXT_SIZE];
1578     int i, j, context_count;
1579     RangeCoder * const c= &f->slice_context[0]->c;
1580
1581     memset(state, 128, sizeof(state));
1582
1583     if(f->version < 2){
1584         f->version= get_symbol(c, state, 0);
1585         f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1586         if(f->ac>1){
1587             for(i=1; i<256; i++){
1588                 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1589             }
1590         }
1591         f->colorspace= get_symbol(c, state, 0); //YUV cs type
1592         if(f->version>0)
1593             f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1594         f->chroma_planes= get_rac(c, state);
1595         f->chroma_h_shift= get_symbol(c, state, 0);
1596         f->chroma_v_shift= get_symbol(c, state, 0);
1597         f->transparency= get_rac(c, state);
1598         f->plane_count= 2 + f->transparency;
1599     }
1600
1601     if(f->colorspace==0){
1602         if(!f->transparency && !f->chroma_planes){
1603             if (f->avctx->bits_per_raw_sample<=8)
1604                 f->avctx->pix_fmt= PIX_FMT_GRAY8;
1605             else
1606                 f->avctx->pix_fmt= PIX_FMT_GRAY16;
1607         }else if(f->avctx->bits_per_raw_sample<=8 && !f->transparency){
1608             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1609             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1610             case 0x01: f->avctx->pix_fmt= PIX_FMT_YUV440P; break;
1611             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1612             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1613             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1614             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1615             default:
1616                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1617                 return -1;
1618             }
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_YUVA444P; break;
1622             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUVA420P; 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==9) {
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_YUV422P16; break;
1631             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P9 ; 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 if(f->avctx->bits_per_raw_sample==10) {
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_YUV422P10; f->packed_at_lsb=1; break;
1640             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P10; f->packed_at_lsb=1; break;
1641             default:
1642                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1643                 return -1;
1644             }
1645         }else {
1646             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1647             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1648             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1649             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1650             default:
1651                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1652                 return -1;
1653             }
1654         }
1655     }else if(f->colorspace==1){
1656         if(f->chroma_h_shift || f->chroma_v_shift){
1657             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1658             return -1;
1659         }
1660         if(f->transparency) f->avctx->pix_fmt= PIX_FMT_RGB32;
1661         else                f->avctx->pix_fmt= PIX_FMT_0RGB32;
1662     }else{
1663         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1664         return -1;
1665     }
1666
1667 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1668     if(f->version < 2){
1669         context_count= read_quant_tables(c, f->quant_table);
1670         if(context_count < 0){
1671                 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1672                 return -1;
1673         }
1674     }else{
1675         f->slice_count= get_symbol(c, state, 0);
1676         if(f->slice_count > (unsigned)MAX_SLICES)
1677             return -1;
1678     }
1679
1680     for(j=0; j<f->slice_count; j++){
1681         FFV1Context *fs= f->slice_context[j];
1682         fs->ac= f->ac;
1683         fs->packed_at_lsb= f->packed_at_lsb;
1684
1685         if(f->version >= 2){
1686             fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1687             fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1688             fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1689             fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1690
1691             fs->slice_x /= f->num_h_slices;
1692             fs->slice_y /= f->num_v_slices;
1693             fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1694             fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1695             if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1696                 return -1;
1697             if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1698                 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1699                 return -1;
1700         }
1701
1702         for(i=0; i<f->plane_count; i++){
1703             PlaneContext * const p= &fs->plane[i];
1704
1705             if(f->version >= 2){
1706                 int idx=get_symbol(c, state, 0);
1707                 if(idx > (unsigned)f->quant_table_count){
1708                     av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1709                     return -1;
1710                 }
1711                 p->quant_table_index= idx;
1712                 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1713                 context_count= f->context_count[idx];
1714             }else{
1715                 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1716             }
1717
1718             if(p->context_count < context_count){
1719                 av_freep(&p->state);
1720                 av_freep(&p->vlc_state);
1721             }
1722             p->context_count= context_count;
1723         }
1724     }
1725
1726     return 0;
1727 }
1728
1729 static av_cold int decode_init(AVCodecContext *avctx)
1730 {
1731     FFV1Context *f = avctx->priv_data;
1732
1733     common_init(avctx);
1734
1735     if(avctx->extradata && read_extra_header(f) < 0)
1736         return -1;
1737
1738     if(init_slice_contexts(f) < 0)
1739         return -1;
1740
1741     return 0;
1742 }
1743
1744 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1745     const uint8_t *buf = avpkt->data;
1746     int buf_size = avpkt->size;
1747     FFV1Context *f = avctx->priv_data;
1748     RangeCoder * const c= &f->slice_context[0]->c;
1749     AVFrame * const p= &f->picture;
1750     int bytes_read, i;
1751     uint8_t keystate= 128;
1752     const uint8_t *buf_p;
1753
1754     AVFrame *picture = data;
1755
1756     /* release previously stored data */
1757     if (p->data[0])
1758         avctx->release_buffer(avctx, p);
1759
1760     ff_init_range_decoder(c, buf, buf_size);
1761     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1762
1763
1764     p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1765     if(get_rac(c, &keystate)){
1766         p->key_frame= 1;
1767         if(read_header(f) < 0)
1768             return -1;
1769         if(init_slice_state(f) < 0)
1770             return -1;
1771
1772         clear_state(f);
1773     }else{
1774         p->key_frame= 0;
1775     }
1776     if(f->ac>1){
1777         int i;
1778         for(i=1; i<256; i++){
1779             c->one_state[i]= f->state_transition[i];
1780             c->zero_state[256-i]= 256-c->one_state[i];
1781         }
1782     }
1783
1784     p->reference= 0;
1785     if(avctx->get_buffer(avctx, p) < 0){
1786         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1787         return -1;
1788     }
1789
1790     if(avctx->debug&FF_DEBUG_PICT_INFO)
1791         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1792
1793     if(!f->ac){
1794         bytes_read = c->bytestream - c->bytestream_start - 1;
1795         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1796 //printf("pos=%d\n", bytes_read);
1797         init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1798     } else {
1799         bytes_read = 0; /* avoid warning */
1800     }
1801
1802     buf_p= buf + buf_size;
1803     for(i=f->slice_count-1; i>0; i--){
1804         FFV1Context *fs= f->slice_context[i];
1805         int v= AV_RB24(buf_p-3)+3;
1806         if(buf_p - buf <= v){
1807             av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1808             return -1;
1809         }
1810         buf_p -= v;
1811         if(fs->ac){
1812             ff_init_range_decoder(&fs->c, buf_p, v);
1813         }else{
1814             init_get_bits(&fs->gb, buf_p, v * 8);
1815         }
1816     }
1817
1818     avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1819     f->picture_number++;
1820
1821     *picture= *p;
1822     *data_size = sizeof(AVFrame);
1823
1824     return buf_size;
1825 }
1826
1827 AVCodec ff_ffv1_decoder = {
1828     .name           = "ffv1",
1829     .type           = AVMEDIA_TYPE_VIDEO,
1830     .id             = CODEC_ID_FFV1,
1831     .priv_data_size = sizeof(FFV1Context),
1832     .init           = decode_init,
1833     .close          = common_end,
1834     .decode         = decode_frame,
1835     .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
1836     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1837 };
1838
1839 #if CONFIG_FFV1_ENCODER
1840 AVCodec ff_ffv1_encoder = {
1841     .name           = "ffv1",
1842     .type           = AVMEDIA_TYPE_VIDEO,
1843     .id             = CODEC_ID_FFV1,
1844     .priv_data_size = sizeof(FFV1Context),
1845     .init           = encode_init,
1846     .encode         = encode_frame,
1847     .close          = common_end,
1848     .capabilities = CODEC_CAP_SLICE_THREADS,
1849     .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},
1850     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1851 };
1852 #endif