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);
776 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
777 return AVERROR(ENOSYS);
779 if (s->transparency) {
780 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
782 if (avctx->context_model > 1U) {
783 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
784 return AVERROR(EINVAL);
788 for (i = 1; i < 256; i++)
789 s->state_transition[i] = ver2_state[i];
791 for (i = 0; i < 256; i++) {
792 s->quant_table_count = 2;
793 if (s->bits_per_raw_sample <= 8) {
794 s->quant_tables[0][0][i]= quant11[i];
795 s->quant_tables[0][1][i]= 11*quant11[i];
796 s->quant_tables[0][2][i]= 11*11*quant11[i];
797 s->quant_tables[1][0][i]= quant11[i];
798 s->quant_tables[1][1][i]= 11*quant11[i];
799 s->quant_tables[1][2][i]= 11*11*quant5 [i];
800 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
801 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
803 s->quant_tables[0][0][i]= quant9_10bit[i];
804 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
805 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
806 s->quant_tables[1][0][i]= quant9_10bit[i];
807 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
808 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
809 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
810 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
813 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
814 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
815 memcpy(s->quant_table, s->quant_tables[avctx->context_model],
816 sizeof(s->quant_table));
818 for (i = 0; i < s->plane_count; i++) {
819 PlaneContext *const p = &s->plane[i];
821 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
822 p->quant_table_index = avctx->context_model;
823 p->context_count = s->context_count[p->quant_table_index];
826 if ((ret = ffv1_allocate_initial_states(s)) < 0)
829 if (!s->transparency)
831 if (!s->chroma_planes && s->version > 3)
834 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
835 s->picture_number = 0;
837 if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
838 for (i = 0; i < s->quant_table_count; i++) {
839 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
840 sizeof(*s->rc_stat2[i]));
842 return AVERROR(ENOMEM);
845 if (avctx->stats_in) {
846 char *p = avctx->stats_in;
847 uint8_t best_state[256][256];
851 av_assert0(s->version >= 2);
854 for (j = 0; j < 256; j++)
855 for (i = 0; i < 2; i++) {
856 s->rc_stat[j][i] = strtol(p, &next, 0);
858 av_log(avctx, AV_LOG_ERROR,
859 "2Pass file invalid at %d %d [%s]\n", j, i, p);
860 return AVERROR_INVALIDDATA;
864 for (i = 0; i < s->quant_table_count; i++)
865 for (j = 0; j < s->context_count[i]; j++) {
866 for (k = 0; k < 32; k++)
867 for (m = 0; m < 2; m++) {
868 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
870 av_log(avctx, AV_LOG_ERROR,
871 "2Pass file invalid at %d %d %d %d [%s]\n",
873 return AVERROR_INVALIDDATA;
878 gob_count = strtol(p, &next, 0);
879 if (next == p || gob_count <= 0) {
880 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
881 return AVERROR_INVALIDDATA;
884 while (*p == '\n' || *p == ' ')
889 sort_stt(s, s->state_transition);
891 find_best_state(best_state, s->state_transition);
893 for (i = 0; i < s->quant_table_count; i++) {
894 for (k = 0; k < 32; k++) {
897 for (j = 0; j < s->context_count[i]; j++) {
899 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
901 p = 256.0 * b / (a + b);
902 s->initial_states[i][jp][k] =
903 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
904 for(jp++; jp<j; jp++)
905 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
908 a += s->rc_stat2[i][j][k][0];
909 b += s->rc_stat2[i][j][k][1];
911 p = 256.0 * b / (a + b);
913 s->initial_states[i][j][k] =
914 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
920 if (s->version > 1) {
921 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
922 for (; s->num_v_slices < 9; s->num_v_slices++) {
923 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
924 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
928 av_log(avctx, AV_LOG_ERROR,
929 "Unsupported number %d of slices requested, please specify a "
930 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
932 return AVERROR(ENOSYS);
934 if ((ret = write_extradata(s)) < 0)
938 if ((ret = ffv1_init_slice_contexts(s)) < 0)
940 if ((ret = ffv1_init_slices_state(s)) < 0)
943 #define STATS_OUT_SIZE 1024 * 1024 * 6
944 if (avctx->flags & CODEC_FLAG_PASS1) {
945 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
946 if (!avctx->stats_out)
947 return AVERROR(ENOMEM);
948 for (i = 0; i < s->quant_table_count; i++)
949 for (j = 0; j < s->slice_count; j++) {
950 FFV1Context *sf = s->slice_context[j];
951 av_assert0(!sf->rc_stat2[i]);
952 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
953 sizeof(*sf->rc_stat2[i]));
954 if (!sf->rc_stat2[i])
955 return AVERROR(ENOMEM);
962 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
964 RangeCoder *c = &fs->c;
965 uint8_t state[CONTEXT_SIZE];
967 memset(state, 128, sizeof(state));
969 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
970 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
971 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
972 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
973 for (j=0; j<f->plane_count; j++) {
974 put_symbol(c, state, f->plane[j].quant_table_index, 0);
975 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
977 if (!f->picture.f->interlaced_frame)
978 put_symbol(c, state, 3, 0);
980 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
981 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
982 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
983 if (f->version > 3) {
984 put_rac(c, state, fs->slice_coding_mode == 1);
985 if (fs->slice_coding_mode == 1)
986 ffv1_clear_slice_state(f, fs);
987 put_symbol(c, state, fs->slice_coding_mode, 0);
991 static int encode_slice(AVCodecContext *c, void *arg)
993 FFV1Context *fs = *(void **)arg;
994 FFV1Context *f = fs->avctx->priv_data;
995 int width = fs->slice_width;
996 int height = fs->slice_height;
999 AVFrame *const p = f->picture.f;
1000 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
1002 RangeCoder c_bak = fs->c;
1004 fs->slice_coding_mode = 0;
1008 ffv1_clear_slice_state(f, fs);
1009 if (f->version > 2) {
1010 encode_slice_header(f, fs);
1014 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1015 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1016 init_put_bits(&fs->pb,
1017 fs->c.bytestream_start + fs->ac_byte_count,
1018 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1021 if (f->colorspace == 0) {
1022 const int chroma_width = FF_CEIL_RSHIFT(width, f->chroma_h_shift);
1023 const int chroma_height = FF_CEIL_RSHIFT(height, f->chroma_v_shift);
1024 const int cx = x >> f->chroma_h_shift;
1025 const int cy = y >> f->chroma_v_shift;
1027 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1029 if (f->chroma_planes) {
1030 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1031 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1033 if (fs->transparency)
1034 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1036 uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1037 p->data[1] + ps*x + y*p->linesize[1],
1038 p->data[2] + ps*x + y*p->linesize[2]};
1039 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1044 av_assert0(fs->slice_coding_mode == 0);
1045 if (fs->version < 4 || !fs->ac) {
1046 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1049 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1050 fs->slice_coding_mode = 1;
1058 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1059 const AVFrame *pict, int *got_packet)
1061 FFV1Context *f = avctx->priv_data;
1062 RangeCoder *const c = &f->slice_context[0]->c;
1063 AVFrame *const p = f->picture.f;
1065 uint8_t keystate = 128;
1068 int64_t maxsize = FF_MIN_BUFFER_SIZE
1069 + avctx->width*avctx->height*35LL*4;
1072 maxsize = FF_MIN_BUFFER_SIZE + avctx->width*avctx->height*3*4;
1074 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize)) < 0)
1077 ff_init_range_encoder(c, pkt->data, pkt->size);
1078 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1081 if ((ret = av_frame_ref(p, pict)) < 0)
1083 p->pict_type = AV_PICTURE_TYPE_I;
1085 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1086 put_rac(c, &keystate, 1);
1091 put_rac(c, &keystate, 0);
1097 for (i = 1; i < 256; i++) {
1098 c->one_state[i] = f->state_transition[i];
1099 c->zero_state[256 - i] = 256 - c->one_state[i];
1103 for (i = 1; i < f->slice_count; i++) {
1104 FFV1Context *fs = f->slice_context[i];
1105 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1106 int len = pkt->size / f->slice_count;
1107 ff_init_range_encoder(&fs->c, start, len);
1109 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1110 f->slice_count, sizeof(void *));
1113 for (i = 0; i < f->slice_count; i++) {
1114 FFV1Context *fs = f->slice_context[i];
1118 uint8_t state = 129;
1119 put_rac(&fs->c, &state, 0);
1120 bytes = ff_rac_terminate(&fs->c);
1122 flush_put_bits(&fs->pb); // FIXME: nicer padding
1123 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1125 if (i > 0 || f->version > 2) {
1126 av_assert0(bytes < pkt->size / f->slice_count);
1127 memmove(buf_p, fs->c.bytestream_start, bytes);
1128 av_assert0(bytes < (1 << 24));
1129 AV_WB24(buf_p + bytes, bytes);
1135 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1136 AV_WL32(buf_p + bytes, v);
1142 if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
1144 char *p = avctx->stats_out;
1145 char *end = p + STATS_OUT_SIZE;
1147 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1148 for (i = 0; i < f->quant_table_count; i++)
1149 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1151 for (j = 0; j < f->slice_count; j++) {
1152 FFV1Context *fs = f->slice_context[j];
1153 for (i = 0; i < 256; i++) {
1154 f->rc_stat[i][0] += fs->rc_stat[i][0];
1155 f->rc_stat[i][1] += fs->rc_stat[i][1];
1157 for (i = 0; i < f->quant_table_count; i++) {
1158 for (k = 0; k < f->context_count[i]; k++)
1159 for (m = 0; m < 32; m++) {
1160 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1161 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1166 for (j = 0; j < 256; j++) {
1167 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1168 f->rc_stat[j][0], f->rc_stat[j][1]);
1171 snprintf(p, end - p, "\n");
1173 for (i = 0; i < f->quant_table_count; i++) {
1174 for (j = 0; j < f->context_count[i]; j++)
1175 for (m = 0; m < 32; m++) {
1176 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1177 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1181 snprintf(p, end - p, "%d\n", f->gob_count);
1182 } else if (avctx->flags & CODEC_FLAG_PASS1)
1183 avctx->stats_out[0] = '\0';
1185 f->picture_number++;
1186 pkt->size = buf_p - pkt->data;
1187 pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
1193 #define OFFSET(x) offsetof(FFV1Context, x)
1194 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1195 static const AVOption options[] = {
1196 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1200 static const AVClass ffv1_class = {
1201 .class_name = "ffv1 encoder",
1202 .item_name = av_default_item_name,
1204 .version = LIBAVUTIL_VERSION_INT,
1207 static const AVCodecDefault ffv1_defaults[] = {
1212 AVCodec ff_ffv1_encoder = {
1214 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1215 .type = AVMEDIA_TYPE_VIDEO,
1216 .id = AV_CODEC_ID_FFV1,
1217 .priv_data_size = sizeof(FFV1Context),
1218 .init = encode_init,
1219 .encode2 = encode_frame,
1220 .close = ffv1_close,
1221 .capabilities = CODEC_CAP_SLICE_THREADS,
1222 .pix_fmts = (const enum AVPixelFormat[]) {
1223 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1224 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1225 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1226 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1227 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1228 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1229 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1230 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1231 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1232 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1236 .defaults = ffv1_defaults,
1237 .priv_class = &ffv1_class,