ffv1: split init_slice_state() out so individual slices can be inited
[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_state(FFV1Context *f){
1122     int i, si, j;
1123
1124     for(si=0; si<f->slice_count; si++){
1125         FFV1Context *fs= f->slice_context[si];
1126         for(i=0; i<f->plane_count; i++){
1127             PlaneContext *p= &fs->plane[i];
1128
1129             p->interlace_bit_state[0]= 128;
1130             p->interlace_bit_state[1]= 128;
1131
1132             if(fs->ac){
1133                 if(f->initial_states[p->quant_table_index]){
1134                     memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1135                 }else
1136                 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1137             }else{
1138                 for(j=0; j<p->context_count; j++){
1139                     p->vlc_state[j].drift= 0;
1140                     p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1141                     p->vlc_state[j].bias= 0;
1142                     p->vlc_state[j].count= 1;
1143                 }
1144             }
1145         }
1146     }
1147 }
1148
1149 #if CONFIG_FFV1_ENCODER
1150 static int encode_slice(AVCodecContext *c, void *arg){
1151     FFV1Context *fs= *(void**)arg;
1152     FFV1Context *f= fs->avctx->priv_data;
1153     int width = fs->slice_width;
1154     int height= fs->slice_height;
1155     int x= fs->slice_x;
1156     int y= fs->slice_y;
1157     AVFrame * const p= &f->picture;
1158     const int ps= (f->bits_per_raw_sample>8)+1;
1159
1160     if(f->colorspace==0){
1161         const int chroma_width = -((-width )>>f->chroma_h_shift);
1162         const int chroma_height= -((-height)>>f->chroma_v_shift);
1163         const int cx= x>>f->chroma_h_shift;
1164         const int cy= y>>f->chroma_v_shift;
1165
1166         encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1167
1168         if (f->chroma_planes){
1169             encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1170             encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1171         }
1172         if (fs->transparency)
1173             encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1174     }else{
1175         encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1176     }
1177     emms_c();
1178
1179     return 0;
1180 }
1181
1182 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1183                         const AVFrame *pict, int *got_packet)
1184 {
1185     FFV1Context *f = avctx->priv_data;
1186     RangeCoder * const c= &f->slice_context[0]->c;
1187     AVFrame * const p= &f->picture;
1188     int used_count= 0;
1189     uint8_t keystate=128;
1190     uint8_t *buf_p;
1191     int i, ret;
1192
1193     if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1194                                   + FF_MIN_BUFFER_SIZE)) < 0)
1195         return ret;
1196
1197     ff_init_range_encoder(c, pkt->data, pkt->size);
1198     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1199
1200     *p = *pict;
1201     p->pict_type= AV_PICTURE_TYPE_I;
1202
1203     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1204         put_rac(c, &keystate, 1);
1205         p->key_frame= 1;
1206         f->gob_count++;
1207         write_header(f);
1208         clear_state(f);
1209     }else{
1210         put_rac(c, &keystate, 0);
1211         p->key_frame= 0;
1212     }
1213
1214     if(!f->ac){
1215         used_count += ff_rac_terminate(c);
1216 //printf("pos=%d\n", used_count);
1217         init_put_bits(&f->slice_context[0]->pb, pkt->data + used_count, pkt->size - used_count);
1218     }else if (f->ac>1){
1219         int i;
1220         for(i=1; i<256; i++){
1221             c->one_state[i]= f->state_transition[i];
1222             c->zero_state[256-i]= 256-c->one_state[i];
1223         }
1224     }
1225
1226     for(i=1; i<f->slice_count; i++){
1227         FFV1Context *fs= f->slice_context[i];
1228         uint8_t *start = pkt->data + (pkt->size-used_count)*i/f->slice_count;
1229         int len = pkt->size/f->slice_count;
1230
1231         if(fs->ac){
1232             ff_init_range_encoder(&fs->c, start, len);
1233         }else{
1234             init_put_bits(&fs->pb, start, len);
1235         }
1236     }
1237     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1238
1239     buf_p = pkt->data;
1240     for(i=0; i<f->slice_count; i++){
1241         FFV1Context *fs= f->slice_context[i];
1242         int bytes;
1243
1244         if(fs->ac){
1245             uint8_t state=128;
1246             put_rac(&fs->c, &state, 0);
1247             bytes= ff_rac_terminate(&fs->c);
1248         }else{
1249             flush_put_bits(&fs->pb); //nicer padding FIXME
1250             bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1251             used_count= 0;
1252         }
1253         if(i>0){
1254             av_assert0(bytes < pkt->size/f->slice_count);
1255             memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1256             av_assert0(bytes < (1<<24));
1257             AV_WB24(buf_p+bytes, bytes);
1258             bytes+=3;
1259         }
1260         buf_p += bytes;
1261     }
1262
1263     if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1264         int j, k, m;
1265         char *p= avctx->stats_out;
1266         char *end= p + STATS_OUT_SIZE;
1267
1268         memset(f->rc_stat, 0, sizeof(f->rc_stat));
1269         for(i=0; i<f->quant_table_count; i++)
1270             memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1271
1272         for(j=0; j<f->slice_count; j++){
1273             FFV1Context *fs= f->slice_context[j];
1274             for(i=0; i<256; i++){
1275                 f->rc_stat[i][0] += fs->rc_stat[i][0];
1276                 f->rc_stat[i][1] += fs->rc_stat[i][1];
1277             }
1278             for(i=0; i<f->quant_table_count; i++){
1279                 for(k=0; k<f->context_count[i]; k++){
1280                     for(m=0; m<32; m++){
1281                         f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1282                         f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1283                     }
1284                 }
1285             }
1286         }
1287
1288         for(j=0; j<256; j++){
1289             snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1290             p+= strlen(p);
1291         }
1292         snprintf(p, end-p, "\n");
1293
1294         for(i=0; i<f->quant_table_count; i++){
1295             for(j=0; j<f->context_count[i]; j++){
1296                 for(m=0; m<32; m++){
1297                     snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1298                     p+= strlen(p);
1299                 }
1300             }
1301         }
1302         snprintf(p, end-p, "%d\n", f->gob_count);
1303     } else if(avctx->flags&CODEC_FLAG_PASS1)
1304         avctx->stats_out[0] = '\0';
1305
1306     f->picture_number++;
1307     pkt->size   = buf_p - pkt->data;
1308     pkt->flags |= AV_PKT_FLAG_KEY*p->key_frame;
1309     *got_packet = 1;
1310
1311     return 0;
1312 }
1313 #endif /* CONFIG_FFV1_ENCODER */
1314
1315 static av_cold int common_end(AVCodecContext *avctx){
1316     FFV1Context *s = avctx->priv_data;
1317     int i, j;
1318
1319     if (avctx->codec->decode && s->picture.data[0])
1320         avctx->release_buffer(avctx, &s->picture);
1321
1322     for(j=0; j<s->slice_count; j++){
1323         FFV1Context *fs= s->slice_context[j];
1324         for(i=0; i<s->plane_count; i++){
1325             PlaneContext *p= &fs->plane[i];
1326
1327             av_freep(&p->state);
1328             av_freep(&p->vlc_state);
1329         }
1330         av_freep(&fs->sample_buffer);
1331     }
1332
1333     av_freep(&avctx->stats_out);
1334     for(j=0; j<s->quant_table_count; j++){
1335         av_freep(&s->initial_states[j]);
1336         for(i=0; i<s->slice_count; i++){
1337             FFV1Context *sf= s->slice_context[i];
1338             av_freep(&sf->rc_stat2[j]);
1339         }
1340         av_freep(&s->rc_stat2[j]);
1341     }
1342
1343     for(i=0; i<s->slice_count; i++){
1344         av_freep(&s->slice_context[i]);
1345     }
1346
1347     return 0;
1348 }
1349
1350 static av_always_inline void decode_line(FFV1Context *s, int w,
1351                                          int16_t *sample[2],
1352                                          int plane_index, int bits)
1353 {
1354     PlaneContext * const p= &s->plane[plane_index];
1355     RangeCoder * const c= &s->c;
1356     int x;
1357     int run_count=0;
1358     int run_mode=0;
1359     int run_index= s->run_index;
1360
1361     for(x=0; x<w; x++){
1362         int diff, context, sign;
1363
1364         context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1365         if(context < 0){
1366             context= -context;
1367             sign=1;
1368         }else
1369             sign=0;
1370
1371         av_assert2(context < p->context_count);
1372
1373         if(s->ac){
1374             diff= get_symbol_inline(c, p->state[context], 1);
1375         }else{
1376             if(context == 0 && run_mode==0) run_mode=1;
1377
1378             if(run_mode){
1379                 if(run_count==0 && run_mode==1){
1380                     if(get_bits1(&s->gb)){
1381                         run_count = 1<<ff_log2_run[run_index];
1382                         if(x + run_count <= w) run_index++;
1383                     }else{
1384                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1385                         else run_count=0;
1386                         if(run_index) run_index--;
1387                         run_mode=2;
1388                     }
1389                 }
1390                 run_count--;
1391                 if(run_count < 0){
1392                     run_mode=0;
1393                     run_count=0;
1394                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1395                     if(diff>=0) diff++;
1396                 }else
1397                     diff=0;
1398             }else
1399                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1400
1401 //            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));
1402         }
1403
1404         if(sign) diff= -diff;
1405
1406         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1407     }
1408     s->run_index= run_index;
1409 }
1410
1411 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1412     int x, y;
1413     int16_t *sample[2];
1414     sample[0]=s->sample_buffer    +3;
1415     sample[1]=s->sample_buffer+w+6+3;
1416
1417     s->run_index=0;
1418
1419     memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1420
1421     for(y=0; y<h; y++){
1422         int16_t *temp = sample[0]; //FIXME try a normal buffer
1423
1424         sample[0]= sample[1];
1425         sample[1]= temp;
1426
1427         sample[1][-1]= sample[0][0  ];
1428         sample[0][ w]= sample[0][w-1];
1429
1430 //{START_TIMER
1431         if(s->avctx->bits_per_raw_sample <= 8){
1432             decode_line(s, w, sample, plane_index, 8);
1433             for(x=0; x<w; x++){
1434                 src[x + stride*y]= sample[1][x];
1435             }
1436         }else{
1437             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1438             if(s->packed_at_lsb){
1439                 for(x=0; x<w; x++){
1440                     ((uint16_t*)(src + stride*y))[x]= sample[1][x];
1441                 }
1442             }else{
1443                 for(x=0; x<w; x++){
1444                     ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1445                 }
1446             }
1447         }
1448 //STOP_TIMER("decode-line")}
1449     }
1450 }
1451
1452 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1453     int x, y, p;
1454     int16_t *sample[4][2];
1455     for(x=0; x<4; x++){
1456         sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1457         sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1458     }
1459
1460     s->run_index=0;
1461
1462     memset(s->sample_buffer, 0, 8*(w+6)*sizeof(*s->sample_buffer));
1463
1464     for(y=0; y<h; y++){
1465         for(p=0; p<3 + s->transparency; p++){
1466             int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1467
1468             sample[p][0]= sample[p][1];
1469             sample[p][1]= temp;
1470
1471             sample[p][1][-1]= sample[p][0][0  ];
1472             sample[p][0][ w]= sample[p][0][w-1];
1473             decode_line(s, w, sample[p], (p+1)/2, 9);
1474         }
1475         for(x=0; x<w; x++){
1476             int g= sample[0][1][x];
1477             int b= sample[1][1][x];
1478             int r= sample[2][1][x];
1479             int a= sample[3][1][x];
1480
1481 //            assert(g>=0 && b>=0 && r>=0);
1482 //            assert(g<256 && b<512 && r<512);
1483
1484             b -= 0x100;
1485             r -= 0x100;
1486             g -= (b + r)>>2;
1487             b += g;
1488             r += g;
1489
1490             src[x + stride*y]= b + (g<<8) + (r<<16) + (a<<24);
1491         }
1492     }
1493 }
1494
1495 static int decode_slice(AVCodecContext *c, void *arg){
1496     FFV1Context *fs= *(void**)arg;
1497     FFV1Context *f= fs->avctx->priv_data;
1498     int width = fs->slice_width;
1499     int height= fs->slice_height;
1500     int x= fs->slice_x;
1501     int y= fs->slice_y;
1502     const int ps= (c->bits_per_raw_sample>8)+1;
1503     AVFrame * const p= &f->picture;
1504
1505     av_assert1(width && height);
1506     if(f->colorspace==0){
1507         const int chroma_width = -((-width )>>f->chroma_h_shift);
1508         const int chroma_height= -((-height)>>f->chroma_v_shift);
1509         const int cx= x>>f->chroma_h_shift;
1510         const int cy= y>>f->chroma_v_shift;
1511         decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1512
1513         if (f->chroma_planes){
1514             decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1515             decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1516         }
1517         if (fs->transparency)
1518             decode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1519     }else{
1520         decode_rgb_frame(fs, (uint32_t*)p->data[0] + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1521     }
1522
1523     emms_c();
1524
1525     return 0;
1526 }
1527
1528 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1529     int v;
1530     int i=0;
1531     uint8_t state[CONTEXT_SIZE];
1532
1533     memset(state, 128, sizeof(state));
1534
1535     for(v=0; i<128 ; v++){
1536         int len= get_symbol(c, state, 0) + 1;
1537
1538         if(len + i > 128) return -1;
1539
1540         while(len--){
1541             quant_table[i] = scale*v;
1542             i++;
1543 //printf("%2d ",v);
1544 //if(i%16==0) printf("\n");
1545         }
1546     }
1547
1548     for(i=1; i<128; i++){
1549         quant_table[256-i]= -quant_table[i];
1550     }
1551     quant_table[128]= -quant_table[127];
1552
1553     return 2*v - 1;
1554 }
1555
1556 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1557     int i;
1558     int context_count=1;
1559
1560     for(i=0; i<5; i++){
1561         context_count*= read_quant_table(c, quant_table[i], context_count);
1562         if(context_count > 32768U){
1563             return -1;
1564         }
1565     }
1566     return (context_count+1)/2;
1567 }
1568
1569 static int read_extra_header(FFV1Context *f){
1570     RangeCoder * const c= &f->c;
1571     uint8_t state[CONTEXT_SIZE];
1572     int i, j, k;
1573     uint8_t state2[32][CONTEXT_SIZE];
1574
1575     memset(state2, 128, sizeof(state2));
1576     memset(state, 128, sizeof(state));
1577
1578     ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1579     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1580
1581     f->version= get_symbol(c, state, 0);
1582     if(f->version > 2)
1583         f->minor_version= get_symbol(c, state, 0);
1584     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1585     if(f->ac>1){
1586         for(i=1; i<256; i++){
1587             f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1588         }
1589     }
1590     f->colorspace= get_symbol(c, state, 0); //YUV cs type
1591     f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1592     f->chroma_planes= get_rac(c, state);
1593     f->chroma_h_shift= get_symbol(c, state, 0);
1594     f->chroma_v_shift= get_symbol(c, state, 0);
1595     f->transparency= get_rac(c, state);
1596     f->plane_count= 2 + f->transparency;
1597     f->num_h_slices= 1 + get_symbol(c, state, 0);
1598     f->num_v_slices= 1 + get_symbol(c, state, 0);
1599     if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1600         av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1601         return -1;
1602     }
1603
1604     f->quant_table_count= get_symbol(c, state, 0);
1605     if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1606         return -1;
1607     for(i=0; i<f->quant_table_count; i++){
1608         if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1609             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1610             return -1;
1611         }
1612     }
1613
1614     if(allocate_initial_states(f) < 0)
1615         return AVERROR(ENOMEM);
1616
1617     for(i=0; i<f->quant_table_count; i++){
1618         if(get_rac(c, state)){
1619             for(j=0; j<f->context_count[i]; j++){
1620                 for(k=0; k<CONTEXT_SIZE; k++){
1621                     int pred= j ? f->initial_states[i][j-1][k] : 128;
1622                     f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1623                 }
1624             }
1625         }
1626     }
1627
1628     if(f->version > 2){
1629         unsigned v;
1630         v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
1631         if(v){
1632             av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
1633             return AVERROR_INVALIDDATA;
1634         }
1635     }
1636
1637     return 0;
1638 }
1639
1640 static int read_header(FFV1Context *f){
1641     uint8_t state[CONTEXT_SIZE];
1642     int i, j, context_count;
1643     RangeCoder * const c= &f->slice_context[0]->c;
1644
1645     memset(state, 128, sizeof(state));
1646
1647     if(f->version < 2){
1648         f->version= get_symbol(c, state, 0);
1649         f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1650         if(f->ac>1){
1651             for(i=1; i<256; i++){
1652                 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1653             }
1654         }
1655         f->colorspace= get_symbol(c, state, 0); //YUV cs type
1656         if(f->version>0)
1657             f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1658         f->chroma_planes= get_rac(c, state);
1659         f->chroma_h_shift= get_symbol(c, state, 0);
1660         f->chroma_v_shift= get_symbol(c, state, 0);
1661         f->transparency= get_rac(c, state);
1662         f->plane_count= 2 + f->transparency;
1663     }
1664
1665     if(f->colorspace==0){
1666         if(!f->transparency && !f->chroma_planes){
1667             if (f->avctx->bits_per_raw_sample<=8)
1668                 f->avctx->pix_fmt= PIX_FMT_GRAY8;
1669             else
1670                 f->avctx->pix_fmt= PIX_FMT_GRAY16;
1671         }else if(f->avctx->bits_per_raw_sample<=8 && !f->transparency){
1672             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1673             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1674             case 0x01: f->avctx->pix_fmt= PIX_FMT_YUV440P; break;
1675             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1676             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1677             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1678             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1679             default:
1680                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1681                 return -1;
1682             }
1683         }else if(f->avctx->bits_per_raw_sample<=8 && f->transparency){
1684             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1685             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUVA444P; break;
1686             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUVA420P; break;
1687             default:
1688                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1689                 return -1;
1690             }
1691         }else if(f->avctx->bits_per_raw_sample==9) {
1692             f->packed_at_lsb=1;
1693             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1694             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P9; break;
1695             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P9; break;
1696             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P9; break;
1697             default:
1698                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1699                 return -1;
1700             }
1701         }else if(f->avctx->bits_per_raw_sample==10) {
1702             f->packed_at_lsb=1;
1703             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1704             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P10; break;
1705             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P10; break;
1706             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P10; break;
1707             default:
1708                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1709                 return -1;
1710             }
1711         }else {
1712             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1713             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1714             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1715             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1716             default:
1717                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1718                 return -1;
1719             }
1720         }
1721     }else if(f->colorspace==1){
1722         if(f->chroma_h_shift || f->chroma_v_shift){
1723             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1724             return -1;
1725         }
1726         if(f->transparency) f->avctx->pix_fmt= PIX_FMT_RGB32;
1727         else                f->avctx->pix_fmt= PIX_FMT_0RGB32;
1728     }else{
1729         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1730         return -1;
1731     }
1732
1733 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1734     if(f->version < 2){
1735         context_count= read_quant_tables(c, f->quant_table);
1736         if(context_count < 0){
1737                 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1738                 return -1;
1739         }
1740     }else{
1741         f->slice_count= get_symbol(c, state, 0);
1742         if(f->slice_count > (unsigned)MAX_SLICES)
1743             return -1;
1744     }
1745
1746     for(j=0; j<f->slice_count; j++){
1747         FFV1Context *fs= f->slice_context[j];
1748         fs->ac= f->ac;
1749         fs->packed_at_lsb= f->packed_at_lsb;
1750
1751         if(f->version >= 2){
1752             fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1753             fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1754             fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1755             fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1756
1757             fs->slice_x /= f->num_h_slices;
1758             fs->slice_y /= f->num_v_slices;
1759             fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1760             fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1761             if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1762                 return -1;
1763             if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1764                 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1765                 return -1;
1766         }
1767
1768         for(i=0; i<f->plane_count; i++){
1769             PlaneContext * const p= &fs->plane[i];
1770
1771             if(f->version >= 2){
1772                 int idx=get_symbol(c, state, 0);
1773                 if(idx > (unsigned)f->quant_table_count){
1774                     av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1775                     return -1;
1776                 }
1777                 p->quant_table_index= idx;
1778                 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1779                 context_count= f->context_count[idx];
1780             }else{
1781                 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1782             }
1783
1784             if(p->context_count < context_count){
1785                 av_freep(&p->state);
1786                 av_freep(&p->vlc_state);
1787             }
1788             p->context_count= context_count;
1789         }
1790     }
1791     return 0;
1792 }
1793
1794 static av_cold int decode_init(AVCodecContext *avctx)
1795 {
1796     FFV1Context *f = avctx->priv_data;
1797
1798     common_init(avctx);
1799
1800     if(avctx->extradata && read_extra_header(f) < 0)
1801         return -1;
1802
1803     if(init_slice_contexts(f) < 0)
1804         return -1;
1805
1806     return 0;
1807 }
1808
1809 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1810     const uint8_t *buf = avpkt->data;
1811     int buf_size = avpkt->size;
1812     FFV1Context *f = avctx->priv_data;
1813     RangeCoder * const c= &f->slice_context[0]->c;
1814     AVFrame * const p= &f->picture;
1815     int bytes_read, i;
1816     uint8_t keystate= 128;
1817     const uint8_t *buf_p;
1818
1819     AVFrame *picture = data;
1820
1821     /* release previously stored data */
1822     if (p->data[0])
1823         avctx->release_buffer(avctx, p);
1824
1825     ff_init_range_decoder(c, buf, buf_size);
1826     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1827
1828
1829     p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1830     if(get_rac(c, &keystate)){
1831         p->key_frame= 1;
1832         if(read_header(f) < 0)
1833             return -1;
1834         if(init_slices_state(f) < 0)
1835             return -1;
1836
1837         clear_state(f);
1838     }else{
1839         p->key_frame= 0;
1840     }
1841     if(f->ac>1){
1842         int i;
1843         for(i=1; i<256; i++){
1844             c->one_state[i]= f->state_transition[i];
1845             c->zero_state[256-i]= 256-c->one_state[i];
1846         }
1847     }
1848
1849     p->reference= 0;
1850     if(avctx->get_buffer(avctx, p) < 0){
1851         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1852         return -1;
1853     }
1854
1855     if(avctx->debug&FF_DEBUG_PICT_INFO)
1856         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1857
1858     if(!f->ac){
1859         bytes_read = c->bytestream - c->bytestream_start - 1;
1860         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1861 //printf("pos=%d\n", bytes_read);
1862         init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1863     } else {
1864         bytes_read = 0; /* avoid warning */
1865     }
1866
1867     buf_p= buf + buf_size;
1868     for(i=f->slice_count-1; i>0; i--){
1869         FFV1Context *fs= f->slice_context[i];
1870         int v= AV_RB24(buf_p-3)+3;
1871         if(buf_p - buf <= v){
1872             av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1873             return -1;
1874         }
1875         buf_p -= v;
1876         if(fs->ac){
1877             ff_init_range_decoder(&fs->c, buf_p, v);
1878         }else{
1879             init_get_bits(&fs->gb, buf_p, v * 8);
1880         }
1881     }
1882
1883     avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1884     f->picture_number++;
1885
1886     *picture= *p;
1887     *data_size = sizeof(AVFrame);
1888
1889     return buf_size;
1890 }
1891
1892 AVCodec ff_ffv1_decoder = {
1893     .name           = "ffv1",
1894     .type           = AVMEDIA_TYPE_VIDEO,
1895     .id             = CODEC_ID_FFV1,
1896     .priv_data_size = sizeof(FFV1Context),
1897     .init           = decode_init,
1898     .close          = common_end,
1899     .decode         = decode_frame,
1900     .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ |
1901                       CODEC_CAP_SLICE_THREADS,
1902     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1903 };
1904
1905 #if CONFIG_FFV1_ENCODER
1906 AVCodec ff_ffv1_encoder = {
1907     .name           = "ffv1",
1908     .type           = AVMEDIA_TYPE_VIDEO,
1909     .id             = CODEC_ID_FFV1,
1910     .priv_data_size = sizeof(FFV1Context),
1911     .init           = encode_init,
1912     .encode2        = encode_frame,
1913     .close          = common_end,
1914     .capabilities   = CODEC_CAP_SLICE_THREADS,
1915     .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},
1916     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1917 };
1918 #endif