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_GRAY10:
577 case AV_PIX_FMT_YUV444P10:
578 case AV_PIX_FMT_YUV420P10:
579 case AV_PIX_FMT_YUV422P10:
580 case AV_PIX_FMT_YUVA444P10:
581 case AV_PIX_FMT_YUVA422P10:
582 case AV_PIX_FMT_YUVA420P10:
583 s->packed_at_lsb = 1;
584 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
585 s->bits_per_raw_sample = 10;
586 case AV_PIX_FMT_GRAY16:
587 case AV_PIX_FMT_YUV444P16:
588 case AV_PIX_FMT_YUV422P16:
589 case AV_PIX_FMT_YUV420P16:
590 case AV_PIX_FMT_YUVA444P16:
591 case AV_PIX_FMT_YUVA422P16:
592 case AV_PIX_FMT_YUVA420P16:
593 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
594 s->bits_per_raw_sample = 16;
595 } else if (!s->bits_per_raw_sample) {
596 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
598 if (s->bits_per_raw_sample <= 8) {
599 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
600 return AVERROR_INVALIDDATA;
602 s->version = FFMAX(s->version, 1);
603 case AV_PIX_FMT_GRAY8:
605 case AV_PIX_FMT_YUV444P:
606 case AV_PIX_FMT_YUV440P:
607 case AV_PIX_FMT_YUV422P:
608 case AV_PIX_FMT_YUV420P:
609 case AV_PIX_FMT_YUV411P:
610 case AV_PIX_FMT_YUV410P:
611 case AV_PIX_FMT_YUVA444P:
612 case AV_PIX_FMT_YUVA422P:
613 case AV_PIX_FMT_YUVA420P:
614 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
616 s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
617 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
618 s->bits_per_raw_sample = 8;
619 else if (!s->bits_per_raw_sample)
620 s->bits_per_raw_sample = 8;
622 case AV_PIX_FMT_RGB32:
625 s->chroma_planes = 1;
626 s->bits_per_raw_sample = 8;
628 case AV_PIX_FMT_RGB48:
630 s->chroma_planes = 1;
631 s->bits_per_raw_sample = 16;
633 s->version = FFMAX(s->version, 1);
634 if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
635 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
636 return AVERROR_INVALIDDATA;
639 case AV_PIX_FMT_0RGB32:
641 s->chroma_planes = 1;
642 s->bits_per_raw_sample = 8;
644 case AV_PIX_FMT_GBRP9:
645 if (!avctx->bits_per_raw_sample)
646 s->bits_per_raw_sample = 9;
647 case AV_PIX_FMT_GBRP10:
648 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
649 s->bits_per_raw_sample = 10;
650 case AV_PIX_FMT_GBRP12:
651 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
652 s->bits_per_raw_sample = 12;
653 case AV_PIX_FMT_GBRP14:
654 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
655 s->bits_per_raw_sample = 14;
656 case AV_PIX_FMT_GBRP16:
657 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
658 s->bits_per_raw_sample = 16;
659 else if (!s->bits_per_raw_sample)
660 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
662 s->chroma_planes = 1;
663 if (s->bits_per_raw_sample >= 16) {
665 if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
666 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
667 return AVERROR_INVALIDDATA;
670 s->version = FFMAX(s->version, 1);
673 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
674 return AVERROR(ENOSYS);
676 av_assert0(s->bits_per_raw_sample >= 8);
678 if (s->bits_per_raw_sample > 8) {
679 if (s->ac == AC_GOLOMB_RICE) {
680 av_log(avctx, AV_LOG_INFO,
681 "bits_per_raw_sample > 8, forcing range coder\n");
682 s->ac = AC_RANGE_CUSTOM_TAB;
685 if (s->transparency) {
686 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
688 #if FF_API_PRIVATE_OPT
689 FF_DISABLE_DEPRECATION_WARNINGS
690 if (avctx->context_model)
691 s->context_model = avctx->context_model;
692 if (avctx->context_model > 1U) {
693 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
694 return AVERROR(EINVAL);
696 FF_ENABLE_DEPRECATION_WARNINGS
699 if (s->ac == AC_RANGE_CUSTOM_TAB) {
700 for (i = 1; i < 256; i++)
701 s->state_transition[i] = ver2_state[i];
704 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
705 for (i = 1; i < 256; i++)
706 s->state_transition[i] = c.one_state[i];
709 for (i = 0; i < 256; i++) {
710 s->quant_table_count = 2;
711 if (s->bits_per_raw_sample <= 8) {
712 s->quant_tables[0][0][i]= quant11[i];
713 s->quant_tables[0][1][i]= 11*quant11[i];
714 s->quant_tables[0][2][i]= 11*11*quant11[i];
715 s->quant_tables[1][0][i]= quant11[i];
716 s->quant_tables[1][1][i]= 11*quant11[i];
717 s->quant_tables[1][2][i]= 11*11*quant5 [i];
718 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
719 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
721 s->quant_tables[0][0][i]= quant9_10bit[i];
722 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
723 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
724 s->quant_tables[1][0][i]= quant9_10bit[i];
725 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
726 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
727 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
728 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
731 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
732 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
733 memcpy(s->quant_table, s->quant_tables[s->context_model],
734 sizeof(s->quant_table));
736 for (i = 0; i < s->plane_count; i++) {
737 PlaneContext *const p = &s->plane[i];
739 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
740 p->quant_table_index = s->context_model;
741 p->context_count = s->context_count[p->quant_table_index];
744 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
747 #if FF_API_CODED_FRAME
748 FF_DISABLE_DEPRECATION_WARNINGS
749 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
750 FF_ENABLE_DEPRECATION_WARNINGS
753 if (!s->transparency)
755 if (!s->chroma_planes && s->version > 3)
758 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
759 s->picture_number = 0;
761 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
762 for (i = 0; i < s->quant_table_count; i++) {
763 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
764 sizeof(*s->rc_stat2[i]));
766 return AVERROR(ENOMEM);
769 if (avctx->stats_in) {
770 char *p = avctx->stats_in;
771 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
775 return AVERROR(ENOMEM);
777 av_assert0(s->version >= 2);
780 for (j = 0; j < 256; j++)
781 for (i = 0; i < 2; i++) {
782 s->rc_stat[j][i] = strtol(p, &next, 0);
784 av_log(avctx, AV_LOG_ERROR,
785 "2Pass file invalid at %d %d [%s]\n", j, i, p);
786 av_freep(&best_state);
787 return AVERROR_INVALIDDATA;
791 for (i = 0; i < s->quant_table_count; i++)
792 for (j = 0; j < s->context_count[i]; j++) {
793 for (k = 0; k < 32; k++)
794 for (m = 0; m < 2; m++) {
795 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
797 av_log(avctx, AV_LOG_ERROR,
798 "2Pass file invalid at %d %d %d %d [%s]\n",
800 av_freep(&best_state);
801 return AVERROR_INVALIDDATA;
806 gob_count = strtol(p, &next, 0);
807 if (next == p || gob_count <= 0) {
808 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
809 av_freep(&best_state);
810 return AVERROR_INVALIDDATA;
813 while (*p == '\n' || *p == ' ')
818 if (s->ac == AC_RANGE_CUSTOM_TAB)
819 sort_stt(s, s->state_transition);
821 find_best_state(best_state, s->state_transition);
823 for (i = 0; i < s->quant_table_count; i++) {
824 for (k = 0; k < 32; k++) {
827 for (j = 0; j < s->context_count[i]; j++) {
829 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
831 p = 256.0 * b / (a + b);
832 s->initial_states[i][jp][k] =
833 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
834 for(jp++; jp<j; jp++)
835 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
838 a += s->rc_stat2[i][j][k][0];
839 b += s->rc_stat2[i][j][k][1];
841 p = 256.0 * b / (a + b);
843 s->initial_states[i][j][k] =
844 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
848 av_freep(&best_state);
851 if (s->version > 1) {
852 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
853 for (; s->num_v_slices < 9; s->num_v_slices++) {
854 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
855 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
859 av_log(avctx, AV_LOG_ERROR,
860 "Unsupported number %d of slices requested, please specify a "
861 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
863 return AVERROR(ENOSYS);
865 if ((ret = write_extradata(s)) < 0)
869 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
871 s->slice_count = s->max_slice_count;
872 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
875 #define STATS_OUT_SIZE 1024 * 1024 * 6
876 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
877 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
878 if (!avctx->stats_out)
879 return AVERROR(ENOMEM);
880 for (i = 0; i < s->quant_table_count; i++)
881 for (j = 0; j < s->max_slice_count; j++) {
882 FFV1Context *sf = s->slice_context[j];
883 av_assert0(!sf->rc_stat2[i]);
884 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
885 sizeof(*sf->rc_stat2[i]));
886 if (!sf->rc_stat2[i])
887 return AVERROR(ENOMEM);
894 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
896 RangeCoder *c = &fs->c;
897 uint8_t state[CONTEXT_SIZE];
899 memset(state, 128, sizeof(state));
901 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
902 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
903 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
904 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
905 for (j=0; j<f->plane_count; j++) {
906 put_symbol(c, state, f->plane[j].quant_table_index, 0);
907 av_assert0(f->plane[j].quant_table_index == f->context_model);
909 if (!f->picture.f->interlaced_frame)
910 put_symbol(c, state, 3, 0);
912 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
913 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
914 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
915 if (f->version > 3) {
916 put_rac(c, state, fs->slice_coding_mode == 1);
917 if (fs->slice_coding_mode == 1)
918 ff_ffv1_clear_slice_state(f, fs);
919 put_symbol(c, state, fs->slice_coding_mode, 0);
920 if (fs->slice_coding_mode != 1) {
921 put_symbol(c, state, fs->slice_rct_by_coef, 0);
922 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
927 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
929 #define NB_Y_COEFF 15
930 static const int rct_y_coeff[15][2] = {
932 {1, 1}, // R + 2G + B
943 {1, 2}, // R + G + 2B
944 {2, 1}, // 2R + G + B
949 int stat[NB_Y_COEFF] = {0};
950 int x, y, i, p, best;
952 int lbd = fs->bits_per_raw_sample <= 8;
954 for (y = 0; y < h; y++) {
955 int lastr=0, lastg=0, lastb=0;
956 for (p = 0; p < 3; p++)
957 sample[p] = fs->sample_buffer + p*w;
959 for (x = 0; x < w; x++) {
963 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
966 r = (v >> 16) & 0xFF;
968 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
969 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
970 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
977 int bg = ag - sample[0][x];
978 int bb = ab - sample[1][x];
979 int br = ar - sample[2][x];
984 for (i = 0; i<NB_Y_COEFF; i++) {
985 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1000 for (i=1; i<NB_Y_COEFF; i++) {
1001 if (stat[i] < stat[best])
1005 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1006 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1009 static int encode_slice(AVCodecContext *c, void *arg)
1011 FFV1Context *fs = *(void **)arg;
1012 FFV1Context *f = fs->avctx->priv_data;
1013 int width = fs->slice_width;
1014 int height = fs->slice_height;
1015 int x = fs->slice_x;
1016 int y = fs->slice_y;
1017 const AVFrame *const p = f->picture.f;
1018 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1020 RangeCoder c_bak = fs->c;
1021 const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1022 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1023 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL};
1025 fs->slice_coding_mode = 0;
1026 if (f->version > 3) {
1027 choose_rct_params(fs, planes, p->linesize, width, height);
1029 fs->slice_rct_by_coef = 1;
1030 fs->slice_rct_ry_coef = 1;
1035 ff_ffv1_clear_slice_state(f, fs);
1036 if (f->version > 2) {
1037 encode_slice_header(f, fs);
1039 if (fs->ac == AC_GOLOMB_RICE) {
1041 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1042 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1043 init_put_bits(&fs->pb,
1044 fs->c.bytestream_start + fs->ac_byte_count,
1045 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1048 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1049 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1050 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1051 const int cx = x >> f->chroma_h_shift;
1052 const int cy = y >> f->chroma_v_shift;
1054 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1056 if (f->chroma_planes) {
1057 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1058 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1060 if (fs->transparency)
1061 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1062 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1063 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1064 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1065 } else if (f->use32bit) {
1066 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1068 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1073 av_assert0(fs->slice_coding_mode == 0);
1074 if (fs->version < 4 || !fs->ac) {
1075 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1078 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1079 fs->slice_coding_mode = 1;
1087 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1088 const AVFrame *pict, int *got_packet)
1090 FFV1Context *f = avctx->priv_data;
1091 RangeCoder *const c = &f->slice_context[0]->c;
1092 AVFrame *const p = f->picture.f;
1094 uint8_t keystate = 128;
1097 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1098 + avctx->width*avctx->height*37LL*4;
1101 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1103 char *p = avctx->stats_out;
1104 char *end = p + STATS_OUT_SIZE;
1106 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1107 for (i = 0; i < f->quant_table_count; i++)
1108 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1110 av_assert0(f->slice_count == f->max_slice_count);
1111 for (j = 0; j < f->slice_count; j++) {
1112 FFV1Context *fs = f->slice_context[j];
1113 for (i = 0; i < 256; i++) {
1114 f->rc_stat[i][0] += fs->rc_stat[i][0];
1115 f->rc_stat[i][1] += fs->rc_stat[i][1];
1117 for (i = 0; i < f->quant_table_count; i++) {
1118 for (k = 0; k < f->context_count[i]; k++)
1119 for (m = 0; m < 32; m++) {
1120 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1121 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1126 for (j = 0; j < 256; j++) {
1127 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1128 f->rc_stat[j][0], f->rc_stat[j][1]);
1131 snprintf(p, end - p, "\n");
1133 for (i = 0; i < f->quant_table_count; i++) {
1134 for (j = 0; j < f->context_count[i]; j++)
1135 for (m = 0; m < 32; m++) {
1136 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1137 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1141 snprintf(p, end - p, "%d\n", f->gob_count);
1147 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1149 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1152 ff_init_range_encoder(c, pkt->data, pkt->size);
1153 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1156 if ((ret = av_frame_ref(p, pict)) < 0)
1158 #if FF_API_CODED_FRAME
1159 FF_DISABLE_DEPRECATION_WARNINGS
1160 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1161 FF_ENABLE_DEPRECATION_WARNINGS
1164 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1165 put_rac(c, &keystate, 1);
1170 put_rac(c, &keystate, 0);
1174 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1176 for (i = 1; i < 256; i++) {
1177 c->one_state[i] = f->state_transition[i];
1178 c->zero_state[256 - i] = 256 - c->one_state[i];
1182 for (i = 1; i < f->slice_count; i++) {
1183 FFV1Context *fs = f->slice_context[i];
1184 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1185 int len = pkt->size / f->slice_count;
1186 ff_init_range_encoder(&fs->c, start, len);
1188 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1189 f->slice_count, sizeof(void *));
1192 for (i = 0; i < f->slice_count; i++) {
1193 FFV1Context *fs = f->slice_context[i];
1196 if (fs->ac != AC_GOLOMB_RICE) {
1197 uint8_t state = 129;
1198 put_rac(&fs->c, &state, 0);
1199 bytes = ff_rac_terminate(&fs->c);
1201 flush_put_bits(&fs->pb); // FIXME: nicer padding
1202 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1204 if (i > 0 || f->version > 2) {
1205 av_assert0(bytes < pkt->size / f->slice_count);
1206 memmove(buf_p, fs->c.bytestream_start, bytes);
1207 av_assert0(bytes < (1 << 24));
1208 AV_WB24(buf_p + bytes, bytes);
1214 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1215 AV_WL32(buf_p + bytes, v);
1221 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1222 avctx->stats_out[0] = '\0';
1224 #if FF_API_CODED_FRAME
1225 FF_DISABLE_DEPRECATION_WARNINGS
1226 avctx->coded_frame->key_frame = f->key_frame;
1227 FF_ENABLE_DEPRECATION_WARNINGS
1230 f->picture_number++;
1231 pkt->size = buf_p - pkt->data;
1233 pkt->dts = pict->pts;
1234 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1240 static av_cold int encode_close(AVCodecContext *avctx)
1242 ff_ffv1_close(avctx);
1246 #define OFFSET(x) offsetof(FFV1Context, x)
1247 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1248 static const AVOption options[] = {
1249 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1250 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1251 { .i64 = 0 }, -2, 2, VE, "coder" },
1252 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1253 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1254 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1255 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1256 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1257 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1258 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1259 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1260 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1261 { .i64 = 0 }, 0, 1, VE },
1266 static const AVClass ffv1_class = {
1267 .class_name = "ffv1 encoder",
1268 .item_name = av_default_item_name,
1270 .version = LIBAVUTIL_VERSION_INT,
1273 #if FF_API_CODER_TYPE
1274 static const AVCodecDefault ffv1_defaults[] = {
1280 AVCodec ff_ffv1_encoder = {
1282 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1283 .type = AVMEDIA_TYPE_VIDEO,
1284 .id = AV_CODEC_ID_FFV1,
1285 .priv_data_size = sizeof(FFV1Context),
1286 .init = encode_init,
1287 .encode2 = encode_frame,
1288 .close = encode_close,
1289 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1290 .pix_fmts = (const enum AVPixelFormat[]) {
1291 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1292 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1293 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1294 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1295 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1296 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1297 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1298 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1299 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1300 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1303 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1307 #if FF_API_CODER_TYPE
1308 .defaults = ffv1_defaults,
1310 .priv_class = &ffv1_class,