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