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) {
444 g += (b * s->slice_rct_by_coef + r * s->slice_rct_ry_coef) >> 2;
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) {
560 if (f->version == 3) {
561 f->micro_version = 4;
562 } else if (f->version == 4)
563 f->micro_version = 2;
564 put_symbol(c, state, f->micro_version, 0);
567 put_symbol(c, state, f->ac, 0);
569 for (i = 1; i < 256; i++)
570 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
572 put_symbol(c, state, f->colorspace, 0); // YUV cs type
573 put_symbol(c, state, f->bits_per_raw_sample, 0);
574 put_rac(c, state, f->chroma_planes);
575 put_symbol(c, state, f->chroma_h_shift, 0);
576 put_symbol(c, state, f->chroma_v_shift, 0);
577 put_rac(c, state, f->transparency);
578 put_symbol(c, state, f->num_h_slices - 1, 0);
579 put_symbol(c, state, f->num_v_slices - 1, 0);
581 put_symbol(c, state, f->quant_table_count, 0);
582 for (i = 0; i < f->quant_table_count; i++)
583 write_quant_tables(c, f->quant_tables[i]);
585 for (i = 0; i < f->quant_table_count; i++) {
586 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
587 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
589 if (j < f->context_count[i] * CONTEXT_SIZE) {
590 put_rac(c, state, 1);
591 for (j = 0; j < f->context_count[i]; j++)
592 for (k = 0; k < CONTEXT_SIZE; k++) {
593 int pred = j ? f->initial_states[i][j - 1][k] : 128;
594 put_symbol(c, state2[k],
595 (int8_t)(f->initial_states[i][j][k] - pred), 1);
598 put_rac(c, state, 0);
602 if (f->version > 2) {
603 put_symbol(c, state, f->ec, 0);
604 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
607 f->avctx->extradata_size = ff_rac_terminate(c);
608 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
609 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
610 f->avctx->extradata_size += 4;
615 static int sort_stt(FFV1Context *s, uint8_t stt[256])
617 int i, i2, changed, print = 0;
621 for (i = 12; i < 244; i++) {
622 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
624 #define COST(old, new) \
625 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
626 s->rc_stat[old][1] * -log2((new) / 256.0)
628 #define COST2(old, new) \
629 COST(old, new) + COST(256 - (old), 256 - (new))
631 double size0 = COST2(i, i) + COST2(i2, i2);
632 double sizeX = COST2(i, i2) + COST2(i2, i);
633 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
635 FFSWAP(int, stt[i], stt[i2]);
636 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
637 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
639 FFSWAP(int, stt[256 - i], stt[256 - i2]);
640 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
641 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
643 for (j = 1; j < 256; j++) {
646 else if (stt[j] == i2)
649 if (stt[256 - j] == 256 - i)
650 stt[256 - j] = 256 - i2;
651 else if (stt[256 - j] == 256 - i2)
652 stt[256 - j] = 256 - i;
663 static av_cold int encode_init(AVCodecContext *avctx)
665 FFV1Context *s = avctx->priv_data;
666 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
669 if ((ret = ffv1_common_init(avctx)) < 0)
674 if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
675 s->version = FFMAX(s->version, 2);
677 if (avctx->level <= 0 && s->version == 2) {
680 if (avctx->level >= 0 && avctx->level <= 4)
681 s->version = FFMAX(s->version, avctx->level);
684 s->ec = (s->version >= 3);
687 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
688 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
689 return AVERROR_INVALIDDATA;
692 s->ac = avctx->coder_type > 0 ? 2 : 0;
695 switch(avctx->pix_fmt) {
696 case AV_PIX_FMT_YUV444P9:
697 case AV_PIX_FMT_YUV422P9:
698 case AV_PIX_FMT_YUV420P9:
699 case AV_PIX_FMT_YUVA444P9:
700 case AV_PIX_FMT_YUVA422P9:
701 case AV_PIX_FMT_YUVA420P9:
702 if (!avctx->bits_per_raw_sample)
703 s->bits_per_raw_sample = 9;
704 case AV_PIX_FMT_YUV444P10:
705 case AV_PIX_FMT_YUV420P10:
706 case AV_PIX_FMT_YUV422P10:
707 case AV_PIX_FMT_YUVA444P10:
708 case AV_PIX_FMT_YUVA422P10:
709 case AV_PIX_FMT_YUVA420P10:
710 s->packed_at_lsb = 1;
711 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
712 s->bits_per_raw_sample = 10;
713 case AV_PIX_FMT_GRAY16:
714 case AV_PIX_FMT_YUV444P16:
715 case AV_PIX_FMT_YUV422P16:
716 case AV_PIX_FMT_YUV420P16:
717 case AV_PIX_FMT_YUVA444P16:
718 case AV_PIX_FMT_YUVA422P16:
719 case AV_PIX_FMT_YUVA420P16:
720 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
721 s->bits_per_raw_sample = 16;
722 } else if (!s->bits_per_raw_sample) {
723 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
725 if (s->bits_per_raw_sample <= 8) {
726 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
727 return AVERROR_INVALIDDATA;
729 if (!s->ac && avctx->coder_type == -1) {
730 av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
734 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
735 return AVERROR(ENOSYS);
737 s->version = FFMAX(s->version, 1);
738 case AV_PIX_FMT_GRAY8:
739 case AV_PIX_FMT_YUV444P:
740 case AV_PIX_FMT_YUV440P:
741 case AV_PIX_FMT_YUV422P:
742 case AV_PIX_FMT_YUV420P:
743 case AV_PIX_FMT_YUV411P:
744 case AV_PIX_FMT_YUV410P:
745 case AV_PIX_FMT_YUVA444P:
746 case AV_PIX_FMT_YUVA422P:
747 case AV_PIX_FMT_YUVA420P:
748 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
750 s->transparency = desc->nb_components == 4;
752 case AV_PIX_FMT_RGB32:
755 s->chroma_planes = 1;
757 case AV_PIX_FMT_0RGB32:
759 s->chroma_planes = 1;
761 case AV_PIX_FMT_GBRP9:
762 if (!avctx->bits_per_raw_sample)
763 s->bits_per_raw_sample = 9;
764 case AV_PIX_FMT_GBRP10:
765 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
766 s->bits_per_raw_sample = 10;
767 case AV_PIX_FMT_GBRP12:
768 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
769 s->bits_per_raw_sample = 12;
770 case AV_PIX_FMT_GBRP14:
771 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
772 s->bits_per_raw_sample = 14;
773 else if (!s->bits_per_raw_sample)
774 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
776 s->chroma_planes = 1;
777 s->version = FFMAX(s->version, 1);
779 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
780 return AVERROR(ENOSYS);
784 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
785 return AVERROR(ENOSYS);
787 if (s->transparency) {
788 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
790 if (avctx->context_model > 1U) {
791 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
792 return AVERROR(EINVAL);
796 for (i = 1; i < 256; i++)
797 s->state_transition[i] = ver2_state[i];
799 for (i = 0; i < 256; i++) {
800 s->quant_table_count = 2;
801 if (s->bits_per_raw_sample <= 8) {
802 s->quant_tables[0][0][i]= quant11[i];
803 s->quant_tables[0][1][i]= 11*quant11[i];
804 s->quant_tables[0][2][i]= 11*11*quant11[i];
805 s->quant_tables[1][0][i]= quant11[i];
806 s->quant_tables[1][1][i]= 11*quant11[i];
807 s->quant_tables[1][2][i]= 11*11*quant5 [i];
808 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
809 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
811 s->quant_tables[0][0][i]= quant9_10bit[i];
812 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
813 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
814 s->quant_tables[1][0][i]= quant9_10bit[i];
815 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
816 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
817 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
818 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
821 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
822 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
823 memcpy(s->quant_table, s->quant_tables[avctx->context_model],
824 sizeof(s->quant_table));
826 for (i = 0; i < s->plane_count; i++) {
827 PlaneContext *const p = &s->plane[i];
829 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
830 p->quant_table_index = avctx->context_model;
831 p->context_count = s->context_count[p->quant_table_index];
834 if ((ret = ffv1_allocate_initial_states(s)) < 0)
837 avctx->coded_frame = av_frame_alloc();
838 if (!avctx->coded_frame)
839 return AVERROR(ENOMEM);
841 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
843 if (!s->transparency)
845 if (!s->chroma_planes && s->version > 3)
848 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
849 s->picture_number = 0;
851 if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
852 for (i = 0; i < s->quant_table_count; i++) {
853 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
854 sizeof(*s->rc_stat2[i]));
856 return AVERROR(ENOMEM);
859 if (avctx->stats_in) {
860 char *p = avctx->stats_in;
861 uint8_t best_state[256][256];
865 av_assert0(s->version >= 2);
868 for (j = 0; j < 256; j++)
869 for (i = 0; i < 2; i++) {
870 s->rc_stat[j][i] = strtol(p, &next, 0);
872 av_log(avctx, AV_LOG_ERROR,
873 "2Pass file invalid at %d %d [%s]\n", j, i, p);
874 return AVERROR_INVALIDDATA;
878 for (i = 0; i < s->quant_table_count; i++)
879 for (j = 0; j < s->context_count[i]; j++) {
880 for (k = 0; k < 32; k++)
881 for (m = 0; m < 2; m++) {
882 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
884 av_log(avctx, AV_LOG_ERROR,
885 "2Pass file invalid at %d %d %d %d [%s]\n",
887 return AVERROR_INVALIDDATA;
892 gob_count = strtol(p, &next, 0);
893 if (next == p || gob_count <= 0) {
894 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
895 return AVERROR_INVALIDDATA;
898 while (*p == '\n' || *p == ' ')
903 sort_stt(s, s->state_transition);
905 find_best_state(best_state, s->state_transition);
907 for (i = 0; i < s->quant_table_count; i++) {
908 for (k = 0; k < 32; k++) {
911 for (j = 0; j < s->context_count[i]; j++) {
913 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
915 p = 256.0 * b / (a + b);
916 s->initial_states[i][jp][k] =
917 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
918 for(jp++; jp<j; jp++)
919 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
922 a += s->rc_stat2[i][j][k][0];
923 b += s->rc_stat2[i][j][k][1];
925 p = 256.0 * b / (a + b);
927 s->initial_states[i][j][k] =
928 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
934 if (s->version > 1) {
935 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
936 for (; s->num_v_slices < 9; s->num_v_slices++) {
937 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
938 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
942 av_log(avctx, AV_LOG_ERROR,
943 "Unsupported number %d of slices requested, please specify a "
944 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
946 return AVERROR(ENOSYS);
948 if ((ret = write_extradata(s)) < 0)
952 if ((ret = ffv1_init_slice_contexts(s)) < 0)
954 if ((ret = ffv1_init_slices_state(s)) < 0)
957 #define STATS_OUT_SIZE 1024 * 1024 * 6
958 if (avctx->flags & CODEC_FLAG_PASS1) {
959 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
960 if (!avctx->stats_out)
961 return AVERROR(ENOMEM);
962 for (i = 0; i < s->quant_table_count; i++)
963 for (j = 0; j < s->slice_count; j++) {
964 FFV1Context *sf = s->slice_context[j];
965 av_assert0(!sf->rc_stat2[i]);
966 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
967 sizeof(*sf->rc_stat2[i]));
968 if (!sf->rc_stat2[i])
969 return AVERROR(ENOMEM);
976 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
978 RangeCoder *c = &fs->c;
979 uint8_t state[CONTEXT_SIZE];
981 memset(state, 128, sizeof(state));
983 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
984 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
985 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
986 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
987 for (j=0; j<f->plane_count; j++) {
988 put_symbol(c, state, f->plane[j].quant_table_index, 0);
989 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
991 if (!f->picture.f->interlaced_frame)
992 put_symbol(c, state, 3, 0);
994 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
995 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
996 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
997 if (f->version > 3) {
998 put_rac(c, state, fs->slice_coding_mode == 1);
999 if (fs->slice_coding_mode == 1)
1000 ffv1_clear_slice_state(f, fs);
1001 put_symbol(c, state, fs->slice_coding_mode, 0);
1002 if (fs->slice_coding_mode != 1) {
1003 put_symbol(c, state, fs->slice_rct_by_coef, 0);
1004 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
1009 static void choose_rct_params(FFV1Context *fs, uint8_t *src[3], const int stride[3], int w, int h)
1011 #define NB_Y_COEFF 15
1012 static const int rct_y_coeff[15][2] = {
1014 {1, 1}, // R + 2G + B
1025 {1, 2}, // R + G + 2B
1026 {2, 1}, // 2R + G + B
1031 int stat[NB_Y_COEFF] = {0};
1032 int x, y, i, p, best;
1034 int lbd = fs->bits_per_raw_sample <= 8;
1036 for (y = 0; y < h; y++) {
1037 int lastr=0, lastg=0, lastb=0;
1038 for (p = 0; p < 3; p++)
1039 sample[p] = fs->sample_buffer + p*w;
1041 for (x = 0; x < w; x++) {
1045 unsigned v = *((uint32_t*)(src[0] + x*4 + stride[0]*y));
1047 g = (v >> 8) & 0xFF;
1048 r = (v >> 16) & 0xFF;
1050 b = *((uint16_t*)(src[0] + x*2 + stride[0]*y));
1051 g = *((uint16_t*)(src[1] + x*2 + stride[1]*y));
1052 r = *((uint16_t*)(src[2] + x*2 + stride[2]*y));
1059 int bg = ag - sample[0][x];
1060 int bb = ab - sample[1][x];
1061 int br = ar - sample[2][x];
1066 for (i = 0; i<NB_Y_COEFF; i++) {
1067 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1082 for (i=1; i<NB_Y_COEFF; i++) {
1083 if (stat[i] < stat[best])
1087 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1088 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1091 static int encode_slice(AVCodecContext *c, void *arg)
1093 FFV1Context *fs = *(void **)arg;
1094 FFV1Context *f = fs->avctx->priv_data;
1095 int width = fs->slice_width;
1096 int height = fs->slice_height;
1097 int x = fs->slice_x;
1098 int y = fs->slice_y;
1099 const AVFrame *const p = f->picture.f;
1100 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
1102 RangeCoder c_bak = fs->c;
1103 uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1104 p->data[1] + ps*x + y*p->linesize[1],
1105 p->data[2] + ps*x + y*p->linesize[2]};
1107 fs->slice_coding_mode = 0;
1108 if (f->version > 3) {
1109 choose_rct_params(fs, planes, p->linesize, width, height);
1111 fs->slice_rct_by_coef = 1;
1112 fs->slice_rct_ry_coef = 1;
1116 if (c->coded_frame->key_frame)
1117 ffv1_clear_slice_state(f, fs);
1118 if (f->version > 2) {
1119 encode_slice_header(f, fs);
1123 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1124 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1125 init_put_bits(&fs->pb,
1126 fs->c.bytestream_start + fs->ac_byte_count,
1127 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1130 if (f->colorspace == 0) {
1131 const int chroma_width = FF_CEIL_RSHIFT(width, f->chroma_h_shift);
1132 const int chroma_height = FF_CEIL_RSHIFT(height, f->chroma_v_shift);
1133 const int cx = x >> f->chroma_h_shift;
1134 const int cy = y >> f->chroma_v_shift;
1136 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1138 if (f->chroma_planes) {
1139 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1140 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1142 if (fs->transparency)
1143 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1145 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1150 av_assert0(fs->slice_coding_mode == 0);
1151 if (fs->version < 4 || !fs->ac) {
1152 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1155 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1156 fs->slice_coding_mode = 1;
1164 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1165 const AVFrame *pict, int *got_packet)
1167 FFV1Context *f = avctx->priv_data;
1168 RangeCoder *const c = &f->slice_context[0]->c;
1169 AVFrame *const p = f->picture.f;
1171 uint8_t keystate = 128;
1174 int64_t maxsize = FF_MIN_BUFFER_SIZE
1175 + avctx->width*avctx->height*35LL*4;
1178 if (avctx->flags & CODEC_FLAG_PASS1) {
1180 char *p = avctx->stats_out;
1181 char *end = p + STATS_OUT_SIZE;
1183 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1184 for (i = 0; i < f->quant_table_count; i++)
1185 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1187 for (j = 0; j < f->slice_count; j++) {
1188 FFV1Context *fs = f->slice_context[j];
1189 for (i = 0; i < 256; i++) {
1190 f->rc_stat[i][0] += fs->rc_stat[i][0];
1191 f->rc_stat[i][1] += fs->rc_stat[i][1];
1193 for (i = 0; i < f->quant_table_count; i++) {
1194 for (k = 0; k < f->context_count[i]; k++)
1195 for (m = 0; m < 32; m++) {
1196 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1197 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1202 for (j = 0; j < 256; j++) {
1203 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1204 f->rc_stat[j][0], f->rc_stat[j][1]);
1207 snprintf(p, end - p, "\n");
1209 for (i = 0; i < f->quant_table_count; i++) {
1210 for (j = 0; j < f->context_count[i]; j++)
1211 for (m = 0; m < 32; m++) {
1212 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1213 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1217 snprintf(p, end - p, "%d\n", f->gob_count);
1223 maxsize = FF_MIN_BUFFER_SIZE + avctx->width*avctx->height*3LL*4;
1225 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize)) < 0)
1228 ff_init_range_encoder(c, pkt->data, pkt->size);
1229 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1232 if ((ret = av_frame_ref(p, pict)) < 0)
1234 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1236 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1237 put_rac(c, &keystate, 1);
1238 avctx->coded_frame->key_frame = 1;
1242 put_rac(c, &keystate, 0);
1243 avctx->coded_frame->key_frame = 0;
1248 for (i = 1; i < 256; i++) {
1249 c->one_state[i] = f->state_transition[i];
1250 c->zero_state[256 - i] = 256 - c->one_state[i];
1254 for (i = 1; i < f->slice_count; i++) {
1255 FFV1Context *fs = f->slice_context[i];
1256 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1257 int len = pkt->size / f->slice_count;
1258 ff_init_range_encoder(&fs->c, start, len);
1260 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1261 f->slice_count, sizeof(void *));
1264 for (i = 0; i < f->slice_count; i++) {
1265 FFV1Context *fs = f->slice_context[i];
1269 uint8_t state = 129;
1270 put_rac(&fs->c, &state, 0);
1271 bytes = ff_rac_terminate(&fs->c);
1273 flush_put_bits(&fs->pb); // FIXME: nicer padding
1274 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1276 if (i > 0 || f->version > 2) {
1277 av_assert0(bytes < pkt->size / f->slice_count);
1278 memmove(buf_p, fs->c.bytestream_start, bytes);
1279 av_assert0(bytes < (1 << 24));
1280 AV_WB24(buf_p + bytes, bytes);
1286 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1287 AV_WL32(buf_p + bytes, v);
1293 if (avctx->flags & CODEC_FLAG_PASS1)
1294 avctx->stats_out[0] = '\0';
1296 f->picture_number++;
1297 pkt->size = buf_p - pkt->data;
1299 pkt->dts = pict->pts;
1300 pkt->flags |= AV_PKT_FLAG_KEY * avctx->coded_frame->key_frame;
1306 static av_cold int encode_close(AVCodecContext *avctx)
1308 av_frame_free(&avctx->coded_frame);
1313 #define OFFSET(x) offsetof(FFV1Context, x)
1314 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1315 static const AVOption options[] = {
1316 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1320 static const AVClass ffv1_class = {
1321 .class_name = "ffv1 encoder",
1322 .item_name = av_default_item_name,
1324 .version = LIBAVUTIL_VERSION_INT,
1327 static const AVCodecDefault ffv1_defaults[] = {
1332 AVCodec ff_ffv1_encoder = {
1334 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1335 .type = AVMEDIA_TYPE_VIDEO,
1336 .id = AV_CODEC_ID_FFV1,
1337 .priv_data_size = sizeof(FFV1Context),
1338 .init = encode_init,
1339 .encode2 = encode_frame,
1340 .close = encode_close,
1341 .capabilities = CODEC_CAP_SLICE_THREADS | CODEC_CAP_DELAY,
1342 .pix_fmts = (const enum AVPixelFormat[]) {
1343 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1344 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1345 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1346 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1347 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1348 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1349 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1350 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1351 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1352 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1356 .defaults = ffv1_defaults,
1357 .priv_class = &ffv1_class,