?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
lavfi: use const for AVFilterPad declarations in all filters.
[FFMpeg-mirror/mplayer-patches.git] / libavcodec / ffv1.c
blob07d6d8855be22dabc72cf5259035b8fb4552e2ee
1 /*
2 * FFV1 codec for libavcodec
3 *
4 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * This file is part of Libav.
7 *
8 * Libav 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 * Libav 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 Libav; 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
25 * FF Video Codec 1 (a lossless codec)
26 */
27
28 #include "avcodec.h"
29 #include "get_bits.h"
30 #include "put_bits.h"
31 #include "dsputil.h"
32 #include "rangecoder.h"
33 #include "golomb.h"
34 #include "mathops.h"
35 #include "libavutil/avassert.h"
36
37 #define MAX_PLANES 4
38 #define CONTEXT_SIZE 32
39
40 #define MAX_QUANT_TABLES 8
41 #define MAX_CONTEXT_INPUTS 5
42
43 extern const uint8_t ff_log2_run[41];
44
45 static const int8_t quant5_10bit[256]={
46 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
50 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
51 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
52 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
53 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
54 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
55 -2,-2,-2,-2,-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,-1,
59 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
60 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
61 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
62 };
63
64 static const int8_t quant5[256]={
65 0, 1, 1, 1, 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,-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,-2,-2,-2,-2,-2,-2,-2,-2,
76 -2,-2,-2,-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,-2,-2,-2,-2,-2,-2,-2,-2,
79 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
80 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
81 };
82
83 static const int8_t quant9_10bit[256]={
84 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
85 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 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, 4, 4, 4, 4, 4, 4, 4, 4,
88 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
92 -4,-4,-4,-4,-4,-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,-3,-3,-3,-3,-3,-3,-3,
97 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
98 -3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
99 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
100 };
101
102 static const int8_t quant11[256]={
103 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 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, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
106 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
107 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
108 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
109 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
110 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
111 -5,-5,-5,-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,-4,-4,
117 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
118 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
119 };
120
121 static const uint8_t ver2_state[256]= {
122 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
123 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
124 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
125 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
126 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
127 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
128 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
129 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
130 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
131 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
132 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
133 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
134 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
135 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
136 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
137 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
138 };
139
140 typedef struct VlcState{
141 int16_t drift;
142 uint16_t error_sum;
143 int8_t bias;
144 uint8_t count;
145 } VlcState;
146
147 typedef struct PlaneContext{
148 int16_t quant_table[MAX_CONTEXT_INPUTS][256];
149 int quant_table_index;
150 int context_count;
151 uint8_t (*state)[CONTEXT_SIZE];
152 VlcState *vlc_state;
153 uint8_t interlace_bit_state[2];
154 } PlaneContext;
155
156 #define MAX_SLICES 256
157
158 typedef struct FFV1Context{
159 AVCodecContext *avctx;
160 RangeCoder c;
161 GetBitContext gb;
162 PutBitContext pb;
163 uint64_t rc_stat[256][2];
164 uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
165 int version;
166 int width, height;
167 int chroma_h_shift, chroma_v_shift;
168 int flags;
169 int picture_number;
170 AVFrame picture;
171 int plane_count;
172 int ac; ///< 1=range coder <-> 0=golomb rice
173 PlaneContext plane[MAX_PLANES];
174 int16_t quant_table[MAX_CONTEXT_INPUTS][256];
175 int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
176 int context_count[MAX_QUANT_TABLES];
177 uint8_t state_transition[256];
178 uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
179 int run_index;
180 int colorspace;
181 int16_t *sample_buffer;
182 int gob_count;
183
184 int quant_table_count;
185
186 DSPContext dsp;
187
188 struct FFV1Context *slice_context[MAX_SLICES];
189 int slice_count;
190 int num_v_slices;
191 int num_h_slices;
192 int slice_width;
193 int slice_height;
194 int slice_x;
195 int slice_y;
196 }FFV1Context;
197
198 static av_always_inline int fold(int diff, int bits){
199 if(bits==8)
200 diff= (int8_t)diff;
201 else{
202 diff+= 1<<(bits-1);
203 diff&=(1<<bits)-1;
204 diff-= 1<<(bits-1);
205 }
206
207 return diff;
208 }
209
210 static inline int predict(int16_t *src, int16_t *last)
211 {
212 const int LT= last[-1];
213 const int T= last[ 0];
214 const int L = src[-1];
215
216 return mid_pred(L, L + T - LT, T);
217 }
218
219 static inline int get_context(PlaneContext *p, int16_t *src,
220 int16_t *last, int16_t *last2)
221 {
222 const int LT= last[-1];
223 const int T= last[ 0];
224 const int RT= last[ 1];
225 const int L = src[-1];
226
227 if(p->quant_table[3][127]){
228 const int TT= last2[0];
229 const int LL= src[-2];
230 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
231 +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
232 }else
233 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
234 }
235
236 static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
237 int i,j,k,m;
238 double l2tab[256];
239
240 for(i=1; i<256; i++)
241 l2tab[i]= log2(i/256.0);
242
243 for(i=0; i<256; i++){
244 double best_len[256];
245 double p= i/256.0;
246
247 for(j=0; j<256; j++)
248 best_len[j]= 1<<30;
249
250 for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
251 double occ[256]={0};
252 double len=0;
253 occ[j]=1.0;
254 for(k=0; k<256; k++){
255 double newocc[256]={0};
256 for(m=0; m<256; m++){
257 if(occ[m]){
258 len -=occ[m]*( p *l2tab[ m]
259 + (1-p)*l2tab[256-m]);
260 }
261 }
262 if(len < best_len[k]){
263 best_len[k]= len;
264 best_state[i][k]= j;
265 }
266 for(m=0; m<256; m++){
267 if(occ[m]){
268 newocc[ one_state[ m]] += occ[m]* p ;
269 newocc[256-one_state[256-m]] += occ[m]*(1-p);
270 }
271 }
272 memcpy(occ, newocc, sizeof(occ));
273 }
274 }
275 }
276 }
277
278 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2]){
279 int i;
280
281 #define put_rac(C,S,B) \
282 do{\
283 if(rc_stat){\
284 rc_stat[*(S)][B]++;\
285 rc_stat2[(S)-state][B]++;\
286 }\
287 put_rac(C,S,B);\
288 }while(0)
289
290 if(v){
291 const int a= FFABS(v);
292 const int e= av_log2(a);
293 put_rac(c, state+0, 0);
294 if(e<=9){
295 for(i=0; i<e; i++){
296 put_rac(c, state+1+i, 1); //1..10
297 }
298 put_rac(c, state+1+i, 0);
299
300 for(i=e-1; i>=0; i--){
301 put_rac(c, state+22+i, (a>>i)&1); //22..31
302 }
303
304 if(is_signed)
305 put_rac(c, state+11 + e, v < 0); //11..21
306 }else{
307 for(i=0; i<e; i++){
308 put_rac(c, state+1+FFMIN(i,9), 1); //1..10
309 }
310 put_rac(c, state+1+9, 0);
311
312 for(i=e-1; i>=0; i--){
313 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
314 }
315
316 if(is_signed)
317 put_rac(c, state+11 + 10, v < 0); //11..21
318 }
319 }else{
320 put_rac(c, state+0, 1);
321 }
322 #undef put_rac
323 }
324
325 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
326 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
327 }
328
329 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
330 if(get_rac(c, state+0))
331 return 0;
332 else{
333 int i, e, a;
334 e= 0;
335 while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
336 e++;
337 }
338
339 a= 1;
340 for(i=e-1; i>=0; i--){
341 a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
342 }
343
344 e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
345 return (a^e)-e;
346 }
347 }
348
349 static av_noinline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
350 return get_symbol_inline(c, state, is_signed);
351 }
352
353 static inline void update_vlc_state(VlcState * const state, const int v){
354 int drift= state->drift;
355 int count= state->count;
356 state->error_sum += FFABS(v);
357 drift += v;
358
359 if(count == 128){ //FIXME variable
360 count >>= 1;
361 drift >>= 1;
362 state->error_sum >>= 1;
363 }
364 count++;
365
366 if(drift <= -count){
367 if(state->bias > -128) state->bias--;
368
369 drift += count;
370 if(drift <= -count)
371 drift= -count + 1;
372 }else if(drift > 0){
373 if(state->bias < 127) state->bias++;
374
375 drift -= count;
376 if(drift > 0)
377 drift= 0;
378 }
379
380 state->drift= drift;
381 state->count= count;
382 }
383
384 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
385 int i, k, code;
386 //printf("final: %d ", v);
387 v = fold(v - state->bias, bits);
388
389 i= state->count;
390 k=0;
391 while(i < state->error_sum){ //FIXME optimize
392 k++;
393 i += i;
394 }
395
396 assert(k<=8);
397
398 #if 0 // JPEG LS
399 if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
400 else code= v;
401 #else
402 code= v ^ ((2*state->drift + state->count)>>31);
403 #endif
404
405 //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);
406 set_sr_golomb(pb, code, k, 12, bits);
407
408 update_vlc_state(state, v);
409 }
410
411 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
412 int k, i, v, ret;
413
414 i= state->count;
415 k=0;
416 while(i < state->error_sum){ //FIXME optimize
417 k++;
418 i += i;
419 }
420
421 assert(k<=8);
422
423 v= get_sr_golomb(gb, k, 12, bits);
424 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
425
426 #if 0 // JPEG LS
427 if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
428 #else
429 v ^= ((2*state->drift + state->count)>>31);
430 #endif
431
432 ret= fold(v + state->bias, bits);
433
434 update_vlc_state(state, v);
435 //printf("final: %d\n", ret);
436 return ret;
437 }
438
439 #if CONFIG_FFV1_ENCODER
440 static av_always_inline int encode_line(FFV1Context *s, int w,
441 int16_t *sample[3],
442 int plane_index, int bits)
443 {
444 PlaneContext * const p= &s->plane[plane_index];
445 RangeCoder * const c= &s->c;
446 int x;
447 int run_index= s->run_index;
448 int run_count=0;
449 int run_mode=0;
450
451 if(s->ac){
452 if(c->bytestream_end - c->bytestream < w*20){
453 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
454 return -1;
455 }
456 }else{
457 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
458 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
459 return -1;
460 }
461 }
462
463 for(x=0; x<w; x++){
464 int diff, context;
465
466 context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
467 diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
468
469 if(context < 0){
470 context = -context;
471 diff= -diff;
472 }
473
474 diff= fold(diff, bits);
475
476 if(s->ac){
477 if(s->flags & CODEC_FLAG_PASS1){
478 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
479 }else{
480 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
481 }
482 }else{
483 if(context == 0) run_mode=1;
484
485 if(run_mode){
486
487 if(diff){
488 while(run_count >= 1<<ff_log2_run[run_index]){
489 run_count -= 1<<ff_log2_run[run_index];
490 run_index++;
491 put_bits(&s->pb, 1, 1);
492 }
493
494 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
495 if(run_index) run_index--;
496 run_count=0;
497 run_mode=0;
498 if(diff>0) diff--;
499 }else{
500 run_count++;
501 }
502 }
503
504 // 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));
505
506 if(run_mode == 0)
507 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
508 }
509 }
510 if(run_mode){
511 while(run_count >= 1<<ff_log2_run[run_index]){
512 run_count -= 1<<ff_log2_run[run_index];
513 run_index++;
514 put_bits(&s->pb, 1, 1);
515 }
516
517 if(run_count)
518 put_bits(&s->pb, 1, 1);
519 }
520 s->run_index= run_index;
521
522 return 0;
523 }
524
525 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
526 int x,y,i;
527 const int ring_size= s->avctx->context_model ? 3 : 2;
528 int16_t *sample[3];
529 s->run_index=0;
530
531 memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
532
533 for(y=0; y<h; y++){
534 for(i=0; i<ring_size; i++)
535 sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
536
537 sample[0][-1]= sample[1][0 ];
538 sample[1][ w]= sample[1][w-1];
539 //{START_TIMER
540 if(s->avctx->bits_per_raw_sample<=8){
541 for(x=0; x<w; x++){
542 sample[0][x]= src[x + stride*y];
543 }
544 encode_line(s, w, sample, plane_index, 8);
545 }else{
546 for(x=0; x<w; x++){
547 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
548 }
549 encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
550 }
551 //STOP_TIMER("encode line")}
552 }
553 }
554
555 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
556 int x, y, p, i;
557 const int ring_size= s->avctx->context_model ? 3 : 2;
558 int16_t *sample[3][3];
559 s->run_index=0;
560
561 memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
562
563 for(y=0; y<h; y++){
564 for(i=0; i<ring_size; i++)
565 for(p=0; p<3; p++)
566 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
567
568 for(x=0; x<w; x++){
569 int v= src[x + stride*y];
570 int b= v&0xFF;
571 int g= (v>>8)&0xFF;
572 int r= (v>>16)&0xFF;
573
574 b -= g;
575 r -= g;
576 g += (b + r)>>2;
577 b += 0x100;
578 r += 0x100;
579
580 // assert(g>=0 && b>=0 && r>=0);
581 // assert(g<256 && b<512 && r<512);
582 sample[0][0][x]= g;
583 sample[1][0][x]= b;
584 sample[2][0][x]= r;
585 }
586 for(p=0; p<3; p++){
587 sample[p][0][-1]= sample[p][1][0 ];
588 sample[p][1][ w]= sample[p][1][w-1];
589 encode_line(s, w, sample[p], FFMIN(p, 1), 9);
590 }
591 }
592 }
593
594 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
595 int last=0;
596 int i;
597 uint8_t state[CONTEXT_SIZE];
598 memset(state, 128, sizeof(state));
599
600 for(i=1; i<128 ; i++){
601 if(quant_table[i] != quant_table[i-1]){
602 put_symbol(c, state, i-last-1, 0);
603 last= i;
604 }
605 }
606 put_symbol(c, state, i-last-1, 0);
607 }
608
609 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
610 int i;
611 for(i=0; i<5; i++)
612 write_quant_table(c, quant_table[i]);
613 }
614
615 static void write_header(FFV1Context *f){
616 uint8_t state[CONTEXT_SIZE];
617 int i, j;
618 RangeCoder * const c= &f->slice_context[0]->c;
619
620 memset(state, 128, sizeof(state));
621
622 if(f->version < 2){
623 put_symbol(c, state, f->version, 0);
624 put_symbol(c, state, f->ac, 0);
625 if(f->ac>1){
626 for(i=1; i<256; i++){
627 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
628 }
629 }
630 put_symbol(c, state, f->colorspace, 0); //YUV cs type
631 if(f->version>0)
632 put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
633 put_rac(c, state, 1); //chroma planes
634 put_symbol(c, state, f->chroma_h_shift, 0);
635 put_symbol(c, state, f->chroma_v_shift, 0);
636 put_rac(c, state, 0); //no transparency plane
637
638 write_quant_tables(c, f->quant_table);
639 }else{
640 put_symbol(c, state, f->slice_count, 0);
641 for(i=0; i<f->slice_count; i++){
642 FFV1Context *fs= f->slice_context[i];
643 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
644 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
645 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
646 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
647 for(j=0; j<f->plane_count; j++){
648 put_symbol(c, state, f->plane[j].quant_table_index, 0);
649 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
650 }
651 }
652 }
653 }
654 #endif /* CONFIG_FFV1_ENCODER */
655
656 static av_cold int common_init(AVCodecContext *avctx){
657 FFV1Context *s = avctx->priv_data;
658
659 s->avctx= avctx;
660 s->flags= avctx->flags;
661
662 ff_dsputil_init(&s->dsp, avctx);
663
664 s->width = avctx->width;
665 s->height= avctx->height;
666
667 assert(s->width && s->height);
668 //defaults
669 s->num_h_slices=1;
670 s->num_v_slices=1;
671
672
673 return 0;
674 }
675
676 static int init_slice_state(FFV1Context *f){
677 int i, j;
678
679 for(i=0; i<f->slice_count; i++){
680 FFV1Context *fs= f->slice_context[i];
681 for(j=0; j<f->plane_count; j++){
682 PlaneContext * const p= &fs->plane[j];
683
684 if(fs->ac){
685 if(!p-> state) p-> state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
686 if(!p-> state)
687 return AVERROR(ENOMEM);
688 }else{
689 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
690 if(!p->vlc_state)
691 return AVERROR(ENOMEM);
692 }
693 }
694
695 if (fs->ac>1){
696 //FIXME only redo if state_transition changed
697 for(j=1; j<256; j++){
698 fs->c.one_state [ j]= fs->state_transition[j];
699 fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
700 }
701 }
702 }
703
704 return 0;
705 }
706
707 static av_cold int init_slice_contexts(FFV1Context *f){
708 int i;
709
710 f->slice_count= f->num_h_slices * f->num_v_slices;
711
712 for(i=0; i<f->slice_count; i++){
713 FFV1Context *fs= av_mallocz(sizeof(*fs));
714 int sx= i % f->num_h_slices;
715 int sy= i / f->num_h_slices;
716 int sxs= f->avctx->width * sx / f->num_h_slices;
717 int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
718 int sys= f->avctx->height* sy / f->num_v_slices;
719 int sye= f->avctx->height*(sy+1) / f->num_v_slices;
720 f->slice_context[i]= fs;
721 memcpy(fs, f, sizeof(*fs));
722 memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
723
724 fs->slice_width = sxe - sxs;
725 fs->slice_height= sye - sys;
726 fs->slice_x = sxs;
727 fs->slice_y = sys;
728
729 fs->sample_buffer = av_malloc(9 * (fs->width+6) * sizeof(*fs->sample_buffer));
730 if (!fs->sample_buffer)
731 return AVERROR(ENOMEM);
732 }
733 return 0;
734 }
735
736 static int allocate_initial_states(FFV1Context *f){
737 int i;
738
739 for(i=0; i<f->quant_table_count; i++){
740 f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
741 if(!f->initial_states[i])
742 return AVERROR(ENOMEM);
743 memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
744 }
745 return 0;
746 }
747
748 #if CONFIG_FFV1_ENCODER
749 static int write_extra_header(FFV1Context *f){
750 RangeCoder * const c= &f->c;
751 uint8_t state[CONTEXT_SIZE];
752 int i, j, k;
753 uint8_t state2[32][CONTEXT_SIZE];
754
755 memset(state2, 128, sizeof(state2));
756 memset(state, 128, sizeof(state));
757
758 f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
759 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
760 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
761
762 put_symbol(c, state, f->version, 0);
763 put_symbol(c, state, f->ac, 0);
764 if(f->ac>1){
765 for(i=1; i<256; i++){
766 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
767 }
768 }
769 put_symbol(c, state, f->colorspace, 0); //YUV cs type
770 put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
771 put_rac(c, state, 1); //chroma planes
772 put_symbol(c, state, f->chroma_h_shift, 0);
773 put_symbol(c, state, f->chroma_v_shift, 0);
774 put_rac(c, state, 0); //no transparency plane
775 put_symbol(c, state, f->num_h_slices-1, 0);
776 put_symbol(c, state, f->num_v_slices-1, 0);
777
778 put_symbol(c, state, f->quant_table_count, 0);
779 for(i=0; i<f->quant_table_count; i++)
780 write_quant_tables(c, f->quant_tables[i]);
781
782 for(i=0; i<f->quant_table_count; i++){
783 for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
784 if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
785 break;
786 if(j<f->context_count[i]*CONTEXT_SIZE){
787 put_rac(c, state, 1);
788 for(j=0; j<f->context_count[i]; j++){
789 for(k=0; k<CONTEXT_SIZE; k++){
790 int pred= j ? f->initial_states[i][j-1][k] : 128;
791 put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
792 }
793 }
794 }else{
795 put_rac(c, state, 0);
796 }
797 }
798
799 f->avctx->extradata_size= ff_rac_terminate(c);
800
801 return 0;
802 }
803
804 static int sort_stt(FFV1Context *s, uint8_t stt[256]){
805 int i,i2,changed,print=0;
806
807 do{
808 changed=0;
809 for(i=12; i<244; i++){
810 for(i2=i+1; i2<245 && i2<i+4; i2++){
811 #define COST(old, new) \
812 s->rc_stat[old][0]*-log2((256-(new))/256.0)\
813 +s->rc_stat[old][1]*-log2( (new) /256.0)
814
815 #define COST2(old, new) \
816 COST(old, new)\
817 +COST(256-(old), 256-(new))
818
819 double size0= COST2(i, i ) + COST2(i2, i2);
820 double sizeX= COST2(i, i2) + COST2(i2, i );
821 if(sizeX < size0 && i!=128 && i2!=128){
822 int j;
823 FFSWAP(int, stt[ i], stt[ i2]);
824 FFSWAP(int, s->rc_stat[i ][0],s->rc_stat[ i2][0]);
825 FFSWAP(int, s->rc_stat[i ][1],s->rc_stat[ i2][1]);
826 if(i != 256-i2){
827 FFSWAP(int, stt[256-i], stt[256-i2]);
828 FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
829 FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
830 }
831 for(j=1; j<256; j++){
832 if (stt[j] == i ) stt[j] = i2;
833 else if(stt[j] == i2) stt[j] = i ;
834 if(i != 256-i2){
835 if (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
836 else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
837 }
838 }
839 print=changed=1;
840 }
841 }
842 }
843 }while(changed);
844 return print;
845 }
846
847 static av_cold int encode_init(AVCodecContext *avctx)
848 {
849 FFV1Context *s = avctx->priv_data;
850 int i, j, k, m;
851
852 common_init(avctx);
853
854 s->version=0;
855 s->ac= avctx->coder_type ? 2:0;
856
857 if(s->ac>1)
858 for(i=1; i<256; i++)
859 s->state_transition[i]=ver2_state[i];
860
861 s->plane_count=2;
862 for(i=0; i<256; i++){
863 s->quant_table_count=2;
864 if(avctx->bits_per_raw_sample <=8){
865 s->quant_tables[0][0][i]= quant11[i];
866 s->quant_tables[0][1][i]= 11*quant11[i];
867 s->quant_tables[0][2][i]= 11*11*quant11[i];
868 s->quant_tables[1][0][i]= quant11[i];
869 s->quant_tables[1][1][i]= 11*quant11[i];
870 s->quant_tables[1][2][i]= 11*11*quant5 [i];
871 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
872 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
873 }else{
874 s->quant_tables[0][0][i]= quant9_10bit[i];
875 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
876 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
877 s->quant_tables[1][0][i]= quant9_10bit[i];
878 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
879 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
880 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
881 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
882 }
883 }
884 s->context_count[0]= (11*11*11+1)/2;
885 s->context_count[1]= (11*11*5*5*5+1)/2;
886 memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
887
888 for(i=0; i<s->plane_count; i++){
889 PlaneContext * const p= &s->plane[i];
890
891 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
892 p->quant_table_index= avctx->context_model;
893 p->context_count= s->context_count[p->quant_table_index];
894 }
895
896 if(allocate_initial_states(s) < 0)
897 return AVERROR(ENOMEM);
898
899 avctx->coded_frame= &s->picture;
900 switch(avctx->pix_fmt){
901 case PIX_FMT_YUV444P16:
902 case PIX_FMT_YUV422P16:
903 case PIX_FMT_YUV420P16:
904 if(avctx->bits_per_raw_sample <=8){
905 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
906 return -1;
907 }
908 if(!s->ac){
909 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
910 return -1;
911 }
912 s->version= FFMAX(s->version, 1);
913 case PIX_FMT_YUV444P:
914 case PIX_FMT_YUV422P:
915 case PIX_FMT_YUV420P:
916 case PIX_FMT_YUV411P:
917 case PIX_FMT_YUV410P:
918 s->colorspace= 0;
919 break;
920 case PIX_FMT_RGB32:
921 s->colorspace= 1;
922 break;
923 default:
924 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
925 return -1;
926 }
927 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
928
929 s->picture_number=0;
930
931 if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
932 for(i=0; i<s->quant_table_count; i++){
933 s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
934 if(!s->rc_stat2[i])
935 return AVERROR(ENOMEM);
936 }
937 }
938 if(avctx->stats_in){
939 char *p= avctx->stats_in;
940 uint8_t best_state[256][256];
941 int gob_count=0;
942 char *next;
943
944 av_assert0(s->version>=2);
945
946 for(;;){
947 for(j=0; j<256; j++){
948 for(i=0; i<2; i++){
949 s->rc_stat[j][i]= strtol(p, &next, 0);
950 if(next==p){
951 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
952 return -1;
953 }
954 p=next;
955 }
956 }
957 for(i=0; i<s->quant_table_count; i++){
958 for(j=0; j<s->context_count[i]; j++){
959 for(k=0; k<32; k++){
960 for(m=0; m<2; m++){
961 s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
962 if(next==p){
963 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
964 return -1;
965 }
966 p=next;
967 }
968 }
969 }
970 }
971 gob_count= strtol(p, &next, 0);
972 if(next==p || gob_count <0){
973 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
974 return -1;
975 }
976 p=next;
977 while(*p=='\n' || *p==' ') p++;
978 if(p[0]==0) break;
979 }
980 sort_stt(s, s->state_transition);
981
982 find_best_state(best_state, s->state_transition);
983
984 for(i=0; i<s->quant_table_count; i++){
985 for(j=0; j<s->context_count[i]; j++){
986 for(k=0; k<32; k++){
987 double p= 128;
988 if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
989 p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
990 }
991 s->initial_states[i][j][k]= best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1])/gob_count, 0, 255)];
992 }
993 }
994 }
995 }
996
997 if(s->version>1){
998 s->num_h_slices=2;
999 s->num_v_slices=2;
1000 write_extra_header(s);
1001 }
1002
1003 if(init_slice_contexts(s) < 0)
1004 return -1;
1005 if(init_slice_state(s) < 0)
1006 return -1;
1007
1008 #define STATS_OUT_SIZE 1024*1024*6
1009 if(avctx->flags & CODEC_FLAG_PASS1){
1010 avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1011 for(i=0; i<s->quant_table_count; i++){
1012 for(j=0; j<s->slice_count; j++){
1013 FFV1Context *sf= s->slice_context[j];
1014 av_assert0(!sf->rc_stat2[i]);
1015 sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1016 if(!sf->rc_stat2[i])
1017 return AVERROR(ENOMEM);
1018 }
1019 }
1020 }
1021
1022 return 0;
1023 }
1024 #endif /* CONFIG_FFV1_ENCODER */
1025
1026
1027 static void clear_state(FFV1Context *f){
1028 int i, si, j;
1029
1030 for(si=0; si<f->slice_count; si++){
1031 FFV1Context *fs= f->slice_context[si];
1032 for(i=0; i<f->plane_count; i++){
1033 PlaneContext *p= &fs->plane[i];
1034
1035 p->interlace_bit_state[0]= 128;
1036 p->interlace_bit_state[1]= 128;
1037
1038 if(fs->ac){
1039 if(f->initial_states[p->quant_table_index]){
1040 memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1041 }else
1042 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1043 }else{
1044 for(j=0; j<p->context_count; j++){
1045 p->vlc_state[j].drift= 0;
1046 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1047 p->vlc_state[j].bias= 0;
1048 p->vlc_state[j].count= 1;
1049 }
1050 }
1051 }
1052 }
1053 }
1054
1055 #if CONFIG_FFV1_ENCODER
1056 static int encode_slice(AVCodecContext *c, void *arg){
1057 FFV1Context *fs= *(void**)arg;
1058 FFV1Context *f= fs->avctx->priv_data;
1059 int width = fs->slice_width;
1060 int height= fs->slice_height;
1061 int x= fs->slice_x;
1062 int y= fs->slice_y;
1063 AVFrame * const p= &f->picture;
1064
1065 if(f->colorspace==0){
1066 const int chroma_width = -((-width )>>f->chroma_h_shift);
1067 const int chroma_height= -((-height)>>f->chroma_v_shift);
1068 const int cx= x>>f->chroma_h_shift;
1069 const int cy= y>>f->chroma_v_shift;
1070
1071 encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1072
1073 encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1074 encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1075 }else{
1076 encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1077 }
1078 emms_c();
1079
1080 return 0;
1081 }
1082
1083 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1084 const AVFrame *pict, int *got_packet)
1085 {
1086 FFV1Context *f = avctx->priv_data;
1087 RangeCoder * const c= &f->slice_context[0]->c;
1088 AVFrame * const p= &f->picture;
1089 int used_count= 0;
1090 uint8_t keystate=128;
1091 uint8_t *buf_p;
1092 int i, ret;
1093
1094 if (!pkt->data &&
1095 (ret = av_new_packet(pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1096 + FF_MIN_BUFFER_SIZE)) < 0) {
1097 av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
1098 return ret;
1099 }
1100
1101 ff_init_range_encoder(c, pkt->data, pkt->size);
1102 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1103
1104 *p = *pict;
1105 p->pict_type= AV_PICTURE_TYPE_I;
1106
1107 if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1108 put_rac(c, &keystate, 1);
1109 p->key_frame= 1;
1110 f->gob_count++;
1111 write_header(f);
1112 clear_state(f);
1113 }else{
1114 put_rac(c, &keystate, 0);
1115 p->key_frame= 0;
1116 }
1117
1118 if(!f->ac){
1119 used_count += ff_rac_terminate(c);
1120 //printf("pos=%d\n", used_count);
1121 init_put_bits(&f->slice_context[0]->pb, pkt->data + used_count, pkt->size - used_count);
1122 }else if (f->ac>1){
1123 int i;
1124 for(i=1; i<256; i++){
1125 c->one_state[i]= f->state_transition[i];
1126 c->zero_state[256-i]= 256-c->one_state[i];
1127 }
1128 }
1129
1130 for(i=1; i<f->slice_count; i++){
1131 FFV1Context *fs= f->slice_context[i];
1132 uint8_t *start = pkt->data + (pkt->size-used_count)*i/f->slice_count;
1133 int len = pkt->size/f->slice_count;
1134
1135 if(fs->ac){
1136 ff_init_range_encoder(&fs->c, start, len);
1137 }else{
1138 init_put_bits(&fs->pb, start, len);
1139 }
1140 }
1141 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1142
1143 buf_p = pkt->data;
1144 for(i=0; i<f->slice_count; i++){
1145 FFV1Context *fs= f->slice_context[i];
1146 int bytes;
1147
1148 if(fs->ac){
1149 uint8_t state=128;
1150 put_rac(&fs->c, &state, 0);
1151 bytes= ff_rac_terminate(&fs->c);
1152 }else{
1153 flush_put_bits(&fs->pb); //nicer padding FIXME
1154 bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1155 used_count= 0;
1156 }
1157 if(i>0){
1158 av_assert0(bytes < pkt->size/f->slice_count);
1159 memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1160 av_assert0(bytes < (1<<24));
1161 AV_WB24(buf_p+bytes, bytes);
1162 bytes+=3;
1163 }
1164 buf_p += bytes;
1165 }
1166
1167 if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1168 int j, k, m;
1169 char *p= avctx->stats_out;
1170 char *end= p + STATS_OUT_SIZE;
1171
1172 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1173 for(i=0; i<f->quant_table_count; i++)
1174 memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1175
1176 for(j=0; j<f->slice_count; j++){
1177 FFV1Context *fs= f->slice_context[j];
1178 for(i=0; i<256; i++){
1179 f->rc_stat[i][0] += fs->rc_stat[i][0];
1180 f->rc_stat[i][1] += fs->rc_stat[i][1];
1181 }
1182 for(i=0; i<f->quant_table_count; i++){
1183 for(k=0; k<f->context_count[i]; k++){
1184 for(m=0; m<32; m++){
1185 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1186 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1187 }
1188 }
1189 }
1190 }
1191
1192 for(j=0; j<256; j++){
1193 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1194 p+= strlen(p);
1195 }
1196 snprintf(p, end-p, "\n");
1197
1198 for(i=0; i<f->quant_table_count; i++){
1199 for(j=0; j<f->context_count[i]; j++){
1200 for(m=0; m<32; m++){
1201 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1202 p+= strlen(p);
1203 }
1204 }
1205 }
1206 snprintf(p, end-p, "%d\n", f->gob_count);
1207 } else if(avctx->flags&CODEC_FLAG_PASS1)
1208 avctx->stats_out[0] = '\0';
1209
1210 f->picture_number++;
1211 pkt->size = buf_p - pkt->data;
1212 pkt->flags |= AV_PKT_FLAG_KEY*p->key_frame;
1213 *got_packet = 1;
1214
1215 return 0;
1216 }
1217 #endif /* CONFIG_FFV1_ENCODER */
1218
1219 static av_cold int common_end(AVCodecContext *avctx){
1220 FFV1Context *s = avctx->priv_data;
1221 int i, j;
1222
1223 if (avctx->codec->decode && s->picture.data[0])
1224 avctx->release_buffer(avctx, &s->picture);
1225
1226 for(j=0; j<s->slice_count; j++){
1227 FFV1Context *fs= s->slice_context[j];
1228 for(i=0; i<s->plane_count; i++){
1229 PlaneContext *p= &fs->plane[i];
1230
1231 av_freep(&p->state);
1232 av_freep(&p->vlc_state);
1233 }
1234 av_freep(&fs->sample_buffer);
1235 }
1236
1237 av_freep(&avctx->stats_out);
1238 for(j=0; j<s->quant_table_count; j++){
1239 av_freep(&s->initial_states[j]);
1240 for(i=0; i<s->slice_count; i++){
1241 FFV1Context *sf= s->slice_context[i];
1242 av_freep(&sf->rc_stat2[j]);
1243 }
1244 av_freep(&s->rc_stat2[j]);
1245 }
1246
1247 for(i=0; i<s->slice_count; i++){
1248 av_freep(&s->slice_context[i]);
1249 }
1250
1251 return 0;
1252 }
1253
1254 static av_always_inline void decode_line(FFV1Context *s, int w,
1255 int16_t *sample[2],
1256 int plane_index, int bits)
1257 {
1258 PlaneContext * const p= &s->plane[plane_index];
1259 RangeCoder * const c= &s->c;
1260 int x;
1261 int run_count=0;
1262 int run_mode=0;
1263 int run_index= s->run_index;
1264
1265 for(x=0; x<w; x++){
1266 int diff, context, sign;
1267
1268 context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1269 if(context < 0){
1270 context= -context;
1271 sign=1;
1272 }else
1273 sign=0;
1274
1275 av_assert2(context < p->context_count);
1276
1277 if(s->ac){
1278 diff= get_symbol_inline(c, p->state[context], 1);
1279 }else{
1280 if(context == 0 && run_mode==0) run_mode=1;
1281
1282 if(run_mode){
1283 if(run_count==0 && run_mode==1){
1284 if(get_bits1(&s->gb)){
1285 run_count = 1<<ff_log2_run[run_index];
1286 if(x + run_count <= w) run_index++;
1287 }else{
1288 if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1289 else run_count=0;
1290 if(run_index) run_index--;
1291 run_mode=2;
1292 }
1293 }
1294 run_count--;
1295 if(run_count < 0){
1296 run_mode=0;
1297 run_count=0;
1298 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1299 if(diff>=0) diff++;
1300 }else
1301 diff=0;
1302 }else
1303 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1304
1305 // 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));
1306 }
1307
1308 if(sign) diff= -diff;
1309
1310 sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1311 }
1312 s->run_index= run_index;
1313 }
1314
1315 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1316 int x, y;
1317 int16_t *sample[2];
1318 sample[0]=s->sample_buffer +3;
1319 sample[1]=s->sample_buffer+w+6+3;
1320
1321 s->run_index=0;
1322
1323 memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1324
1325 for(y=0; y<h; y++){
1326 int16_t *temp = sample[0]; //FIXME try a normal buffer
1327
1328 sample[0]= sample[1];
1329 sample[1]= temp;
1330
1331 sample[1][-1]= sample[0][0 ];
1332 sample[0][ w]= sample[0][w-1];
1333
1334 //{START_TIMER
1335 if(s->avctx->bits_per_raw_sample <= 8){
1336 decode_line(s, w, sample, plane_index, 8);
1337 for(x=0; x<w; x++){
1338 src[x + stride*y]= sample[1][x];
1339 }
1340 }else{
1341 decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1342 for(x=0; x<w; x++){
1343 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1344 }
1345 }
1346 //STOP_TIMER("decode-line")}
1347 }
1348 }
1349
1350 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1351 int x, y, p;
1352 int16_t *sample[3][2];
1353 for(x=0; x<3; x++){
1354 sample[x][0] = s->sample_buffer + x*2 *(w+6) + 3;
1355 sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1356 }
1357
1358 s->run_index=0;
1359
1360 memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1361
1362 for(y=0; y<h; y++){
1363 for(p=0; p<3; p++){
1364 int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1365
1366 sample[p][0]= sample[p][1];
1367 sample[p][1]= temp;
1368
1369 sample[p][1][-1]= sample[p][0][0 ];
1370 sample[p][0][ w]= sample[p][0][w-1];
1371 decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1372 }
1373 for(x=0; x<w; x++){
1374 int g= sample[0][1][x];
1375 int b= sample[1][1][x];
1376 int r= sample[2][1][x];
1377
1378 // assert(g>=0 && b>=0 && r>=0);
1379 // assert(g<256 && b<512 && r<512);
1380
1381 b -= 0x100;
1382 r -= 0x100;
1383 g -= (b + r)>>2;
1384 b += g;
1385 r += g;
1386
1387 src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1388 }
1389 }
1390 }
1391
1392 static int decode_slice(AVCodecContext *c, void *arg){
1393 FFV1Context *fs= *(void**)arg;
1394 FFV1Context *f= fs->avctx->priv_data;
1395 int width = fs->slice_width;
1396 int height= fs->slice_height;
1397 int x= fs->slice_x;
1398 int y= fs->slice_y;
1399 AVFrame * const p= &f->picture;
1400
1401 av_assert1(width && height);
1402 if(f->colorspace==0){
1403 const int chroma_width = -((-width )>>f->chroma_h_shift);
1404 const int chroma_height= -((-height)>>f->chroma_v_shift);
1405 const int cx= x>>f->chroma_h_shift;
1406 const int cy= y>>f->chroma_v_shift;
1407 decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1408
1409 decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1410 decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1411 }else{
1412 decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1413 }
1414
1415 emms_c();
1416
1417 return 0;
1418 }
1419
1420 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1421 int v;
1422 int i=0;
1423 uint8_t state[CONTEXT_SIZE];
1424
1425 memset(state, 128, sizeof(state));
1426
1427 for(v=0; i<128 ; v++){
1428 int len= get_symbol(c, state, 0) + 1;
1429
1430 if(len + i > 128) return -1;
1431
1432 while(len--){
1433 quant_table[i] = scale*v;
1434 i++;
1435 //printf("%2d ",v);
1436 //if(i%16==0) printf("\n");
1437 }
1438 }
1439
1440 for(i=1; i<128; i++){
1441 quant_table[256-i]= -quant_table[i];
1442 }
1443 quant_table[128]= -quant_table[127];
1444
1445 return 2*v - 1;
1446 }
1447
1448 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1449 int i;
1450 int context_count=1;
1451
1452 for(i=0; i<5; i++){
1453 context_count*= read_quant_table(c, quant_table[i], context_count);
1454 if(context_count > 32768U){
1455 return -1;
1456 }
1457 }
1458 return (context_count+1)/2;
1459 }
1460
1461 static int read_extra_header(FFV1Context *f){
1462 RangeCoder * const c= &f->c;
1463 uint8_t state[CONTEXT_SIZE];
1464 int i, j, k;
1465 uint8_t state2[32][CONTEXT_SIZE];
1466
1467 memset(state2, 128, sizeof(state2));
1468 memset(state, 128, sizeof(state));
1469
1470 ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1471 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1472
1473 f->version= get_symbol(c, state, 0);
1474 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1475 if(f->ac>1){
1476 for(i=1; i<256; i++){
1477 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1478 }
1479 }
1480 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1481 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1482 get_rac(c, state); //no chroma = false
1483 f->chroma_h_shift= get_symbol(c, state, 0);
1484 f->chroma_v_shift= get_symbol(c, state, 0);
1485 get_rac(c, state); //transparency plane
1486 f->plane_count= 2;
1487 f->num_h_slices= 1 + get_symbol(c, state, 0);
1488 f->num_v_slices= 1 + get_symbol(c, state, 0);
1489 if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1490 av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1491 return -1;
1492 }
1493
1494 f->quant_table_count= get_symbol(c, state, 0);
1495 if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1496 return -1;
1497 for(i=0; i<f->quant_table_count; i++){
1498 if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1499 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1500 return -1;
1501 }
1502 }
1503
1504 if(allocate_initial_states(f) < 0)
1505 return AVERROR(ENOMEM);
1506
1507 for(i=0; i<f->quant_table_count; i++){
1508 if(get_rac(c, state)){
1509 for(j=0; j<f->context_count[i]; j++){
1510 for(k=0; k<CONTEXT_SIZE; k++){
1511 int pred= j ? f->initial_states[i][j-1][k] : 128;
1512 f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1513 }
1514 }
1515 }
1516 }
1517
1518 return 0;
1519 }
1520
1521 static int read_header(FFV1Context *f){
1522 uint8_t state[CONTEXT_SIZE];
1523 int i, j, context_count;
1524 RangeCoder * const c= &f->slice_context[0]->c;
1525
1526 memset(state, 128, sizeof(state));
1527
1528 if(f->version < 2){
1529 f->version= get_symbol(c, state, 0);
1530 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1531 if(f->ac>1){
1532 for(i=1; i<256; i++){
1533 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1534 }
1535 }
1536 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1537 if(f->version>0)
1538 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1539 get_rac(c, state); //no chroma = false
1540 f->chroma_h_shift= get_symbol(c, state, 0);
1541 f->chroma_v_shift= get_symbol(c, state, 0);
1542 get_rac(c, state); //transparency plane
1543 f->plane_count= 2;
1544 }
1545
1546 if(f->colorspace==0){
1547 if(f->avctx->bits_per_raw_sample<=8){
1548 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1549 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1550 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1551 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1552 case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1553 case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1554 default:
1555 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1556 return -1;
1557 }
1558 }else{
1559 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1560 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1561 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1562 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1563 default:
1564 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1565 return -1;
1566 }
1567 }
1568 }else if(f->colorspace==1){
1569 if(f->chroma_h_shift || f->chroma_v_shift){
1570 av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1571 return -1;
1572 }
1573 f->avctx->pix_fmt= PIX_FMT_RGB32;
1574 }else{
1575 av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1576 return -1;
1577 }
1578
1579 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1580 if(f->version < 2){
1581 context_count= read_quant_tables(c, f->quant_table);
1582 if(context_count < 0){
1583 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1584 return -1;
1585 }
1586 }else{
1587 f->slice_count= get_symbol(c, state, 0);
1588 if(f->slice_count > (unsigned)MAX_SLICES)
1589 return -1;
1590 }
1591
1592 for(j=0; j<f->slice_count; j++){
1593 FFV1Context *fs= f->slice_context[j];
1594 fs->ac= f->ac;
1595
1596 if(f->version >= 2){
1597 fs->slice_x = get_symbol(c, state, 0) *f->width ;
1598 fs->slice_y = get_symbol(c, state, 0) *f->height;
1599 fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
1600 fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1601
1602 fs->slice_x /= f->num_h_slices;
1603 fs->slice_y /= f->num_v_slices;
1604 fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
1605 fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1606 if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1607 return -1;
1608 if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
1609 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1610 return -1;
1611 }
1612
1613 for(i=0; i<f->plane_count; i++){
1614 PlaneContext * const p= &fs->plane[i];
1615
1616 if(f->version >= 2){
1617 int idx=get_symbol(c, state, 0);
1618 if(idx > (unsigned)f->quant_table_count){
1619 av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1620 return -1;
1621 }
1622 p->quant_table_index= idx;
1623 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1624 context_count= f->context_count[idx];
1625 }else{
1626 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1627 }
1628
1629 if(p->context_count < context_count){
1630 av_freep(&p->state);
1631 av_freep(&p->vlc_state);
1632 }
1633 p->context_count= context_count;
1634 }
1635 }
1636
1637 return 0;
1638 }
1639
1640 static av_cold int decode_init(AVCodecContext *avctx)
1641 {
1642 FFV1Context *f = avctx->priv_data;
1643
1644 common_init(avctx);
1645
1646 if(avctx->extradata && read_extra_header(f) < 0)
1647 return -1;
1648
1649 if(init_slice_contexts(f) < 0)
1650 return -1;
1651
1652 return 0;
1653 }
1654
1655 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1656 const uint8_t *buf = avpkt->data;
1657 int buf_size = avpkt->size;
1658 FFV1Context *f = avctx->priv_data;
1659 RangeCoder * const c= &f->slice_context[0]->c;
1660 AVFrame * const p= &f->picture;
1661 int bytes_read, i;
1662 uint8_t keystate= 128;
1663 const uint8_t *buf_p;
1664
1665 AVFrame *picture = data;
1666
1667 /* release previously stored data */
1668 if (p->data[0])
1669 avctx->release_buffer(avctx, p);
1670
1671 ff_init_range_decoder(c, buf, buf_size);
1672 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1673
1674
1675 p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1676 if(get_rac(c, &keystate)){
1677 p->key_frame= 1;
1678 if(read_header(f) < 0)
1679 return -1;
1680 if(init_slice_state(f) < 0)
1681 return -1;
1682
1683 clear_state(f);
1684 }else{
1685 p->key_frame= 0;
1686 }
1687 if(f->ac>1){
1688 int i;
1689 for(i=1; i<256; i++){
1690 c->one_state[i]= f->state_transition[i];
1691 c->zero_state[256-i]= 256-c->one_state[i];
1692 }
1693 }
1694
1695 p->reference= 0;
1696 if(avctx->get_buffer(avctx, p) < 0){
1697 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1698 return -1;
1699 }
1700
1701 if(avctx->debug&FF_DEBUG_PICT_INFO)
1702 av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1703
1704 if(!f->ac){
1705 bytes_read = c->bytestream - c->bytestream_start - 1;
1706 if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1707 //printf("pos=%d\n", bytes_read);
1708 init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1709 } else {
1710 bytes_read = 0; /* avoid warning */
1711 }
1712
1713 buf_p= buf + buf_size;
1714 for(i=f->slice_count-1; i>0; i--){
1715 FFV1Context *fs= f->slice_context[i];
1716 int v= AV_RB24(buf_p-3)+3;
1717 if(buf_p - buf <= v){
1718 av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1719 return -1;
1720 }
1721 buf_p -= v;
1722 if(fs->ac){
1723 ff_init_range_decoder(&fs->c, buf_p, v);
1724 }else{
1725 init_get_bits(&fs->gb, buf_p, v * 8);
1726 }
1727 }
1728
1729 avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1730 f->picture_number++;
1731
1732 *picture= *p;
1733 *data_size = sizeof(AVFrame);
1734
1735 return buf_size;
1736 }
1737
1738 AVCodec ff_ffv1_decoder = {
1739 .name = "ffv1",
1740 .type = AVMEDIA_TYPE_VIDEO,
1741 .id = CODEC_ID_FFV1,
1742 .priv_data_size = sizeof(FFV1Context),
1743 .init = decode_init,
1744 .close = common_end,
1745 .decode = decode_frame,
1746 .capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ |
1747 CODEC_CAP_SLICE_THREADS,
1748 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1749 };
1750
1751 #if CONFIG_FFV1_ENCODER
1752 AVCodec ff_ffv1_encoder = {
1753 .name = "ffv1",
1754 .type = AVMEDIA_TYPE_VIDEO,
1755 .id = CODEC_ID_FFV1,
1756 .priv_data_size = sizeof(FFV1Context),
1757 .init = encode_init,
1758 .encode2 = encode_frame,
1759 .close = common_end,
1760 .capabilities = CODEC_CAP_SLICE_THREADS,
1761 .pix_fmts = (const enum PixelFormat[]){
1762 PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P,
1763 PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16,
1764 PIX_FMT_YUV444P16, PIX_FMT_NONE
1765 },
1766 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1767 };
1768 #endif
A couple of patches to make building with MPlayer easier