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