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