avoid buf_size == 0 checks in every decoder
[ffmpeg.git] / libavcodec / ffv1.c
1 /*
2  * FFV1 codec for libavcodec
3  *
4  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21  
22 /**
23  * @file ffv1.c
24  * FF Video Codec 1 (an experimental lossless codec)
25  */
26
27 #include "common.h"
28 #include "bitstream.h"
29 #include "avcodec.h"
30 #include "dsputil.h"
31 #include "rangecoder.h"
32 #include "golomb.h"
33
34 #define MAX_PLANES 4
35 #define CONTEXT_SIZE 32
36
37 static const int8_t quant3[256]={
38  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
39  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
40  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
41  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
42  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
43  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
44  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
45  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
46 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
47 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
48 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
49 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
50 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
51 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
52 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
53 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
54 };
55 static const int8_t quant5[256]={
56  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
57  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
58  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
59  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
60  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
61  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
62  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
63  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
64 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
65 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-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,-2,
69 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
70 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
71 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
72 };
73 static const int8_t quant7[256]={
74  0, 1, 1, 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, 3, 3, 3, 3, 3, 3, 3, 3,
77  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
78  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
79  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
80  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
81  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
82 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
83 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
84 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
85 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
86 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
87 -3,-3,-3,-3,-3,-3,-3,-3,-3,-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,-1,-1,
90 };
91 static const int8_t quant9[256]={
92  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
93  3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
94  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
95  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
96  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
97  4, 4, 4, 4, 4, 4, 4, 4, 4, 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,-4,-4,-4,-3,-3,-3,-3,
107 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
108 };
109 static const int8_t quant11[256]={
110  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
111  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
112  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
113  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
114  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
115  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
116  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
117  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
118 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
119 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
120 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
121 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
122 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
123 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
124 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
125 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
126 };
127 static const int8_t quant13[256]={
128  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
129  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
130  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
131  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
132  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
133  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
134  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
135  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
136 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
137 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
138 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
139 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
140 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
141 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
142 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
143 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
144 };
145
146 static const uint8_t log2_run[32]={
147  0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 
148  4, 4, 5, 5, 6, 6, 7, 7, 
149  8, 9,10,11,12,13,14,15,
150 };
151
152 typedef struct VlcState{
153     int16_t drift;
154     uint16_t error_sum;
155     int8_t bias;
156     uint8_t count;
157 } VlcState;
158
159 typedef struct PlaneContext{
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 typedef struct FFV1Context{
167     AVCodecContext *avctx;
168     RangeCoder c;
169     GetBitContext gb;
170     PutBitContext pb;
171     int version;
172     int width, height;
173     int chroma_h_shift, chroma_v_shift;
174     int flags;
175     int picture_number;
176     AVFrame picture;
177     int plane_count;
178     int ac;                              ///< 1-> CABAC 0-> golomb rice
179     PlaneContext plane[MAX_PLANES];
180     int16_t quant_table[5][256];
181     int run_index;
182     int colorspace;
183     
184     DSPContext dsp; 
185 }FFV1Context;
186
187 static always_inline int fold(int diff, int bits){
188     if(bits==8)
189         diff= (int8_t)diff;
190     else{
191         diff+= 1<<(bits-1);
192         diff&=(1<<bits)-1;
193         diff-= 1<<(bits-1);
194     }
195
196     return diff;
197 }
198
199 static inline int predict(int_fast16_t *src, int_fast16_t *last){
200     const int LT= last[-1];
201     const int  T= last[ 0];
202     const int L =  src[-1];
203
204     return mid_pred(L, L + T - LT, T);
205 }
206
207 static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
208     const int LT= last[-1];
209     const int  T= last[ 0];
210     const int RT= last[ 1];
211     const int L =  src[-1];
212
213     if(f->quant_table[3][127]){
214         const int TT= last2[0];
215         const int LL=  src[-2];
216         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
217               +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
218     }else
219         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
220 }
221
222 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
223     int i;
224
225     if(v){
226         const int a= ABS(v);
227         const int e= av_log2(a);
228         put_rac(c, state+0, 0);
229         
230         assert(e<=9);
231
232         for(i=0; i<e; i++){
233             put_rac(c, state+1+i, 1);  //1..10
234         }
235         put_rac(c, state+1+i, 0);
236
237         for(i=e-1; i>=0; i--){
238             put_rac(c, state+22+i, (a>>i)&1); //22..31
239         }
240
241         if(is_signed)
242             put_rac(c, state+11 + e, v < 0); //11..21
243     }else{
244         put_rac(c, state+0, 1);
245     }
246 }
247
248 static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
249     if(get_rac(c, state+0))
250         return 0;
251     else{
252         int i, e, a;
253         e= 0;
254         while(get_rac(c, state+1 + e)){ //1..10
255             e++;
256         }
257         assert(e<=9);
258
259         a= 1;
260         for(i=e-1; i>=0; i--){
261             a += a + get_rac(c, state+22 + i); //22..31
262         }
263
264         if(is_signed && get_rac(c, state+11 + e)) //11..21
265             return -a;
266         else
267             return a;
268     }
269 }
270
271 static inline void update_vlc_state(VlcState * const state, const int v){
272     int drift= state->drift;
273     int count= state->count;
274     state->error_sum += ABS(v);
275     drift += v;
276
277     if(count == 128){ //FIXME variable
278         count >>= 1;
279         drift >>= 1;
280         state->error_sum >>= 1;
281     }
282     count++;
283
284     if(drift <= -count){
285         if(state->bias > -128) state->bias--;
286         
287         drift += count;
288         if(drift <= -count)
289             drift= -count + 1;
290     }else if(drift > 0){
291         if(state->bias <  127) state->bias++;
292         
293         drift -= count;
294         if(drift > 0) 
295             drift= 0;
296     }
297
298     state->drift= drift;
299     state->count= count;
300 }
301
302 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
303     int i, k, code;
304 //printf("final: %d ", v);
305     v = fold(v - state->bias, bits);
306
307     i= state->count;
308     k=0;
309     while(i < state->error_sum){ //FIXME optimize
310         k++;
311         i += i;
312     }
313
314     assert(k<=8);
315
316 #if 0 // JPEG LS
317     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
318     else                                         code= v;
319 #else
320      code= v ^ ((2*state->drift + state->count)>>31);
321 #endif
322     
323 //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);
324     set_sr_golomb(pb, code, k, 12, bits);
325
326     update_vlc_state(state, v);
327 }
328
329 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
330     int k, i, v, ret;
331
332     i= state->count;
333     k=0;
334     while(i < state->error_sum){ //FIXME optimize
335         k++;
336         i += i;
337     }
338
339     assert(k<=8);
340
341     v= get_sr_golomb(gb, k, 12, bits);
342 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
343
344 #if 0 // JPEG LS
345     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
346 #else
347      v ^= ((2*state->drift + state->count)>>31);
348 #endif
349
350     ret= fold(v + state->bias, bits);
351     
352     update_vlc_state(state, v);
353 //printf("final: %d\n", ret);
354     return ret;
355 }
356
357 static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
358     PlaneContext * const p= &s->plane[plane_index];
359     RangeCoder * const c= &s->c;
360     int x;
361     int run_index= s->run_index;
362     int run_count=0;
363     int run_mode=0;
364
365     if(s->ac){
366         if(c->bytestream_end - c->bytestream < w*20){
367             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
368             return -1;
369         }
370     }else{
371         if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
372             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
373             return -1;
374         }
375     }
376
377     for(x=0; x<w; x++){
378         int diff, context;
379         
380         context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
381         diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
382
383         if(context < 0){
384             context = -context;
385             diff= -diff;
386         }
387
388         diff= fold(diff, bits);
389         
390         if(s->ac){
391             put_symbol(c, p->state[context], diff, 1);
392         }else{
393             if(context == 0) run_mode=1;
394             
395             if(run_mode){
396
397                 if(diff){
398                     while(run_count >= 1<<log2_run[run_index]){
399                         run_count -= 1<<log2_run[run_index];
400                         run_index++;
401                         put_bits(&s->pb, 1, 1);
402                     }
403                     
404                     put_bits(&s->pb, 1 + log2_run[run_index], run_count);
405                     if(run_index) run_index--;
406                     run_count=0;
407                     run_mode=0;
408                     if(diff>0) diff--;
409                 }else{
410                     run_count++;
411                 }
412             }
413             
414 //            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));
415
416             if(run_mode == 0)
417                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
418         }
419     }
420     if(run_mode){
421         while(run_count >= 1<<log2_run[run_index]){
422             run_count -= 1<<log2_run[run_index];
423             run_index++;
424             put_bits(&s->pb, 1, 1);
425         }
426
427         if(run_count)
428             put_bits(&s->pb, 1, 1);
429     }
430     s->run_index= run_index;
431     
432     return 0;
433 }
434
435 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
436     int x,y,i;
437     const int ring_size= s->avctx->context_model ? 3 : 2;
438     int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
439     s->run_index=0;
440     
441     memset(sample_buffer, 0, sizeof(sample_buffer));
442     
443     for(y=0; y<h; y++){
444         for(i=0; i<ring_size; i++)
445             sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
446         
447         sample[0][-1]= sample[1][0  ];
448         sample[1][ w]= sample[1][w-1];
449 //{START_TIMER
450         for(x=0; x<w; x++){
451             sample[0][x]= src[x + stride*y];
452         }
453         encode_line(s, w, sample, plane_index, 8);
454 //STOP_TIMER("encode line")}
455     }
456 }
457
458 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
459     int x, y, p, i;
460     const int ring_size= s->avctx->context_model ? 3 : 2;
461     int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
462     s->run_index=0;
463     
464     memset(sample_buffer, 0, sizeof(sample_buffer));
465     
466     for(y=0; y<h; y++){
467         for(i=0; i<ring_size; i++)
468             for(p=0; p<3; p++)
469                 sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
470
471         for(x=0; x<w; x++){
472             int v= src[x + stride*y];
473             int b= v&0xFF;
474             int g= (v>>8)&0xFF;
475             int r= (v>>16)&0xFF;
476             
477             b -= g;
478             r -= g;
479             g += (b + r)>>2;
480             b += 0x100;
481             r += 0x100;
482             
483 //            assert(g>=0 && b>=0 && r>=0);
484 //            assert(g<256 && b<512 && r<512);
485             sample[0][0][x]= g;
486             sample[1][0][x]= b;
487             sample[2][0][x]= r;
488         }
489         for(p=0; p<3; p++){
490             sample[p][0][-1]= sample[p][1][0  ];
491             sample[p][1][ w]= sample[p][1][w-1];
492             encode_line(s, w, sample[p], FFMIN(p, 1), 9);
493         }
494     }
495 }
496
497 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
498     int last=0;
499     int i;
500     uint8_t state[CONTEXT_SIZE];
501     memset(state, 128, sizeof(state));
502
503     for(i=1; i<128 ; i++){
504         if(quant_table[i] != quant_table[i-1]){
505             put_symbol(c, state, i-last-1, 0);
506             last= i;
507         }
508     }
509     put_symbol(c, state, i-last-1, 0);
510 }
511
512 static void write_header(FFV1Context *f){
513     uint8_t state[CONTEXT_SIZE];
514     int i;
515     RangeCoder * const c= &f->c;
516
517     memset(state, 128, sizeof(state));
518     
519     put_symbol(c, state, f->version, 0);
520     put_symbol(c, state, f->avctx->coder_type, 0);
521     put_symbol(c, state, f->colorspace, 0); //YUV cs type 
522     put_rac(c, state, 1); //chroma planes
523         put_symbol(c, state, f->chroma_h_shift, 0);
524         put_symbol(c, state, f->chroma_v_shift, 0);
525     put_rac(c, state, 0); //no transparency plane
526
527     for(i=0; i<5; i++)
528         write_quant_table(c, f->quant_table[i]);
529 }
530
531 static int common_init(AVCodecContext *avctx){
532     FFV1Context *s = avctx->priv_data;
533     int width, height;
534
535     s->avctx= avctx;
536     s->flags= avctx->flags;
537         
538     dsputil_init(&s->dsp, avctx);
539     
540     width= s->width= avctx->width;
541     height= s->height= avctx->height;
542     
543     assert(width && height);
544
545     return 0;
546 }
547
548 static int encode_init(AVCodecContext *avctx)
549 {
550     FFV1Context *s = avctx->priv_data;
551     int i;
552
553     if(avctx->strict_std_compliance >= 0){
554         av_log(avctx, AV_LOG_ERROR, "this codec is under development, files encoded with it wont be decodeable with future versions!!!\n"
555                "use vstrict=-1 to use it anyway\n");
556         return -1;
557     }
558         
559     common_init(avctx);
560  
561     s->version=0;
562     s->ac= avctx->coder_type;
563     
564     s->plane_count=2;
565     for(i=0; i<256; i++){
566         s->quant_table[0][i]=           quant11[i];
567         s->quant_table[1][i]=        11*quant11[i];
568         if(avctx->context_model==0){
569             s->quant_table[2][i]=     11*11*quant11[i];
570             s->quant_table[3][i]=
571             s->quant_table[4][i]=0;
572         }else{
573             s->quant_table[2][i]=     11*11*quant5 [i];
574             s->quant_table[3][i]=   5*11*11*quant5 [i];
575             s->quant_table[4][i]= 5*5*11*11*quant5 [i];
576         }
577     }
578
579     for(i=0; i<s->plane_count; i++){
580         PlaneContext * const p= &s->plane[i];
581                
582         if(avctx->context_model==0){
583             p->context_count= (11*11*11+1)/2;
584         }else{        
585             p->context_count= (11*11*5*5*5+1)/2;
586         }
587
588         if(s->ac){
589             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
590         }else{
591             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
592         }
593     }
594
595     avctx->coded_frame= &s->picture;
596     switch(avctx->pix_fmt){
597     case PIX_FMT_YUV444P:
598     case PIX_FMT_YUV422P:
599     case PIX_FMT_YUV420P:
600     case PIX_FMT_YUV411P:
601     case PIX_FMT_YUV410P:
602         s->colorspace= 0;
603         break;
604     case PIX_FMT_RGBA32:
605         s->colorspace= 1;
606         break;
607     default:
608         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
609         return -1;
610     }
611     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
612
613     s->picture_number=0;
614     
615     return 0;
616 }
617
618
619 static void clear_state(FFV1Context *f){
620     int i, j;
621
622     for(i=0; i<f->plane_count; i++){
623         PlaneContext *p= &f->plane[i];
624
625         p->interlace_bit_state[0]= 128;
626         p->interlace_bit_state[1]= 128;
627         
628         for(j=0; j<p->context_count; j++){
629             if(f->ac){
630                 memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
631             }else{
632                 p->vlc_state[j].drift= 0;
633                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
634                 p->vlc_state[j].bias= 0;
635                 p->vlc_state[j].count= 1;
636             }
637         }
638     }
639 }
640
641 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
642     FFV1Context *f = avctx->priv_data;
643     RangeCoder * const c= &f->c;
644     AVFrame *pict = data;
645     const int width= f->width;
646     const int height= f->height;
647     AVFrame * const p= &f->picture;
648     int used_count= 0;
649     uint8_t keystate=128;
650
651     ff_init_range_encoder(c, buf, buf_size);
652 //    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
653     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
654
655     *p = *pict;
656     p->pict_type= FF_I_TYPE;
657     
658     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
659         put_rac(c, &keystate, 1);
660         p->key_frame= 1;
661         write_header(f);
662         clear_state(f);
663     }else{
664         put_rac(c, &keystate, 0);
665         p->key_frame= 0;
666     }
667
668     if(!f->ac){
669         used_count += ff_rac_terminate(c);
670 //printf("pos=%d\n", used_count);
671         init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
672     }
673     
674     if(f->colorspace==0){
675         const int chroma_width = -((-width )>>f->chroma_h_shift);
676         const int chroma_height= -((-height)>>f->chroma_v_shift);
677
678         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
679
680         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
681         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
682     }else{
683         encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
684     }
685     emms_c();
686     
687     f->picture_number++;
688
689     if(f->ac){
690         return ff_rac_terminate(c);
691     }else{
692         flush_put_bits(&f->pb); //nicer padding FIXME
693         return used_count + (put_bits_count(&f->pb)+7)/8;
694     }
695 }
696
697 static void common_end(FFV1Context *s){
698     int i; 
699
700     for(i=0; i<s->plane_count; i++){
701         PlaneContext *p= &s->plane[i];
702
703         av_freep(&p->state);
704     }
705 }
706
707 static int encode_end(AVCodecContext *avctx)
708 {
709     FFV1Context *s = avctx->priv_data;
710
711     common_end(s);
712
713     return 0;
714 }
715
716 static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
717     PlaneContext * const p= &s->plane[plane_index];
718     RangeCoder * const c= &s->c;
719     int x;
720     int run_count=0;
721     int run_mode=0;
722     int run_index= s->run_index;
723
724     for(x=0; x<w; x++){
725         int diff, context, sign;
726          
727         context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
728         if(context < 0){
729             context= -context;
730             sign=1;
731         }else
732             sign=0;
733         
734
735         if(s->ac){
736             diff= get_symbol(c, p->state[context], 1);
737         }else{
738             if(context == 0 && run_mode==0) run_mode=1;
739             
740             if(run_mode){
741                 if(run_count==0 && run_mode==1){
742                     if(get_bits1(&s->gb)){
743                         run_count = 1<<log2_run[run_index];
744                         if(x + run_count <= w) run_index++;
745                     }else{
746                         if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
747                         else run_count=0;
748                         if(run_index) run_index--;
749                         run_mode=2;
750                     }
751                 }
752                 run_count--;
753                 if(run_count < 0){
754                     run_mode=0;
755                     run_count=0;
756                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
757                     if(diff>=0) diff++;
758                 }else
759                     diff=0;
760             }else
761                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
762             
763 //            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));
764         }
765
766         if(sign) diff= -diff;
767
768         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
769     }
770     s->run_index= run_index;        
771 }
772
773 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
774     int x, y;
775     int_fast16_t sample_buffer[2][w+6];
776     int_fast16_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
777
778     s->run_index=0;
779     
780     memset(sample_buffer, 0, sizeof(sample_buffer));
781     
782     for(y=0; y<h; y++){
783         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
784
785         sample[0]= sample[1];
786         sample[1]= temp;
787
788         sample[1][-1]= sample[0][0  ];
789         sample[0][ w]= sample[0][w-1];
790         
791 //{START_TIMER
792         decode_line(s, w, sample, plane_index, 8);
793         for(x=0; x<w; x++){
794             src[x + stride*y]= sample[1][x];
795         }
796 //STOP_TIMER("decode-line")}
797     }
798 }
799
800 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
801     int x, y, p;
802     int_fast16_t sample_buffer[3][2][w+6];
803     int_fast16_t *sample[3][2]= {
804         {sample_buffer[0][0]+3, sample_buffer[0][1]+3},
805         {sample_buffer[1][0]+3, sample_buffer[1][1]+3},
806         {sample_buffer[2][0]+3, sample_buffer[2][1]+3}};
807
808     s->run_index=0;
809     
810     memset(sample_buffer, 0, sizeof(sample_buffer));
811     
812     for(y=0; y<h; y++){
813         for(p=0; p<3; p++){
814             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
815
816             sample[p][0]= sample[p][1];
817             sample[p][1]= temp;
818
819             sample[p][1][-1]= sample[p][0][0  ];
820             sample[p][0][ w]= sample[p][0][w-1];
821             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
822         }
823         for(x=0; x<w; x++){
824             int g= sample[0][1][x];
825             int b= sample[1][1][x];
826             int r= sample[2][1][x];
827
828 //            assert(g>=0 && b>=0 && r>=0);
829 //            assert(g<256 && b<512 && r<512);
830             
831             b -= 0x100;
832             r -= 0x100;
833             g -= (b + r)>>2;
834             b += g;
835             r += g;
836             
837             src[x + stride*y]= b + (g<<8) + (r<<16);
838         }
839     }
840 }
841
842 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
843     int v;
844     int i=0;
845     uint8_t state[CONTEXT_SIZE];
846
847     memset(state, 128, sizeof(state));
848
849     for(v=0; i<128 ; v++){
850         int len= get_symbol(c, state, 0) + 1;
851
852         if(len + i > 128) return -1;
853         
854         while(len--){
855             quant_table[i] = scale*v;
856             i++;
857 //printf("%2d ",v);
858 //if(i%16==0) printf("\n");
859         }
860     }
861
862     for(i=1; i<128; i++){
863         quant_table[256-i]= -quant_table[i];
864     }
865     quant_table[128]= -quant_table[127];
866     
867     return 2*v - 1;
868 }
869
870 static int read_header(FFV1Context *f){
871     uint8_t state[CONTEXT_SIZE];
872     int i, context_count;
873     RangeCoder * const c= &f->c;
874     
875     memset(state, 128, sizeof(state));
876
877     f->version= get_symbol(c, state, 0);
878     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
879     f->colorspace= get_symbol(c, state, 0); //YUV cs type
880     get_rac(c, state); //no chroma = false
881     f->chroma_h_shift= get_symbol(c, state, 0);
882     f->chroma_v_shift= get_symbol(c, state, 0);
883     get_rac(c, state); //transparency plane
884     f->plane_count= 2;
885
886     if(f->colorspace==0){
887         switch(16*f->chroma_h_shift + f->chroma_v_shift){
888         case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
889         case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
890         case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
891         case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
892         case 0x33: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
893         default:
894             av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
895             return -1;
896         }
897     }else if(f->colorspace==1){
898         if(f->chroma_h_shift || f->chroma_v_shift){
899             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
900             return -1;
901         }
902         f->avctx->pix_fmt= PIX_FMT_RGBA32;
903     }else{
904         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
905         return -1;
906     }
907
908 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
909
910     context_count=1;
911     for(i=0; i<5; i++){
912         context_count*= read_quant_table(c, f->quant_table[i], context_count);
913         if(context_count < 0 || context_count > 32768){
914             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
915             return -1;
916         }
917     }
918     context_count= (context_count+1)/2;
919     
920     for(i=0; i<f->plane_count; i++){
921         PlaneContext * const p= &f->plane[i];
922
923         p->context_count= context_count;
924
925         if(f->ac){
926             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
927         }else{
928             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
929         }
930     }
931     
932     return 0;
933 }
934
935 static int decode_init(AVCodecContext *avctx)
936 {
937 //    FFV1Context *s = avctx->priv_data;
938
939     common_init(avctx);
940     
941     return 0;
942 }
943
944 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
945     FFV1Context *f = avctx->priv_data;
946     RangeCoder * const c= &f->c;
947     const int width= f->width;
948     const int height= f->height;
949     AVFrame * const p= &f->picture;
950     int bytes_read;
951     uint8_t keystate= 128;
952
953     AVFrame *picture = data;
954
955     ff_init_range_decoder(c, buf, buf_size);
956     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
957
958
959     p->pict_type= FF_I_TYPE; //FIXME I vs. P
960     if(get_rac(c, &keystate)){
961         p->key_frame= 1;
962         read_header(f);
963         clear_state(f);
964     }else{
965         p->key_frame= 0;
966     }
967
968     p->reference= 0;
969     if(avctx->get_buffer(avctx, p) < 0){
970         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
971         return -1;
972     }
973
974     if(avctx->debug&FF_DEBUG_PICT_INFO)
975         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
976     
977     if(!f->ac){
978         bytes_read = c->bytestream - c->bytestream_start - 1;
979         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
980 //printf("pos=%d\n", bytes_read);
981         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
982     } else {
983         bytes_read = 0; /* avoid warning */
984     }
985     
986     if(f->colorspace==0){
987         const int chroma_width = -((-width )>>f->chroma_h_shift);
988         const int chroma_height= -((-height)>>f->chroma_v_shift);
989         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
990         
991         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
992         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
993     }else{
994         decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
995     }
996         
997     emms_c();
998
999     f->picture_number++;
1000
1001     *picture= *p;
1002     
1003     avctx->release_buffer(avctx, p); //FIXME
1004
1005     *data_size = sizeof(AVFrame);
1006     
1007     if(f->ac){
1008         bytes_read= c->bytestream - c->bytestream_start - 1;
1009         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1010     }else{
1011         bytes_read+= (get_bits_count(&f->gb)+7)/8;
1012     }
1013
1014     return bytes_read;
1015 }
1016
1017 AVCodec ffv1_decoder = {
1018     "ffv1",
1019     CODEC_TYPE_VIDEO,
1020     CODEC_ID_FFV1,
1021     sizeof(FFV1Context),
1022     decode_init,
1023     NULL,
1024     NULL,
1025     decode_frame,
1026     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1027     NULL
1028 };
1029
1030 #ifdef CONFIG_ENCODERS
1031 AVCodec ffv1_encoder = {
1032     "ffv1",
1033     CODEC_TYPE_VIDEO,
1034     CODEC_ID_FFV1,
1035     sizeof(FFV1Context),
1036     encode_init,
1037     encode_frame,
1038     encode_end,
1039 };
1040 #endif