4 * Copyright (c) 2003-2013 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
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.
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.
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
25 * FF Video Codec 1 (a lossless codec) encoder
28 #include "libavutil/attributes.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/crc.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/timer.h"
38 #include "rangecoder.h"
43 static const int8_t quant5_10bit[256] = {
44 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
48 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
49 2, 2, 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, -1,
57 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
58 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
59 -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
62 static const int8_t quant5[256] = {
63 0, 1, 1, 1, 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, -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, -1, -1, -1,
81 static const int8_t quant9_10bit[256] = {
82 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
83 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 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, 4, 4, 4, 4, 4, 4, 4, 4,
86 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87 4, 4, 4, 4, 4, 4, 4, 4, 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, -3, -3, -3, -3, -3, -3, -3,
95 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
96 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
97 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
100 static const int8_t quant11[256] = {
101 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 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, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
104 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
105 5, 5, 5, 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, -4, -4,
115 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
116 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
119 static const uint8_t ver2_state[256] = {
120 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
121 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
122 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
123 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
124 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
125 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
126 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
127 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
128 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
129 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
130 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
131 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
132 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
133 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
134 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
135 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
138 static void find_best_state(uint8_t best_state[256][256],
139 const uint8_t one_state[256])
144 for (i = 1; i < 256; i++)
145 l2tab[i] = log2(i / 256.0);
147 for (i = 0; i < 256; i++) {
148 double best_len[256];
149 double p = i / 256.0;
151 for (j = 0; j < 256; j++)
152 best_len[j] = 1 << 30;
154 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
155 double occ[256] = { 0 };
158 for (k = 0; k < 256; k++) {
159 double newocc[256] = { 0 };
160 for (m = 1; m < 256; m++)
162 len -=occ[m]*( p *l2tab[ m]
163 + (1-p)*l2tab[256-m]);
165 if (len < best_len[k]) {
167 best_state[i][k] = j;
169 for (m = 0; m < 256; m++)
171 newocc[ one_state[ m]] += occ[m] * p;
172 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
174 memcpy(occ, newocc, sizeof(occ));
180 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
181 uint8_t *state, int v,
183 uint64_t rc_stat[256][2],
184 uint64_t rc_stat2[32][2])
188 #define put_rac(C, S, B) \
191 rc_stat[*(S)][B]++; \
192 rc_stat2[(S) - state][B]++; \
198 const int a = FFABS(v);
199 const int e = av_log2(a);
200 put_rac(c, state + 0, 0);
202 for (i = 0; i < e; i++)
203 put_rac(c, state + 1 + i, 1); // 1..10
204 put_rac(c, state + 1 + i, 0);
206 for (i = e - 1; i >= 0; i--)
207 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
210 put_rac(c, state + 11 + e, v < 0); // 11..21
212 for (i = 0; i < e; i++)
213 put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
214 put_rac(c, state + 1 + 9, 0);
216 for (i = e - 1; i >= 0; i--)
217 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
220 put_rac(c, state + 11 + 10, v < 0); // 11..21
223 put_rac(c, state + 0, 1);
228 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
229 int v, int is_signed)
231 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
235 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
239 v = fold(v - state->bias, bits);
243 while (i < state->error_sum) { // FIXME: optimize
251 if (k == 0 && 2 * state->drift <= -state->count)
256 code = v ^ ((2 * state->drift + state->count) >> 31);
259 av_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
260 state->bias, state->error_sum, state->drift, state->count, k);
261 set_sr_golomb(pb, code, k, 12, bits);
263 update_vlc_state(state, v);
266 static av_always_inline int encode_line(FFV1Context *s, int w,
268 int plane_index, int bits)
270 PlaneContext *const p = &s->plane[plane_index];
271 RangeCoder *const c = &s->c;
273 int run_index = s->run_index;
278 if (c->bytestream_end - c->bytestream < w * 35) {
279 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
280 return AVERROR_INVALIDDATA;
283 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
284 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
285 return AVERROR_INVALIDDATA;
289 if (s->slice_coding_mode == 1) {
290 for (x = 0; x < w; x++) {
292 int v = sample[0][x];
293 for (i = bits-1; i>=0; i--) {
295 put_rac(c, &state, (v>>i) & 1);
301 for (x = 0; x < w; x++) {
304 context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
305 diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
312 diff = fold(diff, bits);
315 if (s->flags & CODEC_FLAG_PASS1) {
316 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
317 s->rc_stat2[p->quant_table_index][context]);
319 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
327 while (run_count >= 1 << ff_log2_run[run_index]) {
328 run_count -= 1 << ff_log2_run[run_index];
330 put_bits(&s->pb, 1, 1);
333 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
345 av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
346 run_count, run_index, run_mode, x,
347 (int)put_bits_count(&s->pb));
350 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
354 while (run_count >= 1 << ff_log2_run[run_index]) {
355 run_count -= 1 << ff_log2_run[run_index];
357 put_bits(&s->pb, 1, 1);
361 put_bits(&s->pb, 1, 1);
363 s->run_index = run_index;
368 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
369 int stride, int plane_index)
372 const int ring_size = s->avctx->context_model ? 3 : 2;
376 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
378 for (y = 0; y < h; y++) {
379 for (i = 0; i < ring_size; i++)
380 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
382 sample[0][-1]= sample[1][0 ];
383 sample[1][ w]= sample[1][w-1];
385 if (s->bits_per_raw_sample <= 8) {
386 for (x = 0; x < w; x++)
387 sample[0][x] = src[x + stride * y];
388 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
391 if (s->packed_at_lsb) {
392 for (x = 0; x < w; x++) {
393 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
396 for (x = 0; x < w; x++) {
397 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
400 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
403 // STOP_TIMER("encode line") }
408 static int encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3])
411 const int ring_size = s->avctx->context_model ? 3 : 2;
412 int16_t *sample[4][3];
413 int lbd = s->bits_per_raw_sample <= 8;
414 int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
415 int offset = 1 << bits;
419 memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
420 (w + 6) * sizeof(*s->sample_buffer));
422 for (y = 0; y < h; y++) {
423 for (i = 0; i < ring_size; i++)
424 for (p = 0; p < MAX_PLANES; p++)
425 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
427 for (x = 0; x < w; x++) {
428 int b, g, r, av_uninit(a);
430 unsigned v = *((uint32_t*)(src[0] + x*4 + stride[0]*y));
433 r = (v >> 16) & 0xFF;
436 b = *((uint16_t*)(src[0] + x*2 + stride[0]*y));
437 g = *((uint16_t*)(src[1] + x*2 + stride[1]*y));
438 r = *((uint16_t*)(src[2] + x*2 + stride[2]*y));
441 if (s->slice_coding_mode != 1) {
454 for (p = 0; p < 3 + s->transparency; p++) {
456 sample[p][0][-1] = sample[p][1][0 ];
457 sample[p][1][ w] = sample[p][1][w-1];
458 if (lbd && s->slice_coding_mode == 0)
459 ret = encode_line(s, w, sample[p], (p + 1) / 2, 9);
461 ret = encode_line(s, w, sample[p], (p + 1) / 2, bits + (s->slice_coding_mode != 1));
469 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
473 uint8_t state[CONTEXT_SIZE];
474 memset(state, 128, sizeof(state));
476 for (i = 1; i < 128; i++)
477 if (quant_table[i] != quant_table[i - 1]) {
478 put_symbol(c, state, i - last - 1, 0);
481 put_symbol(c, state, i - last - 1, 0);
484 static void write_quant_tables(RangeCoder *c,
485 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
488 for (i = 0; i < 5; i++)
489 write_quant_table(c, quant_table[i]);
492 static void write_header(FFV1Context *f)
494 uint8_t state[CONTEXT_SIZE];
496 RangeCoder *const c = &f->slice_context[0]->c;
498 memset(state, 128, sizeof(state));
500 if (f->version < 2) {
501 put_symbol(c, state, f->version, 0);
502 put_symbol(c, state, f->ac, 0);
504 for (i = 1; i < 256; i++)
506 f->state_transition[i] - c->one_state[i], 1);
508 put_symbol(c, state, f->colorspace, 0); //YUV cs type
510 put_symbol(c, state, f->bits_per_raw_sample, 0);
511 put_rac(c, state, f->chroma_planes);
512 put_symbol(c, state, f->chroma_h_shift, 0);
513 put_symbol(c, state, f->chroma_v_shift, 0);
514 put_rac(c, state, f->transparency);
516 write_quant_tables(c, f->quant_table);
517 } else if (f->version < 3) {
518 put_symbol(c, state, f->slice_count, 0);
519 for (i = 0; i < f->slice_count; i++) {
520 FFV1Context *fs = f->slice_context[i];
522 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
524 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
526 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
529 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
531 for (j = 0; j < f->plane_count; j++) {
532 put_symbol(c, state, f->plane[j].quant_table_index, 0);
533 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
539 static int write_extradata(FFV1Context *f)
541 RangeCoder *const c = &f->c;
542 uint8_t state[CONTEXT_SIZE];
544 uint8_t state2[32][CONTEXT_SIZE];
547 memset(state2, 128, sizeof(state2));
548 memset(state, 128, sizeof(state));
550 f->avctx->extradata_size = 10000 + 4 +
551 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
552 f->avctx->extradata = av_malloc(f->avctx->extradata_size);
553 if (!f->avctx->extradata)
554 return AVERROR(ENOMEM);
555 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
556 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
558 put_symbol(c, state, f->version, 0);
559 if (f->version > 2) {
561 f->micro_version = 4;
562 put_symbol(c, state, f->micro_version, 0);
565 put_symbol(c, state, f->ac, 0);
567 for (i = 1; i < 256; i++)
568 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
570 put_symbol(c, state, f->colorspace, 0); // YUV cs type
571 put_symbol(c, state, f->bits_per_raw_sample, 0);
572 put_rac(c, state, f->chroma_planes);
573 put_symbol(c, state, f->chroma_h_shift, 0);
574 put_symbol(c, state, f->chroma_v_shift, 0);
575 put_rac(c, state, f->transparency);
576 put_symbol(c, state, f->num_h_slices - 1, 0);
577 put_symbol(c, state, f->num_v_slices - 1, 0);
579 put_symbol(c, state, f->quant_table_count, 0);
580 for (i = 0; i < f->quant_table_count; i++)
581 write_quant_tables(c, f->quant_tables[i]);
583 for (i = 0; i < f->quant_table_count; i++) {
584 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
585 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
587 if (j < f->context_count[i] * CONTEXT_SIZE) {
588 put_rac(c, state, 1);
589 for (j = 0; j < f->context_count[i]; j++)
590 for (k = 0; k < CONTEXT_SIZE; k++) {
591 int pred = j ? f->initial_states[i][j - 1][k] : 128;
592 put_symbol(c, state2[k],
593 (int8_t)(f->initial_states[i][j][k] - pred), 1);
596 put_rac(c, state, 0);
600 if (f->version > 2) {
601 put_symbol(c, state, f->ec, 0);
602 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
605 f->avctx->extradata_size = ff_rac_terminate(c);
606 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
607 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
608 f->avctx->extradata_size += 4;
613 static int sort_stt(FFV1Context *s, uint8_t stt[256])
615 int i, i2, changed, print = 0;
619 for (i = 12; i < 244; i++) {
620 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
622 #define COST(old, new) \
623 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
624 s->rc_stat[old][1] * -log2((new) / 256.0)
626 #define COST2(old, new) \
627 COST(old, new) + COST(256 - (old), 256 - (new))
629 double size0 = COST2(i, i) + COST2(i2, i2);
630 double sizeX = COST2(i, i2) + COST2(i2, i);
631 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
633 FFSWAP(int, stt[i], stt[i2]);
634 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
635 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
637 FFSWAP(int, stt[256 - i], stt[256 - i2]);
638 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
639 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
641 for (j = 1; j < 256; j++) {
644 else if (stt[j] == i2)
647 if (stt[256 - j] == 256 - i)
648 stt[256 - j] = 256 - i2;
649 else if (stt[256 - j] == 256 - i2)
650 stt[256 - j] = 256 - i;
661 static av_cold int encode_init(AVCodecContext *avctx)
663 FFV1Context *s = avctx->priv_data;
664 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
667 if ((ret = ffv1_common_init(avctx)) < 0)
672 if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
673 s->version = FFMAX(s->version, 2);
675 if (avctx->level == 3 || (avctx->level <= 0 && s->version == 2)) {
680 s->ec = (s->version >= 3);
683 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
684 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
685 return AVERROR_INVALIDDATA;
688 s->ac = avctx->coder_type > 0 ? 2 : 0;
691 switch(avctx->pix_fmt) {
692 case AV_PIX_FMT_YUV444P9:
693 case AV_PIX_FMT_YUV422P9:
694 case AV_PIX_FMT_YUV420P9:
695 case AV_PIX_FMT_YUVA444P9:
696 case AV_PIX_FMT_YUVA422P9:
697 case AV_PIX_FMT_YUVA420P9:
698 if (!avctx->bits_per_raw_sample)
699 s->bits_per_raw_sample = 9;
700 case AV_PIX_FMT_YUV444P10:
701 case AV_PIX_FMT_YUV420P10:
702 case AV_PIX_FMT_YUV422P10:
703 case AV_PIX_FMT_YUVA444P10:
704 case AV_PIX_FMT_YUVA422P10:
705 case AV_PIX_FMT_YUVA420P10:
706 s->packed_at_lsb = 1;
707 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
708 s->bits_per_raw_sample = 10;
709 case AV_PIX_FMT_GRAY16:
710 case AV_PIX_FMT_YUV444P16:
711 case AV_PIX_FMT_YUV422P16:
712 case AV_PIX_FMT_YUV420P16:
713 case AV_PIX_FMT_YUVA444P16:
714 case AV_PIX_FMT_YUVA422P16:
715 case AV_PIX_FMT_YUVA420P16:
716 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
717 s->bits_per_raw_sample = 16;
718 } else if (!s->bits_per_raw_sample) {
719 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
721 if (s->bits_per_raw_sample <= 8) {
722 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
723 return AVERROR_INVALIDDATA;
725 if (!s->ac && avctx->coder_type == -1) {
726 av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
730 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
731 return AVERROR(ENOSYS);
733 s->version = FFMAX(s->version, 1);
734 case AV_PIX_FMT_GRAY8:
735 case AV_PIX_FMT_YUV444P:
736 case AV_PIX_FMT_YUV440P:
737 case AV_PIX_FMT_YUV422P:
738 case AV_PIX_FMT_YUV420P:
739 case AV_PIX_FMT_YUV411P:
740 case AV_PIX_FMT_YUV410P:
741 case AV_PIX_FMT_YUVA444P:
742 case AV_PIX_FMT_YUVA422P:
743 case AV_PIX_FMT_YUVA420P:
744 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
746 s->transparency = desc->nb_components == 4;
748 case AV_PIX_FMT_RGB32:
751 s->chroma_planes = 1;
753 case AV_PIX_FMT_0RGB32:
755 s->chroma_planes = 1;
757 case AV_PIX_FMT_GBRP9:
758 if (!avctx->bits_per_raw_sample)
759 s->bits_per_raw_sample = 9;
760 case AV_PIX_FMT_GBRP10:
761 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
762 s->bits_per_raw_sample = 10;
763 case AV_PIX_FMT_GBRP12:
764 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
765 s->bits_per_raw_sample = 12;
766 case AV_PIX_FMT_GBRP14:
767 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
768 s->bits_per_raw_sample = 14;
769 else if (!s->bits_per_raw_sample)
770 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
772 s->chroma_planes = 1;
773 s->version = FFMAX(s->version, 1);
775 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
776 return AVERROR(ENOSYS);
780 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
781 return AVERROR(ENOSYS);
783 if (s->transparency) {
784 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
786 if (avctx->context_model > 1U) {
787 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
788 return AVERROR(EINVAL);
792 for (i = 1; i < 256; i++)
793 s->state_transition[i] = ver2_state[i];
795 for (i = 0; i < 256; i++) {
796 s->quant_table_count = 2;
797 if (s->bits_per_raw_sample <= 8) {
798 s->quant_tables[0][0][i]= quant11[i];
799 s->quant_tables[0][1][i]= 11*quant11[i];
800 s->quant_tables[0][2][i]= 11*11*quant11[i];
801 s->quant_tables[1][0][i]= quant11[i];
802 s->quant_tables[1][1][i]= 11*quant11[i];
803 s->quant_tables[1][2][i]= 11*11*quant5 [i];
804 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
805 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
807 s->quant_tables[0][0][i]= quant9_10bit[i];
808 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
809 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
810 s->quant_tables[1][0][i]= quant9_10bit[i];
811 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
812 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
813 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
814 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
817 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
818 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
819 memcpy(s->quant_table, s->quant_tables[avctx->context_model],
820 sizeof(s->quant_table));
822 for (i = 0; i < s->plane_count; i++) {
823 PlaneContext *const p = &s->plane[i];
825 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
826 p->quant_table_index = avctx->context_model;
827 p->context_count = s->context_count[p->quant_table_index];
830 if ((ret = ffv1_allocate_initial_states(s)) < 0)
833 avctx->coded_frame = av_frame_alloc();
834 if (!avctx->coded_frame)
835 return AVERROR(ENOMEM);
837 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
839 if (!s->transparency)
841 if (!s->chroma_planes && s->version > 3)
844 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
845 s->picture_number = 0;
847 if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
848 for (i = 0; i < s->quant_table_count; i++) {
849 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
850 sizeof(*s->rc_stat2[i]));
852 return AVERROR(ENOMEM);
855 if (avctx->stats_in) {
856 char *p = avctx->stats_in;
857 uint8_t best_state[256][256];
861 av_assert0(s->version >= 2);
864 for (j = 0; j < 256; j++)
865 for (i = 0; i < 2; i++) {
866 s->rc_stat[j][i] = strtol(p, &next, 0);
868 av_log(avctx, AV_LOG_ERROR,
869 "2Pass file invalid at %d %d [%s]\n", j, i, p);
870 return AVERROR_INVALIDDATA;
874 for (i = 0; i < s->quant_table_count; i++)
875 for (j = 0; j < s->context_count[i]; j++) {
876 for (k = 0; k < 32; k++)
877 for (m = 0; m < 2; m++) {
878 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
880 av_log(avctx, AV_LOG_ERROR,
881 "2Pass file invalid at %d %d %d %d [%s]\n",
883 return AVERROR_INVALIDDATA;
888 gob_count = strtol(p, &next, 0);
889 if (next == p || gob_count <= 0) {
890 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
891 return AVERROR_INVALIDDATA;
894 while (*p == '\n' || *p == ' ')
899 sort_stt(s, s->state_transition);
901 find_best_state(best_state, s->state_transition);
903 for (i = 0; i < s->quant_table_count; i++) {
904 for (k = 0; k < 32; k++) {
907 for (j = 0; j < s->context_count[i]; j++) {
909 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
911 p = 256.0 * b / (a + b);
912 s->initial_states[i][jp][k] =
913 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
914 for(jp++; jp<j; jp++)
915 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
918 a += s->rc_stat2[i][j][k][0];
919 b += s->rc_stat2[i][j][k][1];
921 p = 256.0 * b / (a + b);
923 s->initial_states[i][j][k] =
924 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
930 if (s->version > 1) {
931 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
932 for (; s->num_v_slices < 9; s->num_v_slices++) {
933 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
934 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
938 av_log(avctx, AV_LOG_ERROR,
939 "Unsupported number %d of slices requested, please specify a "
940 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
942 return AVERROR(ENOSYS);
944 if ((ret = write_extradata(s)) < 0)
948 if ((ret = ffv1_init_slice_contexts(s)) < 0)
950 if ((ret = ffv1_init_slices_state(s)) < 0)
953 #define STATS_OUT_SIZE 1024 * 1024 * 6
954 if (avctx->flags & CODEC_FLAG_PASS1) {
955 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
956 if (!avctx->stats_out)
957 return AVERROR(ENOMEM);
958 for (i = 0; i < s->quant_table_count; i++)
959 for (j = 0; j < s->slice_count; j++) {
960 FFV1Context *sf = s->slice_context[j];
961 av_assert0(!sf->rc_stat2[i]);
962 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
963 sizeof(*sf->rc_stat2[i]));
964 if (!sf->rc_stat2[i])
965 return AVERROR(ENOMEM);
972 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
974 RangeCoder *c = &fs->c;
975 uint8_t state[CONTEXT_SIZE];
977 memset(state, 128, sizeof(state));
979 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
980 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
981 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
982 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
983 for (j=0; j<f->plane_count; j++) {
984 put_symbol(c, state, f->plane[j].quant_table_index, 0);
985 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
987 if (!f->picture.f->interlaced_frame)
988 put_symbol(c, state, 3, 0);
990 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
991 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
992 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
993 if (f->version > 3) {
994 put_rac(c, state, fs->slice_coding_mode == 1);
995 if (fs->slice_coding_mode == 1)
996 ffv1_clear_slice_state(f, fs);
997 put_symbol(c, state, fs->slice_coding_mode, 0);
1001 static int encode_slice(AVCodecContext *c, void *arg)
1003 FFV1Context *fs = *(void **)arg;
1004 FFV1Context *f = fs->avctx->priv_data;
1005 int width = fs->slice_width;
1006 int height = fs->slice_height;
1007 int x = fs->slice_x;
1008 int y = fs->slice_y;
1009 const AVFrame *const p = f->picture.f;
1010 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
1012 RangeCoder c_bak = fs->c;
1014 fs->slice_coding_mode = 0;
1017 if (c->coded_frame->key_frame)
1018 ffv1_clear_slice_state(f, fs);
1019 if (f->version > 2) {
1020 encode_slice_header(f, fs);
1024 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1025 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1026 init_put_bits(&fs->pb,
1027 fs->c.bytestream_start + fs->ac_byte_count,
1028 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1031 if (f->colorspace == 0) {
1032 const int chroma_width = FF_CEIL_RSHIFT(width, f->chroma_h_shift);
1033 const int chroma_height = FF_CEIL_RSHIFT(height, f->chroma_v_shift);
1034 const int cx = x >> f->chroma_h_shift;
1035 const int cy = y >> f->chroma_v_shift;
1037 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1039 if (f->chroma_planes) {
1040 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1041 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1043 if (fs->transparency)
1044 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1046 uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1047 p->data[1] + ps*x + y*p->linesize[1],
1048 p->data[2] + ps*x + y*p->linesize[2]};
1049 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1054 av_assert0(fs->slice_coding_mode == 0);
1055 if (fs->version < 4 || !fs->ac) {
1056 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1059 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1060 fs->slice_coding_mode = 1;
1068 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1069 const AVFrame *pict, int *got_packet)
1071 FFV1Context *f = avctx->priv_data;
1072 RangeCoder *const c = &f->slice_context[0]->c;
1073 AVFrame *const p = f->picture.f;
1075 uint8_t keystate = 128;
1078 int64_t maxsize = FF_MIN_BUFFER_SIZE
1079 + avctx->width*avctx->height*35LL*4;
1082 if (avctx->flags & CODEC_FLAG_PASS1) {
1084 char *p = avctx->stats_out;
1085 char *end = p + STATS_OUT_SIZE;
1087 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1088 for (i = 0; i < f->quant_table_count; i++)
1089 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1091 for (j = 0; j < f->slice_count; j++) {
1092 FFV1Context *fs = f->slice_context[j];
1093 for (i = 0; i < 256; i++) {
1094 f->rc_stat[i][0] += fs->rc_stat[i][0];
1095 f->rc_stat[i][1] += fs->rc_stat[i][1];
1097 for (i = 0; i < f->quant_table_count; i++) {
1098 for (k = 0; k < f->context_count[i]; k++)
1099 for (m = 0; m < 32; m++) {
1100 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1101 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1106 for (j = 0; j < 256; j++) {
1107 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1108 f->rc_stat[j][0], f->rc_stat[j][1]);
1111 snprintf(p, end - p, "\n");
1113 for (i = 0; i < f->quant_table_count; i++) {
1114 for (j = 0; j < f->context_count[i]; j++)
1115 for (m = 0; m < 32; m++) {
1116 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1117 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1121 snprintf(p, end - p, "%d\n", f->gob_count);
1127 maxsize = FF_MIN_BUFFER_SIZE + avctx->width*avctx->height*3LL*4;
1129 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize)) < 0)
1132 ff_init_range_encoder(c, pkt->data, pkt->size);
1133 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1136 if ((ret = av_frame_ref(p, pict)) < 0)
1138 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1140 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1141 put_rac(c, &keystate, 1);
1142 avctx->coded_frame->key_frame = 1;
1146 put_rac(c, &keystate, 0);
1147 avctx->coded_frame->key_frame = 0;
1152 for (i = 1; i < 256; i++) {
1153 c->one_state[i] = f->state_transition[i];
1154 c->zero_state[256 - i] = 256 - c->one_state[i];
1158 for (i = 1; i < f->slice_count; i++) {
1159 FFV1Context *fs = f->slice_context[i];
1160 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1161 int len = pkt->size / f->slice_count;
1162 ff_init_range_encoder(&fs->c, start, len);
1164 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1165 f->slice_count, sizeof(void *));
1168 for (i = 0; i < f->slice_count; i++) {
1169 FFV1Context *fs = f->slice_context[i];
1173 uint8_t state = 129;
1174 put_rac(&fs->c, &state, 0);
1175 bytes = ff_rac_terminate(&fs->c);
1177 flush_put_bits(&fs->pb); // FIXME: nicer padding
1178 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1180 if (i > 0 || f->version > 2) {
1181 av_assert0(bytes < pkt->size / f->slice_count);
1182 memmove(buf_p, fs->c.bytestream_start, bytes);
1183 av_assert0(bytes < (1 << 24));
1184 AV_WB24(buf_p + bytes, bytes);
1190 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1191 AV_WL32(buf_p + bytes, v);
1197 if (avctx->flags & CODEC_FLAG_PASS1)
1198 avctx->stats_out[0] = '\0';
1200 f->picture_number++;
1201 pkt->size = buf_p - pkt->data;
1203 pkt->dts = pict->pts;
1204 pkt->flags |= AV_PKT_FLAG_KEY * avctx->coded_frame->key_frame;
1210 static av_cold int encode_close(AVCodecContext *avctx)
1212 av_frame_free(&avctx->coded_frame);
1217 #define OFFSET(x) offsetof(FFV1Context, x)
1218 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1219 static const AVOption options[] = {
1220 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1224 static const AVClass ffv1_class = {
1225 .class_name = "ffv1 encoder",
1226 .item_name = av_default_item_name,
1228 .version = LIBAVUTIL_VERSION_INT,
1231 static const AVCodecDefault ffv1_defaults[] = {
1236 AVCodec ff_ffv1_encoder = {
1238 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1239 .type = AVMEDIA_TYPE_VIDEO,
1240 .id = AV_CODEC_ID_FFV1,
1241 .priv_data_size = sizeof(FFV1Context),
1242 .init = encode_init,
1243 .encode2 = encode_frame,
1244 .close = encode_close,
1245 .capabilities = CODEC_CAP_SLICE_THREADS | CODEC_CAP_DELAY,
1246 .pix_fmts = (const enum AVPixelFormat[]) {
1247 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1248 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1249 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1250 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1251 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1252 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1253 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1254 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1255 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1256 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1260 .defaults = ffv1_defaults,
1261 .priv_class = &ffv1_class,