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