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