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