Remove the word "experimental"
[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 libavcodec/ffv1.c
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
36 #define MAX_PLANES 4
37 #define CONTEXT_SIZE 32
38
39 extern const uint8_t ff_log2_run[32];
40
41 static const int8_t quant3[256]={
42  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
43  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
44  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
45  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
46  1, 1, 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, 0,
58 };
59
60 static const int8_t quant5_10bit[256]={
61  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
62  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
63  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
64  1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
65  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
66  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
67  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
68  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
69 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-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,-1,
74 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
75 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
76 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
77 };
78
79 static const int8_t quant5[256]={
80  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
81  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
82  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
83  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
84  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
85  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
86  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
87  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
88 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
89 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
90 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
91 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-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,-1,-1,-1,
96 };
97 static const int8_t quant7[256]={
98  0, 1, 1, 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, 2, 2, 2,
100  2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
101  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
102  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
103  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
104  3, 3, 3, 3, 3, 3, 3, 3, 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,-2,-2,-2,-2,-2,-2,-2,
112 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
113 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
114 };
115 static const int8_t quant9[256]={
116  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
117  3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
118  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
119  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
120  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
121  4, 4, 4, 4, 4, 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,-3,-3,-3,-3,
131 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
132 };
133 static const int8_t quant9_10bit[256]={
134  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
135  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
136  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
137  3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
138  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
139  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
140  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
141  4, 4, 4, 4, 4, 4, 4, 4, 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,-3,-3,-3,-3,-3,-3,-3,
147 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
148 -3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
149 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
150 };
151
152 static const int8_t quant11[256]={
153  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
154  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
155  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
156  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
157  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
158  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
159  5, 5, 5, 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,-4,-4,
167 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
168 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
169 };
170 static const int8_t quant13[256]={
171  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
172  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
173  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
174  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
175  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
176  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
177  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
178  6, 6, 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,-5,
184 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
185 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
186 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
187 };
188
189 typedef struct VlcState{
190     int16_t drift;
191     uint16_t error_sum;
192     int8_t bias;
193     uint8_t count;
194 } VlcState;
195
196 typedef struct PlaneContext{
197     int context_count;
198     uint8_t (*state)[CONTEXT_SIZE];
199     VlcState *vlc_state;
200     uint8_t interlace_bit_state[2];
201 } PlaneContext;
202
203 typedef struct FFV1Context{
204     AVCodecContext *avctx;
205     RangeCoder c;
206     GetBitContext gb;
207     PutBitContext pb;
208     int version;
209     int width, height;
210     int chroma_h_shift, chroma_v_shift;
211     int flags;
212     int picture_number;
213     AVFrame picture;
214     int plane_count;
215     int ac;                              ///< 1=range coder <-> 0=golomb rice
216     PlaneContext plane[MAX_PLANES];
217     int16_t quant_table[5][256];
218     int run_index;
219     int colorspace;
220
221     DSPContext dsp;
222 }FFV1Context;
223
224 static av_always_inline int fold(int diff, int bits){
225     if(bits==8)
226         diff= (int8_t)diff;
227     else{
228         diff+= 1<<(bits-1);
229         diff&=(1<<bits)-1;
230         diff-= 1<<(bits-1);
231     }
232
233     return diff;
234 }
235
236 static inline int predict(int_fast16_t *src, int_fast16_t *last){
237     const int LT= last[-1];
238     const int  T= last[ 0];
239     const int L =  src[-1];
240
241     return mid_pred(L, L + T - LT, T);
242 }
243
244 static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
245     const int LT= last[-1];
246     const int  T= last[ 0];
247     const int RT= last[ 1];
248     const int L =  src[-1];
249
250     if(f->quant_table[3][127]){
251         const int TT= last2[0];
252         const int LL=  src[-2];
253         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
254               +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
255     }else
256         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
257 }
258
259 static inline void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed){
260     int i;
261
262     if(v){
263         const int a= FFABS(v);
264         const int e= av_log2(a);
265         put_rac(c, state+0, 0);
266         if(e<=9){
267             for(i=0; i<e; i++){
268                 put_rac(c, state+1+i, 1);  //1..10
269             }
270             put_rac(c, state+1+i, 0);
271
272             for(i=e-1; i>=0; i--){
273                 put_rac(c, state+22+i, (a>>i)&1); //22..31
274             }
275
276             if(is_signed)
277                 put_rac(c, state+11 + e, v < 0); //11..21
278         }else{
279             for(i=0; i<e; i++){
280                 put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
281             }
282             put_rac(c, state+1+9, 0);
283
284             for(i=e-1; i>=0; i--){
285                 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
286             }
287
288             if(is_signed)
289                 put_rac(c, state+11 + 10, v < 0); //11..21
290         }
291     }else{
292         put_rac(c, state+0, 1);
293     }
294 }
295
296 static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
297     put_symbol_inline(c, state, v, is_signed);
298 }
299
300 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
301     if(get_rac(c, state+0))
302         return 0;
303     else{
304         int i, e, a;
305         e= 0;
306         while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
307             e++;
308         }
309
310         a= 1;
311         for(i=e-1; i>=0; i--){
312             a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
313         }
314
315         e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
316         return (a^e)-e;
317     }
318 }
319
320 static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
321     return get_symbol_inline(c, state, is_signed);
322 }
323
324 static inline void update_vlc_state(VlcState * const state, const int v){
325     int drift= state->drift;
326     int count= state->count;
327     state->error_sum += FFABS(v);
328     drift += v;
329
330     if(count == 128){ //FIXME variable
331         count >>= 1;
332         drift >>= 1;
333         state->error_sum >>= 1;
334     }
335     count++;
336
337     if(drift <= -count){
338         if(state->bias > -128) state->bias--;
339
340         drift += count;
341         if(drift <= -count)
342             drift= -count + 1;
343     }else if(drift > 0){
344         if(state->bias <  127) state->bias++;
345
346         drift -= count;
347         if(drift > 0)
348             drift= 0;
349     }
350
351     state->drift= drift;
352     state->count= count;
353 }
354
355 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
356     int i, k, code;
357 //printf("final: %d ", v);
358     v = fold(v - state->bias, bits);
359
360     i= state->count;
361     k=0;
362     while(i < state->error_sum){ //FIXME optimize
363         k++;
364         i += i;
365     }
366
367     assert(k<=8);
368
369 #if 0 // JPEG LS
370     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
371     else                                         code= v;
372 #else
373      code= v ^ ((2*state->drift + state->count)>>31);
374 #endif
375
376 //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);
377     set_sr_golomb(pb, code, k, 12, bits);
378
379     update_vlc_state(state, v);
380 }
381
382 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
383     int k, i, v, ret;
384
385     i= state->count;
386     k=0;
387     while(i < state->error_sum){ //FIXME optimize
388         k++;
389         i += i;
390     }
391
392     assert(k<=8);
393
394     v= get_sr_golomb(gb, k, 12, bits);
395 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
396
397 #if 0 // JPEG LS
398     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
399 #else
400      v ^= ((2*state->drift + state->count)>>31);
401 #endif
402
403     ret= fold(v + state->bias, bits);
404
405     update_vlc_state(state, v);
406 //printf("final: %d\n", ret);
407     return ret;
408 }
409
410 #if CONFIG_FFV1_ENCODER
411 static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
412     PlaneContext * const p= &s->plane[plane_index];
413     RangeCoder * const c= &s->c;
414     int x;
415     int run_index= s->run_index;
416     int run_count=0;
417     int run_mode=0;
418
419     if(s->ac){
420         if(c->bytestream_end - c->bytestream < w*20){
421             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
422             return -1;
423         }
424     }else{
425         if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
426             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
427             return -1;
428         }
429     }
430
431     for(x=0; x<w; x++){
432         int diff, context;
433
434         context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
435         diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
436
437         if(context < 0){
438             context = -context;
439             diff= -diff;
440         }
441
442         diff= fold(diff, bits);
443
444         if(s->ac){
445             put_symbol_inline(c, p->state[context], diff, 1);
446         }else{
447             if(context == 0) run_mode=1;
448
449             if(run_mode){
450
451                 if(diff){
452                     while(run_count >= 1<<ff_log2_run[run_index]){
453                         run_count -= 1<<ff_log2_run[run_index];
454                         run_index++;
455                         put_bits(&s->pb, 1, 1);
456                     }
457
458                     put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
459                     if(run_index) run_index--;
460                     run_count=0;
461                     run_mode=0;
462                     if(diff>0) diff--;
463                 }else{
464                     run_count++;
465                 }
466             }
467
468 //            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));
469
470             if(run_mode == 0)
471                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
472         }
473     }
474     if(run_mode){
475         while(run_count >= 1<<ff_log2_run[run_index]){
476             run_count -= 1<<ff_log2_run[run_index];
477             run_index++;
478             put_bits(&s->pb, 1, 1);
479         }
480
481         if(run_count)
482             put_bits(&s->pb, 1, 1);
483     }
484     s->run_index= run_index;
485
486     return 0;
487 }
488
489 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
490     int x,y,i;
491     const int ring_size= s->avctx->context_model ? 3 : 2;
492     int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
493     s->run_index=0;
494
495     memset(sample_buffer, 0, sizeof(sample_buffer));
496
497     for(y=0; y<h; y++){
498         for(i=0; i<ring_size; i++)
499             sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
500
501         sample[0][-1]= sample[1][0  ];
502         sample[1][ w]= sample[1][w-1];
503 //{START_TIMER
504         if(s->avctx->bits_per_raw_sample<=8){
505             for(x=0; x<w; x++){
506                 sample[0][x]= src[x + stride*y];
507             }
508             encode_line(s, w, sample, plane_index, 8);
509         }else{
510             for(x=0; x<w; x++){
511                 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
512             }
513             encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
514         }
515 //STOP_TIMER("encode line")}
516     }
517 }
518
519 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
520     int x, y, p, i;
521     const int ring_size= s->avctx->context_model ? 3 : 2;
522     int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
523     s->run_index=0;
524
525     memset(sample_buffer, 0, sizeof(sample_buffer));
526
527     for(y=0; y<h; y++){
528         for(i=0; i<ring_size; i++)
529             for(p=0; p<3; p++)
530                 sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
531
532         for(x=0; x<w; x++){
533             int v= src[x + stride*y];
534             int b= v&0xFF;
535             int g= (v>>8)&0xFF;
536             int r= (v>>16)&0xFF;
537
538             b -= g;
539             r -= g;
540             g += (b + r)>>2;
541             b += 0x100;
542             r += 0x100;
543
544 //            assert(g>=0 && b>=0 && r>=0);
545 //            assert(g<256 && b<512 && r<512);
546             sample[0][0][x]= g;
547             sample[1][0][x]= b;
548             sample[2][0][x]= r;
549         }
550         for(p=0; p<3; p++){
551             sample[p][0][-1]= sample[p][1][0  ];
552             sample[p][1][ w]= sample[p][1][w-1];
553             encode_line(s, w, sample[p], FFMIN(p, 1), 9);
554         }
555     }
556 }
557
558 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
559     int last=0;
560     int i;
561     uint8_t state[CONTEXT_SIZE];
562     memset(state, 128, sizeof(state));
563
564     for(i=1; i<128 ; i++){
565         if(quant_table[i] != quant_table[i-1]){
566             put_symbol(c, state, i-last-1, 0);
567             last= i;
568         }
569     }
570     put_symbol(c, state, i-last-1, 0);
571 }
572
573 static void write_header(FFV1Context *f){
574     uint8_t state[CONTEXT_SIZE];
575     int i;
576     RangeCoder * const c= &f->c;
577
578     memset(state, 128, sizeof(state));
579
580     put_symbol(c, state, f->version, 0);
581     put_symbol(c, state, f->avctx->coder_type, 0);
582     put_symbol(c, state, f->colorspace, 0); //YUV cs type
583     if(f->version>0)
584         put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
585     put_rac(c, state, 1); //chroma planes
586         put_symbol(c, state, f->chroma_h_shift, 0);
587         put_symbol(c, state, f->chroma_v_shift, 0);
588     put_rac(c, state, 0); //no transparency plane
589
590     for(i=0; i<5; i++)
591         write_quant_table(c, f->quant_table[i]);
592 }
593 #endif /* CONFIG_FFV1_ENCODER */
594
595 static av_cold int common_init(AVCodecContext *avctx){
596     FFV1Context *s = avctx->priv_data;
597
598     s->avctx= avctx;
599     s->flags= avctx->flags;
600
601     dsputil_init(&s->dsp, avctx);
602
603     s->width = avctx->width;
604     s->height= avctx->height;
605
606     assert(s->width && s->height);
607
608     return 0;
609 }
610
611 #if CONFIG_FFV1_ENCODER
612 static av_cold int encode_init(AVCodecContext *avctx)
613 {
614     FFV1Context *s = avctx->priv_data;
615     int i;
616
617     common_init(avctx);
618
619     s->version=0;
620     s->ac= avctx->coder_type;
621
622     s->plane_count=2;
623     for(i=0; i<256; i++){
624         if(avctx->bits_per_raw_sample <=8){
625             s->quant_table[0][i]=           quant11[i];
626             s->quant_table[1][i]=        11*quant11[i];
627             if(avctx->context_model==0){
628                 s->quant_table[2][i]=     11*11*quant11[i];
629                 s->quant_table[3][i]=
630                 s->quant_table[4][i]=0;
631             }else{
632                 s->quant_table[2][i]=     11*11*quant5 [i];
633                 s->quant_table[3][i]=   5*11*11*quant5 [i];
634                 s->quant_table[4][i]= 5*5*11*11*quant5 [i];
635             }
636         }else{
637             s->quant_table[0][i]=           quant9_10bit[i];
638             s->quant_table[1][i]=        11*quant9_10bit[i];
639             if(avctx->context_model==0){
640                 s->quant_table[2][i]=     11*11*quant9_10bit[i];
641                 s->quant_table[3][i]=
642                 s->quant_table[4][i]=0;
643             }else{
644                 s->quant_table[2][i]=     11*11*quant5_10bit[i];
645                 s->quant_table[3][i]=   5*11*11*quant5_10bit[i];
646                 s->quant_table[4][i]= 5*5*11*11*quant5_10bit[i];
647             }
648         }
649     }
650
651     for(i=0; i<s->plane_count; i++){
652         PlaneContext * const p= &s->plane[i];
653
654         if(avctx->context_model==0){
655             p->context_count= (11*11*11+1)/2;
656         }else{
657             p->context_count= (11*11*5*5*5+1)/2;
658         }
659
660         if(s->ac){
661             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
662         }else{
663             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
664         }
665     }
666
667     avctx->coded_frame= &s->picture;
668     switch(avctx->pix_fmt){
669     case PIX_FMT_YUV444P16:
670     case PIX_FMT_YUV422P16:
671     case PIX_FMT_YUV420P16:
672         if(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
673             av_log(avctx, AV_LOG_ERROR, "More than 8 bit per component is still experimental and no gurantee is yet made for future compatibility\n"
674                "Use vstrict=-2 / -strict -2 to use it anyway.\n");
675             return -1;
676         }
677         if(avctx->bits_per_raw_sample <=8){
678             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
679             return -1;
680         }
681         s->version= 1;
682     case PIX_FMT_YUV444P:
683     case PIX_FMT_YUV422P:
684     case PIX_FMT_YUV420P:
685     case PIX_FMT_YUV411P:
686     case PIX_FMT_YUV410P:
687         s->colorspace= 0;
688         break;
689     case PIX_FMT_RGB32:
690         s->colorspace= 1;
691         break;
692     default:
693         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
694         return -1;
695     }
696     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
697
698     s->picture_number=0;
699
700     return 0;
701 }
702 #endif /* CONFIG_FFV1_ENCODER */
703
704
705 static void clear_state(FFV1Context *f){
706     int i, j;
707
708     for(i=0; i<f->plane_count; i++){
709         PlaneContext *p= &f->plane[i];
710
711         p->interlace_bit_state[0]= 128;
712         p->interlace_bit_state[1]= 128;
713
714         for(j=0; j<p->context_count; j++){
715             if(f->ac){
716                 memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
717             }else{
718                 p->vlc_state[j].drift= 0;
719                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
720                 p->vlc_state[j].bias= 0;
721                 p->vlc_state[j].count= 1;
722             }
723         }
724     }
725 }
726
727 #if CONFIG_FFV1_ENCODER
728 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
729     FFV1Context *f = avctx->priv_data;
730     RangeCoder * const c= &f->c;
731     AVFrame *pict = data;
732     const int width= f->width;
733     const int height= f->height;
734     AVFrame * const p= &f->picture;
735     int used_count= 0;
736     uint8_t keystate=128;
737
738     ff_init_range_encoder(c, buf, buf_size);
739     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
740
741     *p = *pict;
742     p->pict_type= FF_I_TYPE;
743
744     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
745         put_rac(c, &keystate, 1);
746         p->key_frame= 1;
747         write_header(f);
748         clear_state(f);
749     }else{
750         put_rac(c, &keystate, 0);
751         p->key_frame= 0;
752     }
753
754     if(!f->ac){
755         used_count += ff_rac_terminate(c);
756 //printf("pos=%d\n", used_count);
757         init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
758     }
759
760     if(f->colorspace==0){
761         const int chroma_width = -((-width )>>f->chroma_h_shift);
762         const int chroma_height= -((-height)>>f->chroma_v_shift);
763
764         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
765
766         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
767         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
768     }else{
769         encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
770     }
771     emms_c();
772
773     f->picture_number++;
774
775     if(f->ac){
776         return ff_rac_terminate(c);
777     }else{
778         flush_put_bits(&f->pb); //nicer padding FIXME
779         return used_count + (put_bits_count(&f->pb)+7)/8;
780     }
781 }
782 #endif /* CONFIG_FFV1_ENCODER */
783
784 static av_cold int common_end(AVCodecContext *avctx){
785     FFV1Context *s = avctx->priv_data;
786     int i;
787
788     for(i=0; i<s->plane_count; i++){
789         PlaneContext *p= &s->plane[i];
790
791         av_freep(&p->state);
792         av_freep(&p->vlc_state);
793     }
794
795     return 0;
796 }
797
798 static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
799     PlaneContext * const p= &s->plane[plane_index];
800     RangeCoder * const c= &s->c;
801     int x;
802     int run_count=0;
803     int run_mode=0;
804     int run_index= s->run_index;
805
806     for(x=0; x<w; x++){
807         int diff, context, sign;
808
809         context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
810         if(context < 0){
811             context= -context;
812             sign=1;
813         }else
814             sign=0;
815
816
817         if(s->ac){
818             diff= get_symbol_inline(c, p->state[context], 1);
819         }else{
820             if(context == 0 && run_mode==0) run_mode=1;
821
822             if(run_mode){
823                 if(run_count==0 && run_mode==1){
824                     if(get_bits1(&s->gb)){
825                         run_count = 1<<ff_log2_run[run_index];
826                         if(x + run_count <= w) run_index++;
827                     }else{
828                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
829                         else run_count=0;
830                         if(run_index) run_index--;
831                         run_mode=2;
832                     }
833                 }
834                 run_count--;
835                 if(run_count < 0){
836                     run_mode=0;
837                     run_count=0;
838                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
839                     if(diff>=0) diff++;
840                 }else
841                     diff=0;
842             }else
843                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
844
845 //            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));
846         }
847
848         if(sign) diff= -diff;
849
850         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
851     }
852     s->run_index= run_index;
853 }
854
855 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
856     int x, y;
857     int_fast16_t sample_buffer[2][w+6];
858     int_fast16_t *sample[2];
859     sample[0]=sample_buffer[0]+3;
860     sample[1]=sample_buffer[1]+3;
861
862     s->run_index=0;
863
864     memset(sample_buffer, 0, sizeof(sample_buffer));
865
866     for(y=0; y<h; y++){
867         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
868
869         sample[0]= sample[1];
870         sample[1]= temp;
871
872         sample[1][-1]= sample[0][0  ];
873         sample[0][ w]= sample[0][w-1];
874
875 //{START_TIMER
876         if(s->avctx->bits_per_raw_sample <= 8){
877             decode_line(s, w, sample, plane_index, 8);
878             for(x=0; x<w; x++){
879                 src[x + stride*y]= sample[1][x];
880             }
881         }else{
882             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
883             for(x=0; x<w; x++){
884                 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
885             }
886         }
887 //STOP_TIMER("decode-line")}
888     }
889 }
890
891 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
892     int x, y, p;
893     int_fast16_t sample_buffer[3][2][w+6];
894     int_fast16_t *sample[3][2];
895     for(x=0; x<3; x++){
896         sample[x][0] = sample_buffer[x][0]+3;
897         sample[x][1] = sample_buffer[x][1]+3;
898     }
899
900     s->run_index=0;
901
902     memset(sample_buffer, 0, sizeof(sample_buffer));
903
904     for(y=0; y<h; y++){
905         for(p=0; p<3; p++){
906             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
907
908             sample[p][0]= sample[p][1];
909             sample[p][1]= temp;
910
911             sample[p][1][-1]= sample[p][0][0  ];
912             sample[p][0][ w]= sample[p][0][w-1];
913             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
914         }
915         for(x=0; x<w; x++){
916             int g= sample[0][1][x];
917             int b= sample[1][1][x];
918             int r= sample[2][1][x];
919
920 //            assert(g>=0 && b>=0 && r>=0);
921 //            assert(g<256 && b<512 && r<512);
922
923             b -= 0x100;
924             r -= 0x100;
925             g -= (b + r)>>2;
926             b += g;
927             r += g;
928
929             src[x + stride*y]= b + (g<<8) + (r<<16);
930         }
931     }
932 }
933
934 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
935     int v;
936     int i=0;
937     uint8_t state[CONTEXT_SIZE];
938
939     memset(state, 128, sizeof(state));
940
941     for(v=0; i<128 ; v++){
942         int len= get_symbol(c, state, 0) + 1;
943
944         if(len + i > 128) return -1;
945
946         while(len--){
947             quant_table[i] = scale*v;
948             i++;
949 //printf("%2d ",v);
950 //if(i%16==0) printf("\n");
951         }
952     }
953
954     for(i=1; i<128; i++){
955         quant_table[256-i]= -quant_table[i];
956     }
957     quant_table[128]= -quant_table[127];
958
959     return 2*v - 1;
960 }
961
962 static int read_header(FFV1Context *f){
963     uint8_t state[CONTEXT_SIZE];
964     int i, context_count;
965     RangeCoder * const c= &f->c;
966
967     memset(state, 128, sizeof(state));
968
969     f->version= get_symbol(c, state, 0);
970     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
971     f->colorspace= get_symbol(c, state, 0); //YUV cs type
972     if(f->version>0)
973         f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
974     get_rac(c, state); //no chroma = false
975     f->chroma_h_shift= get_symbol(c, state, 0);
976     f->chroma_v_shift= get_symbol(c, state, 0);
977     get_rac(c, state); //transparency plane
978     f->plane_count= 2;
979
980     if(f->colorspace==0){
981         if(f->avctx->bits_per_raw_sample<=8){
982             switch(16*f->chroma_h_shift + f->chroma_v_shift){
983             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
984             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
985             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
986             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
987             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
988             default:
989                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
990                 return -1;
991             }
992         }else{
993             switch(16*f->chroma_h_shift + f->chroma_v_shift){
994             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
995             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
996             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
997             default:
998                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
999                 return -1;
1000             }
1001         }
1002     }else if(f->colorspace==1){
1003         if(f->chroma_h_shift || f->chroma_v_shift){
1004             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1005             return -1;
1006         }
1007         f->avctx->pix_fmt= PIX_FMT_RGB32;
1008     }else{
1009         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1010         return -1;
1011     }
1012
1013 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1014
1015     context_count=1;
1016     for(i=0; i<5; i++){
1017         context_count*= read_quant_table(c, f->quant_table[i], context_count);
1018         if(context_count < 0 || context_count > 32768){
1019             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1020             return -1;
1021         }
1022     }
1023     context_count= (context_count+1)/2;
1024
1025     for(i=0; i<f->plane_count; i++){
1026         PlaneContext * const p= &f->plane[i];
1027
1028         p->context_count= context_count;
1029
1030         if(f->ac){
1031             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
1032         }else{
1033             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
1034         }
1035     }
1036
1037     return 0;
1038 }
1039
1040 static av_cold int decode_init(AVCodecContext *avctx)
1041 {
1042 //    FFV1Context *s = avctx->priv_data;
1043
1044     common_init(avctx);
1045
1046     return 0;
1047 }
1048
1049 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1050     const uint8_t *buf = avpkt->data;
1051     int buf_size = avpkt->size;
1052     FFV1Context *f = avctx->priv_data;
1053     RangeCoder * const c= &f->c;
1054     const int width= f->width;
1055     const int height= f->height;
1056     AVFrame * const p= &f->picture;
1057     int bytes_read;
1058     uint8_t keystate= 128;
1059
1060     AVFrame *picture = data;
1061
1062     ff_init_range_decoder(c, buf, buf_size);
1063     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1064
1065
1066     p->pict_type= FF_I_TYPE; //FIXME I vs. P
1067     if(get_rac(c, &keystate)){
1068         p->key_frame= 1;
1069         if(read_header(f) < 0)
1070             return -1;
1071         clear_state(f);
1072     }else{
1073         p->key_frame= 0;
1074     }
1075     if(!f->plane[0].state && !f->plane[0].vlc_state)
1076         return -1;
1077
1078     p->reference= 0;
1079     if(avctx->get_buffer(avctx, p) < 0){
1080         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1081         return -1;
1082     }
1083
1084     if(avctx->debug&FF_DEBUG_PICT_INFO)
1085         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1086
1087     if(!f->ac){
1088         bytes_read = c->bytestream - c->bytestream_start - 1;
1089         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1090 //printf("pos=%d\n", bytes_read);
1091         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
1092     } else {
1093         bytes_read = 0; /* avoid warning */
1094     }
1095
1096     if(f->colorspace==0){
1097         const int chroma_width = -((-width )>>f->chroma_h_shift);
1098         const int chroma_height= -((-height)>>f->chroma_v_shift);
1099         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
1100
1101         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
1102         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
1103     }else{
1104         decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
1105     }
1106
1107     emms_c();
1108
1109     f->picture_number++;
1110
1111     *picture= *p;
1112
1113     avctx->release_buffer(avctx, p); //FIXME
1114
1115     *data_size = sizeof(AVFrame);
1116
1117     if(f->ac){
1118         bytes_read= c->bytestream - c->bytestream_start - 1;
1119         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1120     }else{
1121         bytes_read+= (get_bits_count(&f->gb)+7)/8;
1122     }
1123
1124     return bytes_read;
1125 }
1126
1127 AVCodec ffv1_decoder = {
1128     "ffv1",
1129     CODEC_TYPE_VIDEO,
1130     CODEC_ID_FFV1,
1131     sizeof(FFV1Context),
1132     decode_init,
1133     NULL,
1134     common_end,
1135     decode_frame,
1136     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1137     NULL,
1138     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1139 };
1140
1141 #if CONFIG_FFV1_ENCODER
1142 AVCodec ffv1_encoder = {
1143     "ffv1",
1144     CODEC_TYPE_VIDEO,
1145     CODEC_ID_FFV1,
1146     sizeof(FFV1Context),
1147     encode_init,
1148     encode_frame,
1149     common_end,
1150     .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},
1151     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1152 };
1153 #endif