ffv1: fix packed rgb with 1.3
[ffmpeg.git] / 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= (av_pix_fmt_desc_get(c->pix_fmt)->flags & PIX_FMT_PLANAR)
1241                         ?
1242                     (f->bits_per_raw_sample>8)+1
1243                         :
1244                     4;
1245
1246     if(p->key_frame)
1247         clear_slice_state(f, fs);
1248     if(f->version > 2){
1249         encode_slice_header(f, fs);
1250     }
1251     if(!fs->ac){
1252         if(f->version > 2)
1253             put_rac(&fs->c, (uint8_t[]){129}, 0);
1254         fs->ac_byte_count = f->version > 2 || (!x&&!y) ? ff_rac_terminate(&fs->c) : 0;
1255         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);
1256     }
1257
1258     if(f->colorspace==0){
1259         const int chroma_width = -((-width )>>f->chroma_h_shift);
1260         const int chroma_height= -((-height)>>f->chroma_v_shift);
1261         const int cx= x>>f->chroma_h_shift;
1262         const int cy= y>>f->chroma_v_shift;
1263
1264         encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1265
1266         if (f->chroma_planes){
1267             encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1268             encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1269         }
1270         if (fs->transparency)
1271             encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1272     }else{
1273         uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1274                               p->data[1] + ps*x + y*p->linesize[1],
1275                               p->data[2] + ps*x + y*p->linesize[2]};
1276         encode_rgb_frame(fs, planes, width, height, p->linesize);
1277     }
1278     emms_c();
1279
1280     return 0;
1281 }
1282
1283 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1284                         const AVFrame *pict, int *got_packet)
1285 {
1286     FFV1Context *f = avctx->priv_data;
1287     RangeCoder * const c= &f->slice_context[0]->c;
1288     AVFrame * const p= &f->picture;
1289     int used_count= 0;
1290     uint8_t keystate=128;
1291     uint8_t *buf_p;
1292     int i, ret;
1293
1294     if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1295                                   + FF_MIN_BUFFER_SIZE)) < 0)
1296         return ret;
1297
1298     ff_init_range_encoder(c, pkt->data, pkt->size);
1299     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1300
1301     *p = *pict;
1302     p->pict_type= AV_PICTURE_TYPE_I;
1303
1304     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1305         put_rac(c, &keystate, 1);
1306         p->key_frame= 1;
1307         f->gob_count++;
1308         write_header(f);
1309     }else{
1310         put_rac(c, &keystate, 0);
1311         p->key_frame= 0;
1312     }
1313
1314     if (f->ac>1){
1315         int i;
1316         for(i=1; i<256; i++){
1317             c->one_state[i]= f->state_transition[i];
1318             c->zero_state[256-i]= 256-c->one_state[i];
1319         }
1320     }
1321
1322     for(i=1; i<f->slice_count; i++){
1323         FFV1Context *fs= f->slice_context[i];
1324         uint8_t *start = pkt->data + (pkt->size-used_count)*(int64_t)i/f->slice_count;
1325         int len = pkt->size/f->slice_count;
1326         ff_init_range_encoder(&fs->c, start, len);
1327     }
1328     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1329
1330     buf_p = pkt->data;
1331     for(i=0; i<f->slice_count; i++){
1332         FFV1Context *fs= f->slice_context[i];
1333         int bytes;
1334
1335         if(fs->ac){
1336             uint8_t state=129;
1337             put_rac(&fs->c, &state, 0);
1338             bytes= ff_rac_terminate(&fs->c);
1339         }else{
1340             flush_put_bits(&fs->pb); //nicer padding FIXME
1341             bytes= fs->ac_byte_count + (put_bits_count(&fs->pb)+7)/8;
1342         }
1343         if(i>0 || f->version>2){
1344             av_assert0(bytes < pkt->size/f->slice_count);
1345             memmove(buf_p, fs->c.bytestream_start, bytes);
1346             av_assert0(bytes < (1<<24));
1347             AV_WB24(buf_p+bytes, bytes);
1348             bytes+=3;
1349         }
1350         if(f->ec){
1351             unsigned v;
1352             buf_p[bytes++] = 0;
1353             v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1354             AV_WL32(buf_p + bytes, v); bytes += 4;
1355         }
1356         buf_p += bytes;
1357     }
1358
1359     if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1360         int j, k, m;
1361         char *p= avctx->stats_out;
1362         char *end= p + STATS_OUT_SIZE;
1363
1364         memset(f->rc_stat, 0, sizeof(f->rc_stat));
1365         for(i=0; i<f->quant_table_count; i++)
1366             memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1367
1368         for(j=0; j<f->slice_count; j++){
1369             FFV1Context *fs= f->slice_context[j];
1370             for(i=0; i<256; i++){
1371                 f->rc_stat[i][0] += fs->rc_stat[i][0];
1372                 f->rc_stat[i][1] += fs->rc_stat[i][1];
1373             }
1374             for(i=0; i<f->quant_table_count; i++){
1375                 for(k=0; k<f->context_count[i]; k++){
1376                     for(m=0; m<32; m++){
1377                         f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1378                         f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1379                     }
1380                 }
1381             }
1382         }
1383
1384         for(j=0; j<256; j++){
1385             snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1386             p+= strlen(p);
1387         }
1388         snprintf(p, end-p, "\n");
1389
1390         for(i=0; i<f->quant_table_count; i++){
1391             for(j=0; j<f->context_count[i]; j++){
1392                 for(m=0; m<32; m++){
1393                     snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1394                     p+= strlen(p);
1395                 }
1396             }
1397         }
1398         snprintf(p, end-p, "%d\n", f->gob_count);
1399     } else if(avctx->flags&CODEC_FLAG_PASS1)
1400         avctx->stats_out[0] = '\0';
1401
1402     f->picture_number++;
1403     pkt->size   = buf_p - pkt->data;
1404     pkt->flags |= AV_PKT_FLAG_KEY*p->key_frame;
1405     *got_packet = 1;
1406
1407     return 0;
1408 }
1409 #endif /* CONFIG_FFV1_ENCODER */
1410
1411 static av_cold int common_end(AVCodecContext *avctx){
1412     FFV1Context *s = avctx->priv_data;
1413     int i, j;
1414
1415     if (avctx->codec->decode && s->picture.data[0])
1416         avctx->release_buffer(avctx, &s->picture);
1417     if (avctx->codec->decode && s->last_picture.data[0])
1418         avctx->release_buffer(avctx, &s->last_picture);
1419
1420     for(j=0; j<s->slice_count; j++){
1421         FFV1Context *fs= s->slice_context[j];
1422         for(i=0; i<s->plane_count; i++){
1423             PlaneContext *p= &fs->plane[i];
1424
1425             av_freep(&p->state);
1426             av_freep(&p->vlc_state);
1427         }
1428         av_freep(&fs->sample_buffer);
1429     }
1430
1431     av_freep(&avctx->stats_out);
1432     for(j=0; j<s->quant_table_count; j++){
1433         av_freep(&s->initial_states[j]);
1434         for(i=0; i<s->slice_count; i++){
1435             FFV1Context *sf= s->slice_context[i];
1436             av_freep(&sf->rc_stat2[j]);
1437         }
1438         av_freep(&s->rc_stat2[j]);
1439     }
1440
1441     for(i=0; i<s->slice_count; i++){
1442         av_freep(&s->slice_context[i]);
1443     }
1444
1445     return 0;
1446 }
1447
1448 static av_always_inline void decode_line(FFV1Context *s, int w,
1449                                          int16_t *sample[2],
1450                                          int plane_index, int bits)
1451 {
1452     PlaneContext * const p= &s->plane[plane_index];
1453     RangeCoder * const c= &s->c;
1454     int x;
1455     int run_count=0;
1456     int run_mode=0;
1457     int run_index= s->run_index;
1458
1459     for(x=0; x<w; x++){
1460         int diff, context, sign;
1461
1462         context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1463         if(context < 0){
1464             context= -context;
1465             sign=1;
1466         }else
1467             sign=0;
1468
1469         av_assert2(context < p->context_count);
1470
1471         if(s->ac){
1472             diff= get_symbol_inline(c, p->state[context], 1);
1473         }else{
1474             if(context == 0 && run_mode==0) run_mode=1;
1475
1476             if(run_mode){
1477                 if(run_count==0 && run_mode==1){
1478                     if(get_bits1(&s->gb)){
1479                         run_count = 1<<ff_log2_run[run_index];
1480                         if(x + run_count <= w) run_index++;
1481                     }else{
1482                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1483                         else run_count=0;
1484                         if(run_index) run_index--;
1485                         run_mode=2;
1486                     }
1487                 }
1488                 run_count--;
1489                 if(run_count < 0){
1490                     run_mode=0;
1491                     run_count=0;
1492                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1493                     if(diff>=0) diff++;
1494                 }else
1495                     diff=0;
1496             }else
1497                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1498
1499             av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
1500                     run_count, run_index, run_mode, x, get_bits_count(&s->gb));
1501         }
1502
1503         if(sign) diff= -diff;
1504
1505         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1506     }
1507     s->run_index= run_index;
1508 }
1509
1510 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1511     int x, y;
1512     int16_t *sample[2];
1513     sample[0]=s->sample_buffer    +3;
1514     sample[1]=s->sample_buffer+w+6+3;
1515
1516     s->run_index=0;
1517
1518     memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1519
1520     for(y=0; y<h; y++){
1521         int16_t *temp = sample[0]; //FIXME try a normal buffer
1522
1523         sample[0]= sample[1];
1524         sample[1]= temp;
1525
1526         sample[1][-1]= sample[0][0  ];
1527         sample[0][ w]= sample[0][w-1];
1528
1529 //{START_TIMER
1530         if(s->avctx->bits_per_raw_sample <= 8){
1531             decode_line(s, w, sample, plane_index, 8);
1532             for(x=0; x<w; x++){
1533                 src[x + stride*y]= sample[1][x];
1534             }
1535         }else{
1536             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1537             if(s->packed_at_lsb){
1538                 for(x=0; x<w; x++){
1539                     ((uint16_t*)(src + stride*y))[x]= sample[1][x];
1540                 }
1541             }else{
1542                 for(x=0; x<w; x++){
1543                     ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1544                 }
1545             }
1546         }
1547 //STOP_TIMER("decode-line")}
1548     }
1549 }
1550
1551 static void decode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3]){
1552     int x, y, p;
1553     int16_t *sample[4][2];
1554     int lbd=  s->avctx->bits_per_raw_sample <= 8;
1555     int bits= s->avctx->bits_per_raw_sample > 0 ? s->avctx->bits_per_raw_sample : 8;
1556     int offset= 1 << bits;
1557     for(x=0; x<4; x++){
1558         sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1559         sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1560     }
1561
1562     s->run_index=0;
1563
1564     memset(s->sample_buffer, 0, 8*(w+6)*sizeof(*s->sample_buffer));
1565
1566     for(y=0; y<h; y++){
1567         for(p=0; p<3 + s->transparency; p++){
1568             int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1569
1570             sample[p][0]= sample[p][1];
1571             sample[p][1]= temp;
1572
1573             sample[p][1][-1]= sample[p][0][0  ];
1574             sample[p][0][ w]= sample[p][0][w-1];
1575             if (lbd)
1576                 decode_line(s, w, sample[p], (p+1)/2, 9);
1577             else
1578                 decode_line(s, w, sample[p], (p+1)/2, bits+1);
1579         }
1580         for(x=0; x<w; x++){
1581             int g= sample[0][1][x];
1582             int b= sample[1][1][x];
1583             int r= sample[2][1][x];
1584             int a= sample[3][1][x];
1585
1586             b -= offset;
1587             r -= offset;
1588             g -= (b + r)>>2;
1589             b += g;
1590             r += g;
1591
1592             if(lbd)
1593                 *((uint32_t*)(src[0] + x*4 + stride[0]*y))= b + (g<<8) + (r<<16) + (a<<24);
1594             else{
1595                 *((uint16_t*)(src[0] + x*2 + stride[0]*y)) = b;
1596                 *((uint16_t*)(src[1] + x*2 + stride[1]*y)) = g;
1597                 *((uint16_t*)(src[2] + x*2 + stride[2]*y)) = r;
1598             }
1599         }
1600     }
1601 }
1602
1603 static int decode_slice_header(FFV1Context *f, FFV1Context *fs){
1604     RangeCoder *c = &fs->c;
1605     uint8_t state[CONTEXT_SIZE];
1606     unsigned ps, i, context_count;
1607     memset(state, 128, sizeof(state));
1608
1609     av_assert0(f->version > 2);
1610
1611     fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1612     fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1613     fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1614     fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1615
1616     fs->slice_x /= f->num_h_slices;
1617     fs->slice_y /= f->num_v_slices;
1618     fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1619     fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1620     if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1621         return -1;
1622     if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1623         || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1624         return -1;
1625
1626     for(i=0; i<f->plane_count; i++){
1627         PlaneContext * const p= &fs->plane[i];
1628         int idx=get_symbol(c, state, 0);
1629         if(idx > (unsigned)f->quant_table_count){
1630             av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1631             return -1;
1632         }
1633         p->quant_table_index= idx;
1634         memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1635         context_count= f->context_count[idx];
1636
1637         if(p->context_count < context_count){
1638             av_freep(&p->state);
1639             av_freep(&p->vlc_state);
1640         }
1641         p->context_count= context_count;
1642     }
1643
1644     ps = get_symbol(c, state, 0);
1645     if(ps==1){
1646         f->picture.interlaced_frame = 1;
1647         f->picture.top_field_first  = 1;
1648     } else if(ps==2){
1649         f->picture.interlaced_frame = 1;
1650         f->picture.top_field_first  = 0;
1651     } else if(ps==3){
1652         f->picture.interlaced_frame = 0;
1653     }
1654     f->picture.sample_aspect_ratio.num = get_symbol(c, state, 0);
1655     f->picture.sample_aspect_ratio.den = get_symbol(c, state, 0);
1656
1657     return 0;
1658 }
1659
1660 static int decode_slice(AVCodecContext *c, void *arg){
1661     FFV1Context *fs= *(void**)arg;
1662     FFV1Context *f= fs->avctx->priv_data;
1663     int width, height, x, y;
1664     const int ps= (av_pix_fmt_desc_get(c->pix_fmt)->flags & PIX_FMT_PLANAR)
1665                         ?
1666                     (c->bits_per_raw_sample>8)+1
1667                         :
1668                     4;
1669     AVFrame * const p= &f->picture;
1670
1671     if(f->version > 2){
1672         if(init_slice_state(f, fs) < 0)
1673             return AVERROR(ENOMEM);
1674         if(decode_slice_header(f, fs) < 0) {
1675             fs->slice_damaged = 1;
1676             return AVERROR_INVALIDDATA;
1677         }
1678     }
1679     if(init_slice_state(f, fs) < 0)
1680         return AVERROR(ENOMEM);
1681     if(f->picture.key_frame)
1682         clear_slice_state(f, fs);
1683     width = fs->slice_width;
1684     height= fs->slice_height;
1685     x= fs->slice_x;
1686     y= fs->slice_y;
1687
1688     if(!fs->ac){
1689         if (f->version == 3 && f->minor_version > 1 || f->version > 3)
1690             get_rac(&fs->c, (uint8_t[]){129});
1691         fs->ac_byte_count = f->version > 2 || (!x&&!y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0;
1692         init_get_bits(&fs->gb,
1693                       fs->c.bytestream_start + fs->ac_byte_count,
1694                       (fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count) * 8);
1695     }
1696
1697     av_assert1(width && height);
1698     if(f->colorspace==0){
1699         const int chroma_width = -((-width )>>f->chroma_h_shift);
1700         const int chroma_height= -((-height)>>f->chroma_v_shift);
1701         const int cx= x>>f->chroma_h_shift;
1702         const int cy= y>>f->chroma_v_shift;
1703         decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1704
1705         if (f->chroma_planes){
1706             decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1707             decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1708         }
1709         if (fs->transparency)
1710             decode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1711     }else{
1712         uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1713                               p->data[1] + ps*x + y*p->linesize[1],
1714                               p->data[2] + ps*x + y*p->linesize[2]};
1715         decode_rgb_frame(fs, planes, width, height, p->linesize);
1716     }
1717     if(fs->ac && f->version > 2) {
1718         int v;
1719         get_rac(&fs->c, (uint8_t[]){129});
1720         v = fs->c.bytestream_end - fs->c.bytestream - 2 - 5*f->ec;
1721         if(v) {
1722             av_log(f->avctx, AV_LOG_ERROR, "bytestream end mismatching by %d\n", v);
1723             fs->slice_damaged = 1;
1724         }
1725     }
1726
1727     emms_c();
1728
1729     return 0;
1730 }
1731
1732 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1733     int v;
1734     int i=0;
1735     uint8_t state[CONTEXT_SIZE];
1736
1737     memset(state, 128, sizeof(state));
1738
1739     for(v=0; i<128 ; v++){
1740         unsigned len= get_symbol(c, state, 0) + 1;
1741
1742         if(len > 128 - i) return -1;
1743
1744         while(len--){
1745             quant_table[i] = scale*v;
1746             i++;
1747         }
1748     }
1749
1750     for(i=1; i<128; i++){
1751         quant_table[256-i]= -quant_table[i];
1752     }
1753     quant_table[128]= -quant_table[127];
1754
1755     return 2*v - 1;
1756 }
1757
1758 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1759     int i;
1760     int context_count=1;
1761
1762     for(i=0; i<5; i++){
1763         context_count*= read_quant_table(c, quant_table[i], context_count);
1764         if(context_count > 32768U){
1765             return -1;
1766         }
1767     }
1768     return (context_count+1)/2;
1769 }
1770
1771 static int read_extra_header(FFV1Context *f){
1772     RangeCoder * const c= &f->c;
1773     uint8_t state[CONTEXT_SIZE];
1774     int i, j, k;
1775     uint8_t state2[32][CONTEXT_SIZE];
1776
1777     memset(state2, 128, sizeof(state2));
1778     memset(state, 128, sizeof(state));
1779
1780     ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1781     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1782
1783     f->version= get_symbol(c, state, 0);
1784     if(f->version > 2) {
1785         c->bytestream_end -= 4;
1786         f->minor_version= get_symbol(c, state, 0);
1787     }
1788     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1789     if(f->ac>1){
1790         for(i=1; i<256; i++){
1791             f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1792         }
1793     }
1794     f->colorspace= get_symbol(c, state, 0); //YUV cs type
1795     f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1796     f->chroma_planes= get_rac(c, state);
1797     f->chroma_h_shift= get_symbol(c, state, 0);
1798     f->chroma_v_shift= get_symbol(c, state, 0);
1799     f->transparency= get_rac(c, state);
1800     f->plane_count= 2 + f->transparency;
1801     f->num_h_slices= 1 + get_symbol(c, state, 0);
1802     f->num_v_slices= 1 + get_symbol(c, state, 0);
1803     if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1804         av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1805         return -1;
1806     }
1807
1808     f->quant_table_count= get_symbol(c, state, 0);
1809     if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1810         return -1;
1811     for(i=0; i<f->quant_table_count; i++){
1812         if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1813             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1814             return -1;
1815         }
1816     }
1817
1818     if(allocate_initial_states(f) < 0)
1819         return AVERROR(ENOMEM);
1820
1821     for(i=0; i<f->quant_table_count; i++){
1822         if(get_rac(c, state)){
1823             for(j=0; j<f->context_count[i]; j++){
1824                 for(k=0; k<CONTEXT_SIZE; k++){
1825                     int pred= j ? f->initial_states[i][j-1][k] : 128;
1826                     f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1827                 }
1828             }
1829         }
1830     }
1831
1832     if(f->version > 2){
1833         f->ec = get_symbol(c, state, 0);
1834     }
1835
1836     if(f->version > 2){
1837         unsigned v;
1838         v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
1839         if(v){
1840             av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
1841             return AVERROR_INVALIDDATA;
1842         }
1843     }
1844
1845     return 0;
1846 }
1847
1848 static int read_header(FFV1Context *f){
1849     uint8_t state[CONTEXT_SIZE];
1850     int i, j, context_count = -1; //-1 to avoid warning
1851     RangeCoder * const c= &f->slice_context[0]->c;
1852
1853     memset(state, 128, sizeof(state));
1854
1855     if(f->version < 2){
1856         unsigned v= get_symbol(c, state, 0);
1857         if(v >= 2){
1858             av_log(f->avctx, AV_LOG_ERROR, "invalid version %d in ver01 header\n", v);
1859             return AVERROR_INVALIDDATA;
1860         }
1861         f->version = v;
1862         f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1863         if(f->ac>1){
1864             for(i=1; i<256; i++){
1865                 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1866             }
1867         }
1868         f->colorspace= get_symbol(c, state, 0); //YUV cs type
1869         if(f->version>0)
1870             f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1871         f->chroma_planes= get_rac(c, state);
1872         f->chroma_h_shift= get_symbol(c, state, 0);
1873         f->chroma_v_shift= get_symbol(c, state, 0);
1874         f->transparency= get_rac(c, state);
1875         f->plane_count= 2 + f->transparency;
1876     }
1877
1878     if(f->colorspace==0){
1879         if(!f->transparency && !f->chroma_planes){
1880             if (f->avctx->bits_per_raw_sample<=8)
1881                 f->avctx->pix_fmt= AV_PIX_FMT_GRAY8;
1882             else
1883                 f->avctx->pix_fmt= AV_PIX_FMT_GRAY16;
1884         }else if(f->avctx->bits_per_raw_sample<=8 && !f->transparency){
1885             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1886             case 0x00: f->avctx->pix_fmt= AV_PIX_FMT_YUV444P; break;
1887             case 0x01: f->avctx->pix_fmt= AV_PIX_FMT_YUV440P; break;
1888             case 0x10: f->avctx->pix_fmt= AV_PIX_FMT_YUV422P; break;
1889             case 0x11: f->avctx->pix_fmt= AV_PIX_FMT_YUV420P; break;
1890             case 0x20: f->avctx->pix_fmt= AV_PIX_FMT_YUV411P; break;
1891             case 0x22: f->avctx->pix_fmt= AV_PIX_FMT_YUV410P; break;
1892             default:
1893                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1894                 return -1;
1895             }
1896         }else if(f->avctx->bits_per_raw_sample<=8 && f->transparency){
1897             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1898             case 0x00: f->avctx->pix_fmt= AV_PIX_FMT_YUVA444P; break;
1899             case 0x10: f->avctx->pix_fmt= AV_PIX_FMT_YUVA422P; break;
1900             case 0x11: f->avctx->pix_fmt= AV_PIX_FMT_YUVA420P; break;
1901             default:
1902                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1903                 return -1;
1904             }
1905         }else if(f->avctx->bits_per_raw_sample==9) {
1906             f->packed_at_lsb=1;
1907             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1908             case 0x00: f->avctx->pix_fmt= AV_PIX_FMT_YUV444P9; break;
1909             case 0x10: f->avctx->pix_fmt= AV_PIX_FMT_YUV422P9; break;
1910             case 0x11: f->avctx->pix_fmt= AV_PIX_FMT_YUV420P9; break;
1911             default:
1912                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1913                 return -1;
1914             }
1915         }else if(f->avctx->bits_per_raw_sample==10) {
1916             f->packed_at_lsb=1;
1917             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1918             case 0x00: f->avctx->pix_fmt= AV_PIX_FMT_YUV444P10; break;
1919             case 0x10: f->avctx->pix_fmt= AV_PIX_FMT_YUV422P10; break;
1920             case 0x11: f->avctx->pix_fmt= AV_PIX_FMT_YUV420P10; break;
1921             default:
1922                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1923                 return -1;
1924             }
1925         }else {
1926             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1927             case 0x00: f->avctx->pix_fmt= AV_PIX_FMT_YUV444P16; break;
1928             case 0x10: f->avctx->pix_fmt= AV_PIX_FMT_YUV422P16; break;
1929             case 0x11: f->avctx->pix_fmt= AV_PIX_FMT_YUV420P16; break;
1930             default:
1931                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1932                 return -1;
1933             }
1934         }
1935     }else if(f->colorspace==1){
1936         if(f->chroma_h_shift || f->chroma_v_shift){
1937             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1938             return -1;
1939         }
1940         if(f->avctx->bits_per_raw_sample==9)
1941             f->avctx->pix_fmt= AV_PIX_FMT_GBRP9;
1942         else if(f->avctx->bits_per_raw_sample==10)
1943             f->avctx->pix_fmt= AV_PIX_FMT_GBRP10;
1944         else if(f->avctx->bits_per_raw_sample==12)
1945             f->avctx->pix_fmt= AV_PIX_FMT_GBRP12;
1946         else if(f->avctx->bits_per_raw_sample==14)
1947             f->avctx->pix_fmt= AV_PIX_FMT_GBRP14;
1948         else
1949         if(f->transparency) f->avctx->pix_fmt= AV_PIX_FMT_RGB32;
1950         else                f->avctx->pix_fmt= AV_PIX_FMT_0RGB32;
1951     }else{
1952         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1953         return -1;
1954     }
1955
1956     av_dlog(f->avctx, "%d %d %d\n",
1957             f->chroma_h_shift, f->chroma_v_shift, f->avctx->pix_fmt);
1958     if(f->version < 2){
1959         context_count= read_quant_tables(c, f->quant_table);
1960         if(context_count < 0){
1961                 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1962                 return -1;
1963         }
1964     }else if(f->version < 3){
1965         f->slice_count= get_symbol(c, state, 0);
1966     }else{
1967         const uint8_t *p= c->bytestream_end;
1968         for(f->slice_count = 0; f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start; f->slice_count++){
1969             int trailer = 3 + 5*!!f->ec;
1970             int size = AV_RB24(p-trailer);
1971             if(size + trailer > p - c->bytestream_start)
1972                 break;
1973             p -= size + trailer;
1974         }
1975     }
1976     if(f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0){
1977         av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid\n", f->slice_count);
1978         return -1;
1979     }
1980
1981     for(j=0; j<f->slice_count; j++){
1982         FFV1Context *fs= f->slice_context[j];
1983         fs->ac= f->ac;
1984         fs->packed_at_lsb= f->packed_at_lsb;
1985
1986         fs->slice_damaged = 0;
1987
1988         if(f->version == 2){
1989             fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1990             fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1991             fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1992             fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1993
1994             fs->slice_x /= f->num_h_slices;
1995             fs->slice_y /= f->num_v_slices;
1996             fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1997             fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1998             if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1999                 return -1;
2000             if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
2001                 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
2002                 return -1;
2003         }
2004
2005         for(i=0; i<f->plane_count; i++){
2006             PlaneContext * const p= &fs->plane[i];
2007
2008             if(f->version == 2){
2009                 int idx=get_symbol(c, state, 0);
2010                 if(idx > (unsigned)f->quant_table_count){
2011                     av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
2012                     return -1;
2013                 }
2014                 p->quant_table_index= idx;
2015                 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
2016                 context_count= f->context_count[idx];
2017             }else{
2018                 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
2019             }
2020
2021             if(f->version <= 2){
2022                 av_assert0(context_count>=0);
2023                 if(p->context_count < context_count){
2024                     av_freep(&p->state);
2025                     av_freep(&p->vlc_state);
2026                 }
2027                 p->context_count= context_count;
2028             }
2029         }
2030     }
2031     return 0;
2032 }
2033
2034 static av_cold int decode_init(AVCodecContext *avctx)
2035 {
2036     FFV1Context *f = avctx->priv_data;
2037
2038     common_init(avctx);
2039
2040     if(avctx->extradata && read_extra_header(f) < 0)
2041         return -1;
2042
2043     if(init_slice_contexts(f) < 0)
2044         return -1;
2045
2046     return 0;
2047 }
2048
2049 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
2050     const uint8_t *buf = avpkt->data;
2051     int buf_size = avpkt->size;
2052     FFV1Context *f = avctx->priv_data;
2053     RangeCoder * const c= &f->slice_context[0]->c;
2054     AVFrame * const p= &f->picture;
2055     int i;
2056     uint8_t keystate= 128;
2057     const uint8_t *buf_p;
2058
2059     AVFrame *picture = data;
2060
2061     /* release previously stored data */
2062     if (p->data[0])
2063         avctx->release_buffer(avctx, p);
2064
2065     ff_init_range_decoder(c, buf, buf_size);
2066     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
2067
2068
2069     p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
2070     if(get_rac(c, &keystate)){
2071         p->key_frame= 1;
2072         f->key_frame_ok = 0;
2073         if(read_header(f) < 0)
2074             return -1;
2075         f->key_frame_ok = 1;
2076     }else{
2077         if (!f->key_frame_ok) {
2078             av_log(avctx, AV_LOG_ERROR, "Cant decode non keyframe without valid keyframe\n");
2079             return AVERROR_INVALIDDATA;
2080         }
2081         p->key_frame= 0;
2082     }
2083
2084     p->reference= 3; //for error concealment
2085     if(avctx->get_buffer(avctx, p) < 0){
2086         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2087         return -1;
2088     }
2089
2090     if(avctx->debug&FF_DEBUG_PICT_INFO)
2091         av_log(avctx, AV_LOG_DEBUG, "ver:%d keyframe:%d coder:%d ec:%d slices:%d bps:%d\n",
2092                f->version, p->key_frame, f->ac, f->ec, f->slice_count, f->avctx->bits_per_raw_sample);
2093
2094     buf_p= buf + buf_size;
2095     for(i=f->slice_count-1; i>=0; i--){
2096         FFV1Context *fs= f->slice_context[i];
2097         int trailer = 3 + 5*!!f->ec;
2098         int v;
2099
2100         if(i || f->version>2) v = AV_RB24(buf_p-trailer)+trailer;
2101         else                  v = buf_p - c->bytestream_start;
2102         if(buf_p - c->bytestream_start < v){
2103             av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
2104             return -1;
2105         }
2106         buf_p -= v;
2107
2108         if(f->ec){
2109             unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, v);
2110             if(crc){
2111                 int64_t ts = avpkt->pts != AV_NOPTS_VALUE ? avpkt->pts : avpkt->dts;
2112                 av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!", crc);
2113                 if(ts != AV_NOPTS_VALUE && avctx->pkt_timebase.num) {
2114                     av_log(f->avctx, AV_LOG_ERROR, "at %f seconds\n",ts*av_q2d(avctx->pkt_timebase));
2115                 } else if(ts != AV_NOPTS_VALUE) {
2116                     av_log(f->avctx, AV_LOG_ERROR, "at %"PRId64"\n", ts);
2117                 } else {
2118                     av_log(f->avctx, AV_LOG_ERROR, "\n");
2119                 }
2120                 fs->slice_damaged = 1;
2121             }
2122         }
2123
2124         if(i){
2125             ff_init_range_decoder(&fs->c, buf_p, v);
2126         }else
2127             fs->c.bytestream_end = (uint8_t *)(buf_p + v);
2128     }
2129
2130     avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
2131
2132     for(i=f->slice_count-1; i>=0; i--){
2133         FFV1Context *fs= f->slice_context[i];
2134         int j;
2135         if(fs->slice_damaged && f->last_picture.data[0]){
2136             uint8_t *dst[4], *src[4];
2137             for(j=0; j<4; j++){
2138                 int sh = (j==1 || j==2) ? f->chroma_h_shift : 0;
2139                 int sv = (j==1 || j==2) ? f->chroma_v_shift : 0;
2140                 dst[j] = f->picture     .data[j] + f->picture     .linesize[j]*
2141                          (fs->slice_y>>sv) + (fs->slice_x>>sh);
2142                 src[j] = f->last_picture.data[j] + f->last_picture.linesize[j]*
2143                          (fs->slice_y>>sv) + (fs->slice_x>>sh);
2144             }
2145             av_image_copy(dst, f->picture.linesize, (const uint8_t **)src, f->last_picture.linesize,
2146                           avctx->pix_fmt, fs->slice_width, fs->slice_height);
2147         }
2148     }
2149
2150     f->picture_number++;
2151
2152     *picture= *p;
2153     *data_size = sizeof(AVFrame);
2154
2155     FFSWAP(AVFrame, f->picture, f->last_picture);
2156
2157     return buf_size;
2158 }
2159
2160 AVCodec ff_ffv1_decoder = {
2161     .name           = "ffv1",
2162     .type           = AVMEDIA_TYPE_VIDEO,
2163     .id             = AV_CODEC_ID_FFV1,
2164     .priv_data_size = sizeof(FFV1Context),
2165     .init           = decode_init,
2166     .close          = common_end,
2167     .decode         = decode_frame,
2168     .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ |
2169                       CODEC_CAP_SLICE_THREADS,
2170     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
2171 };
2172
2173 #if CONFIG_FFV1_ENCODER
2174
2175 #define OFFSET(x) offsetof(FFV1Context, x)
2176 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
2177 static const AVOption options[] = {
2178     { "slicecrc",        "Protect slices with CRCs",               OFFSET(ec),              AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, VE},
2179 {NULL}
2180 };
2181
2182 static const AVClass class = {
2183     .class_name = "ffv1 encoder",
2184     .item_name  = av_default_item_name,
2185     .option     = options,
2186     .version    = LIBAVUTIL_VERSION_INT,
2187 };
2188
2189 static const AVCodecDefault ffv1_defaults[] = {
2190     { "coder",                "-1" },
2191     { NULL },
2192 };
2193
2194 AVCodec ff_ffv1_encoder = {
2195     .name           = "ffv1",
2196     .type           = AVMEDIA_TYPE_VIDEO,
2197     .id             = AV_CODEC_ID_FFV1,
2198     .priv_data_size = sizeof(FFV1Context),
2199     .init           = encode_init,
2200     .encode2        = encode_frame,
2201     .close          = common_end,
2202     .capabilities   = CODEC_CAP_SLICE_THREADS,
2203     .defaults       = ffv1_defaults,
2204     .pix_fmts       = (const enum AVPixelFormat[]){
2205         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
2206         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
2207         AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
2208         AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
2209         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
2210         AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
2211         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
2212         AV_PIX_FMT_NONE
2213     },
2214     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
2215     .priv_class     = &class,
2216 };
2217 #endif