Add 8088flex TMV video decoder.
[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 (an experimental 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-> CABAC 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 inavlid\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_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
740     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
741
742     *p = *pict;
743     p->pict_type= FF_I_TYPE;
744
745     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
746         put_rac(c, &keystate, 1);
747         p->key_frame= 1;
748         write_header(f);
749         clear_state(f);
750     }else{
751         put_rac(c, &keystate, 0);
752         p->key_frame= 0;
753     }
754
755     if(!f->ac){
756         used_count += ff_rac_terminate(c);
757 //printf("pos=%d\n", used_count);
758         init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
759     }
760
761     if(f->colorspace==0){
762         const int chroma_width = -((-width )>>f->chroma_h_shift);
763         const int chroma_height= -((-height)>>f->chroma_v_shift);
764
765         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
766
767         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
768         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
769     }else{
770         encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
771     }
772     emms_c();
773
774     f->picture_number++;
775
776     if(f->ac){
777         return ff_rac_terminate(c);
778     }else{
779         flush_put_bits(&f->pb); //nicer padding FIXME
780         return used_count + (put_bits_count(&f->pb)+7)/8;
781     }
782 }
783 #endif /* CONFIG_FFV1_ENCODER */
784
785 static av_cold int common_end(AVCodecContext *avctx){
786     FFV1Context *s = avctx->priv_data;
787     int i;
788
789     for(i=0; i<s->plane_count; i++){
790         PlaneContext *p= &s->plane[i];
791
792         av_freep(&p->state);
793         av_freep(&p->vlc_state);
794     }
795
796     return 0;
797 }
798
799 static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
800     PlaneContext * const p= &s->plane[plane_index];
801     RangeCoder * const c= &s->c;
802     int x;
803     int run_count=0;
804     int run_mode=0;
805     int run_index= s->run_index;
806
807     for(x=0; x<w; x++){
808         int diff, context, sign;
809
810         context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
811         if(context < 0){
812             context= -context;
813             sign=1;
814         }else
815             sign=0;
816
817
818         if(s->ac){
819             diff= get_symbol_inline(c, p->state[context], 1);
820         }else{
821             if(context == 0 && run_mode==0) run_mode=1;
822
823             if(run_mode){
824                 if(run_count==0 && run_mode==1){
825                     if(get_bits1(&s->gb)){
826                         run_count = 1<<ff_log2_run[run_index];
827                         if(x + run_count <= w) run_index++;
828                     }else{
829                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
830                         else run_count=0;
831                         if(run_index) run_index--;
832                         run_mode=2;
833                     }
834                 }
835                 run_count--;
836                 if(run_count < 0){
837                     run_mode=0;
838                     run_count=0;
839                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
840                     if(diff>=0) diff++;
841                 }else
842                     diff=0;
843             }else
844                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
845
846 //            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));
847         }
848
849         if(sign) diff= -diff;
850
851         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
852     }
853     s->run_index= run_index;
854 }
855
856 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
857     int x, y;
858     int_fast16_t sample_buffer[2][w+6];
859     int_fast16_t *sample[2];
860     sample[0]=sample_buffer[0]+3;
861     sample[1]=sample_buffer[1]+3;
862
863     s->run_index=0;
864
865     memset(sample_buffer, 0, sizeof(sample_buffer));
866
867     for(y=0; y<h; y++){
868         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
869
870         sample[0]= sample[1];
871         sample[1]= temp;
872
873         sample[1][-1]= sample[0][0  ];
874         sample[0][ w]= sample[0][w-1];
875
876 //{START_TIMER
877         if(s->avctx->bits_per_raw_sample <= 8){
878             decode_line(s, w, sample, plane_index, 8);
879             for(x=0; x<w; x++){
880                 src[x + stride*y]= sample[1][x];
881             }
882         }else{
883             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
884             for(x=0; x<w; x++){
885                 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
886             }
887         }
888 //STOP_TIMER("decode-line")}
889     }
890 }
891
892 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
893     int x, y, p;
894     int_fast16_t sample_buffer[3][2][w+6];
895     int_fast16_t *sample[3][2];
896     for(x=0; x<3; x++){
897         sample[x][0] = sample_buffer[x][0]+3;
898         sample[x][1] = sample_buffer[x][1]+3;
899     }
900
901     s->run_index=0;
902
903     memset(sample_buffer, 0, sizeof(sample_buffer));
904
905     for(y=0; y<h; y++){
906         for(p=0; p<3; p++){
907             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
908
909             sample[p][0]= sample[p][1];
910             sample[p][1]= temp;
911
912             sample[p][1][-1]= sample[p][0][0  ];
913             sample[p][0][ w]= sample[p][0][w-1];
914             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
915         }
916         for(x=0; x<w; x++){
917             int g= sample[0][1][x];
918             int b= sample[1][1][x];
919             int r= sample[2][1][x];
920
921 //            assert(g>=0 && b>=0 && r>=0);
922 //            assert(g<256 && b<512 && r<512);
923
924             b -= 0x100;
925             r -= 0x100;
926             g -= (b + r)>>2;
927             b += g;
928             r += g;
929
930             src[x + stride*y]= b + (g<<8) + (r<<16);
931         }
932     }
933 }
934
935 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
936     int v;
937     int i=0;
938     uint8_t state[CONTEXT_SIZE];
939
940     memset(state, 128, sizeof(state));
941
942     for(v=0; i<128 ; v++){
943         int len= get_symbol(c, state, 0) + 1;
944
945         if(len + i > 128) return -1;
946
947         while(len--){
948             quant_table[i] = scale*v;
949             i++;
950 //printf("%2d ",v);
951 //if(i%16==0) printf("\n");
952         }
953     }
954
955     for(i=1; i<128; i++){
956         quant_table[256-i]= -quant_table[i];
957     }
958     quant_table[128]= -quant_table[127];
959
960     return 2*v - 1;
961 }
962
963 static int read_header(FFV1Context *f){
964     uint8_t state[CONTEXT_SIZE];
965     int i, context_count;
966     RangeCoder * const c= &f->c;
967
968     memset(state, 128, sizeof(state));
969
970     f->version= get_symbol(c, state, 0);
971     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
972     f->colorspace= get_symbol(c, state, 0); //YUV cs type
973     if(f->version>0)
974         f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
975     get_rac(c, state); //no chroma = false
976     f->chroma_h_shift= get_symbol(c, state, 0);
977     f->chroma_v_shift= get_symbol(c, state, 0);
978     get_rac(c, state); //transparency plane
979     f->plane_count= 2;
980
981     if(f->colorspace==0){
982         if(f->avctx->bits_per_raw_sample<=8){
983             switch(16*f->chroma_h_shift + f->chroma_v_shift){
984             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
985             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
986             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
987             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
988             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
989             default:
990                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
991                 return -1;
992             }
993         }else{
994             switch(16*f->chroma_h_shift + f->chroma_v_shift){
995             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
996             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
997             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
998             default:
999                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1000                 return -1;
1001             }
1002         }
1003     }else if(f->colorspace==1){
1004         if(f->chroma_h_shift || f->chroma_v_shift){
1005             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1006             return -1;
1007         }
1008         f->avctx->pix_fmt= PIX_FMT_RGB32;
1009     }else{
1010         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1011         return -1;
1012     }
1013
1014 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1015
1016     context_count=1;
1017     for(i=0; i<5; i++){
1018         context_count*= read_quant_table(c, f->quant_table[i], context_count);
1019         if(context_count < 0 || context_count > 32768){
1020             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1021             return -1;
1022         }
1023     }
1024     context_count= (context_count+1)/2;
1025
1026     for(i=0; i<f->plane_count; i++){
1027         PlaneContext * const p= &f->plane[i];
1028
1029         p->context_count= context_count;
1030
1031         if(f->ac){
1032             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
1033         }else{
1034             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
1035         }
1036     }
1037
1038     return 0;
1039 }
1040
1041 static av_cold int decode_init(AVCodecContext *avctx)
1042 {
1043 //    FFV1Context *s = avctx->priv_data;
1044
1045     common_init(avctx);
1046
1047     return 0;
1048 }
1049
1050 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1051     const uint8_t *buf = avpkt->data;
1052     int buf_size = avpkt->size;
1053     FFV1Context *f = avctx->priv_data;
1054     RangeCoder * const c= &f->c;
1055     const int width= f->width;
1056     const int height= f->height;
1057     AVFrame * const p= &f->picture;
1058     int bytes_read;
1059     uint8_t keystate= 128;
1060
1061     AVFrame *picture = data;
1062
1063     ff_init_range_decoder(c, buf, buf_size);
1064     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1065
1066
1067     p->pict_type= FF_I_TYPE; //FIXME I vs. P
1068     if(get_rac(c, &keystate)){
1069         p->key_frame= 1;
1070         if(read_header(f) < 0)
1071             return -1;
1072         clear_state(f);
1073     }else{
1074         p->key_frame= 0;
1075     }
1076     if(!f->plane[0].state && !f->plane[0].vlc_state)
1077         return -1;
1078
1079     p->reference= 0;
1080     if(avctx->get_buffer(avctx, p) < 0){
1081         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1082         return -1;
1083     }
1084
1085     if(avctx->debug&FF_DEBUG_PICT_INFO)
1086         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1087
1088     if(!f->ac){
1089         bytes_read = c->bytestream - c->bytestream_start - 1;
1090         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1091 //printf("pos=%d\n", bytes_read);
1092         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
1093     } else {
1094         bytes_read = 0; /* avoid warning */
1095     }
1096
1097     if(f->colorspace==0){
1098         const int chroma_width = -((-width )>>f->chroma_h_shift);
1099         const int chroma_height= -((-height)>>f->chroma_v_shift);
1100         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
1101
1102         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
1103         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
1104     }else{
1105         decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
1106     }
1107
1108     emms_c();
1109
1110     f->picture_number++;
1111
1112     *picture= *p;
1113
1114     avctx->release_buffer(avctx, p); //FIXME
1115
1116     *data_size = sizeof(AVFrame);
1117
1118     if(f->ac){
1119         bytes_read= c->bytestream - c->bytestream_start - 1;
1120         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1121     }else{
1122         bytes_read+= (get_bits_count(&f->gb)+7)/8;
1123     }
1124
1125     return bytes_read;
1126 }
1127
1128 AVCodec ffv1_decoder = {
1129     "ffv1",
1130     CODEC_TYPE_VIDEO,
1131     CODEC_ID_FFV1,
1132     sizeof(FFV1Context),
1133     decode_init,
1134     NULL,
1135     common_end,
1136     decode_frame,
1137     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1138     NULL,
1139     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg codec #1"),
1140 };
1141
1142 #if CONFIG_FFV1_ENCODER
1143 AVCodec ffv1_encoder = {
1144     "ffv1",
1145     CODEC_TYPE_VIDEO,
1146     CODEC_ID_FFV1,
1147     sizeof(FFV1Context),
1148     encode_init,
1149     encode_frame,
1150     common_end,
1151     .pix_fmts= (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},
1152     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg codec #1"),
1153 };
1154 #endif