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"
39 #include "rangecoder.h"
44 static const int8_t quant5_10bit[256] = {
45 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
46 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
47 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
48 1, 1, 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, -2,
57 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
60 -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
63 static const int8_t quant5[256] = {
64 0, 1, 1, 1, 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, -2, -2, -2,
79 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
82 static const int8_t quant9_10bit[256] = {
83 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
84 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
85 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
86 3, 3, 3, 3, 3, 3, 3, 3, 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, -4, -4, -4, -4, -4, -4, -4,
95 -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
96 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
97 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
98 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
101 static const int8_t quant11[256] = {
102 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
103 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
104 4, 4, 4, 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, -5, -5,
115 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
116 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
117 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
120 static const uint8_t ver2_state[256] = {
121 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
122 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
123 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
124 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
125 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
126 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
127 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
128 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
129 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
130 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
131 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
132 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
133 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
134 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
135 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
136 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
139 static void find_best_state(uint8_t best_state[256][256],
140 const uint8_t one_state[256])
145 for (i = 1; i < 256; i++)
146 l2tab[i] = log2(i / 256.0);
148 for (i = 0; i < 256; i++) {
149 double best_len[256];
150 double p = i / 256.0;
152 for (j = 0; j < 256; j++)
153 best_len[j] = 1 << 30;
155 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
156 double occ[256] = { 0 };
163 for (k = 0; k < 256; k++) {
164 double newocc[256] = { 0 };
165 for (m = 1; m < 256; m++)
167 len -=occ[m]*( p *l2tab[ m]
168 + (1-p)*l2tab[256-m]);
170 if (len < best_len[k]) {
172 best_state[i][k] = j;
174 for (m = 1; m < 256; m++)
176 newocc[ one_state[ m]] += occ[m] * p;
177 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
179 memcpy(occ, newocc, sizeof(occ));
185 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
186 uint8_t *state, int v,
188 uint64_t rc_stat[256][2],
189 uint64_t rc_stat2[32][2])
193 #define put_rac(C, S, B) \
196 rc_stat[*(S)][B]++; \
197 rc_stat2[(S) - state][B]++; \
203 const int a = FFABS(v);
204 const int e = av_log2(a);
205 put_rac(c, state + 0, 0);
207 for (i = 0; i < e; i++)
208 put_rac(c, state + 1 + i, 1); // 1..10
209 put_rac(c, state + 1 + i, 0);
211 for (i = e - 1; i >= 0; i--)
212 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
215 put_rac(c, state + 11 + e, v < 0); // 11..21
217 for (i = 0; i < e; i++)
218 put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
219 put_rac(c, state + 1 + 9, 0);
221 for (i = e - 1; i >= 0; i--)
222 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
225 put_rac(c, state + 11 + 10, v < 0); // 11..21
228 put_rac(c, state + 0, 1);
233 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
234 int v, int is_signed)
236 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
240 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
244 v = fold(v - state->bias, bits);
248 while (i < state->error_sum) { // FIXME: optimize
256 if (k == 0 && 2 * state->drift <= -state->count)
261 code = v ^ ((2 * state->drift + state->count) >> 31);
264 ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
265 state->bias, state->error_sum, state->drift, state->count, k);
266 set_sr_golomb(pb, code, k, 12, bits);
268 update_vlc_state(state, v);
272 #define RENAME(name) name
273 #include "ffv1enc_template.c"
278 #define RENAME(name) name ## 32
279 #include "ffv1enc_template.c"
281 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
282 int stride, int plane_index, int pixel_stride)
285 const int ring_size = s->context_model ? 3 : 2;
289 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
291 for (y = 0; y < h; y++) {
292 for (i = 0; i < ring_size; i++)
293 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
295 sample[0][-1]= sample[1][0 ];
296 sample[1][ w]= sample[1][w-1];
298 if (s->bits_per_raw_sample <= 8) {
299 for (x = 0; x < w; x++)
300 sample[0][x] = src[x * pixel_stride + stride * y];
301 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
304 if (s->packed_at_lsb) {
305 for (x = 0; x < w; x++) {
306 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
309 for (x = 0; x < w; x++) {
310 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
313 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
316 // STOP_TIMER("encode line") }
321 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
325 uint8_t state[CONTEXT_SIZE];
326 memset(state, 128, sizeof(state));
328 for (i = 1; i < 128; i++)
329 if (quant_table[i] != quant_table[i - 1]) {
330 put_symbol(c, state, i - last - 1, 0);
333 put_symbol(c, state, i - last - 1, 0);
336 static void write_quant_tables(RangeCoder *c,
337 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
340 for (i = 0; i < 5; i++)
341 write_quant_table(c, quant_table[i]);
344 static void write_header(FFV1Context *f)
346 uint8_t state[CONTEXT_SIZE];
348 RangeCoder *const c = &f->slice_context[0]->c;
350 memset(state, 128, sizeof(state));
352 if (f->version < 2) {
353 put_symbol(c, state, f->version, 0);
354 put_symbol(c, state, f->ac, 0);
355 if (f->ac == AC_RANGE_CUSTOM_TAB) {
356 for (i = 1; i < 256; i++)
358 f->state_transition[i] - c->one_state[i], 1);
360 put_symbol(c, state, f->colorspace, 0); //YUV cs type
362 put_symbol(c, state, f->bits_per_raw_sample, 0);
363 put_rac(c, state, f->chroma_planes);
364 put_symbol(c, state, f->chroma_h_shift, 0);
365 put_symbol(c, state, f->chroma_v_shift, 0);
366 put_rac(c, state, f->transparency);
368 write_quant_tables(c, f->quant_table);
369 } else if (f->version < 3) {
370 put_symbol(c, state, f->slice_count, 0);
371 for (i = 0; i < f->slice_count; i++) {
372 FFV1Context *fs = f->slice_context[i];
374 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
376 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
378 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
381 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
383 for (j = 0; j < f->plane_count; j++) {
384 put_symbol(c, state, f->plane[j].quant_table_index, 0);
385 av_assert0(f->plane[j].quant_table_index == f->context_model);
391 static int write_extradata(FFV1Context *f)
393 RangeCoder *const c = &f->c;
394 uint8_t state[CONTEXT_SIZE];
396 uint8_t state2[32][CONTEXT_SIZE];
399 memset(state2, 128, sizeof(state2));
400 memset(state, 128, sizeof(state));
402 f->avctx->extradata_size = 10000 + 4 +
403 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
404 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
405 if (!f->avctx->extradata)
406 return AVERROR(ENOMEM);
407 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
408 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
410 put_symbol(c, state, f->version, 0);
411 if (f->version > 2) {
412 if (f->version == 3) {
413 f->micro_version = 4;
414 } else if (f->version == 4)
415 f->micro_version = 2;
416 put_symbol(c, state, f->micro_version, 0);
419 put_symbol(c, state, f->ac, 0);
420 if (f->ac == AC_RANGE_CUSTOM_TAB)
421 for (i = 1; i < 256; i++)
422 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
424 put_symbol(c, state, f->colorspace, 0); // YUV cs type
425 put_symbol(c, state, f->bits_per_raw_sample, 0);
426 put_rac(c, state, f->chroma_planes);
427 put_symbol(c, state, f->chroma_h_shift, 0);
428 put_symbol(c, state, f->chroma_v_shift, 0);
429 put_rac(c, state, f->transparency);
430 put_symbol(c, state, f->num_h_slices - 1, 0);
431 put_symbol(c, state, f->num_v_slices - 1, 0);
433 put_symbol(c, state, f->quant_table_count, 0);
434 for (i = 0; i < f->quant_table_count; i++)
435 write_quant_tables(c, f->quant_tables[i]);
437 for (i = 0; i < f->quant_table_count; i++) {
438 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
439 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
441 if (j < f->context_count[i] * CONTEXT_SIZE) {
442 put_rac(c, state, 1);
443 for (j = 0; j < f->context_count[i]; j++)
444 for (k = 0; k < CONTEXT_SIZE; k++) {
445 int pred = j ? f->initial_states[i][j - 1][k] : 128;
446 put_symbol(c, state2[k],
447 (int8_t)(f->initial_states[i][j][k] - pred), 1);
450 put_rac(c, state, 0);
454 if (f->version > 2) {
455 put_symbol(c, state, f->ec, 0);
456 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
459 f->avctx->extradata_size = ff_rac_terminate(c);
460 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
461 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
462 f->avctx->extradata_size += 4;
467 static int sort_stt(FFV1Context *s, uint8_t stt[256])
469 int i, i2, changed, print = 0;
473 for (i = 12; i < 244; i++) {
474 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
476 #define COST(old, new) \
477 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
478 s->rc_stat[old][1] * -log2((new) / 256.0)
480 #define COST2(old, new) \
481 COST(old, new) + COST(256 - (old), 256 - (new))
483 double size0 = COST2(i, i) + COST2(i2, i2);
484 double sizeX = COST2(i, i2) + COST2(i2, i);
485 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
487 FFSWAP(int, stt[i], stt[i2]);
488 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
489 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
491 FFSWAP(int, stt[256 - i], stt[256 - i2]);
492 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
493 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
495 for (j = 1; j < 256; j++) {
498 else if (stt[j] == i2)
501 if (stt[256 - j] == 256 - i)
502 stt[256 - j] = 256 - i2;
503 else if (stt[256 - j] == 256 - i2)
504 stt[256 - j] = 256 - i;
515 static av_cold int encode_init(AVCodecContext *avctx)
517 FFV1Context *s = avctx->priv_data;
518 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
521 if ((ret = ff_ffv1_common_init(avctx)) < 0)
526 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
528 s->version = FFMAX(s->version, 2);
530 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
531 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
532 s->version = FFMAX(s->version, 2);
534 if (avctx->level <= 0 && s->version == 2) {
537 if (avctx->level >= 0 && avctx->level <= 4) {
538 if (avctx->level < s->version) {
539 av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
540 return AVERROR(EINVAL);
542 s->version = avctx->level;
546 s->ec = (s->version >= 3);
549 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
550 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
551 return AVERROR_INVALIDDATA;
554 #if FF_API_CODER_TYPE
555 FF_DISABLE_DEPRECATION_WARNINGS
556 if (avctx->coder_type != -1)
557 s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
559 FF_ENABLE_DEPRECATION_WARNINGS
561 if (s->ac == 1) // Compatbility with common command line usage
562 s->ac = AC_RANGE_CUSTOM_TAB;
563 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
564 s->ac = AC_RANGE_DEFAULT_TAB;
567 switch(avctx->pix_fmt) {
568 case AV_PIX_FMT_YUV444P9:
569 case AV_PIX_FMT_YUV422P9:
570 case AV_PIX_FMT_YUV420P9:
571 case AV_PIX_FMT_YUVA444P9:
572 case AV_PIX_FMT_YUVA422P9:
573 case AV_PIX_FMT_YUVA420P9:
574 if (!avctx->bits_per_raw_sample)
575 s->bits_per_raw_sample = 9;
576 case AV_PIX_FMT_YUV444P10:
577 case AV_PIX_FMT_YUV420P10:
578 case AV_PIX_FMT_YUV422P10:
579 case AV_PIX_FMT_YUVA444P10:
580 case AV_PIX_FMT_YUVA422P10:
581 case AV_PIX_FMT_YUVA420P10:
582 s->packed_at_lsb = 1;
583 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
584 s->bits_per_raw_sample = 10;
585 case AV_PIX_FMT_GRAY16:
586 case AV_PIX_FMT_YUV444P16:
587 case AV_PIX_FMT_YUV422P16:
588 case AV_PIX_FMT_YUV420P16:
589 case AV_PIX_FMT_YUVA444P16:
590 case AV_PIX_FMT_YUVA422P16:
591 case AV_PIX_FMT_YUVA420P16:
592 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
593 s->bits_per_raw_sample = 16;
594 } else if (!s->bits_per_raw_sample) {
595 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
597 if (s->bits_per_raw_sample <= 8) {
598 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
599 return AVERROR_INVALIDDATA;
601 s->version = FFMAX(s->version, 1);
602 case AV_PIX_FMT_GRAY8:
604 case AV_PIX_FMT_YUV444P:
605 case AV_PIX_FMT_YUV440P:
606 case AV_PIX_FMT_YUV422P:
607 case AV_PIX_FMT_YUV420P:
608 case AV_PIX_FMT_YUV411P:
609 case AV_PIX_FMT_YUV410P:
610 case AV_PIX_FMT_YUVA444P:
611 case AV_PIX_FMT_YUVA422P:
612 case AV_PIX_FMT_YUVA420P:
613 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
615 s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
616 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
617 s->bits_per_raw_sample = 8;
618 else if (!s->bits_per_raw_sample)
619 s->bits_per_raw_sample = 8;
621 case AV_PIX_FMT_RGB32:
624 s->chroma_planes = 1;
625 s->bits_per_raw_sample = 8;
627 case AV_PIX_FMT_RGB48:
629 s->chroma_planes = 1;
630 s->bits_per_raw_sample = 16;
632 if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
633 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
634 return AVERROR_INVALIDDATA;
637 case AV_PIX_FMT_0RGB32:
639 s->chroma_planes = 1;
640 s->bits_per_raw_sample = 8;
642 case AV_PIX_FMT_GBRP9:
643 if (!avctx->bits_per_raw_sample)
644 s->bits_per_raw_sample = 9;
645 case AV_PIX_FMT_GBRP10:
646 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
647 s->bits_per_raw_sample = 10;
648 case AV_PIX_FMT_GBRP12:
649 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
650 s->bits_per_raw_sample = 12;
651 case AV_PIX_FMT_GBRP14:
652 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
653 s->bits_per_raw_sample = 14;
654 case AV_PIX_FMT_GBRP16:
655 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
656 s->bits_per_raw_sample = 16;
657 else if (!s->bits_per_raw_sample)
658 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
660 s->chroma_planes = 1;
661 if (s->bits_per_raw_sample >= 16) {
663 if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
664 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
665 return AVERROR_INVALIDDATA;
668 s->version = FFMAX(s->version, 1);
671 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
672 return AVERROR(ENOSYS);
674 av_assert0(s->bits_per_raw_sample >= 8);
676 if (s->bits_per_raw_sample > 8) {
677 if (s->ac == AC_GOLOMB_RICE) {
678 av_log(avctx, AV_LOG_INFO,
679 "bits_per_raw_sample > 8, forcing range coder\n");
680 s->ac = AC_RANGE_CUSTOM_TAB;
683 if (s->transparency) {
684 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
686 #if FF_API_PRIVATE_OPT
687 FF_DISABLE_DEPRECATION_WARNINGS
688 if (avctx->context_model)
689 s->context_model = avctx->context_model;
690 if (avctx->context_model > 1U) {
691 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
692 return AVERROR(EINVAL);
694 FF_ENABLE_DEPRECATION_WARNINGS
697 if (s->ac == AC_RANGE_CUSTOM_TAB) {
698 for (i = 1; i < 256; i++)
699 s->state_transition[i] = ver2_state[i];
702 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
703 for (i = 1; i < 256; i++)
704 s->state_transition[i] = c.one_state[i];
707 for (i = 0; i < 256; i++) {
708 s->quant_table_count = 2;
709 if (s->bits_per_raw_sample <= 8) {
710 s->quant_tables[0][0][i]= quant11[i];
711 s->quant_tables[0][1][i]= 11*quant11[i];
712 s->quant_tables[0][2][i]= 11*11*quant11[i];
713 s->quant_tables[1][0][i]= quant11[i];
714 s->quant_tables[1][1][i]= 11*quant11[i];
715 s->quant_tables[1][2][i]= 11*11*quant5 [i];
716 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
717 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
719 s->quant_tables[0][0][i]= quant9_10bit[i];
720 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
721 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
722 s->quant_tables[1][0][i]= quant9_10bit[i];
723 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
724 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
725 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
726 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
729 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
730 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
731 memcpy(s->quant_table, s->quant_tables[s->context_model],
732 sizeof(s->quant_table));
734 for (i = 0; i < s->plane_count; i++) {
735 PlaneContext *const p = &s->plane[i];
737 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
738 p->quant_table_index = s->context_model;
739 p->context_count = s->context_count[p->quant_table_index];
742 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
745 #if FF_API_CODED_FRAME
746 FF_DISABLE_DEPRECATION_WARNINGS
747 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
748 FF_ENABLE_DEPRECATION_WARNINGS
751 if (!s->transparency)
753 if (!s->chroma_planes && s->version > 3)
756 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
757 s->picture_number = 0;
759 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
760 for (i = 0; i < s->quant_table_count; i++) {
761 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
762 sizeof(*s->rc_stat2[i]));
764 return AVERROR(ENOMEM);
767 if (avctx->stats_in) {
768 char *p = avctx->stats_in;
769 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
773 return AVERROR(ENOMEM);
775 av_assert0(s->version >= 2);
778 for (j = 0; j < 256; j++)
779 for (i = 0; i < 2; i++) {
780 s->rc_stat[j][i] = strtol(p, &next, 0);
782 av_log(avctx, AV_LOG_ERROR,
783 "2Pass file invalid at %d %d [%s]\n", j, i, p);
784 av_freep(&best_state);
785 return AVERROR_INVALIDDATA;
789 for (i = 0; i < s->quant_table_count; i++)
790 for (j = 0; j < s->context_count[i]; j++) {
791 for (k = 0; k < 32; k++)
792 for (m = 0; m < 2; m++) {
793 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
795 av_log(avctx, AV_LOG_ERROR,
796 "2Pass file invalid at %d %d %d %d [%s]\n",
798 av_freep(&best_state);
799 return AVERROR_INVALIDDATA;
804 gob_count = strtol(p, &next, 0);
805 if (next == p || gob_count <= 0) {
806 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
807 av_freep(&best_state);
808 return AVERROR_INVALIDDATA;
811 while (*p == '\n' || *p == ' ')
816 if (s->ac == AC_RANGE_CUSTOM_TAB)
817 sort_stt(s, s->state_transition);
819 find_best_state(best_state, s->state_transition);
821 for (i = 0; i < s->quant_table_count; i++) {
822 for (k = 0; k < 32; k++) {
825 for (j = 0; j < s->context_count[i]; j++) {
827 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
829 p = 256.0 * b / (a + b);
830 s->initial_states[i][jp][k] =
831 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
832 for(jp++; jp<j; jp++)
833 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
836 a += s->rc_stat2[i][j][k][0];
837 b += s->rc_stat2[i][j][k][1];
839 p = 256.0 * b / (a + b);
841 s->initial_states[i][j][k] =
842 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
846 av_freep(&best_state);
849 if (s->version > 1) {
850 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
851 for (; s->num_v_slices < 9; s->num_v_slices++) {
852 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
853 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
857 av_log(avctx, AV_LOG_ERROR,
858 "Unsupported number %d of slices requested, please specify a "
859 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
861 return AVERROR(ENOSYS);
863 if ((ret = write_extradata(s)) < 0)
867 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
869 s->slice_count = s->max_slice_count;
870 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
873 #define STATS_OUT_SIZE 1024 * 1024 * 6
874 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
875 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
876 if (!avctx->stats_out)
877 return AVERROR(ENOMEM);
878 for (i = 0; i < s->quant_table_count; i++)
879 for (j = 0; j < s->max_slice_count; j++) {
880 FFV1Context *sf = s->slice_context[j];
881 av_assert0(!sf->rc_stat2[i]);
882 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
883 sizeof(*sf->rc_stat2[i]));
884 if (!sf->rc_stat2[i])
885 return AVERROR(ENOMEM);
892 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
894 RangeCoder *c = &fs->c;
895 uint8_t state[CONTEXT_SIZE];
897 memset(state, 128, sizeof(state));
899 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
900 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
901 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
902 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
903 for (j=0; j<f->plane_count; j++) {
904 put_symbol(c, state, f->plane[j].quant_table_index, 0);
905 av_assert0(f->plane[j].quant_table_index == f->context_model);
907 if (!f->picture.f->interlaced_frame)
908 put_symbol(c, state, 3, 0);
910 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
911 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
912 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
913 if (f->version > 3) {
914 put_rac(c, state, fs->slice_coding_mode == 1);
915 if (fs->slice_coding_mode == 1)
916 ff_ffv1_clear_slice_state(f, fs);
917 put_symbol(c, state, fs->slice_coding_mode, 0);
918 if (fs->slice_coding_mode != 1) {
919 put_symbol(c, state, fs->slice_rct_by_coef, 0);
920 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
925 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
927 #define NB_Y_COEFF 15
928 static const int rct_y_coeff[15][2] = {
930 {1, 1}, // R + 2G + B
941 {1, 2}, // R + G + 2B
942 {2, 1}, // 2R + G + B
947 int stat[NB_Y_COEFF] = {0};
948 int x, y, i, p, best;
950 int lbd = fs->bits_per_raw_sample <= 8;
952 for (y = 0; y < h; y++) {
953 int lastr=0, lastg=0, lastb=0;
954 for (p = 0; p < 3; p++)
955 sample[p] = fs->sample_buffer + p*w;
957 for (x = 0; x < w; x++) {
961 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
964 r = (v >> 16) & 0xFF;
966 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
967 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
968 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
975 int bg = ag - sample[0][x];
976 int bb = ab - sample[1][x];
977 int br = ar - sample[2][x];
982 for (i = 0; i<NB_Y_COEFF; i++) {
983 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
998 for (i=1; i<NB_Y_COEFF; i++) {
999 if (stat[i] < stat[best])
1003 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1004 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1007 static int encode_slice(AVCodecContext *c, void *arg)
1009 FFV1Context *fs = *(void **)arg;
1010 FFV1Context *f = fs->avctx->priv_data;
1011 int width = fs->slice_width;
1012 int height = fs->slice_height;
1013 int x = fs->slice_x;
1014 int y = fs->slice_y;
1015 const AVFrame *const p = f->picture.f;
1016 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1018 RangeCoder c_bak = fs->c;
1019 const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1020 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1021 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL};
1023 fs->slice_coding_mode = 0;
1024 if (f->version > 3) {
1025 choose_rct_params(fs, planes, p->linesize, width, height);
1027 fs->slice_rct_by_coef = 1;
1028 fs->slice_rct_ry_coef = 1;
1033 ff_ffv1_clear_slice_state(f, fs);
1034 if (f->version > 2) {
1035 encode_slice_header(f, fs);
1037 if (fs->ac == AC_GOLOMB_RICE) {
1039 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1040 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1041 init_put_bits(&fs->pb,
1042 fs->c.bytestream_start + fs->ac_byte_count,
1043 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1046 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1047 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1048 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1049 const int cx = x >> f->chroma_h_shift;
1050 const int cy = y >> f->chroma_v_shift;
1052 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1054 if (f->chroma_planes) {
1055 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1056 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1058 if (fs->transparency)
1059 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1060 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1061 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1062 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1063 } else if (f->use32bit) {
1064 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1066 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1071 av_assert0(fs->slice_coding_mode == 0);
1072 if (fs->version < 4 || !fs->ac) {
1073 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1076 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1077 fs->slice_coding_mode = 1;
1085 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1086 const AVFrame *pict, int *got_packet)
1088 FFV1Context *f = avctx->priv_data;
1089 RangeCoder *const c = &f->slice_context[0]->c;
1090 AVFrame *const p = f->picture.f;
1092 uint8_t keystate = 128;
1095 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1096 + avctx->width*avctx->height*37LL*4;
1099 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1101 char *p = avctx->stats_out;
1102 char *end = p + STATS_OUT_SIZE;
1104 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1105 for (i = 0; i < f->quant_table_count; i++)
1106 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1108 av_assert0(f->slice_count == f->max_slice_count);
1109 for (j = 0; j < f->slice_count; j++) {
1110 FFV1Context *fs = f->slice_context[j];
1111 for (i = 0; i < 256; i++) {
1112 f->rc_stat[i][0] += fs->rc_stat[i][0];
1113 f->rc_stat[i][1] += fs->rc_stat[i][1];
1115 for (i = 0; i < f->quant_table_count; i++) {
1116 for (k = 0; k < f->context_count[i]; k++)
1117 for (m = 0; m < 32; m++) {
1118 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1119 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1124 for (j = 0; j < 256; j++) {
1125 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1126 f->rc_stat[j][0], f->rc_stat[j][1]);
1129 snprintf(p, end - p, "\n");
1131 for (i = 0; i < f->quant_table_count; i++) {
1132 for (j = 0; j < f->context_count[i]; j++)
1133 for (m = 0; m < 32; m++) {
1134 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1135 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1139 snprintf(p, end - p, "%d\n", f->gob_count);
1145 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1147 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1150 ff_init_range_encoder(c, pkt->data, pkt->size);
1151 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1154 if ((ret = av_frame_ref(p, pict)) < 0)
1156 #if FF_API_CODED_FRAME
1157 FF_DISABLE_DEPRECATION_WARNINGS
1158 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1159 FF_ENABLE_DEPRECATION_WARNINGS
1162 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1163 put_rac(c, &keystate, 1);
1168 put_rac(c, &keystate, 0);
1172 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1174 for (i = 1; i < 256; i++) {
1175 c->one_state[i] = f->state_transition[i];
1176 c->zero_state[256 - i] = 256 - c->one_state[i];
1180 for (i = 1; i < f->slice_count; i++) {
1181 FFV1Context *fs = f->slice_context[i];
1182 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1183 int len = pkt->size / f->slice_count;
1184 ff_init_range_encoder(&fs->c, start, len);
1186 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1187 f->slice_count, sizeof(void *));
1190 for (i = 0; i < f->slice_count; i++) {
1191 FFV1Context *fs = f->slice_context[i];
1194 if (fs->ac != AC_GOLOMB_RICE) {
1195 uint8_t state = 129;
1196 put_rac(&fs->c, &state, 0);
1197 bytes = ff_rac_terminate(&fs->c);
1199 flush_put_bits(&fs->pb); // FIXME: nicer padding
1200 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1202 if (i > 0 || f->version > 2) {
1203 av_assert0(bytes < pkt->size / f->slice_count);
1204 memmove(buf_p, fs->c.bytestream_start, bytes);
1205 av_assert0(bytes < (1 << 24));
1206 AV_WB24(buf_p + bytes, bytes);
1212 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1213 AV_WL32(buf_p + bytes, v);
1219 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1220 avctx->stats_out[0] = '\0';
1222 #if FF_API_CODED_FRAME
1223 FF_DISABLE_DEPRECATION_WARNINGS
1224 avctx->coded_frame->key_frame = f->key_frame;
1225 FF_ENABLE_DEPRECATION_WARNINGS
1228 f->picture_number++;
1229 pkt->size = buf_p - pkt->data;
1231 pkt->dts = pict->pts;
1232 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1238 static av_cold int encode_close(AVCodecContext *avctx)
1240 ff_ffv1_close(avctx);
1244 #define OFFSET(x) offsetof(FFV1Context, x)
1245 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1246 static const AVOption options[] = {
1247 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1248 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1249 { .i64 = 0 }, -2, 2, VE, "coder" },
1250 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1251 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1252 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1253 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1254 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1255 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1256 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1257 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1258 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1259 { .i64 = 0 }, 0, 1, VE },
1264 static const AVClass ffv1_class = {
1265 .class_name = "ffv1 encoder",
1266 .item_name = av_default_item_name,
1268 .version = LIBAVUTIL_VERSION_INT,
1271 #if FF_API_CODER_TYPE
1272 static const AVCodecDefault ffv1_defaults[] = {
1278 AVCodec ff_ffv1_encoder = {
1280 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1281 .type = AVMEDIA_TYPE_VIDEO,
1282 .id = AV_CODEC_ID_FFV1,
1283 .priv_data_size = sizeof(FFV1Context),
1284 .init = encode_init,
1285 .encode2 = encode_frame,
1286 .close = encode_close,
1287 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1288 .pix_fmts = (const enum AVPixelFormat[]) {
1289 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1290 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1291 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1292 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1293 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1294 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1295 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1296 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1297 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1298 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1300 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1304 #if FF_API_CODER_TYPE
1305 .defaults = ffv1_defaults,
1307 .priv_class = &ffv1_class,