get/set_sr_golomb() cleanup
[libav.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 //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);
328 set_sr_golomb(pb, code, k, 12, bits);
329
330 update_vlc_state(state, v);
331 }
332
333 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
334 int k, i, v, ret;
335
336 i= state->count;
337 k=0;
338 while(i < state->error_sum){ //FIXME optimize
339 k++;
340 i += i;
341 }
342
343 assert(k<=8);
344
345 v= get_sr_golomb(gb, k, 12, bits);
346 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
347
348 #if 0 // JPEG LS
349 if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
350 #else
351 v ^= ((2*state->drift + state->count)>>31);
352 #endif
353
354 ret= fold(v + state->bias, bits);
355
356 update_vlc_state(state, v);
357 //printf("final: %d\n", ret);
358 return ret;
359 }
360
361 static inline void encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
362 PlaneContext * const p= &s->plane[plane_index];
363 CABACContext * const c= &s->c;
364 int x;
365 int run_index= s->run_index;
366 int run_count=0;
367 int run_mode=0;
368
369 for(x=0; x<w; x++){
370 int diff, context;
371
372 context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
373 diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
374
375 if(context < 0){
376 context = -context;
377 diff= -diff;
378 }
379
380 diff= fold(diff, bits);
381
382 if(s->ac){
383 put_symbol(c, p->state[context], diff, 1, bits-1);
384 }else{
385 if(context == 0) run_mode=1;
386
387 if(run_mode){
388
389 if(diff){
390 while(run_count >= 1<<log2_run[run_index]){
391 run_count -= 1<<log2_run[run_index];
392 run_index++;
393 put_bits(&s->pb, 1, 1);
394 }
395
396 put_bits(&s->pb, 1 + log2_run[run_index], run_count);
397 if(run_index) run_index--;
398 run_count=0;
399 run_mode=0;
400 if(diff>0) diff--;
401 }else{
402 run_count++;
403 }
404 }
405
406 // 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));
407
408 if(run_mode == 0)
409 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
410 }
411 }
412 if(run_mode){
413 while(run_count >= 1<<log2_run[run_index]){
414 run_count -= 1<<log2_run[run_index];
415 run_index++;
416 put_bits(&s->pb, 1, 1);
417 }
418
419 if(run_count)
420 put_bits(&s->pb, 1, 1);
421 }
422 s->run_index= run_index;
423 }
424
425 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
426 int x,y,i;
427 const int ring_size= s->avctx->context_model ? 3 : 2;
428 int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
429 s->run_index=0;
430
431 memset(sample_buffer, 0, sizeof(sample_buffer));
432
433 for(y=0; y<h; y++){
434 for(i=0; i<ring_size; i++)
435 sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
436
437 sample[0][-1]= sample[1][0 ];
438 sample[1][ w]= sample[1][w-1];
439 //{START_TIMER
440 for(x=0; x<w; x++){
441 sample[0][x]= src[x + stride*y];
442 }
443 encode_line(s, w, sample, plane_index, 8);
444 //STOP_TIMER("encode line")}
445 }
446 }
447
448 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
449 int x, y, p, i;
450 const int ring_size= s->avctx->context_model ? 3 : 2;
451 int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
452 s->run_index=0;
453
454 memset(sample_buffer, 0, sizeof(sample_buffer));
455
456 for(y=0; y<h; y++){
457 for(i=0; i<ring_size; i++)
458 for(p=0; p<3; p++)
459 sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
460
461 for(x=0; x<w; x++){
462 int v= src[x + stride*y];
463 int b= v&0xFF;
464 int g= (v>>8)&0xFF;
465 int r= (v>>16)&0xFF;
466
467 b -= g;
468 r -= g;
469 g += (b + r)>>2;
470 b += 0x100;
471 r += 0x100;
472
473 // assert(g>=0 && b>=0 && r>=0);
474 // assert(g<256 && b<512 && r<512);
475 sample[0][0][x]= g;
476 sample[1][0][x]= b;
477 sample[2][0][x]= r;
478 }
479 for(p=0; p<3; p++){
480 sample[p][0][-1]= sample[p][1][0 ];
481 sample[p][1][ w]= sample[p][1][w-1];
482 encode_line(s, w, sample[p], FFMIN(p, 1), 9);
483 }
484 }
485 }
486
487 static void write_quant_table(CABACContext *c, int16_t *quant_table){
488 int last=0;
489 int i;
490 uint8_t state[CONTEXT_SIZE]={0};
491
492 for(i=1; i<128 ; i++){
493 if(quant_table[i] != quant_table[i-1]){
494 put_symbol(c, state, i-last-1, 0, 7);
495 last= i;
496 }
497 }
498 put_symbol(c, state, i-last-1, 0, 7);
499 }
500
501 static void write_header(FFV1Context *f){
502 uint8_t state[CONTEXT_SIZE]={0};
503 int i;
504 CABACContext * const c= &f->c;
505
506 put_symbol(c, state, f->version, 0, 7);
507 put_symbol(c, state, f->avctx->coder_type, 0, 7);
508 put_symbol(c, state, f->colorspace, 0, 7); //YUV cs type
509 put_cabac(c, state, 1); //chroma planes
510 put_symbol(c, state, f->chroma_h_shift, 0, 7);
511 put_symbol(c, state, f->chroma_v_shift, 0, 7);
512 put_cabac(c, state, 0); //no transparency plane
513
514 for(i=0; i<5; i++)
515 write_quant_table(c, f->quant_table[i]);
516 }
517
518 static int common_init(AVCodecContext *avctx){
519 FFV1Context *s = avctx->priv_data;
520 int width, height;
521
522 s->avctx= avctx;
523 s->flags= avctx->flags;
524
525 dsputil_init(&s->dsp, avctx);
526
527 width= s->width= avctx->width;
528 height= s->height= avctx->height;
529
530 assert(width && height);
531
532 return 0;
533 }
534
535 static int encode_init(AVCodecContext *avctx)
536 {
537 FFV1Context *s = avctx->priv_data;
538 int i;
539
540 if(avctx->strict_std_compliance >= 0){
541 av_log(avctx, AV_LOG_ERROR, "this codec is under development, files encoded with it wont be decodeable with future versions!!!\n"
542 "use vstrict=-1 to use it anyway\n");
543 return -1;
544 }
545
546 common_init(avctx);
547
548 s->version=0;
549 s->ac= avctx->coder_type;
550
551 s->plane_count=2;
552 for(i=0; i<256; i++){
553 s->quant_table[0][i]= quant11[i];
554 s->quant_table[1][i]= 11*quant11[i];
555 if(avctx->context_model==0){
556 s->quant_table[2][i]= 11*11*quant11[i];
557 s->quant_table[3][i]=
558 s->quant_table[4][i]=0;
559 }else{
560 s->quant_table[2][i]= 11*11*quant5 [i];
561 s->quant_table[3][i]= 5*11*11*quant5 [i];
562 s->quant_table[4][i]= 5*5*11*11*quant5 [i];
563 }
564 }
565
566 for(i=0; i<s->plane_count; i++){
567 PlaneContext * const p= &s->plane[i];
568
569 if(avctx->context_model==0){
570 p->context_count= (11*11*11+1)/2;
571 }else{
572 p->context_count= (11*11*5*5*5+1)/2;
573 }
574
575 if(s->ac){
576 if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
577 }else{
578 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
579 }
580 }
581
582 avctx->coded_frame= &s->picture;
583 switch(avctx->pix_fmt){
584 case PIX_FMT_YUV444P:
585 case PIX_FMT_YUV422P:
586 case PIX_FMT_YUV420P:
587 case PIX_FMT_YUV411P:
588 case PIX_FMT_YUV410P:
589 s->colorspace= 0;
590 break;
591 case PIX_FMT_RGBA32:
592 s->colorspace= 1;
593 break;
594 default:
595 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
596 return -1;
597 }
598 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
599
600 s->picture_number=0;
601
602 return 0;
603 }
604
605
606 static void clear_state(FFV1Context *f){
607 int i, j;
608
609 for(i=0; i<f->plane_count; i++){
610 PlaneContext *p= &f->plane[i];
611
612 p->interlace_bit_state[0]= 0;
613 p->interlace_bit_state[1]= 0;
614
615 for(j=0; j<p->context_count; j++){
616 if(f->ac){
617 memset(p->state[j], 0, sizeof(uint8_t)*CONTEXT_SIZE);
618 p->state[j][7] = 2*62;
619 }else{
620 p->vlc_state[j].drift= 0;
621 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
622 p->vlc_state[j].bias= 0;
623 p->vlc_state[j].count= 1;
624 }
625 }
626 }
627 }
628
629 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
630 FFV1Context *f = avctx->priv_data;
631 CABACContext * const c= &f->c;
632 AVFrame *pict = data;
633 const int width= f->width;
634 const int height= f->height;
635 AVFrame * const p= &f->picture;
636 int used_count= 0;
637
638 ff_init_cabac_encoder(c, buf, buf_size);
639 ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
640 c->lps_state[2] = 1;
641 c->lps_state[3] = 0;
642
643 *p = *pict;
644 p->pict_type= FF_I_TYPE;
645
646 if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
647 put_cabac_bypass(c, 1);
648 p->key_frame= 1;
649 write_header(f);
650 clear_state(f);
651 }else{
652 put_cabac_bypass(c, 0);
653 p->key_frame= 0;
654 }
655
656 if(!f->ac){
657 used_count += put_cabac_terminate(c, 1);
658 //printf("pos=%d\n", used_count);
659 init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
660 }
661
662 if(f->colorspace==0){
663 const int chroma_width = -((-width )>>f->chroma_h_shift);
664 const int chroma_height= -((-height)>>f->chroma_v_shift);
665
666 encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
667
668 encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
669 encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
670 }else{
671 encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
672 }
673 emms_c();
674
675 f->picture_number++;
676
677 if(f->ac){
678 return put_cabac_terminate(c, 1);
679 }else{
680 flush_put_bits(&f->pb); //nicer padding FIXME
681 return used_count + (put_bits_count(&f->pb)+7)/8;
682 }
683 }
684
685 static void common_end(FFV1Context *s){
686 int i;
687
688 for(i=0; i<s->plane_count; i++){
689 PlaneContext *p= &s->plane[i];
690
691 av_freep(&p->state);
692 }
693 }
694
695 static int encode_end(AVCodecContext *avctx)
696 {
697 FFV1Context *s = avctx->priv_data;
698
699 common_end(s);
700
701 return 0;
702 }
703
704 static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
705 PlaneContext * const p= &s->plane[plane_index];
706 CABACContext * const c= &s->c;
707 int x;
708 int run_count=0;
709 int run_mode=0;
710 int run_index= s->run_index;
711
712 for(x=0; x<w; x++){
713 int diff, context, sign;
714
715 context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
716 if(context < 0){
717 context= -context;
718 sign=1;
719 }else
720 sign=0;
721
722
723 if(s->ac)
724 diff= get_symbol(c, p->state[context], 1, bits-1);
725 else{
726 if(context == 0 && run_mode==0) run_mode=1;
727
728 if(run_mode){
729 if(run_count==0 && run_mode==1){
730 if(get_bits1(&s->gb)){
731 run_count = 1<<log2_run[run_index];
732 if(x + run_count <= w) run_index++;
733 }else{
734 if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
735 else run_count=0;
736 if(run_index) run_index--;
737 run_mode=2;
738 }
739 }
740 run_count--;
741 if(run_count < 0){
742 run_mode=0;
743 run_count=0;
744 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
745 if(diff>=0) diff++;
746 }else
747 diff=0;
748 }else
749 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
750
751 // 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));
752 }
753
754 if(sign) diff= -diff;
755
756 sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
757 }
758 s->run_index= run_index;
759 }
760
761 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
762 int x, y;
763 int_fast16_t sample_buffer[2][w+6];
764 int_fast16_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
765
766 s->run_index=0;
767
768 memset(sample_buffer, 0, sizeof(sample_buffer));
769
770 for(y=0; y<h; y++){
771 int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
772
773 sample[0]= sample[1];
774 sample[1]= temp;
775
776 sample[1][-1]= sample[0][0 ];
777 sample[0][ w]= sample[0][w-1];
778
779 //{START_TIMER
780 decode_line(s, w, sample, plane_index, 8);
781 for(x=0; x<w; x++){
782 src[x + stride*y]= sample[1][x];
783 }
784 //STOP_TIMER("decode-line")}
785 }
786 }
787
788 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
789 int x, y, p;
790 int_fast16_t sample_buffer[3][2][w+6];
791 int_fast16_t *sample[3][2]= {
792 {sample_buffer[0][0]+3, sample_buffer[0][1]+3},
793 {sample_buffer[1][0]+3, sample_buffer[1][1]+3},
794 {sample_buffer[2][0]+3, sample_buffer[2][1]+3}};
795
796 s->run_index=0;
797
798 memset(sample_buffer, 0, sizeof(sample_buffer));
799
800 for(y=0; y<h; y++){
801 for(p=0; p<3; p++){
802 int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
803
804 sample[p][0]= sample[p][1];
805 sample[p][1]= temp;
806
807 sample[p][1][-1]= sample[p][0][0 ];
808 sample[p][0][ w]= sample[p][0][w-1];
809 decode_line(s, w, sample[p], FFMIN(p, 1), 9);
810 }
811 for(x=0; x<w; x++){
812 int g= sample[0][1][x];
813 int b= sample[1][1][x];
814 int r= sample[2][1][x];
815
816 // assert(g>=0 && b>=0 && r>=0);
817 // assert(g<256 && b<512 && r<512);
818
819 b -= 0x100;
820 r -= 0x100;
821 g -= (b + r)>>2;
822 b += g;
823 r += g;
824
825 src[x + stride*y]= b + (g<<8) + (r<<16);
826 }
827 }
828 }
829
830 static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
831 int v;
832 int i=0;
833 uint8_t state[CONTEXT_SIZE]={0};
834
835 for(v=0; i<128 ; v++){
836 int len= get_symbol(c, state, 0, 7) + 1;
837
838 if(len + i > 128) return -1;
839
840 while(len--){
841 quant_table[i] = scale*v;
842 i++;
843 //printf("%2d ",v);
844 //if(i%16==0) printf("\n");
845 }
846 }
847
848 for(i=1; i<128; i++){
849 quant_table[256-i]= -quant_table[i];
850 }
851 quant_table[128]= -quant_table[127];
852
853 return 2*v - 1;
854 }
855
856 static int read_header(FFV1Context *f){
857 uint8_t state[CONTEXT_SIZE]={0};
858 int i, context_count;
859 CABACContext * const c= &f->c;
860
861 f->version= get_symbol(c, state, 0, 7);
862 f->ac= f->avctx->coder_type= get_symbol(c, state, 0, 7);
863 f->colorspace= get_symbol(c, state, 0, 7); //YUV cs type
864 get_cabac(c, state); //no chroma = false
865 f->chroma_h_shift= get_symbol(c, state, 0, 7);
866 f->chroma_v_shift= get_symbol(c, state, 0, 7);
867 get_cabac(c, state); //transparency plane
868 f->plane_count= 2;
869
870 if(f->colorspace==0){
871 switch(16*f->chroma_h_shift + f->chroma_v_shift){
872 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
873 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
874 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
875 case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
876 case 0x33: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
877 default:
878 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
879 return -1;
880 }
881 }else if(f->colorspace==1){
882 if(f->chroma_h_shift || f->chroma_v_shift){
883 av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
884 return -1;
885 }
886 f->avctx->pix_fmt= PIX_FMT_RGBA32;
887 }else{
888 av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
889 return -1;
890 }
891
892 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
893
894 context_count=1;
895 for(i=0; i<5; i++){
896 context_count*= read_quant_table(c, f->quant_table[i], context_count);
897 if(context_count < 0){
898 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
899 return -1;
900 }
901 }
902 context_count= (context_count+1)/2;
903
904 for(i=0; i<f->plane_count; i++){
905 PlaneContext * const p= &f->plane[i];
906
907 p->context_count= context_count;
908
909 if(f->ac){
910 if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
911 }else{
912 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
913 }
914 }
915
916 return 0;
917 }
918
919 static int decode_init(AVCodecContext *avctx)
920 {
921 // FFV1Context *s = avctx->priv_data;
922
923 common_init(avctx);
924
925 return 0;
926 }
927
928 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
929 FFV1Context *f = avctx->priv_data;
930 CABACContext * const c= &f->c;
931 const int width= f->width;
932 const int height= f->height;
933 AVFrame * const p= &f->picture;
934 int bytes_read;
935
936 AVFrame *picture = data;
937
938 /* no supplementary picture */
939 if (buf_size == 0)
940 return 0;
941
942 ff_init_cabac_decoder(c, buf, buf_size);
943 ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
944 c->lps_state[2] = 1;
945 c->lps_state[3] = 0;
946
947
948 p->pict_type= FF_I_TYPE; //FIXME I vs. P
949 if(get_cabac_bypass(c)){
950 p->key_frame= 1;
951 read_header(f);
952 clear_state(f);
953 }else{
954 p->key_frame= 0;
955 }
956
957 p->reference= 0;
958 if(avctx->get_buffer(avctx, p) < 0){
959 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
960 return -1;
961 }
962
963 if(avctx->debug&FF_DEBUG_PICT_INFO)
964 av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
965
966 if(!f->ac){
967 bytes_read = get_cabac_terminate(c);
968 if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n");
969 //printf("pos=%d\n", bytes_read);
970 init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
971 } else {
972 bytes_read = 0; /* avoid warning */
973 }
974
975 if(f->colorspace==0){
976 const int chroma_width = -((-width )>>f->chroma_h_shift);
977 const int chroma_height= -((-height)>>f->chroma_v_shift);
978 decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
979
980 decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
981 decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
982 }else{
983 decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
984 }
985
986 emms_c();
987
988 f->picture_number++;
989
990 *picture= *p;
991
992 avctx->release_buffer(avctx, p); //FIXME
993
994 *data_size = sizeof(AVFrame);
995
996 if(f->ac){
997 bytes_read= get_cabac_terminate(c);
998 if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
999 }else{
1000 bytes_read+= (get_bits_count(&f->gb)+7)/8;
1001 }
1002
1003 return bytes_read;
1004 }
1005
1006 AVCodec ffv1_decoder = {
1007 "ffv1",
1008 CODEC_TYPE_VIDEO,
1009 CODEC_ID_FFV1,
1010 sizeof(FFV1Context),
1011 decode_init,
1012 NULL,
1013 NULL,
1014 decode_frame,
1015 CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1016 NULL
1017 };
1018
1019 #ifdef CONFIG_ENCODERS
1020 AVCodec ffv1_encoder = {
1021 "ffv1",
1022 CODEC_TYPE_VIDEO,
1023 CODEC_ID_FFV1,
1024 sizeof(FFV1Context),
1025 encode_init,
1026 encode_frame,
1027 encode_end,
1028 };
1029 #endif