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