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