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