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