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 ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
761 s->picture_number = 0;
763 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
764 for (i = 0; i < s->quant_table_count; i++) {
765 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
766 sizeof(*s->rc_stat2[i]));
768 return AVERROR(ENOMEM);
771 if (avctx->stats_in) {
772 char *p = avctx->stats_in;
773 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
777 return AVERROR(ENOMEM);
779 av_assert0(s->version >= 2);
782 for (j = 0; j < 256; j++)
783 for (i = 0; i < 2; i++) {
784 s->rc_stat[j][i] = strtol(p, &next, 0);
786 av_log(avctx, AV_LOG_ERROR,
787 "2Pass file invalid at %d %d [%s]\n", j, i, p);
788 av_freep(&best_state);
789 return AVERROR_INVALIDDATA;
793 for (i = 0; i < s->quant_table_count; i++)
794 for (j = 0; j < s->context_count[i]; j++) {
795 for (k = 0; k < 32; k++)
796 for (m = 0; m < 2; m++) {
797 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
799 av_log(avctx, AV_LOG_ERROR,
800 "2Pass file invalid at %d %d %d %d [%s]\n",
802 av_freep(&best_state);
803 return AVERROR_INVALIDDATA;
808 gob_count = strtol(p, &next, 0);
809 if (next == p || gob_count <= 0) {
810 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
811 av_freep(&best_state);
812 return AVERROR_INVALIDDATA;
815 while (*p == '\n' || *p == ' ')
820 if (s->ac == AC_RANGE_CUSTOM_TAB)
821 sort_stt(s, s->state_transition);
823 find_best_state(best_state, s->state_transition);
825 for (i = 0; i < s->quant_table_count; i++) {
826 for (k = 0; k < 32; k++) {
829 for (j = 0; j < s->context_count[i]; j++) {
831 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
833 p = 256.0 * b / (a + b);
834 s->initial_states[i][jp][k] =
835 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
836 for(jp++; jp<j; jp++)
837 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
840 a += s->rc_stat2[i][j][k][0];
841 b += s->rc_stat2[i][j][k][1];
843 p = 256.0 * b / (a + b);
845 s->initial_states[i][j][k] =
846 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
850 av_freep(&best_state);
853 if (s->version > 1) {
854 int plane_count = 1 + 2*s->chroma_planes + s->transparency;
855 int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
856 int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
857 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
859 s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
861 for (; s->num_v_slices < 32; s->num_v_slices++) {
862 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
863 int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
864 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
865 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
867 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
869 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
873 av_log(avctx, AV_LOG_ERROR,
874 "Unsupported number %d of slices requested, please specify a "
875 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
877 return AVERROR(ENOSYS);
879 if ((ret = write_extradata(s)) < 0)
883 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
885 s->slice_count = s->max_slice_count;
886 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
889 #define STATS_OUT_SIZE 1024 * 1024 * 6
890 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
891 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
892 if (!avctx->stats_out)
893 return AVERROR(ENOMEM);
894 for (i = 0; i < s->quant_table_count; i++)
895 for (j = 0; j < s->max_slice_count; j++) {
896 FFV1Context *sf = s->slice_context[j];
897 av_assert0(!sf->rc_stat2[i]);
898 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
899 sizeof(*sf->rc_stat2[i]));
900 if (!sf->rc_stat2[i])
901 return AVERROR(ENOMEM);
908 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
910 RangeCoder *c = &fs->c;
911 uint8_t state[CONTEXT_SIZE];
913 memset(state, 128, sizeof(state));
915 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
916 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
917 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
918 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
919 for (j=0; j<f->plane_count; j++) {
920 put_symbol(c, state, f->plane[j].quant_table_index, 0);
921 av_assert0(f->plane[j].quant_table_index == f->context_model);
923 if (!f->picture.f->interlaced_frame)
924 put_symbol(c, state, 3, 0);
926 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
927 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
928 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
929 if (f->version > 3) {
930 put_rac(c, state, fs->slice_coding_mode == 1);
931 if (fs->slice_coding_mode == 1)
932 ff_ffv1_clear_slice_state(f, fs);
933 put_symbol(c, state, fs->slice_coding_mode, 0);
934 if (fs->slice_coding_mode != 1) {
935 put_symbol(c, state, fs->slice_rct_by_coef, 0);
936 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
941 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
943 #define NB_Y_COEFF 15
944 static const int rct_y_coeff[15][2] = {
946 {1, 1}, // R + 2G + B
957 {1, 2}, // R + G + 2B
958 {2, 1}, // 2R + G + B
963 int stat[NB_Y_COEFF] = {0};
964 int x, y, i, p, best;
966 int lbd = fs->bits_per_raw_sample <= 8;
968 for (y = 0; y < h; y++) {
969 int lastr=0, lastg=0, lastb=0;
970 for (p = 0; p < 3; p++)
971 sample[p] = fs->sample_buffer + p*w;
973 for (x = 0; x < w; x++) {
977 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
980 r = (v >> 16) & 0xFF;
982 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
983 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
984 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
991 int bg = ag - sample[0][x];
992 int bb = ab - sample[1][x];
993 int br = ar - sample[2][x];
998 for (i = 0; i<NB_Y_COEFF; i++) {
999 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1014 for (i=1; i<NB_Y_COEFF; i++) {
1015 if (stat[i] < stat[best])
1019 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1020 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1023 static int encode_slice(AVCodecContext *c, void *arg)
1025 FFV1Context *fs = *(void **)arg;
1026 FFV1Context *f = fs->avctx->priv_data;
1027 int width = fs->slice_width;
1028 int height = fs->slice_height;
1029 int x = fs->slice_x;
1030 int y = fs->slice_y;
1031 const AVFrame *const p = f->picture.f;
1032 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1034 RangeCoder c_bak = fs->c;
1035 const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1036 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1037 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL};
1039 fs->slice_coding_mode = 0;
1040 if (f->version > 3) {
1041 choose_rct_params(fs, planes, p->linesize, width, height);
1043 fs->slice_rct_by_coef = 1;
1044 fs->slice_rct_ry_coef = 1;
1049 ff_ffv1_clear_slice_state(f, fs);
1050 if (f->version > 2) {
1051 encode_slice_header(f, fs);
1053 if (fs->ac == AC_GOLOMB_RICE) {
1055 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1056 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1057 init_put_bits(&fs->pb,
1058 fs->c.bytestream_start + fs->ac_byte_count,
1059 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1062 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1063 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1064 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1065 const int cx = x >> f->chroma_h_shift;
1066 const int cy = y >> f->chroma_v_shift;
1068 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1070 if (f->chroma_planes) {
1071 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1072 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1074 if (fs->transparency)
1075 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1076 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1077 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1078 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1079 } else if (f->use32bit) {
1080 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1082 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1087 av_assert0(fs->slice_coding_mode == 0);
1088 if (fs->version < 4 || !fs->ac) {
1089 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1092 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1093 fs->slice_coding_mode = 1;
1101 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1102 const AVFrame *pict, int *got_packet)
1104 FFV1Context *f = avctx->priv_data;
1105 RangeCoder *const c = &f->slice_context[0]->c;
1106 AVFrame *const p = f->picture.f;
1107 uint8_t keystate = 128;
1110 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1111 + avctx->width*avctx->height*37LL*4;
1114 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1116 char *p = avctx->stats_out;
1117 char *end = p + STATS_OUT_SIZE;
1119 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1120 for (i = 0; i < f->quant_table_count; i++)
1121 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1123 av_assert0(f->slice_count == f->max_slice_count);
1124 for (j = 0; j < f->slice_count; j++) {
1125 FFV1Context *fs = f->slice_context[j];
1126 for (i = 0; i < 256; i++) {
1127 f->rc_stat[i][0] += fs->rc_stat[i][0];
1128 f->rc_stat[i][1] += fs->rc_stat[i][1];
1130 for (i = 0; i < f->quant_table_count; i++) {
1131 for (k = 0; k < f->context_count[i]; k++)
1132 for (m = 0; m < 32; m++) {
1133 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1134 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1139 for (j = 0; j < 256; j++) {
1140 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1141 f->rc_stat[j][0], f->rc_stat[j][1]);
1144 snprintf(p, end - p, "\n");
1146 for (i = 0; i < f->quant_table_count; i++) {
1147 for (j = 0; j < f->context_count[i]; j++)
1148 for (m = 0; m < 32; m++) {
1149 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1150 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1154 snprintf(p, end - p, "%d\n", f->gob_count);
1160 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1162 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1163 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1164 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1167 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1170 ff_init_range_encoder(c, pkt->data, pkt->size);
1171 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1174 if ((ret = av_frame_ref(p, pict)) < 0)
1176 #if FF_API_CODED_FRAME
1177 FF_DISABLE_DEPRECATION_WARNINGS
1178 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1179 FF_ENABLE_DEPRECATION_WARNINGS
1182 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1183 put_rac(c, &keystate, 1);
1188 put_rac(c, &keystate, 0);
1192 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1194 for (i = 1; i < 256; i++) {
1195 c->one_state[i] = f->state_transition[i];
1196 c->zero_state[256 - i] = 256 - c->one_state[i];
1200 for (i = 0; i < f->slice_count; i++) {
1201 FFV1Context *fs = f->slice_context[i];
1202 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1203 int len = pkt->size / f->slice_count;
1205 ff_init_range_encoder(&fs->c, start, len);
1207 av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1208 av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1209 fs->c.bytestream_end = fs->c.bytestream_start + len;
1212 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1213 f->slice_count, sizeof(void *));
1216 for (i = 0; i < f->slice_count; i++) {
1217 FFV1Context *fs = f->slice_context[i];
1220 if (fs->ac != AC_GOLOMB_RICE) {
1221 uint8_t state = 129;
1222 put_rac(&fs->c, &state, 0);
1223 bytes = ff_rac_terminate(&fs->c);
1225 flush_put_bits(&fs->pb); // FIXME: nicer padding
1226 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1228 if (i > 0 || f->version > 2) {
1229 av_assert0(bytes < pkt->size / f->slice_count);
1230 memmove(buf_p, fs->c.bytestream_start, bytes);
1231 av_assert0(bytes < (1 << 24));
1232 AV_WB24(buf_p + bytes, bytes);
1238 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1239 AV_WL32(buf_p + bytes, v);
1245 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1246 avctx->stats_out[0] = '\0';
1248 #if FF_API_CODED_FRAME
1249 FF_DISABLE_DEPRECATION_WARNINGS
1250 avctx->coded_frame->key_frame = f->key_frame;
1251 FF_ENABLE_DEPRECATION_WARNINGS
1254 f->picture_number++;
1255 pkt->size = buf_p - pkt->data;
1257 pkt->dts = pict->pts;
1258 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1264 static av_cold int encode_close(AVCodecContext *avctx)
1266 ff_ffv1_close(avctx);
1270 #define OFFSET(x) offsetof(FFV1Context, x)
1271 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1272 static const AVOption options[] = {
1273 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1274 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1275 { .i64 = 0 }, -2, 2, VE, "coder" },
1276 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1277 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1278 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1279 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1280 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1281 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1282 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1283 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1284 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1285 { .i64 = 0 }, 0, 1, VE },
1290 static const AVClass ffv1_class = {
1291 .class_name = "ffv1 encoder",
1292 .item_name = av_default_item_name,
1294 .version = LIBAVUTIL_VERSION_INT,
1297 #if FF_API_CODER_TYPE
1298 static const AVCodecDefault ffv1_defaults[] = {
1304 AVCodec ff_ffv1_encoder = {
1306 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1307 .type = AVMEDIA_TYPE_VIDEO,
1308 .id = AV_CODEC_ID_FFV1,
1309 .priv_data_size = sizeof(FFV1Context),
1310 .init = encode_init,
1311 .encode2 = encode_frame,
1312 .close = encode_close,
1313 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1314 .pix_fmts = (const enum AVPixelFormat[]) {
1315 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1316 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1317 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1318 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1319 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1320 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1321 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1322 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1323 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1324 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1325 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1327 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1328 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1332 #if FF_API_CODER_TYPE
1333 .defaults = ffv1_defaults,
1335 .priv_class = &ffv1_class,