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
255 code = v ^ ((2 * state->drift + state->count) >> 31);
257 ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
258 state->bias, state->error_sum, state->drift, state->count, k);
259 set_sr_golomb(pb, code, k, 12, bits);
261 update_vlc_state(state, v);
265 #define RENAME(name) name
266 #include "ffv1enc_template.c"
271 #define RENAME(name) name ## 32
272 #include "ffv1enc_template.c"
274 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
275 int stride, int plane_index, int pixel_stride)
278 const int ring_size = s->context_model ? 3 : 2;
282 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
284 for (y = 0; y < h; y++) {
285 for (i = 0; i < ring_size; i++)
286 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
288 sample[0][-1]= sample[1][0 ];
289 sample[1][ w]= sample[1][w-1];
291 if (s->bits_per_raw_sample <= 8) {
292 for (x = 0; x < w; x++)
293 sample[0][x] = src[x * pixel_stride + stride * y];
294 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
297 if (s->packed_at_lsb) {
298 for (x = 0; x < w; x++) {
299 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
302 for (x = 0; x < w; x++) {
303 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
306 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
309 // STOP_TIMER("encode line") }
314 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
318 uint8_t state[CONTEXT_SIZE];
319 memset(state, 128, sizeof(state));
321 for (i = 1; i < 128; i++)
322 if (quant_table[i] != quant_table[i - 1]) {
323 put_symbol(c, state, i - last - 1, 0);
326 put_symbol(c, state, i - last - 1, 0);
329 static void write_quant_tables(RangeCoder *c,
330 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
333 for (i = 0; i < 5; i++)
334 write_quant_table(c, quant_table[i]);
337 static void write_header(FFV1Context *f)
339 uint8_t state[CONTEXT_SIZE];
341 RangeCoder *const c = &f->slice_context[0]->c;
343 memset(state, 128, sizeof(state));
345 if (f->version < 2) {
346 put_symbol(c, state, f->version, 0);
347 put_symbol(c, state, f->ac, 0);
348 if (f->ac == AC_RANGE_CUSTOM_TAB) {
349 for (i = 1; i < 256; i++)
351 f->state_transition[i] - c->one_state[i], 1);
353 put_symbol(c, state, f->colorspace, 0); //YUV cs type
355 put_symbol(c, state, f->bits_per_raw_sample, 0);
356 put_rac(c, state, f->chroma_planes);
357 put_symbol(c, state, f->chroma_h_shift, 0);
358 put_symbol(c, state, f->chroma_v_shift, 0);
359 put_rac(c, state, f->transparency);
361 write_quant_tables(c, f->quant_table);
362 } else if (f->version < 3) {
363 put_symbol(c, state, f->slice_count, 0);
364 for (i = 0; i < f->slice_count; i++) {
365 FFV1Context *fs = f->slice_context[i];
367 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
369 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
371 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
374 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
376 for (j = 0; j < f->plane_count; j++) {
377 put_symbol(c, state, f->plane[j].quant_table_index, 0);
378 av_assert0(f->plane[j].quant_table_index == f->context_model);
384 static int write_extradata(FFV1Context *f)
386 RangeCoder *const c = &f->c;
387 uint8_t state[CONTEXT_SIZE];
389 uint8_t state2[32][CONTEXT_SIZE];
392 memset(state2, 128, sizeof(state2));
393 memset(state, 128, sizeof(state));
395 f->avctx->extradata_size = 10000 + 4 +
396 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
397 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
398 if (!f->avctx->extradata)
399 return AVERROR(ENOMEM);
400 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
401 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
403 put_symbol(c, state, f->version, 0);
404 if (f->version > 2) {
405 if (f->version == 3) {
406 f->micro_version = 4;
407 } else if (f->version == 4)
408 f->micro_version = 2;
409 put_symbol(c, state, f->micro_version, 0);
412 put_symbol(c, state, f->ac, 0);
413 if (f->ac == AC_RANGE_CUSTOM_TAB)
414 for (i = 1; i < 256; i++)
415 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
417 put_symbol(c, state, f->colorspace, 0); // YUV cs type
418 put_symbol(c, state, f->bits_per_raw_sample, 0);
419 put_rac(c, state, f->chroma_planes);
420 put_symbol(c, state, f->chroma_h_shift, 0);
421 put_symbol(c, state, f->chroma_v_shift, 0);
422 put_rac(c, state, f->transparency);
423 put_symbol(c, state, f->num_h_slices - 1, 0);
424 put_symbol(c, state, f->num_v_slices - 1, 0);
426 put_symbol(c, state, f->quant_table_count, 0);
427 for (i = 0; i < f->quant_table_count; i++)
428 write_quant_tables(c, f->quant_tables[i]);
430 for (i = 0; i < f->quant_table_count; i++) {
431 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
432 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
434 if (j < f->context_count[i] * CONTEXT_SIZE) {
435 put_rac(c, state, 1);
436 for (j = 0; j < f->context_count[i]; j++)
437 for (k = 0; k < CONTEXT_SIZE; k++) {
438 int pred = j ? f->initial_states[i][j - 1][k] : 128;
439 put_symbol(c, state2[k],
440 (int8_t)(f->initial_states[i][j][k] - pred), 1);
443 put_rac(c, state, 0);
447 if (f->version > 2) {
448 put_symbol(c, state, f->ec, 0);
449 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
452 f->avctx->extradata_size = ff_rac_terminate(c);
453 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
454 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
455 f->avctx->extradata_size += 4;
460 static int sort_stt(FFV1Context *s, uint8_t stt[256])
462 int i, i2, changed, print = 0;
466 for (i = 12; i < 244; i++) {
467 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
469 #define COST(old, new) \
470 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
471 s->rc_stat[old][1] * -log2((new) / 256.0)
473 #define COST2(old, new) \
474 COST(old, new) + COST(256 - (old), 256 - (new))
476 double size0 = COST2(i, i) + COST2(i2, i2);
477 double sizeX = COST2(i, i2) + COST2(i2, i);
478 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
480 FFSWAP(int, stt[i], stt[i2]);
481 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
482 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
484 FFSWAP(int, stt[256 - i], stt[256 - i2]);
485 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
486 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
488 for (j = 1; j < 256; j++) {
491 else if (stt[j] == i2)
494 if (stt[256 - j] == 256 - i)
495 stt[256 - j] = 256 - i2;
496 else if (stt[256 - j] == 256 - i2)
497 stt[256 - j] = 256 - i;
508 static av_cold int encode_init(AVCodecContext *avctx)
510 FFV1Context *s = avctx->priv_data;
511 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
514 if ((ret = ff_ffv1_common_init(avctx)) < 0)
519 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
521 s->version = FFMAX(s->version, 2);
523 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
524 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
525 s->version = FFMAX(s->version, 2);
527 if (avctx->level <= 0 && s->version == 2) {
530 if (avctx->level >= 0 && avctx->level <= 4) {
531 if (avctx->level < s->version) {
532 av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
533 return AVERROR(EINVAL);
535 s->version = avctx->level;
539 s->ec = (s->version >= 3);
542 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
543 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
544 return AVERROR_INVALIDDATA;
547 #if FF_API_CODER_TYPE
548 FF_DISABLE_DEPRECATION_WARNINGS
549 if (avctx->coder_type != -1)
550 s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
552 FF_ENABLE_DEPRECATION_WARNINGS
554 if (s->ac == 1) // Compatbility with common command line usage
555 s->ac = AC_RANGE_CUSTOM_TAB;
556 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
557 s->ac = AC_RANGE_DEFAULT_TAB;
560 switch(avctx->pix_fmt) {
561 case AV_PIX_FMT_YUV444P9:
562 case AV_PIX_FMT_YUV422P9:
563 case AV_PIX_FMT_YUV420P9:
564 case AV_PIX_FMT_YUVA444P9:
565 case AV_PIX_FMT_YUVA422P9:
566 case AV_PIX_FMT_YUVA420P9:
567 if (!avctx->bits_per_raw_sample)
568 s->bits_per_raw_sample = 9;
569 case AV_PIX_FMT_GRAY10:
570 case AV_PIX_FMT_YUV444P10:
571 case AV_PIX_FMT_YUV420P10:
572 case AV_PIX_FMT_YUV422P10:
573 case AV_PIX_FMT_YUVA444P10:
574 case AV_PIX_FMT_YUVA422P10:
575 case AV_PIX_FMT_YUVA420P10:
576 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
577 s->bits_per_raw_sample = 10;
578 case AV_PIX_FMT_GRAY12:
579 case AV_PIX_FMT_YUV444P12:
580 case AV_PIX_FMT_YUV420P12:
581 case AV_PIX_FMT_YUV422P12:
582 s->packed_at_lsb = 1;
583 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
584 s->bits_per_raw_sample = 12;
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 s->version = FFMAX(s->version, 1);
633 if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
634 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
635 return AVERROR_INVALIDDATA;
638 case AV_PIX_FMT_0RGB32:
640 s->chroma_planes = 1;
641 s->bits_per_raw_sample = 8;
643 case AV_PIX_FMT_GBRP9:
644 if (!avctx->bits_per_raw_sample)
645 s->bits_per_raw_sample = 9;
646 case AV_PIX_FMT_GBRP10:
647 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
648 s->bits_per_raw_sample = 10;
649 case AV_PIX_FMT_GBRP12:
650 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
651 s->bits_per_raw_sample = 12;
652 case AV_PIX_FMT_GBRP14:
653 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
654 s->bits_per_raw_sample = 14;
655 case AV_PIX_FMT_GBRP16:
656 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
657 s->bits_per_raw_sample = 16;
658 else if (!s->bits_per_raw_sample)
659 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
661 s->chroma_planes = 1;
662 if (s->bits_per_raw_sample >= 16) {
664 if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
665 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
666 return AVERROR_INVALIDDATA;
669 s->version = FFMAX(s->version, 1);
672 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
673 return AVERROR(ENOSYS);
675 av_assert0(s->bits_per_raw_sample >= 8);
677 if (s->bits_per_raw_sample > 8) {
678 if (s->ac == AC_GOLOMB_RICE) {
679 av_log(avctx, AV_LOG_INFO,
680 "bits_per_raw_sample > 8, forcing range coder\n");
681 s->ac = AC_RANGE_CUSTOM_TAB;
684 if (s->transparency) {
685 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
687 #if FF_API_PRIVATE_OPT
688 FF_DISABLE_DEPRECATION_WARNINGS
689 if (avctx->context_model)
690 s->context_model = avctx->context_model;
691 if (avctx->context_model > 1U) {
692 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
693 return AVERROR(EINVAL);
695 FF_ENABLE_DEPRECATION_WARNINGS
698 if (s->ac == AC_RANGE_CUSTOM_TAB) {
699 for (i = 1; i < 256; i++)
700 s->state_transition[i] = ver2_state[i];
703 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
704 for (i = 1; i < 256; i++)
705 s->state_transition[i] = c.one_state[i];
708 for (i = 0; i < 256; i++) {
709 s->quant_table_count = 2;
710 if (s->bits_per_raw_sample <= 8) {
711 s->quant_tables[0][0][i]= quant11[i];
712 s->quant_tables[0][1][i]= 11*quant11[i];
713 s->quant_tables[0][2][i]= 11*11*quant11[i];
714 s->quant_tables[1][0][i]= quant11[i];
715 s->quant_tables[1][1][i]= 11*quant11[i];
716 s->quant_tables[1][2][i]= 11*11*quant5 [i];
717 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
718 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
720 s->quant_tables[0][0][i]= quant9_10bit[i];
721 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
722 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
723 s->quant_tables[1][0][i]= quant9_10bit[i];
724 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
725 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
726 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
727 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
730 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
731 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
732 memcpy(s->quant_table, s->quant_tables[s->context_model],
733 sizeof(s->quant_table));
735 for (i = 0; i < s->plane_count; i++) {
736 PlaneContext *const p = &s->plane[i];
738 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
739 p->quant_table_index = s->context_model;
740 p->context_count = s->context_count[p->quant_table_index];
743 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
746 #if FF_API_CODED_FRAME
747 FF_DISABLE_DEPRECATION_WARNINGS
748 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
749 FF_ENABLE_DEPRECATION_WARNINGS
752 if (!s->transparency)
754 if (!s->chroma_planes && s->version > 3)
757 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
758 s->picture_number = 0;
760 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
761 for (i = 0; i < s->quant_table_count; i++) {
762 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
763 sizeof(*s->rc_stat2[i]));
765 return AVERROR(ENOMEM);
768 if (avctx->stats_in) {
769 char *p = avctx->stats_in;
770 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
774 return AVERROR(ENOMEM);
776 av_assert0(s->version >= 2);
779 for (j = 0; j < 256; j++)
780 for (i = 0; i < 2; i++) {
781 s->rc_stat[j][i] = strtol(p, &next, 0);
783 av_log(avctx, AV_LOG_ERROR,
784 "2Pass file invalid at %d %d [%s]\n", j, i, p);
785 av_freep(&best_state);
786 return AVERROR_INVALIDDATA;
790 for (i = 0; i < s->quant_table_count; i++)
791 for (j = 0; j < s->context_count[i]; j++) {
792 for (k = 0; k < 32; k++)
793 for (m = 0; m < 2; m++) {
794 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
796 av_log(avctx, AV_LOG_ERROR,
797 "2Pass file invalid at %d %d %d %d [%s]\n",
799 av_freep(&best_state);
800 return AVERROR_INVALIDDATA;
805 gob_count = strtol(p, &next, 0);
806 if (next == p || gob_count <= 0) {
807 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
808 av_freep(&best_state);
809 return AVERROR_INVALIDDATA;
812 while (*p == '\n' || *p == ' ')
817 if (s->ac == AC_RANGE_CUSTOM_TAB)
818 sort_stt(s, s->state_transition);
820 find_best_state(best_state, s->state_transition);
822 for (i = 0; i < s->quant_table_count; i++) {
823 for (k = 0; k < 32; k++) {
826 for (j = 0; j < s->context_count[i]; j++) {
828 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
830 p = 256.0 * b / (a + b);
831 s->initial_states[i][jp][k] =
832 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
833 for(jp++; jp<j; jp++)
834 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
837 a += s->rc_stat2[i][j][k][0];
838 b += s->rc_stat2[i][j][k][1];
840 p = 256.0 * b / (a + b);
842 s->initial_states[i][j][k] =
843 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
847 av_freep(&best_state);
850 if (s->version > 1) {
851 int plane_count = 1 + 2*s->chroma_planes + s->transparency;
852 int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
853 int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
854 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
856 s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
858 for (; s->num_v_slices < 32; s->num_v_slices++) {
859 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
860 int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
861 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
862 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
864 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
866 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
870 av_log(avctx, AV_LOG_ERROR,
871 "Unsupported number %d of slices requested, please specify a "
872 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
874 return AVERROR(ENOSYS);
876 if ((ret = write_extradata(s)) < 0)
880 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
882 s->slice_count = s->max_slice_count;
883 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
886 #define STATS_OUT_SIZE 1024 * 1024 * 6
887 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
888 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
889 if (!avctx->stats_out)
890 return AVERROR(ENOMEM);
891 for (i = 0; i < s->quant_table_count; i++)
892 for (j = 0; j < s->max_slice_count; j++) {
893 FFV1Context *sf = s->slice_context[j];
894 av_assert0(!sf->rc_stat2[i]);
895 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
896 sizeof(*sf->rc_stat2[i]));
897 if (!sf->rc_stat2[i])
898 return AVERROR(ENOMEM);
905 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
907 RangeCoder *c = &fs->c;
908 uint8_t state[CONTEXT_SIZE];
910 memset(state, 128, sizeof(state));
912 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
913 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
914 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
915 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
916 for (j=0; j<f->plane_count; j++) {
917 put_symbol(c, state, f->plane[j].quant_table_index, 0);
918 av_assert0(f->plane[j].quant_table_index == f->context_model);
920 if (!f->picture.f->interlaced_frame)
921 put_symbol(c, state, 3, 0);
923 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
924 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
925 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
926 if (f->version > 3) {
927 put_rac(c, state, fs->slice_coding_mode == 1);
928 if (fs->slice_coding_mode == 1)
929 ff_ffv1_clear_slice_state(f, fs);
930 put_symbol(c, state, fs->slice_coding_mode, 0);
931 if (fs->slice_coding_mode != 1) {
932 put_symbol(c, state, fs->slice_rct_by_coef, 0);
933 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
938 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
940 #define NB_Y_COEFF 15
941 static const int rct_y_coeff[15][2] = {
943 {1, 1}, // R + 2G + B
954 {1, 2}, // R + G + 2B
955 {2, 1}, // 2R + G + B
960 int stat[NB_Y_COEFF] = {0};
961 int x, y, i, p, best;
963 int lbd = fs->bits_per_raw_sample <= 8;
965 for (y = 0; y < h; y++) {
966 int lastr=0, lastg=0, lastb=0;
967 for (p = 0; p < 3; p++)
968 sample[p] = fs->sample_buffer + p*w;
970 for (x = 0; x < w; x++) {
974 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
977 r = (v >> 16) & 0xFF;
979 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
980 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
981 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
988 int bg = ag - sample[0][x];
989 int bb = ab - sample[1][x];
990 int br = ar - sample[2][x];
995 for (i = 0; i<NB_Y_COEFF; i++) {
996 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1011 for (i=1; i<NB_Y_COEFF; i++) {
1012 if (stat[i] < stat[best])
1016 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1017 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1020 static int encode_slice(AVCodecContext *c, void *arg)
1022 FFV1Context *fs = *(void **)arg;
1023 FFV1Context *f = fs->avctx->priv_data;
1024 int width = fs->slice_width;
1025 int height = fs->slice_height;
1026 int x = fs->slice_x;
1027 int y = fs->slice_y;
1028 const AVFrame *const p = f->picture.f;
1029 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1031 RangeCoder c_bak = fs->c;
1032 const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1033 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1034 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL};
1036 fs->slice_coding_mode = 0;
1037 if (f->version > 3) {
1038 choose_rct_params(fs, planes, p->linesize, width, height);
1040 fs->slice_rct_by_coef = 1;
1041 fs->slice_rct_ry_coef = 1;
1046 ff_ffv1_clear_slice_state(f, fs);
1047 if (f->version > 2) {
1048 encode_slice_header(f, fs);
1050 if (fs->ac == AC_GOLOMB_RICE) {
1052 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1053 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1054 init_put_bits(&fs->pb,
1055 fs->c.bytestream_start + fs->ac_byte_count,
1056 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1059 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1060 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1061 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1062 const int cx = x >> f->chroma_h_shift;
1063 const int cy = y >> f->chroma_v_shift;
1065 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1067 if (f->chroma_planes) {
1068 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1069 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1071 if (fs->transparency)
1072 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1073 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1074 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1075 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1076 } else if (f->use32bit) {
1077 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1079 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1084 av_assert0(fs->slice_coding_mode == 0);
1085 if (fs->version < 4 || !fs->ac) {
1086 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1089 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1090 fs->slice_coding_mode = 1;
1098 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1099 const AVFrame *pict, int *got_packet)
1101 FFV1Context *f = avctx->priv_data;
1102 RangeCoder *const c = &f->slice_context[0]->c;
1103 AVFrame *const p = f->picture.f;
1104 uint8_t keystate = 128;
1107 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1108 + avctx->width*avctx->height*37LL*4;
1111 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1113 char *p = avctx->stats_out;
1114 char *end = p + STATS_OUT_SIZE;
1116 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1117 for (i = 0; i < f->quant_table_count; i++)
1118 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1120 av_assert0(f->slice_count == f->max_slice_count);
1121 for (j = 0; j < f->slice_count; j++) {
1122 FFV1Context *fs = f->slice_context[j];
1123 for (i = 0; i < 256; i++) {
1124 f->rc_stat[i][0] += fs->rc_stat[i][0];
1125 f->rc_stat[i][1] += fs->rc_stat[i][1];
1127 for (i = 0; i < f->quant_table_count; i++) {
1128 for (k = 0; k < f->context_count[i]; k++)
1129 for (m = 0; m < 32; m++) {
1130 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1131 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1136 for (j = 0; j < 256; j++) {
1137 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1138 f->rc_stat[j][0], f->rc_stat[j][1]);
1141 snprintf(p, end - p, "\n");
1143 for (i = 0; i < f->quant_table_count; i++) {
1144 for (j = 0; j < f->context_count[i]; j++)
1145 for (m = 0; m < 32; m++) {
1146 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1147 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1151 snprintf(p, end - p, "%d\n", f->gob_count);
1157 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1159 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1160 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1161 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1164 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1167 ff_init_range_encoder(c, pkt->data, pkt->size);
1168 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1171 if ((ret = av_frame_ref(p, pict)) < 0)
1173 #if FF_API_CODED_FRAME
1174 FF_DISABLE_DEPRECATION_WARNINGS
1175 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1176 FF_ENABLE_DEPRECATION_WARNINGS
1179 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1180 put_rac(c, &keystate, 1);
1185 put_rac(c, &keystate, 0);
1189 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1191 for (i = 1; i < 256; i++) {
1192 c->one_state[i] = f->state_transition[i];
1193 c->zero_state[256 - i] = 256 - c->one_state[i];
1197 for (i = 0; i < f->slice_count; i++) {
1198 FFV1Context *fs = f->slice_context[i];
1199 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1200 int len = pkt->size / f->slice_count;
1202 ff_init_range_encoder(&fs->c, start, len);
1204 av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1205 av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1206 fs->c.bytestream_end = fs->c.bytestream_start + len;
1209 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1210 f->slice_count, sizeof(void *));
1213 for (i = 0; i < f->slice_count; i++) {
1214 FFV1Context *fs = f->slice_context[i];
1217 if (fs->ac != AC_GOLOMB_RICE) {
1218 uint8_t state = 129;
1219 put_rac(&fs->c, &state, 0);
1220 bytes = ff_rac_terminate(&fs->c);
1222 flush_put_bits(&fs->pb); // FIXME: nicer padding
1223 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1225 if (i > 0 || f->version > 2) {
1226 av_assert0(bytes < pkt->size / f->slice_count);
1227 memmove(buf_p, fs->c.bytestream_start, bytes);
1228 av_assert0(bytes < (1 << 24));
1229 AV_WB24(buf_p + bytes, bytes);
1235 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1236 AV_WL32(buf_p + bytes, v);
1242 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1243 avctx->stats_out[0] = '\0';
1245 #if FF_API_CODED_FRAME
1246 FF_DISABLE_DEPRECATION_WARNINGS
1247 avctx->coded_frame->key_frame = f->key_frame;
1248 FF_ENABLE_DEPRECATION_WARNINGS
1251 f->picture_number++;
1252 pkt->size = buf_p - pkt->data;
1254 pkt->dts = pict->pts;
1255 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1261 static av_cold int encode_close(AVCodecContext *avctx)
1263 ff_ffv1_close(avctx);
1267 #define OFFSET(x) offsetof(FFV1Context, x)
1268 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1269 static const AVOption options[] = {
1270 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1271 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1272 { .i64 = 0 }, -2, 2, VE, "coder" },
1273 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1274 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1275 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1276 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1277 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1278 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1279 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1280 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1281 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1282 { .i64 = 0 }, 0, 1, VE },
1287 static const AVClass ffv1_class = {
1288 .class_name = "ffv1 encoder",
1289 .item_name = av_default_item_name,
1291 .version = LIBAVUTIL_VERSION_INT,
1294 #if FF_API_CODER_TYPE
1295 static const AVCodecDefault ffv1_defaults[] = {
1301 AVCodec ff_ffv1_encoder = {
1303 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1304 .type = AVMEDIA_TYPE_VIDEO,
1305 .id = AV_CODEC_ID_FFV1,
1306 .priv_data_size = sizeof(FFV1Context),
1307 .init = encode_init,
1308 .encode2 = encode_frame,
1309 .close = encode_close,
1310 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1311 .pix_fmts = (const enum AVPixelFormat[]) {
1312 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1313 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1314 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1315 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1316 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1317 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1318 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1319 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1320 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1321 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1322 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1324 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1325 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1329 #if FF_API_CODER_TYPE
1330 .defaults = ffv1_defaults,
1332 .priv_class = &ffv1_class,