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