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"
38 #include "rangecoder.h"
43 static const int8_t quant5_10bit[256] = {
44 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
45 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
46 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
47 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
48 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
49 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
50 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
51 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
52 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
53 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
54 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
55 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
56 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1,
57 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
58 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
59 -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
62 static const int8_t quant5[256] = {
63 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
64 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
65 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
66 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
67 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
68 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
69 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
70 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
71 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
72 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
73 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
74 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
75 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
76 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
77 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
78 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
81 static const int8_t quant9_10bit[256] = {
82 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
83 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
84 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
85 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
86 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
91 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
92 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
93 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
94 -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
95 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
96 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
97 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
100 static const int8_t quant11[256] = {
101 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
102 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
103 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
104 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
105 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
106 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
107 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
108 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
109 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
110 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
111 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
112 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
113 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
114 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
115 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
116 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
119 static const uint8_t ver2_state[256] = {
120 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
121 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
122 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
123 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
124 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
125 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
126 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
127 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
128 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
129 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
130 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
131 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
132 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
133 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
134 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
135 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
138 static void find_best_state(uint8_t best_state[256][256],
139 const uint8_t one_state[256])
144 for (i = 1; i < 256; i++)
145 l2tab[i] = log2(i / 256.0);
147 for (i = 0; i < 256; i++) {
148 double best_len[256];
149 double p = i / 256.0;
151 for (j = 0; j < 256; j++)
152 best_len[j] = 1 << 30;
154 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
155 double occ[256] = { 0 };
162 for (k = 0; k < 256; k++) {
163 double newocc[256] = { 0 };
164 for (m = 1; m < 256; m++)
166 len -=occ[m]*( p *l2tab[ m]
167 + (1-p)*l2tab[256-m]);
169 if (len < best_len[k]) {
171 best_state[i][k] = j;
173 for (m = 1; m < 256; m++)
175 newocc[ one_state[ m]] += occ[m] * p;
176 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
178 memcpy(occ, newocc, sizeof(occ));
184 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
185 uint8_t *state, int v,
187 uint64_t rc_stat[256][2],
188 uint64_t rc_stat2[32][2])
192 #define put_rac(C, S, B) \
195 rc_stat[*(S)][B]++; \
196 rc_stat2[(S) - state][B]++; \
202 const int a = FFABS(v);
203 const int e = av_log2(a);
204 put_rac(c, state + 0, 0);
206 for (i = 0; i < e; i++)
207 put_rac(c, state + 1 + i, 1); // 1..10
208 put_rac(c, state + 1 + i, 0);
210 for (i = e - 1; i >= 0; i--)
211 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
214 put_rac(c, state + 11 + e, v < 0); // 11..21
216 for (i = 0; i < e; i++)
217 put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
218 put_rac(c, state + 1 + 9, 0);
220 for (i = e - 1; i >= 0; i--)
221 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
224 put_rac(c, state + 11 + 10, v < 0); // 11..21
227 put_rac(c, state + 0, 1);
232 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
233 int v, int is_signed)
235 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
239 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
243 v = fold(v - state->bias, bits);
247 while (i < state->error_sum) { // FIXME: optimize
254 code = v ^ ((2 * state->drift + state->count) >> 31);
256 ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
257 state->bias, state->error_sum, state->drift, state->count, k);
258 set_sr_golomb(pb, code, k, 12, bits);
260 update_vlc_state(state, v);
264 #define RENAME(name) name
265 #include "ffv1enc_template.c"
270 #define RENAME(name) name ## 32
271 #include "ffv1enc_template.c"
273 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
274 int stride, int plane_index, int pixel_stride)
277 const int ring_size = s->context_model ? 3 : 2;
281 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
283 for (y = 0; y < h; y++) {
284 for (i = 0; i < ring_size; i++)
285 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
287 sample[0][-1]= sample[1][0 ];
288 sample[1][ w]= sample[1][w-1];
289 if (s->bits_per_raw_sample <= 8) {
290 for (x = 0; x < w; x++)
291 sample[0][x] = src[x * pixel_stride + stride * y];
292 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
295 if (s->packed_at_lsb) {
296 for (x = 0; x < w; x++) {
297 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
300 for (x = 0; x < w; x++) {
301 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
304 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
311 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
315 uint8_t state[CONTEXT_SIZE];
316 memset(state, 128, sizeof(state));
318 for (i = 1; i < 128; i++)
319 if (quant_table[i] != quant_table[i - 1]) {
320 put_symbol(c, state, i - last - 1, 0);
323 put_symbol(c, state, i - last - 1, 0);
326 static void write_quant_tables(RangeCoder *c,
327 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
330 for (i = 0; i < 5; i++)
331 write_quant_table(c, quant_table[i]);
334 static int contains_non_128(uint8_t (*initial_state)[CONTEXT_SIZE],
339 for (int i = 0; i < nb_contexts; i++)
340 for (int j = 0; j < CONTEXT_SIZE; j++)
341 if (initial_state[i][j] != 128)
346 static void write_header(FFV1Context *f)
348 uint8_t state[CONTEXT_SIZE];
350 RangeCoder *const c = &f->slice_context[0]->c;
352 memset(state, 128, sizeof(state));
354 if (f->version < 2) {
355 put_symbol(c, state, f->version, 0);
356 put_symbol(c, state, f->ac, 0);
357 if (f->ac == AC_RANGE_CUSTOM_TAB) {
358 for (i = 1; i < 256; i++)
360 f->state_transition[i] - c->one_state[i], 1);
362 put_symbol(c, state, f->colorspace, 0); //YUV cs type
364 put_symbol(c, state, f->bits_per_raw_sample, 0);
365 put_rac(c, state, f->chroma_planes);
366 put_symbol(c, state, f->chroma_h_shift, 0);
367 put_symbol(c, state, f->chroma_v_shift, 0);
368 put_rac(c, state, f->transparency);
370 write_quant_tables(c, f->quant_table);
371 } else if (f->version < 3) {
372 put_symbol(c, state, f->slice_count, 0);
373 for (i = 0; i < f->slice_count; i++) {
374 FFV1Context *fs = f->slice_context[i];
376 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
378 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
380 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
383 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
385 for (j = 0; j < f->plane_count; j++) {
386 put_symbol(c, state, f->plane[j].quant_table_index, 0);
387 av_assert0(f->plane[j].quant_table_index == f->context_model);
393 static int write_extradata(FFV1Context *f)
395 RangeCoder *const c = &f->c;
396 uint8_t state[CONTEXT_SIZE];
398 uint8_t state2[32][CONTEXT_SIZE];
401 memset(state2, 128, sizeof(state2));
402 memset(state, 128, sizeof(state));
404 f->avctx->extradata_size = 10000 + 4 +
405 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
406 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
407 if (!f->avctx->extradata)
408 return AVERROR(ENOMEM);
409 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
410 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
412 put_symbol(c, state, f->version, 0);
413 if (f->version > 2) {
414 if (f->version == 3) {
415 f->micro_version = 4;
416 } else if (f->version == 4)
417 f->micro_version = 2;
418 put_symbol(c, state, f->micro_version, 0);
421 put_symbol(c, state, f->ac, 0);
422 if (f->ac == AC_RANGE_CUSTOM_TAB)
423 for (i = 1; i < 256; i++)
424 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
426 put_symbol(c, state, f->colorspace, 0); // YUV cs type
427 put_symbol(c, state, f->bits_per_raw_sample, 0);
428 put_rac(c, state, f->chroma_planes);
429 put_symbol(c, state, f->chroma_h_shift, 0);
430 put_symbol(c, state, f->chroma_v_shift, 0);
431 put_rac(c, state, f->transparency);
432 put_symbol(c, state, f->num_h_slices - 1, 0);
433 put_symbol(c, state, f->num_v_slices - 1, 0);
435 put_symbol(c, state, f->quant_table_count, 0);
436 for (i = 0; i < f->quant_table_count; i++)
437 write_quant_tables(c, f->quant_tables[i]);
439 for (i = 0; i < f->quant_table_count; i++) {
440 if (contains_non_128(f->initial_states[i], f->context_count[i])) {
441 put_rac(c, state, 1);
442 for (j = 0; j < f->context_count[i]; j++)
443 for (k = 0; k < CONTEXT_SIZE; k++) {
444 int pred = j ? f->initial_states[i][j - 1][k] : 128;
445 put_symbol(c, state2[k],
446 (int8_t)(f->initial_states[i][j][k] - pred), 1);
449 put_rac(c, state, 0);
453 if (f->version > 2) {
454 put_symbol(c, state, f->ec, 0);
455 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
458 f->avctx->extradata_size = ff_rac_terminate(c, 0);
459 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
460 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
461 f->avctx->extradata_size += 4;
466 static int sort_stt(FFV1Context *s, uint8_t stt[256])
468 int i, i2, changed, print = 0;
472 for (i = 12; i < 244; i++) {
473 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
475 #define COST(old, new) \
476 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
477 s->rc_stat[old][1] * -log2((new) / 256.0)
479 #define COST2(old, new) \
480 COST(old, new) + COST(256 - (old), 256 - (new))
482 double size0 = COST2(i, i) + COST2(i2, i2);
483 double sizeX = COST2(i, i2) + COST2(i2, i);
484 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
486 FFSWAP(int, stt[i], stt[i2]);
487 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
488 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
490 FFSWAP(int, stt[256 - i], stt[256 - i2]);
491 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
492 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
494 for (j = 1; j < 256; j++) {
497 else if (stt[j] == i2)
500 if (stt[256 - j] == 256 - i)
501 stt[256 - j] = 256 - i2;
502 else if (stt[256 - j] == 256 - i2)
503 stt[256 - j] = 256 - i;
514 static av_cold int encode_init(AVCodecContext *avctx)
516 FFV1Context *s = avctx->priv_data;
517 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
520 if ((ret = ff_ffv1_common_init(avctx)) < 0)
525 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
527 s->version = FFMAX(s->version, 2);
529 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
530 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
531 s->version = FFMAX(s->version, 2);
533 if (avctx->level <= 0 && s->version == 2) {
536 if (avctx->level >= 0 && avctx->level <= 4) {
537 if (avctx->level < s->version) {
538 av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
539 return AVERROR(EINVAL);
541 s->version = avctx->level;
545 s->ec = (s->version >= 3);
548 // CRC requires version 3+
550 s->version = FFMAX(s->version, 3);
552 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
553 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
554 return AVERROR_INVALIDDATA;
557 #if FF_API_CODER_TYPE
558 FF_DISABLE_DEPRECATION_WARNINGS
559 if (avctx->coder_type != -1)
560 s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
562 FF_ENABLE_DEPRECATION_WARNINGS
564 if (s->ac == 1) // Compatbility with common command line usage
565 s->ac = AC_RANGE_CUSTOM_TAB;
566 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
567 s->ac = AC_RANGE_DEFAULT_TAB;
570 switch(avctx->pix_fmt) {
571 case AV_PIX_FMT_GRAY9:
572 case AV_PIX_FMT_YUV444P9:
573 case AV_PIX_FMT_YUV422P9:
574 case AV_PIX_FMT_YUV420P9:
575 case AV_PIX_FMT_YUVA444P9:
576 case AV_PIX_FMT_YUVA422P9:
577 case AV_PIX_FMT_YUVA420P9:
578 if (!avctx->bits_per_raw_sample)
579 s->bits_per_raw_sample = 9;
580 case AV_PIX_FMT_GRAY10:
581 case AV_PIX_FMT_YUV444P10:
582 case AV_PIX_FMT_YUV440P10:
583 case AV_PIX_FMT_YUV420P10:
584 case AV_PIX_FMT_YUV422P10:
585 case AV_PIX_FMT_YUVA444P10:
586 case AV_PIX_FMT_YUVA422P10:
587 case AV_PIX_FMT_YUVA420P10:
588 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
589 s->bits_per_raw_sample = 10;
590 case AV_PIX_FMT_GRAY12:
591 case AV_PIX_FMT_YUV444P12:
592 case AV_PIX_FMT_YUV440P12:
593 case AV_PIX_FMT_YUV420P12:
594 case AV_PIX_FMT_YUV422P12:
595 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
596 s->bits_per_raw_sample = 12;
597 case AV_PIX_FMT_YUV444P14:
598 case AV_PIX_FMT_YUV420P14:
599 case AV_PIX_FMT_YUV422P14:
600 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
601 s->bits_per_raw_sample = 14;
602 s->packed_at_lsb = 1;
603 case AV_PIX_FMT_GRAY16:
604 case AV_PIX_FMT_YUV444P16:
605 case AV_PIX_FMT_YUV422P16:
606 case AV_PIX_FMT_YUV420P16:
607 case AV_PIX_FMT_YUVA444P16:
608 case AV_PIX_FMT_YUVA422P16:
609 case AV_PIX_FMT_YUVA420P16:
610 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
611 s->bits_per_raw_sample = 16;
612 } else if (!s->bits_per_raw_sample) {
613 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
615 if (s->bits_per_raw_sample <= 8) {
616 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
617 return AVERROR_INVALIDDATA;
619 s->version = FFMAX(s->version, 1);
620 case AV_PIX_FMT_GRAY8:
622 case AV_PIX_FMT_YUV444P:
623 case AV_PIX_FMT_YUV440P:
624 case AV_PIX_FMT_YUV422P:
625 case AV_PIX_FMT_YUV420P:
626 case AV_PIX_FMT_YUV411P:
627 case AV_PIX_FMT_YUV410P:
628 case AV_PIX_FMT_YUVA444P:
629 case AV_PIX_FMT_YUVA422P:
630 case AV_PIX_FMT_YUVA420P:
631 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
633 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
634 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
635 s->bits_per_raw_sample = 8;
636 else if (!s->bits_per_raw_sample)
637 s->bits_per_raw_sample = 8;
639 case AV_PIX_FMT_RGB32:
642 s->chroma_planes = 1;
643 s->bits_per_raw_sample = 8;
645 case AV_PIX_FMT_RGBA64:
648 s->chroma_planes = 1;
649 s->bits_per_raw_sample = 16;
651 s->version = FFMAX(s->version, 1);
653 case AV_PIX_FMT_RGB48:
655 s->chroma_planes = 1;
656 s->bits_per_raw_sample = 16;
658 s->version = FFMAX(s->version, 1);
660 case AV_PIX_FMT_0RGB32:
662 s->chroma_planes = 1;
663 s->bits_per_raw_sample = 8;
665 case AV_PIX_FMT_GBRP9:
666 if (!avctx->bits_per_raw_sample)
667 s->bits_per_raw_sample = 9;
668 case AV_PIX_FMT_GBRP10:
669 case AV_PIX_FMT_GBRAP10:
670 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
671 s->bits_per_raw_sample = 10;
672 case AV_PIX_FMT_GBRP12:
673 case AV_PIX_FMT_GBRAP12:
674 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
675 s->bits_per_raw_sample = 12;
676 case AV_PIX_FMT_GBRP14:
677 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
678 s->bits_per_raw_sample = 14;
679 case AV_PIX_FMT_GBRP16:
680 case AV_PIX_FMT_GBRAP16:
681 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
682 s->bits_per_raw_sample = 16;
683 else if (!s->bits_per_raw_sample)
684 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
685 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
687 s->chroma_planes = 1;
688 if (s->bits_per_raw_sample >= 16) {
691 s->version = FFMAX(s->version, 1);
694 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
695 return AVERROR(ENOSYS);
697 av_assert0(s->bits_per_raw_sample >= 8);
699 if (s->bits_per_raw_sample > 8) {
700 if (s->ac == AC_GOLOMB_RICE) {
701 av_log(avctx, AV_LOG_INFO,
702 "bits_per_raw_sample > 8, forcing range coder\n");
703 s->ac = AC_RANGE_CUSTOM_TAB;
706 #if FF_API_PRIVATE_OPT
707 FF_DISABLE_DEPRECATION_WARNINGS
708 if (avctx->context_model)
709 s->context_model = avctx->context_model;
710 if (avctx->context_model > 1U) {
711 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
712 return AVERROR(EINVAL);
714 FF_ENABLE_DEPRECATION_WARNINGS
717 if (s->ac == AC_RANGE_CUSTOM_TAB) {
718 for (i = 1; i < 256; i++)
719 s->state_transition[i] = ver2_state[i];
722 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
723 for (i = 1; i < 256; i++)
724 s->state_transition[i] = c.one_state[i];
727 for (i = 0; i < 256; i++) {
728 s->quant_table_count = 2;
729 if (s->bits_per_raw_sample <= 8) {
730 s->quant_tables[0][0][i]= quant11[i];
731 s->quant_tables[0][1][i]= 11*quant11[i];
732 s->quant_tables[0][2][i]= 11*11*quant11[i];
733 s->quant_tables[1][0][i]= quant11[i];
734 s->quant_tables[1][1][i]= 11*quant11[i];
735 s->quant_tables[1][2][i]= 11*11*quant5 [i];
736 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
737 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
739 s->quant_tables[0][0][i]= quant9_10bit[i];
740 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
741 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
742 s->quant_tables[1][0][i]= quant9_10bit[i];
743 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
744 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
745 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
746 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
749 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
750 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
751 memcpy(s->quant_table, s->quant_tables[s->context_model],
752 sizeof(s->quant_table));
754 for (i = 0; i < s->plane_count; i++) {
755 PlaneContext *const p = &s->plane[i];
757 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
758 p->quant_table_index = s->context_model;
759 p->context_count = s->context_count[p->quant_table_index];
762 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
765 #if FF_API_CODED_FRAME
766 FF_DISABLE_DEPRECATION_WARNINGS
767 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
768 FF_ENABLE_DEPRECATION_WARNINGS
771 if (!s->transparency)
773 if (!s->chroma_planes && s->version > 3)
776 ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
780 s->picture_number = 0;
782 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
783 for (i = 0; i < s->quant_table_count; i++) {
784 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
785 sizeof(*s->rc_stat2[i]));
787 return AVERROR(ENOMEM);
790 if (avctx->stats_in) {
791 char *p = avctx->stats_in;
792 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
796 return AVERROR(ENOMEM);
798 av_assert0(s->version >= 2);
801 for (j = 0; j < 256; j++)
802 for (i = 0; i < 2; i++) {
803 s->rc_stat[j][i] = strtol(p, &next, 0);
805 av_log(avctx, AV_LOG_ERROR,
806 "2Pass file invalid at %d %d [%s]\n", j, i, p);
807 av_freep(&best_state);
808 return AVERROR_INVALIDDATA;
812 for (i = 0; i < s->quant_table_count; i++)
813 for (j = 0; j < s->context_count[i]; j++) {
814 for (k = 0; k < 32; k++)
815 for (m = 0; m < 2; m++) {
816 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
818 av_log(avctx, AV_LOG_ERROR,
819 "2Pass file invalid at %d %d %d %d [%s]\n",
821 av_freep(&best_state);
822 return AVERROR_INVALIDDATA;
827 gob_count = strtol(p, &next, 0);
828 if (next == p || gob_count <= 0) {
829 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
830 av_freep(&best_state);
831 return AVERROR_INVALIDDATA;
834 while (*p == '\n' || *p == ' ')
839 if (s->ac == AC_RANGE_CUSTOM_TAB)
840 sort_stt(s, s->state_transition);
842 find_best_state(best_state, s->state_transition);
844 for (i = 0; i < s->quant_table_count; i++) {
845 for (k = 0; k < 32; k++) {
848 for (j = 0; j < s->context_count[i]; j++) {
850 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
852 p = 256.0 * b / (a + b);
853 s->initial_states[i][jp][k] =
854 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
855 for(jp++; jp<j; jp++)
856 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
859 a += s->rc_stat2[i][j][k][0];
860 b += s->rc_stat2[i][j][k][1];
862 p = 256.0 * b / (a + b);
864 s->initial_states[i][j][k] =
865 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
869 av_freep(&best_state);
872 if (s->version > 1) {
873 int plane_count = 1 + 2*s->chroma_planes + s->transparency;
874 int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
875 int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
876 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
878 s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
880 for (; s->num_v_slices < 32; s->num_v_slices++) {
881 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
882 int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
883 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
884 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
886 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
888 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
892 av_log(avctx, AV_LOG_ERROR,
893 "Unsupported number %d of slices requested, please specify a "
894 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
896 return AVERROR(ENOSYS);
898 if ((ret = write_extradata(s)) < 0)
902 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
904 s->slice_count = s->max_slice_count;
905 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
908 #define STATS_OUT_SIZE 1024 * 1024 * 6
909 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
910 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
911 if (!avctx->stats_out)
912 return AVERROR(ENOMEM);
913 for (i = 0; i < s->quant_table_count; i++)
914 for (j = 0; j < s->max_slice_count; j++) {
915 FFV1Context *sf = s->slice_context[j];
916 av_assert0(!sf->rc_stat2[i]);
917 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
918 sizeof(*sf->rc_stat2[i]));
919 if (!sf->rc_stat2[i])
920 return AVERROR(ENOMEM);
927 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
929 RangeCoder *c = &fs->c;
930 uint8_t state[CONTEXT_SIZE];
932 memset(state, 128, sizeof(state));
934 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
935 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
936 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
937 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
938 for (j=0; j<f->plane_count; j++) {
939 put_symbol(c, state, f->plane[j].quant_table_index, 0);
940 av_assert0(f->plane[j].quant_table_index == f->context_model);
942 if (!f->picture.f->interlaced_frame)
943 put_symbol(c, state, 3, 0);
945 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
946 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
947 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
948 if (f->version > 3) {
949 put_rac(c, state, fs->slice_coding_mode == 1);
950 if (fs->slice_coding_mode == 1)
951 ff_ffv1_clear_slice_state(f, fs);
952 put_symbol(c, state, fs->slice_coding_mode, 0);
953 if (fs->slice_coding_mode != 1) {
954 put_symbol(c, state, fs->slice_rct_by_coef, 0);
955 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
960 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
962 #define NB_Y_COEFF 15
963 static const int rct_y_coeff[15][2] = {
965 {1, 1}, // R + 2G + B
976 {1, 2}, // R + G + 2B
977 {2, 1}, // 2R + G + B
982 int stat[NB_Y_COEFF] = {0};
983 int x, y, i, p, best;
985 int lbd = fs->bits_per_raw_sample <= 8;
987 for (y = 0; y < h; y++) {
988 int lastr=0, lastg=0, lastb=0;
989 for (p = 0; p < 3; p++)
990 sample[p] = fs->sample_buffer + p*w;
992 for (x = 0; x < w; x++) {
996 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
999 r = (v >> 16) & 0xFF;
1001 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1002 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1003 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1010 int bg = ag - sample[0][x];
1011 int bb = ab - sample[1][x];
1012 int br = ar - sample[2][x];
1017 for (i = 0; i<NB_Y_COEFF; i++) {
1018 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1033 for (i=1; i<NB_Y_COEFF; i++) {
1034 if (stat[i] < stat[best])
1038 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1039 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1042 static int encode_slice(AVCodecContext *c, void *arg)
1044 FFV1Context *fs = *(void **)arg;
1045 FFV1Context *f = fs->avctx->priv_data;
1046 int width = fs->slice_width;
1047 int height = fs->slice_height;
1048 int x = fs->slice_x;
1049 int y = fs->slice_y;
1050 const AVFrame *const p = f->picture.f;
1051 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1053 RangeCoder c_bak = fs->c;
1054 const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1055 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1056 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1057 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1059 fs->slice_coding_mode = 0;
1060 if (f->version > 3) {
1061 choose_rct_params(fs, planes, p->linesize, width, height);
1063 fs->slice_rct_by_coef = 1;
1064 fs->slice_rct_ry_coef = 1;
1069 ff_ffv1_clear_slice_state(f, fs);
1070 if (f->version > 2) {
1071 encode_slice_header(f, fs);
1073 if (fs->ac == AC_GOLOMB_RICE) {
1074 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1075 init_put_bits(&fs->pb,
1076 fs->c.bytestream_start + fs->ac_byte_count,
1077 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1080 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1081 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1082 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1083 const int cx = x >> f->chroma_h_shift;
1084 const int cy = y >> f->chroma_v_shift;
1086 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1088 if (f->chroma_planes) {
1089 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1090 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1092 if (fs->transparency)
1093 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1094 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1095 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1096 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1097 } else if (f->use32bit) {
1098 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1100 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1105 av_assert0(fs->slice_coding_mode == 0);
1106 if (fs->version < 4 || !fs->ac) {
1107 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1110 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1111 fs->slice_coding_mode = 1;
1119 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1120 const AVFrame *pict, int *got_packet)
1122 FFV1Context *f = avctx->priv_data;
1123 RangeCoder *const c = &f->slice_context[0]->c;
1124 AVFrame *const p = f->picture.f;
1125 uint8_t keystate = 128;
1128 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1129 + avctx->width*avctx->height*37LL*4;
1132 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1134 char *p = avctx->stats_out;
1135 char *end = p + STATS_OUT_SIZE;
1137 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1138 for (i = 0; i < f->quant_table_count; i++)
1139 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1141 av_assert0(f->slice_count == f->max_slice_count);
1142 for (j = 0; j < f->slice_count; j++) {
1143 FFV1Context *fs = f->slice_context[j];
1144 for (i = 0; i < 256; i++) {
1145 f->rc_stat[i][0] += fs->rc_stat[i][0];
1146 f->rc_stat[i][1] += fs->rc_stat[i][1];
1148 for (i = 0; i < f->quant_table_count; i++) {
1149 for (k = 0; k < f->context_count[i]; k++)
1150 for (m = 0; m < 32; m++) {
1151 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1152 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1157 for (j = 0; j < 256; j++) {
1158 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1159 f->rc_stat[j][0], f->rc_stat[j][1]);
1162 snprintf(p, end - p, "\n");
1164 for (i = 0; i < f->quant_table_count; i++) {
1165 for (j = 0; j < f->context_count[i]; j++)
1166 for (m = 0; m < 32; m++) {
1167 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1168 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1172 snprintf(p, end - p, "%d\n", f->gob_count);
1178 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1180 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1181 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1182 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1185 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1188 ff_init_range_encoder(c, pkt->data, pkt->size);
1189 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1192 if ((ret = av_frame_ref(p, pict)) < 0)
1194 #if FF_API_CODED_FRAME
1195 FF_DISABLE_DEPRECATION_WARNINGS
1196 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1197 FF_ENABLE_DEPRECATION_WARNINGS
1200 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1201 put_rac(c, &keystate, 1);
1206 put_rac(c, &keystate, 0);
1210 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1212 for (i = 1; i < 256; i++) {
1213 c->one_state[i] = f->state_transition[i];
1214 c->zero_state[256 - i] = 256 - c->one_state[i];
1218 for (i = 0; i < f->slice_count; i++) {
1219 FFV1Context *fs = f->slice_context[i];
1220 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1221 int len = pkt->size / f->slice_count;
1223 ff_init_range_encoder(&fs->c, start, len);
1225 av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1226 av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1227 fs->c.bytestream_end = fs->c.bytestream_start + len;
1230 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1231 f->slice_count, sizeof(void *));
1234 for (i = 0; i < f->slice_count; i++) {
1235 FFV1Context *fs = f->slice_context[i];
1238 if (fs->ac != AC_GOLOMB_RICE) {
1239 bytes = ff_rac_terminate(&fs->c, 1);
1241 flush_put_bits(&fs->pb); // FIXME: nicer padding
1242 bytes = fs->ac_byte_count + put_bytes_output(&fs->pb);
1244 if (i > 0 || f->version > 2) {
1245 av_assert0(bytes < pkt->size / f->slice_count);
1246 memmove(buf_p, fs->c.bytestream_start, bytes);
1247 av_assert0(bytes < (1 << 24));
1248 AV_WB24(buf_p + bytes, bytes);
1254 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1255 AV_WL32(buf_p + bytes, v);
1261 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1262 avctx->stats_out[0] = '\0';
1264 #if FF_API_CODED_FRAME
1265 FF_DISABLE_DEPRECATION_WARNINGS
1266 avctx->coded_frame->key_frame = f->key_frame;
1267 FF_ENABLE_DEPRECATION_WARNINGS
1270 f->picture_number++;
1271 pkt->size = buf_p - pkt->data;
1273 pkt->dts = pict->pts;
1274 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1280 static av_cold int encode_close(AVCodecContext *avctx)
1282 ff_ffv1_close(avctx);
1286 #define OFFSET(x) offsetof(FFV1Context, x)
1287 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1288 static const AVOption options[] = {
1289 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1290 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1291 { .i64 = 0 }, -2, 2, VE, "coder" },
1292 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1293 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1294 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1295 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1296 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1297 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1298 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1299 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1300 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1301 { .i64 = 0 }, 0, 1, VE },
1306 static const AVClass ffv1_class = {
1307 .class_name = "ffv1 encoder",
1308 .item_name = av_default_item_name,
1310 .version = LIBAVUTIL_VERSION_INT,
1313 #if FF_API_CODER_TYPE
1314 static const AVCodecDefault ffv1_defaults[] = {
1320 AVCodec ff_ffv1_encoder = {
1322 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1323 .type = AVMEDIA_TYPE_VIDEO,
1324 .id = AV_CODEC_ID_FFV1,
1325 .priv_data_size = sizeof(FFV1Context),
1326 .init = encode_init,
1327 .encode2 = encode_frame,
1328 .close = encode_close,
1329 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1330 .pix_fmts = (const enum AVPixelFormat[]) {
1331 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1332 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1333 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1334 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1335 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1336 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1337 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1338 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1339 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1340 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1341 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1342 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1344 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1345 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1346 AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1348 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1349 AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1353 #if FF_API_CODER_TYPE
1354 .defaults = ffv1_defaults,
1356 .priv_class = &ffv1_class,
1357 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,