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