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