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 // CRC requires version 3+
544 s->version = FFMAX(s->version, 3);
546 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
547 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
548 return AVERROR_INVALIDDATA;
551 #if FF_API_CODER_TYPE
552 FF_DISABLE_DEPRECATION_WARNINGS
553 if (avctx->coder_type != -1)
554 s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
556 FF_ENABLE_DEPRECATION_WARNINGS
558 if (s->ac == 1) // Compatbility with common command line usage
559 s->ac = AC_RANGE_CUSTOM_TAB;
560 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
561 s->ac = AC_RANGE_DEFAULT_TAB;
564 switch(avctx->pix_fmt) {
565 case AV_PIX_FMT_GRAY9:
566 case AV_PIX_FMT_YUV444P9:
567 case AV_PIX_FMT_YUV422P9:
568 case AV_PIX_FMT_YUV420P9:
569 case AV_PIX_FMT_YUVA444P9:
570 case AV_PIX_FMT_YUVA422P9:
571 case AV_PIX_FMT_YUVA420P9:
572 if (!avctx->bits_per_raw_sample)
573 s->bits_per_raw_sample = 9;
574 case AV_PIX_FMT_GRAY10:
575 case AV_PIX_FMT_YUV444P10:
576 case AV_PIX_FMT_YUV440P10:
577 case AV_PIX_FMT_YUV420P10:
578 case AV_PIX_FMT_YUV422P10:
579 case AV_PIX_FMT_YUVA444P10:
580 case AV_PIX_FMT_YUVA422P10:
581 case AV_PIX_FMT_YUVA420P10:
582 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
583 s->bits_per_raw_sample = 10;
584 case AV_PIX_FMT_GRAY12:
585 case AV_PIX_FMT_YUV444P12:
586 case AV_PIX_FMT_YUV440P12:
587 case AV_PIX_FMT_YUV420P12:
588 case AV_PIX_FMT_YUV422P12:
589 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
590 s->bits_per_raw_sample = 12;
591 case AV_PIX_FMT_YUV444P14:
592 case AV_PIX_FMT_YUV420P14:
593 case AV_PIX_FMT_YUV422P14:
594 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
595 s->bits_per_raw_sample = 14;
596 s->packed_at_lsb = 1;
597 case AV_PIX_FMT_GRAY16:
598 case AV_PIX_FMT_YUV444P16:
599 case AV_PIX_FMT_YUV422P16:
600 case AV_PIX_FMT_YUV420P16:
601 case AV_PIX_FMT_YUVA444P16:
602 case AV_PIX_FMT_YUVA422P16:
603 case AV_PIX_FMT_YUVA420P16:
604 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
605 s->bits_per_raw_sample = 16;
606 } else if (!s->bits_per_raw_sample) {
607 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
609 if (s->bits_per_raw_sample <= 8) {
610 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
611 return AVERROR_INVALIDDATA;
613 s->version = FFMAX(s->version, 1);
614 case AV_PIX_FMT_GRAY8:
616 case AV_PIX_FMT_YUV444P:
617 case AV_PIX_FMT_YUV440P:
618 case AV_PIX_FMT_YUV422P:
619 case AV_PIX_FMT_YUV420P:
620 case AV_PIX_FMT_YUV411P:
621 case AV_PIX_FMT_YUV410P:
622 case AV_PIX_FMT_YUVA444P:
623 case AV_PIX_FMT_YUVA422P:
624 case AV_PIX_FMT_YUVA420P:
625 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
627 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
628 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
629 s->bits_per_raw_sample = 8;
630 else if (!s->bits_per_raw_sample)
631 s->bits_per_raw_sample = 8;
633 case AV_PIX_FMT_RGB32:
636 s->chroma_planes = 1;
637 s->bits_per_raw_sample = 8;
639 case AV_PIX_FMT_RGBA64:
642 s->chroma_planes = 1;
643 s->bits_per_raw_sample = 16;
645 s->version = FFMAX(s->version, 1);
647 case AV_PIX_FMT_RGB48:
649 s->chroma_planes = 1;
650 s->bits_per_raw_sample = 16;
652 s->version = FFMAX(s->version, 1);
654 case AV_PIX_FMT_0RGB32:
656 s->chroma_planes = 1;
657 s->bits_per_raw_sample = 8;
659 case AV_PIX_FMT_GBRP9:
660 if (!avctx->bits_per_raw_sample)
661 s->bits_per_raw_sample = 9;
662 case AV_PIX_FMT_GBRP10:
663 case AV_PIX_FMT_GBRAP10:
664 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
665 s->bits_per_raw_sample = 10;
666 case AV_PIX_FMT_GBRP12:
667 case AV_PIX_FMT_GBRAP12:
668 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
669 s->bits_per_raw_sample = 12;
670 case AV_PIX_FMT_GBRP14:
671 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
672 s->bits_per_raw_sample = 14;
673 case AV_PIX_FMT_GBRP16:
674 case AV_PIX_FMT_GBRAP16:
675 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
676 s->bits_per_raw_sample = 16;
677 else if (!s->bits_per_raw_sample)
678 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
679 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
681 s->chroma_planes = 1;
682 if (s->bits_per_raw_sample >= 16) {
685 s->version = FFMAX(s->version, 1);
688 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
689 return AVERROR(ENOSYS);
691 av_assert0(s->bits_per_raw_sample >= 8);
693 if (s->bits_per_raw_sample > 8) {
694 if (s->ac == AC_GOLOMB_RICE) {
695 av_log(avctx, AV_LOG_INFO,
696 "bits_per_raw_sample > 8, forcing range coder\n");
697 s->ac = AC_RANGE_CUSTOM_TAB;
700 #if FF_API_PRIVATE_OPT
701 FF_DISABLE_DEPRECATION_WARNINGS
702 if (avctx->context_model)
703 s->context_model = avctx->context_model;
704 if (avctx->context_model > 1U) {
705 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
706 return AVERROR(EINVAL);
708 FF_ENABLE_DEPRECATION_WARNINGS
711 if (s->ac == AC_RANGE_CUSTOM_TAB) {
712 for (i = 1; i < 256; i++)
713 s->state_transition[i] = ver2_state[i];
716 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
717 for (i = 1; i < 256; i++)
718 s->state_transition[i] = c.one_state[i];
721 for (i = 0; i < 256; i++) {
722 s->quant_table_count = 2;
723 if (s->bits_per_raw_sample <= 8) {
724 s->quant_tables[0][0][i]= quant11[i];
725 s->quant_tables[0][1][i]= 11*quant11[i];
726 s->quant_tables[0][2][i]= 11*11*quant11[i];
727 s->quant_tables[1][0][i]= quant11[i];
728 s->quant_tables[1][1][i]= 11*quant11[i];
729 s->quant_tables[1][2][i]= 11*11*quant5 [i];
730 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
731 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
733 s->quant_tables[0][0][i]= quant9_10bit[i];
734 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
735 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
736 s->quant_tables[1][0][i]= quant9_10bit[i];
737 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
738 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
739 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
740 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
743 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
744 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
745 memcpy(s->quant_table, s->quant_tables[s->context_model],
746 sizeof(s->quant_table));
748 for (i = 0; i < s->plane_count; i++) {
749 PlaneContext *const p = &s->plane[i];
751 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
752 p->quant_table_index = s->context_model;
753 p->context_count = s->context_count[p->quant_table_index];
756 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
759 #if FF_API_CODED_FRAME
760 FF_DISABLE_DEPRECATION_WARNINGS
761 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
762 FF_ENABLE_DEPRECATION_WARNINGS
765 if (!s->transparency)
767 if (!s->chroma_planes && s->version > 3)
770 ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
774 s->picture_number = 0;
776 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
777 for (i = 0; i < s->quant_table_count; i++) {
778 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
779 sizeof(*s->rc_stat2[i]));
781 return AVERROR(ENOMEM);
784 if (avctx->stats_in) {
785 char *p = avctx->stats_in;
786 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
790 return AVERROR(ENOMEM);
792 av_assert0(s->version >= 2);
795 for (j = 0; j < 256; j++)
796 for (i = 0; i < 2; i++) {
797 s->rc_stat[j][i] = strtol(p, &next, 0);
799 av_log(avctx, AV_LOG_ERROR,
800 "2Pass file invalid at %d %d [%s]\n", j, i, p);
801 av_freep(&best_state);
802 return AVERROR_INVALIDDATA;
806 for (i = 0; i < s->quant_table_count; i++)
807 for (j = 0; j < s->context_count[i]; j++) {
808 for (k = 0; k < 32; k++)
809 for (m = 0; m < 2; m++) {
810 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
812 av_log(avctx, AV_LOG_ERROR,
813 "2Pass file invalid at %d %d %d %d [%s]\n",
815 av_freep(&best_state);
816 return AVERROR_INVALIDDATA;
821 gob_count = strtol(p, &next, 0);
822 if (next == p || gob_count <= 0) {
823 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
824 av_freep(&best_state);
825 return AVERROR_INVALIDDATA;
828 while (*p == '\n' || *p == ' ')
833 if (s->ac == AC_RANGE_CUSTOM_TAB)
834 sort_stt(s, s->state_transition);
836 find_best_state(best_state, s->state_transition);
838 for (i = 0; i < s->quant_table_count; i++) {
839 for (k = 0; k < 32; k++) {
842 for (j = 0; j < s->context_count[i]; j++) {
844 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
846 p = 256.0 * b / (a + b);
847 s->initial_states[i][jp][k] =
848 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
849 for(jp++; jp<j; jp++)
850 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
853 a += s->rc_stat2[i][j][k][0];
854 b += s->rc_stat2[i][j][k][1];
856 p = 256.0 * b / (a + b);
858 s->initial_states[i][j][k] =
859 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
863 av_freep(&best_state);
866 if (s->version > 1) {
867 int plane_count = 1 + 2*s->chroma_planes + s->transparency;
868 int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
869 int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
870 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
872 s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
874 for (; s->num_v_slices < 32; s->num_v_slices++) {
875 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
876 int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
877 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
878 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
880 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
882 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
886 av_log(avctx, AV_LOG_ERROR,
887 "Unsupported number %d of slices requested, please specify a "
888 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
890 return AVERROR(ENOSYS);
892 if ((ret = write_extradata(s)) < 0)
896 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
898 s->slice_count = s->max_slice_count;
899 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
902 #define STATS_OUT_SIZE 1024 * 1024 * 6
903 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
904 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
905 if (!avctx->stats_out)
906 return AVERROR(ENOMEM);
907 for (i = 0; i < s->quant_table_count; i++)
908 for (j = 0; j < s->max_slice_count; j++) {
909 FFV1Context *sf = s->slice_context[j];
910 av_assert0(!sf->rc_stat2[i]);
911 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
912 sizeof(*sf->rc_stat2[i]));
913 if (!sf->rc_stat2[i])
914 return AVERROR(ENOMEM);
921 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
923 RangeCoder *c = &fs->c;
924 uint8_t state[CONTEXT_SIZE];
926 memset(state, 128, sizeof(state));
928 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
929 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
930 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
931 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
932 for (j=0; j<f->plane_count; j++) {
933 put_symbol(c, state, f->plane[j].quant_table_index, 0);
934 av_assert0(f->plane[j].quant_table_index == f->context_model);
936 if (!f->picture.f->interlaced_frame)
937 put_symbol(c, state, 3, 0);
939 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
940 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
941 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
942 if (f->version > 3) {
943 put_rac(c, state, fs->slice_coding_mode == 1);
944 if (fs->slice_coding_mode == 1)
945 ff_ffv1_clear_slice_state(f, fs);
946 put_symbol(c, state, fs->slice_coding_mode, 0);
947 if (fs->slice_coding_mode != 1) {
948 put_symbol(c, state, fs->slice_rct_by_coef, 0);
949 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
954 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
956 #define NB_Y_COEFF 15
957 static const int rct_y_coeff[15][2] = {
959 {1, 1}, // R + 2G + B
970 {1, 2}, // R + G + 2B
971 {2, 1}, // 2R + G + B
976 int stat[NB_Y_COEFF] = {0};
977 int x, y, i, p, best;
979 int lbd = fs->bits_per_raw_sample <= 8;
981 for (y = 0; y < h; y++) {
982 int lastr=0, lastg=0, lastb=0;
983 for (p = 0; p < 3; p++)
984 sample[p] = fs->sample_buffer + p*w;
986 for (x = 0; x < w; x++) {
990 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
993 r = (v >> 16) & 0xFF;
995 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
996 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
997 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1004 int bg = ag - sample[0][x];
1005 int bb = ab - sample[1][x];
1006 int br = ar - sample[2][x];
1011 for (i = 0; i<NB_Y_COEFF; i++) {
1012 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1027 for (i=1; i<NB_Y_COEFF; i++) {
1028 if (stat[i] < stat[best])
1032 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1033 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1036 static int encode_slice(AVCodecContext *c, void *arg)
1038 FFV1Context *fs = *(void **)arg;
1039 FFV1Context *f = fs->avctx->priv_data;
1040 int width = fs->slice_width;
1041 int height = fs->slice_height;
1042 int x = fs->slice_x;
1043 int y = fs->slice_y;
1044 const AVFrame *const p = f->picture.f;
1045 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1047 RangeCoder c_bak = fs->c;
1048 const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1049 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1050 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1051 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1053 fs->slice_coding_mode = 0;
1054 if (f->version > 3) {
1055 choose_rct_params(fs, planes, p->linesize, width, height);
1057 fs->slice_rct_by_coef = 1;
1058 fs->slice_rct_ry_coef = 1;
1063 ff_ffv1_clear_slice_state(f, fs);
1064 if (f->version > 2) {
1065 encode_slice_header(f, fs);
1067 if (fs->ac == AC_GOLOMB_RICE) {
1069 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1070 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1071 init_put_bits(&fs->pb,
1072 fs->c.bytestream_start + fs->ac_byte_count,
1073 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1076 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1077 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1078 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1079 const int cx = x >> f->chroma_h_shift;
1080 const int cy = y >> f->chroma_v_shift;
1082 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1084 if (f->chroma_planes) {
1085 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1086 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1088 if (fs->transparency)
1089 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1090 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1091 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1092 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1093 } else if (f->use32bit) {
1094 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1096 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1101 av_assert0(fs->slice_coding_mode == 0);
1102 if (fs->version < 4 || !fs->ac) {
1103 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1106 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1107 fs->slice_coding_mode = 1;
1115 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1116 const AVFrame *pict, int *got_packet)
1118 FFV1Context *f = avctx->priv_data;
1119 RangeCoder *const c = &f->slice_context[0]->c;
1120 AVFrame *const p = f->picture.f;
1121 uint8_t keystate = 128;
1124 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1125 + avctx->width*avctx->height*37LL*4;
1128 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1130 char *p = avctx->stats_out;
1131 char *end = p + STATS_OUT_SIZE;
1133 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1134 for (i = 0; i < f->quant_table_count; i++)
1135 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1137 av_assert0(f->slice_count == f->max_slice_count);
1138 for (j = 0; j < f->slice_count; j++) {
1139 FFV1Context *fs = f->slice_context[j];
1140 for (i = 0; i < 256; i++) {
1141 f->rc_stat[i][0] += fs->rc_stat[i][0];
1142 f->rc_stat[i][1] += fs->rc_stat[i][1];
1144 for (i = 0; i < f->quant_table_count; i++) {
1145 for (k = 0; k < f->context_count[i]; k++)
1146 for (m = 0; m < 32; m++) {
1147 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1148 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1153 for (j = 0; j < 256; j++) {
1154 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1155 f->rc_stat[j][0], f->rc_stat[j][1]);
1158 snprintf(p, end - p, "\n");
1160 for (i = 0; i < f->quant_table_count; i++) {
1161 for (j = 0; j < f->context_count[i]; j++)
1162 for (m = 0; m < 32; m++) {
1163 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1164 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1168 snprintf(p, end - p, "%d\n", f->gob_count);
1174 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1176 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1177 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1178 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1181 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1184 ff_init_range_encoder(c, pkt->data, pkt->size);
1185 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1188 if ((ret = av_frame_ref(p, pict)) < 0)
1190 #if FF_API_CODED_FRAME
1191 FF_DISABLE_DEPRECATION_WARNINGS
1192 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1193 FF_ENABLE_DEPRECATION_WARNINGS
1196 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1197 put_rac(c, &keystate, 1);
1202 put_rac(c, &keystate, 0);
1206 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1208 for (i = 1; i < 256; i++) {
1209 c->one_state[i] = f->state_transition[i];
1210 c->zero_state[256 - i] = 256 - c->one_state[i];
1214 for (i = 0; i < f->slice_count; i++) {
1215 FFV1Context *fs = f->slice_context[i];
1216 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1217 int len = pkt->size / f->slice_count;
1219 ff_init_range_encoder(&fs->c, start, len);
1221 av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1222 av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1223 fs->c.bytestream_end = fs->c.bytestream_start + len;
1226 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1227 f->slice_count, sizeof(void *));
1230 for (i = 0; i < f->slice_count; i++) {
1231 FFV1Context *fs = f->slice_context[i];
1234 if (fs->ac != AC_GOLOMB_RICE) {
1235 uint8_t state = 129;
1236 put_rac(&fs->c, &state, 0);
1237 bytes = ff_rac_terminate(&fs->c);
1239 flush_put_bits(&fs->pb); // FIXME: nicer padding
1240 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1242 if (i > 0 || f->version > 2) {
1243 av_assert0(bytes < pkt->size / f->slice_count);
1244 memmove(buf_p, fs->c.bytestream_start, bytes);
1245 av_assert0(bytes < (1 << 24));
1246 AV_WB24(buf_p + bytes, bytes);
1252 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1253 AV_WL32(buf_p + bytes, v);
1259 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1260 avctx->stats_out[0] = '\0';
1262 #if FF_API_CODED_FRAME
1263 FF_DISABLE_DEPRECATION_WARNINGS
1264 avctx->coded_frame->key_frame = f->key_frame;
1265 FF_ENABLE_DEPRECATION_WARNINGS
1268 f->picture_number++;
1269 pkt->size = buf_p - pkt->data;
1271 pkt->dts = pict->pts;
1272 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1278 static av_cold int encode_close(AVCodecContext *avctx)
1280 ff_ffv1_close(avctx);
1284 #define OFFSET(x) offsetof(FFV1Context, x)
1285 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1286 static const AVOption options[] = {
1287 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1288 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1289 { .i64 = 0 }, -2, 2, VE, "coder" },
1290 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1291 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1292 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1293 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1294 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1295 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1296 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1297 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1298 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1299 { .i64 = 0 }, 0, 1, VE },
1304 static const AVClass ffv1_class = {
1305 .class_name = "ffv1 encoder",
1306 .item_name = av_default_item_name,
1308 .version = LIBAVUTIL_VERSION_INT,
1311 #if FF_API_CODER_TYPE
1312 static const AVCodecDefault ffv1_defaults[] = {
1318 AVCodec ff_ffv1_encoder = {
1320 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1321 .type = AVMEDIA_TYPE_VIDEO,
1322 .id = AV_CODEC_ID_FFV1,
1323 .priv_data_size = sizeof(FFV1Context),
1324 .init = encode_init,
1325 .encode2 = encode_frame,
1326 .close = encode_close,
1327 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1328 .pix_fmts = (const enum AVPixelFormat[]) {
1329 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1330 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1331 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1332 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1333 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1334 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1335 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1336 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1337 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1338 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1339 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1340 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1342 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1343 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1344 AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1346 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1347 AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1351 #if FF_API_CODER_TYPE
1352 .defaults = ffv1_defaults,
1354 .priv_class = &ffv1_class,