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

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