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