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