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