CONFIG_ENCODERS cleanup
[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 (a experimental lossless codec)
25  */
26
27 #include "common.h"
28 #include "avcodec.h"
29 #include "dsputil.h"
30 #include "cabac.h"
31 #include "golomb.h"
32
33 #define MAX_PLANES 4
34 #define CONTEXT_SIZE 32
35
36 static const int8_t quant3[256]={
37  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
38  1, 1, 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, 0,
53 };
54 static const int8_t quant5[256]={
55  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
56  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
57  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
58  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
59  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
60  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
61  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
62  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
63 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
64 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
65 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-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,-1,-1,-1,
71 };
72 static const int8_t quant7[256]={
73  0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
74  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
75  2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
76  3, 3, 3, 3, 3, 3, 3, 3, 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,-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,-1,-1,
89 };
90 static const int8_t quant9[256]={
91  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
92  3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
93  4, 4, 4, 4, 4, 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,-3,-3,-3,-3,
106 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
107 };
108 static const int8_t quant11[256]={
109  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
110  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
111  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
112  5, 5, 5, 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,-4,-4,
123 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
124 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
125 };
126 static const int8_t quant13[256]={
127  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
128  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
129  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
130  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
131  6, 6, 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,-5,
140 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
141 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
142 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
143 };
144
145 static const uint8_t log2_run[32]={
146  0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 
147  4, 4, 5, 5, 6, 6, 7, 7, 
148  8, 9,10,11,12,13,14,15,
149 };
150
151 typedef struct VlcState{
152     int16_t drift;
153     uint16_t error_sum;
154     int8_t bias;
155     uint8_t count;
156 } VlcState;
157
158 typedef struct PlaneContext{
159     int context_count;
160     uint8_t (*state)[CONTEXT_SIZE];
161     VlcState *vlc_state;
162     uint8_t interlace_bit_state[2];
163 } PlaneContext;
164
165 typedef struct FFV1Context{
166     AVCodecContext *avctx;
167     CABACContext c;
168     GetBitContext gb;
169     PutBitContext pb;
170     int version;
171     int width, height;
172     int chroma_h_shift, chroma_v_shift;
173     int flags;
174     int picture_number;
175     AVFrame picture;
176     int plane_count;
177     int ac;                              ///< 1-> CABAC 0-> golomb rice
178     PlaneContext plane[MAX_PLANES];
179     int16_t quant_table[5][256];
180     
181     DSPContext dsp; 
182 }FFV1Context;
183
184 static inline int predict(uint8_t *src, uint8_t *last){
185     const int LT= last[-1];
186     const int  T= last[ 0];
187     const int L =  src[-1];
188     uint8_t *cm = cropTbl + MAX_NEG_CROP;    
189     const int gradient= cm[L + T - LT];
190
191     return mid_pred(L, gradient, T);
192 }
193
194 static inline int get_context(FFV1Context *f, uint8_t *src, uint8_t *last, uint8_t *last2){
195     const int LT= last[-1];
196     const int  T= last[ 0];
197     const int RT= last[ 1];
198     const int L =  src[-1];
199
200     if(f->quant_table[3][127]){
201         const int TT= last2[0];
202         const int LL=  src[-2];
203         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
204               +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
205     }else
206         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
207 }
208
209 /**
210  * put 
211  */
212 static inline void put_symbol(CABACContext *c, uint8_t *state, int v, int is_signed){
213     int i;
214
215     if(v){
216         const int a= ABS(v);
217         const int e= av_log2(a);
218
219         put_cabac(c, state+0, 0);
220         put_cabac_u(c, state+1, e, 7, 6, 1); //1..7
221         if(e<7){
222             for(i=e-1; i>=0; i--){
223                 static const int offset[7]= {15+0, 15+0, 15+1, 15+3, 15+6, 15+10, 15+11};
224                 put_cabac(c, state+offset[e]+i, (a>>i)&1); //15..31
225             }
226             if(is_signed)
227                 put_cabac(c, state+8 + e, v < 0); //8..14
228         }
229     }else{
230         put_cabac(c, state+0, 1);
231     }
232 }
233
234 static inline int get_symbol(CABACContext *c, uint8_t *state, int is_signed){
235     int i;
236
237     if(get_cabac(c, state+0))
238         return 0;
239     else{
240         const int e= get_cabac_u(c, state+1, 7, 6, 1); //1..7
241         
242         if(e<7){
243             int a= 1<<e;
244
245             for(i=e-1; i>=0; i--){
246                 static const int offset[7]= {15+0, 15+0, 15+1, 15+3, 15+6, 15+10, 15+11};
247                 a += get_cabac(c, state+offset[e]+i)<<i; //14..31
248             }
249
250             if(is_signed && get_cabac(c, state+8 + e)) //8..14
251                 return -a;
252             else
253                 return a;
254         }else
255             return -128;
256     }
257 }
258
259 static inline void update_vlc_state(VlcState * const state, const int v){
260     int drift= state->drift;
261     int count= state->count;
262     state->error_sum += ABS(v);
263     drift += v;
264
265     if(count == 128){ //FIXME variable
266         count >>= 1;
267         drift >>= 1;
268         state->error_sum >>= 1;
269     }
270     count++;
271
272     if(drift <= -count){
273         if(state->bias > -128) state->bias--;
274         
275         drift += count;
276         if(drift <= -count)
277             drift= -count + 1;
278     }else if(drift > 0){
279         if(state->bias <  127) state->bias++;
280         
281         drift -= count;
282         if(drift > 0) 
283             drift= 0;
284     }
285
286     state->drift= drift;
287     state->count= count;
288 }
289
290 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v){
291     int i, k, code;
292 //printf("final: %d ", v);
293     v = (int8_t)(v - state->bias);
294     
295     i= state->count;
296     k=0;
297     while(i < state->error_sum){ //FIXME optimize
298         k++;
299         i += i;
300     }
301 #if 0 // JPEG LS
302     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
303     else                                         code= v;
304 #else
305      code= v ^ ((2*state->drift + state->count)>>31);
306 #endif
307     
308     code = -2*code-1;
309     code^= (code>>31);
310 //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);
311     set_ur_golomb(pb, code, k, 8, 8);
312
313     update_vlc_state(state, v);
314 }
315
316 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state){
317     int k, i, v, ret;
318
319     i= state->count;
320     k=0;
321     while(i < state->error_sum){ //FIXME optimize
322         k++;
323         i += i;
324     }
325     
326     v= get_ur_golomb(gb, k, 8, 8);
327 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
328     
329     v++;
330     if(v&1) v=  (v>>1);
331     else    v= -(v>>1);
332
333 #if 0 // JPEG LS
334     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
335 #else
336      v ^= ((2*state->drift + state->count)>>31);
337 #endif
338
339     ret= (int8_t)(v + state->bias);
340     
341     update_vlc_state(state, v);
342 //printf("final: %d\n", ret);
343     return ret;
344 }
345
346
347
348 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
349     PlaneContext * const p= &s->plane[plane_index];
350     CABACContext * const c= &s->c;
351     int x,y;
352     uint8_t pred_diff_buffer[4][w+6]; //FIXME rema,e
353     uint8_t *pred_diff[4]= {pred_diff_buffer[0]+3, pred_diff_buffer[1]+3, pred_diff_buffer[2]+3, pred_diff_buffer[3]+3};
354     int run_index=0;
355     
356     memset(pred_diff_buffer, 0, sizeof(pred_diff_buffer));
357     
358     for(y=0; y<h; y++){
359         uint8_t *temp= pred_diff[0]; //FIXME try a normal buffer
360         int run_count=0;
361         int run_mode=0;
362
363         pred_diff[0]= pred_diff[1];
364         pred_diff[1]= pred_diff[2];
365         pred_diff[2]= pred_diff[3];
366         pred_diff[3]= temp;
367         
368         pred_diff[3][-1]= pred_diff[2][0  ];
369         pred_diff[2][ w]= pred_diff[2][w-1];
370
371         for(x=0; x<w; x++){
372             uint8_t *temp_src= src + x + stride*y;
373             int diff, context;
374             
375             context= get_context(s, pred_diff[3]+x, pred_diff[2]+x, pred_diff[1]+x);
376             diff= temp_src[0] - predict(pred_diff[3]+x, pred_diff[2]+x);
377
378             if(context < 0){
379                 context = -context;
380                 diff= -diff;
381             }
382
383             diff= (int8_t)diff;
384
385             if(s->ac)
386                 put_symbol(c, p->state[context], diff, 1);
387             else{
388                 if(context == 0) run_mode=1;
389                 
390                 if(run_mode){
391
392                     if(diff){
393                         while(run_count >= 1<<log2_run[run_index]){
394                             run_count -= 1<<log2_run[run_index];
395                             run_index++;
396                             put_bits(&s->pb, 1, 1);
397                         }
398                         
399                         put_bits(&s->pb, 1 + log2_run[run_index], run_count);
400                         if(run_index) run_index--;
401                         run_count=0;
402                         run_mode=0;
403                         if(diff>0) diff--;
404                     }else{
405                         run_count++;
406                     }
407                 }
408                 
409 //                printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, (int)get_bit_count(&s->pb));
410
411                 if(run_mode == 0)
412                     put_vlc_symbol(&s->pb, &p->vlc_state[context], diff);
413             }
414
415             pred_diff[3][x]= temp_src[0];
416         }
417         if(run_mode){
418             while(run_count >= 1<<log2_run[run_index]){
419                 run_count -= 1<<log2_run[run_index];
420                 run_index++;
421                 put_bits(&s->pb, 1, 1);
422             }
423
424             if(run_count)
425                 put_bits(&s->pb, 1, 1);
426         }
427     }
428 }
429
430 static void write_quant_table(CABACContext *c, int16_t *quant_table){
431     int last=0;
432     int i;
433     uint8_t state[CONTEXT_SIZE]={0};
434
435     for(i=1; i<128 ; i++){
436         if(quant_table[i] != quant_table[i-1]){
437             put_symbol(c, state, i-last-1, 0);
438             last= i;
439         }
440     }
441     put_symbol(c, state, i-last-1, 0);
442 }
443
444 static void write_header(FFV1Context *f){
445     uint8_t state[CONTEXT_SIZE]={0};
446     int i;
447     CABACContext * const c= &f->c;
448
449     put_symbol(c, state, f->version, 0);
450     put_symbol(c, state, f->avctx->coder_type, 0);
451     put_symbol(c, state, 0, 0); //YUV cs type 
452     put_cabac(c, state, 1); //chroma planes
453         put_symbol(c, state, f->chroma_h_shift, 0);
454         put_symbol(c, state, f->chroma_v_shift, 0);
455     put_cabac(c, state, 0); //no transparency plane
456
457     for(i=0; i<5; i++)
458         write_quant_table(c, f->quant_table[i]);
459 }
460
461 static int common_init(AVCodecContext *avctx){
462     FFV1Context *s = avctx->priv_data;
463     int width, height;
464
465     s->avctx= avctx;
466     s->flags= avctx->flags;
467         
468     dsputil_init(&s->dsp, avctx);
469     
470     width= s->width= avctx->width;
471     height= s->height= avctx->height;
472     
473     assert(width && height);
474
475     return 0;
476 }
477
478 static int encode_init(AVCodecContext *avctx)
479 {
480     FFV1Context *s = avctx->priv_data;
481     int i;
482
483     common_init(avctx);
484  
485     s->version=0;
486     s->ac= avctx->coder_type;
487     
488     s->plane_count=3;
489     for(i=0; i<256; i++){
490         s->quant_table[0][i]=           quant11[i];
491         s->quant_table[1][i]=        11*quant11[i];
492         if(avctx->context_model==0){
493             s->quant_table[2][i]=     11*11*quant11[i];
494             s->quant_table[3][i]=
495             s->quant_table[4][i]=0;
496         }else{
497             s->quant_table[2][i]=     11*11*quant5 [i];
498             s->quant_table[3][i]=   5*11*11*quant5 [i];
499             s->quant_table[4][i]= 5*5*11*11*quant5 [i];
500         }
501     }
502
503     for(i=0; i<s->plane_count; i++){
504         PlaneContext * const p= &s->plane[i];
505                
506         if(avctx->context_model==0){
507             p->context_count= (11*11*11+1)/2;
508         }else{        
509             p->context_count= (11*11*5*5*5+1)/2;
510         }
511
512         if(s->ac){
513             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
514         }else{
515             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
516         }
517     }
518
519     avctx->coded_frame= &s->picture;
520     switch(avctx->pix_fmt){
521     case PIX_FMT_YUV444P:
522     case PIX_FMT_YUV422P:
523     case PIX_FMT_YUV420P:
524     case PIX_FMT_YUV411P:
525     case PIX_FMT_YUV410P:
526         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
527         break;
528     default:
529         fprintf(stderr, "format not supported\n");
530         return -1;
531     }
532     
533    
534     s->picture_number=0;
535     
536     return 0;
537 }
538
539
540 static void clear_state(FFV1Context *f){
541     int i, j;
542
543     for(i=0; i<f->plane_count; i++){
544         PlaneContext *p= &f->plane[i];
545
546         p->interlace_bit_state[0]= 0;
547         p->interlace_bit_state[1]= 0;
548         
549         for(j=0; j<p->context_count; j++){
550             if(f->ac){
551                 memset(p->state[j], 0, sizeof(uint8_t)*CONTEXT_SIZE);
552                 p->state[j][7] = 2*62;
553             }else{
554                 p->vlc_state[j].drift= 0;
555                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
556                 p->vlc_state[j].bias= 0;
557                 p->vlc_state[j].count= 1;
558             }
559         }
560     }
561 }
562
563 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
564     FFV1Context *f = avctx->priv_data;
565     CABACContext * const c= &f->c;
566     AVFrame *pict = data;
567     const int width= f->width;
568     const int height= f->height;
569     AVFrame * const p= &f->picture;
570     int used_count= 0;
571
572     if(avctx->strict_std_compliance >= 0){
573         printf("this codec is under development, files encoded with it wont be decodeable with future versions!!!\n"
574                "use vstrict=-1 to use it anyway\n");
575         return -1;
576     }
577         
578     ff_init_cabac_encoder(c, buf, buf_size);
579     ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
580     
581     *p = *pict;
582     p->pict_type= FF_I_TYPE;
583     
584     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
585         put_cabac_bypass(c, 1);
586         p->key_frame= 1;
587         write_header(f);
588         clear_state(f);
589     }else{
590         put_cabac_bypass(c, 0);
591         p->key_frame= 0;
592     }
593
594     if(!f->ac){
595         used_count += put_cabac_terminate(c, 1);
596 //printf("pos=%d\n", used_count);
597         init_put_bits(&f->pb, buf + used_count, buf_size - used_count, NULL, NULL);
598     }
599     
600     if(1){
601         const int chroma_width = -((-width )>>f->chroma_h_shift);
602         const int chroma_height= -((-height)>>f->chroma_v_shift);
603
604         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
605
606         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
607         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 2);
608     }
609     emms_c();
610     
611     f->picture_number++;
612
613     if(f->ac){
614         return put_cabac_terminate(c, 1);
615     }else{
616         flush_put_bits(&f->pb); //nicer padding FIXME
617         return used_count + (get_bit_count(&f->pb)+7)/8;
618     }
619 }
620
621 static void common_end(FFV1Context *s){
622     int i; 
623
624     for(i=0; i<s->plane_count; i++){
625         PlaneContext *p= &s->plane[i];
626
627         av_freep(&p->state);
628     }
629 }
630
631 static int encode_end(AVCodecContext *avctx)
632 {
633     FFV1Context *s = avctx->priv_data;
634
635     common_end(s);
636
637     return 0;
638 }
639
640 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
641     PlaneContext * const p= &s->plane[plane_index];
642     CABACContext * const c= &s->c;
643     int x,y;
644     uint8_t pred_diff_buffer[4][w+6];
645     uint8_t *pred_diff[4]= {pred_diff_buffer[0]+3, pred_diff_buffer[1]+3, pred_diff_buffer[2]+3, pred_diff_buffer[3]+3};
646     int run_index=0;
647     
648     memset(pred_diff_buffer, 0, sizeof(pred_diff_buffer));
649     
650     for(y=0; y<h; y++){
651         uint8_t *temp= pred_diff[0]; //FIXME try a normal buffer
652         int run_count=0;
653         int run_mode=0;
654
655         pred_diff[0]= pred_diff[1];
656         pred_diff[1]= pred_diff[2];
657         pred_diff[2]= pred_diff[3];
658         pred_diff[3]= temp;
659
660         pred_diff[3][-1]= pred_diff[2][0  ];
661         pred_diff[2][ w]= pred_diff[2][w-1];
662
663         for(x=0; x<w; x++){
664             uint8_t *temp_src= src + x + stride*y;
665             int diff, context, sign;
666              
667             context= get_context(s, pred_diff[3] + x, pred_diff[2] + x, pred_diff[1] + x);
668             if(context < 0){
669                 context= -context;
670                 sign=1;
671             }else
672                 sign=0;
673             
674
675             if(s->ac)
676                 diff= get_symbol(c, p->state[context], 1);
677             else{
678                 if(context == 0 && run_mode==0) run_mode=1;
679                 
680                 if(run_mode){
681                     if(run_count==0 && run_mode==1){
682                         if(get_bits1(&s->gb)){
683                             run_count = 1<<log2_run[run_index];
684                             if(x + run_count <= w) run_index++;
685                         }else{
686                             if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
687                             else run_count=0;
688                             if(run_index) run_index--;
689                             run_mode=2;
690                         }
691                     }
692                     run_count--;
693                     if(run_count < 0){
694                         run_mode=0;
695                         run_count=0;
696                         diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);
697                         if(diff>=0) diff++;
698                     }else
699                         diff=0;
700                 }else
701                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);
702                 
703 //                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));
704             }
705
706             if(sign) diff= (int8_t)(-diff); //FIXME remove cast
707
708             pred_diff[3][x]=
709             temp_src[0] = predict(pred_diff[3] + x, pred_diff[2] + x) + diff;
710             
711             assert(diff>= -128 && diff <= 127);
712         }
713     }
714 }
715
716 static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
717     int v;
718     int i=0;
719     uint8_t state[CONTEXT_SIZE]={0};
720
721     for(v=0; i<128 ; v++){
722         int len= get_symbol(c, state, 0) + 1;
723
724         if(len + i > 128) return -1;
725         
726         while(len--){
727             quant_table[i] = scale*v;
728             i++;
729 //printf("%2d ",v);
730 //if(i%16==0) printf("\n");
731         }
732     }
733
734     for(i=1; i<128; i++){
735         quant_table[256-i]= -quant_table[i];
736     }
737     quant_table[128]= -quant_table[127];
738     
739     return 2*v - 1;
740 }
741
742 static int read_header(FFV1Context *f){
743     uint8_t state[CONTEXT_SIZE]={0};
744     int i, context_count;
745     CABACContext * const c= &f->c;
746     
747     f->version= get_symbol(c, state, 0);
748     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
749     get_symbol(c, state, 0); //YUV cs type
750     get_cabac(c, state); //no chroma = false
751     f->chroma_h_shift= get_symbol(c, state, 0);
752     f->chroma_v_shift= get_symbol(c, state, 0);
753     get_cabac(c, state); //transparency plane
754     f->plane_count= 3;
755     
756     context_count=1;
757     for(i=0; i<5; i++){
758         context_count*= read_quant_table(c, f->quant_table[i], context_count);
759     }
760     context_count= (context_count+1)/2;
761     
762     for(i=0; i<f->plane_count; i++){
763         PlaneContext * const p= &f->plane[i];
764
765         p->context_count= context_count;
766
767         if(f->ac){
768             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
769         }else{
770             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
771         }
772     }
773     
774     return 0;
775 }
776
777 static int decode_init(AVCodecContext *avctx)
778 {
779 //    FFV1Context *s = avctx->priv_data;
780
781     common_init(avctx);
782     
783 #if 0    
784     switch(s->bitstream_bpp){
785     case 12:
786         avctx->pix_fmt = PIX_FMT_YUV420P;
787         break;
788     case 16:
789         avctx->pix_fmt = PIX_FMT_YUV422P;
790         break;
791     case 24:
792     case 32:
793         if(s->bgr32){
794             avctx->pix_fmt = PIX_FMT_RGBA32;
795         }else{
796             avctx->pix_fmt = PIX_FMT_BGR24;
797         }
798         break;
799     default:
800         assert(0);
801     }
802 #endif
803     
804     return 0;
805 }
806
807 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
808     FFV1Context *f = avctx->priv_data;
809     CABACContext * const c= &f->c;
810     const int width= f->width;
811     const int height= f->height;
812     AVFrame * const p= &f->picture;
813     int bytes_read;
814
815     AVFrame *picture = data;
816
817     *data_size = 0;
818
819     /* no supplementary picture */
820     if (buf_size == 0)
821         return 0;
822
823     ff_init_cabac_decoder(c, buf, buf_size);
824     ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
825
826     p->reference= 0;
827     if(avctx->get_buffer(avctx, p) < 0){
828         fprintf(stderr, "get_buffer() failed\n");
829         return -1;
830     }
831
832     p->pict_type= FF_I_TYPE; //FIXME I vs. P
833     if(get_cabac_bypass(c)){
834         p->key_frame= 1;
835         read_header(f);
836         clear_state(f);
837     }else{
838         p->key_frame= 0;
839     }
840     if(avctx->debug&FF_DEBUG_PICT_INFO)
841         printf("keyframe:%d\n", p->key_frame);
842     
843     if(!f->ac){
844         bytes_read = get_cabac_terminate(c);
845         if(bytes_read ==0) printf("error at end of AC stream\n");
846 //printf("pos=%d\n", bytes_read);
847         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
848     }
849     
850     if(1){
851         const int chroma_width = -((-width )>>f->chroma_h_shift);
852         const int chroma_height= -((-height)>>f->chroma_v_shift);
853         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
854         
855         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
856         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 2);
857     }
858         
859     emms_c();
860
861     f->picture_number++;
862
863     *picture= *p;
864     
865     avctx->release_buffer(avctx, p); //FIXME
866
867     *data_size = sizeof(AVFrame);
868     
869     if(f->ac){
870         bytes_read= get_cabac_terminate(c);
871         if(bytes_read ==0) printf("error at end of frame\n");
872     }else{
873         bytes_read+= (get_bits_count(&f->gb)+7)/8;
874     }
875
876     return bytes_read;
877 }
878
879 static int decode_end(AVCodecContext *avctx)
880 {
881     FFV1Context *s = avctx->priv_data;
882     int i;
883     
884     if(avctx->get_buffer == avcodec_default_get_buffer){
885         for(i=0; i<4; i++){
886             av_freep(&s->picture.base[i]);
887             s->picture.data[i]= NULL;
888         }
889         av_freep(&s->picture.opaque);
890     }
891
892     return 0;
893 }
894
895 AVCodec ffv1_decoder = {
896     "ffv1",
897     CODEC_TYPE_VIDEO,
898     CODEC_ID_FFV1,
899     sizeof(FFV1Context),
900     decode_init,
901     NULL,
902     decode_end,
903     decode_frame,
904     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
905     NULL
906 };
907
908 #ifdef CONFIG_ENCODERS
909 AVCodec ffv1_encoder = {
910     "ffv1",
911     CODEC_TYPE_VIDEO,
912     CODEC_ID_FFV1,
913     sizeof(FFV1Context),
914     encode_init,
915     encode_frame,
916     encode_end,
917 };
918 #endif