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, 0);
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) {
1068 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1069 init_put_bits(&fs->pb,
1070 fs->c.bytestream_start + fs->ac_byte_count,
1071 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1074 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1075 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1076 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1077 const int cx = x >> f->chroma_h_shift;
1078 const int cy = y >> f->chroma_v_shift;
1080 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1082 if (f->chroma_planes) {
1083 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1084 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1086 if (fs->transparency)
1087 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1088 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1089 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1090 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1091 } else if (f->use32bit) {
1092 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1094 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1099 av_assert0(fs->slice_coding_mode == 0);
1100 if (fs->version < 4 || !fs->ac) {
1101 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1104 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1105 fs->slice_coding_mode = 1;
1113 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1114 const AVFrame *pict, int *got_packet)
1116 FFV1Context *f = avctx->priv_data;
1117 RangeCoder *const c = &f->slice_context[0]->c;
1118 AVFrame *const p = f->picture.f;
1119 uint8_t keystate = 128;
1122 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1123 + avctx->width*avctx->height*37LL*4;
1126 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1128 char *p = avctx->stats_out;
1129 char *end = p + STATS_OUT_SIZE;
1131 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1132 for (i = 0; i < f->quant_table_count; i++)
1133 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1135 av_assert0(f->slice_count == f->max_slice_count);
1136 for (j = 0; j < f->slice_count; j++) {
1137 FFV1Context *fs = f->slice_context[j];
1138 for (i = 0; i < 256; i++) {
1139 f->rc_stat[i][0] += fs->rc_stat[i][0];
1140 f->rc_stat[i][1] += fs->rc_stat[i][1];
1142 for (i = 0; i < f->quant_table_count; i++) {
1143 for (k = 0; k < f->context_count[i]; k++)
1144 for (m = 0; m < 32; m++) {
1145 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1146 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1151 for (j = 0; j < 256; j++) {
1152 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1153 f->rc_stat[j][0], f->rc_stat[j][1]);
1156 snprintf(p, end - p, "\n");
1158 for (i = 0; i < f->quant_table_count; i++) {
1159 for (j = 0; j < f->context_count[i]; j++)
1160 for (m = 0; m < 32; m++) {
1161 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1162 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1166 snprintf(p, end - p, "%d\n", f->gob_count);
1172 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1174 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1175 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1176 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1179 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1182 ff_init_range_encoder(c, pkt->data, pkt->size);
1183 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1186 if ((ret = av_frame_ref(p, pict)) < 0)
1188 #if FF_API_CODED_FRAME
1189 FF_DISABLE_DEPRECATION_WARNINGS
1190 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1191 FF_ENABLE_DEPRECATION_WARNINGS
1194 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1195 put_rac(c, &keystate, 1);
1200 put_rac(c, &keystate, 0);
1204 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1206 for (i = 1; i < 256; i++) {
1207 c->one_state[i] = f->state_transition[i];
1208 c->zero_state[256 - i] = 256 - c->one_state[i];
1212 for (i = 0; i < f->slice_count; i++) {
1213 FFV1Context *fs = f->slice_context[i];
1214 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1215 int len = pkt->size / f->slice_count;
1217 ff_init_range_encoder(&fs->c, start, len);
1219 av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1220 av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1221 fs->c.bytestream_end = fs->c.bytestream_start + len;
1224 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1225 f->slice_count, sizeof(void *));
1228 for (i = 0; i < f->slice_count; i++) {
1229 FFV1Context *fs = f->slice_context[i];
1232 if (fs->ac != AC_GOLOMB_RICE) {
1233 bytes = ff_rac_terminate(&fs->c, 1);
1235 flush_put_bits(&fs->pb); // FIXME: nicer padding
1236 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1238 if (i > 0 || f->version > 2) {
1239 av_assert0(bytes < pkt->size / f->slice_count);
1240 memmove(buf_p, fs->c.bytestream_start, bytes);
1241 av_assert0(bytes < (1 << 24));
1242 AV_WB24(buf_p + bytes, bytes);
1248 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1249 AV_WL32(buf_p + bytes, v);
1255 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1256 avctx->stats_out[0] = '\0';
1258 #if FF_API_CODED_FRAME
1259 FF_DISABLE_DEPRECATION_WARNINGS
1260 avctx->coded_frame->key_frame = f->key_frame;
1261 FF_ENABLE_DEPRECATION_WARNINGS
1264 f->picture_number++;
1265 pkt->size = buf_p - pkt->data;
1267 pkt->dts = pict->pts;
1268 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1274 static av_cold int encode_close(AVCodecContext *avctx)
1276 ff_ffv1_close(avctx);
1280 #define OFFSET(x) offsetof(FFV1Context, x)
1281 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1282 static const AVOption options[] = {
1283 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1284 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1285 { .i64 = 0 }, -2, 2, VE, "coder" },
1286 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1287 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1288 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1289 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1290 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1291 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1292 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1293 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1294 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1295 { .i64 = 0 }, 0, 1, VE },
1300 static const AVClass ffv1_class = {
1301 .class_name = "ffv1 encoder",
1302 .item_name = av_default_item_name,
1304 .version = LIBAVUTIL_VERSION_INT,
1307 #if FF_API_CODER_TYPE
1308 static const AVCodecDefault ffv1_defaults[] = {
1314 AVCodec ff_ffv1_encoder = {
1316 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1317 .type = AVMEDIA_TYPE_VIDEO,
1318 .id = AV_CODEC_ID_FFV1,
1319 .priv_data_size = sizeof(FFV1Context),
1320 .init = encode_init,
1321 .encode2 = encode_frame,
1322 .close = encode_close,
1323 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1324 .pix_fmts = (const enum AVPixelFormat[]) {
1325 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1326 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1327 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1328 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1329 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1330 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1331 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1332 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1333 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1334 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1335 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1336 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1338 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1339 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1340 AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1342 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1343 AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1347 #if FF_API_CODER_TYPE
1348 .defaults = ffv1_defaults,
1350 .priv_class = &ffv1_class,