4 * Copyright (c) 2003-2013 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * FF Video Codec 1 (a lossless codec) encoder
28 #include "libavutil/attributes.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/crc.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/timer.h"
39 #include "rangecoder.h"
44 static const int8_t quant5_10bit[256] = {
45 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
46 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
47 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
48 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
49 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
50 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
51 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
52 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
53 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
54 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
55 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
56 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
57 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1,
58 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
59 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
60 -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
63 static const int8_t quant5[256] = {
64 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
65 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
66 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
67 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
68 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
69 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
70 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
71 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
72 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
73 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
74 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
75 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
76 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
77 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
78 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
79 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
82 static const int8_t quant9_10bit[256] = {
83 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
84 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
85 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
86 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
87 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
92 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
93 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
94 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
95 -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
96 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
97 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
98 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
101 static const int8_t quant11[256] = {
102 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
103 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
104 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
105 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
106 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
107 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
108 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
109 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
110 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
111 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
112 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
113 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
114 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
115 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
116 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
117 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
120 static const uint8_t ver2_state[256] = {
121 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
122 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
123 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
124 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
125 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
126 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
127 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
128 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
129 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
130 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
131 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
132 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
133 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
134 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
135 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
136 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
139 static void find_best_state(uint8_t best_state[256][256],
140 const uint8_t one_state[256])
145 for (i = 1; i < 256; i++)
146 l2tab[i] = log2(i / 256.0);
148 for (i = 0; i < 256; i++) {
149 double best_len[256];
150 double p = i / 256.0;
152 for (j = 0; j < 256; j++)
153 best_len[j] = 1 << 30;
155 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
156 double occ[256] = { 0 };
163 for (k = 0; k < 256; k++) {
164 double newocc[256] = { 0 };
165 for (m = 1; m < 256; m++)
167 len -=occ[m]*( p *l2tab[ m]
168 + (1-p)*l2tab[256-m]);
170 if (len < best_len[k]) {
172 best_state[i][k] = j;
174 for (m = 1; m < 256; m++)
176 newocc[ one_state[ m]] += occ[m] * p;
177 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
179 memcpy(occ, newocc, sizeof(occ));
185 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
186 uint8_t *state, int v,
188 uint64_t rc_stat[256][2],
189 uint64_t rc_stat2[32][2])
193 #define put_rac(C, S, B) \
196 rc_stat[*(S)][B]++; \
197 rc_stat2[(S) - state][B]++; \
203 const int a = FFABS(v);
204 const int e = av_log2(a);
205 put_rac(c, state + 0, 0);
207 for (i = 0; i < e; i++)
208 put_rac(c, state + 1 + i, 1); // 1..10
209 put_rac(c, state + 1 + i, 0);
211 for (i = e - 1; i >= 0; i--)
212 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
215 put_rac(c, state + 11 + e, v < 0); // 11..21
217 for (i = 0; i < e; i++)
218 put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
219 put_rac(c, state + 1 + 9, 0);
221 for (i = e - 1; i >= 0; i--)
222 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
225 put_rac(c, state + 11 + 10, v < 0); // 11..21
228 put_rac(c, state + 0, 1);
233 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
234 int v, int is_signed)
236 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
240 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
244 v = fold(v - state->bias, bits);
248 while (i < state->error_sum) { // FIXME: optimize
255 code = v ^ ((2 * state->drift + state->count) >> 31);
257 ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
258 state->bias, state->error_sum, state->drift, state->count, k);
259 set_sr_golomb(pb, code, k, 12, bits);
261 update_vlc_state(state, v);
265 #define RENAME(name) name
266 #include "ffv1enc_template.c"
271 #define RENAME(name) name ## 32
272 #include "ffv1enc_template.c"
274 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
275 int stride, int plane_index, int pixel_stride)
278 const int ring_size = s->context_model ? 3 : 2;
282 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
284 for (y = 0; y < h; y++) {
285 for (i = 0; i < ring_size; i++)
286 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
288 sample[0][-1]= sample[1][0 ];
289 sample[1][ w]= sample[1][w-1];
291 if (s->bits_per_raw_sample <= 8) {
292 for (x = 0; x < w; x++)
293 sample[0][x] = src[x * pixel_stride + stride * y];
294 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
297 if (s->packed_at_lsb) {
298 for (x = 0; x < w; x++) {
299 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
302 for (x = 0; x < w; x++) {
303 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
306 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
309 // STOP_TIMER("encode line") }
314 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
318 uint8_t state[CONTEXT_SIZE];
319 memset(state, 128, sizeof(state));
321 for (i = 1; i < 128; i++)
322 if (quant_table[i] != quant_table[i - 1]) {
323 put_symbol(c, state, i - last - 1, 0);
326 put_symbol(c, state, i - last - 1, 0);
329 static void write_quant_tables(RangeCoder *c,
330 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
333 for (i = 0; i < 5; i++)
334 write_quant_table(c, quant_table[i]);
337 static void write_header(FFV1Context *f)
339 uint8_t state[CONTEXT_SIZE];
341 RangeCoder *const c = &f->slice_context[0]->c;
343 memset(state, 128, sizeof(state));
345 if (f->version < 2) {
346 put_symbol(c, state, f->version, 0);
347 put_symbol(c, state, f->ac, 0);
348 if (f->ac == AC_RANGE_CUSTOM_TAB) {
349 for (i = 1; i < 256; i++)
351 f->state_transition[i] - c->one_state[i], 1);
353 put_symbol(c, state, f->colorspace, 0); //YUV cs type
355 put_symbol(c, state, f->bits_per_raw_sample, 0);
356 put_rac(c, state, f->chroma_planes);
357 put_symbol(c, state, f->chroma_h_shift, 0);
358 put_symbol(c, state, f->chroma_v_shift, 0);
359 put_rac(c, state, f->transparency);
361 write_quant_tables(c, f->quant_table);
362 } else if (f->version < 3) {
363 put_symbol(c, state, f->slice_count, 0);
364 for (i = 0; i < f->slice_count; i++) {
365 FFV1Context *fs = f->slice_context[i];
367 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
369 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
371 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
374 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
376 for (j = 0; j < f->plane_count; j++) {
377 put_symbol(c, state, f->plane[j].quant_table_index, 0);
378 av_assert0(f->plane[j].quant_table_index == f->context_model);
384 static int write_extradata(FFV1Context *f)
386 RangeCoder *const c = &f->c;
387 uint8_t state[CONTEXT_SIZE];
389 uint8_t state2[32][CONTEXT_SIZE];
392 memset(state2, 128, sizeof(state2));
393 memset(state, 128, sizeof(state));
395 f->avctx->extradata_size = 10000 + 4 +
396 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
397 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
398 if (!f->avctx->extradata)
399 return AVERROR(ENOMEM);
400 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
401 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
403 put_symbol(c, state, f->version, 0);
404 if (f->version > 2) {
405 if (f->version == 3) {
406 f->micro_version = 4;
407 } else if (f->version == 4)
408 f->micro_version = 2;
409 put_symbol(c, state, f->micro_version, 0);
412 put_symbol(c, state, f->ac, 0);
413 if (f->ac == AC_RANGE_CUSTOM_TAB)
414 for (i = 1; i < 256; i++)
415 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
417 put_symbol(c, state, f->colorspace, 0); // YUV cs type
418 put_symbol(c, state, f->bits_per_raw_sample, 0);
419 put_rac(c, state, f->chroma_planes);
420 put_symbol(c, state, f->chroma_h_shift, 0);
421 put_symbol(c, state, f->chroma_v_shift, 0);
422 put_rac(c, state, f->transparency);
423 put_symbol(c, state, f->num_h_slices - 1, 0);
424 put_symbol(c, state, f->num_v_slices - 1, 0);
426 put_symbol(c, state, f->quant_table_count, 0);
427 for (i = 0; i < f->quant_table_count; i++)
428 write_quant_tables(c, f->quant_tables[i]);
430 for (i = 0; i < f->quant_table_count; i++) {
431 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
432 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
434 if (j < f->context_count[i] * CONTEXT_SIZE) {
435 put_rac(c, state, 1);
436 for (j = 0; j < f->context_count[i]; j++)
437 for (k = 0; k < CONTEXT_SIZE; k++) {
438 int pred = j ? f->initial_states[i][j - 1][k] : 128;
439 put_symbol(c, state2[k],
440 (int8_t)(f->initial_states[i][j][k] - pred), 1);
443 put_rac(c, state, 0);
447 if (f->version > 2) {
448 put_symbol(c, state, f->ec, 0);
449 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
452 f->avctx->extradata_size = ff_rac_terminate(c);
453 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
454 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
455 f->avctx->extradata_size += 4;
460 static int sort_stt(FFV1Context *s, uint8_t stt[256])
462 int i, i2, changed, print = 0;
466 for (i = 12; i < 244; i++) {
467 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
469 #define COST(old, new) \
470 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
471 s->rc_stat[old][1] * -log2((new) / 256.0)
473 #define COST2(old, new) \
474 COST(old, new) + COST(256 - (old), 256 - (new))
476 double size0 = COST2(i, i) + COST2(i2, i2);
477 double sizeX = COST2(i, i2) + COST2(i2, i);
478 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
480 FFSWAP(int, stt[i], stt[i2]);
481 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
482 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
484 FFSWAP(int, stt[256 - i], stt[256 - i2]);
485 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
486 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
488 for (j = 1; j < 256; j++) {
491 else if (stt[j] == i2)
494 if (stt[256 - j] == 256 - i)
495 stt[256 - j] = 256 - i2;
496 else if (stt[256 - j] == 256 - i2)
497 stt[256 - j] = 256 - i;
508 static av_cold int encode_init(AVCodecContext *avctx)
510 FFV1Context *s = avctx->priv_data;
511 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
514 if ((ret = ff_ffv1_common_init(avctx)) < 0)
519 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
521 s->version = FFMAX(s->version, 2);
523 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
524 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
525 s->version = FFMAX(s->version, 2);
527 if (avctx->level <= 0 && s->version == 2) {
530 if (avctx->level >= 0 && avctx->level <= 4) {
531 if (avctx->level < s->version) {
532 av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
533 return AVERROR(EINVAL);
535 s->version = avctx->level;
539 s->ec = (s->version >= 3);
542 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
543 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
544 return AVERROR_INVALIDDATA;
547 #if FF_API_CODER_TYPE
548 FF_DISABLE_DEPRECATION_WARNINGS
549 if (avctx->coder_type != -1)
550 s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
552 FF_ENABLE_DEPRECATION_WARNINGS
554 if (s->ac == 1) // Compatbility with common command line usage
555 s->ac = AC_RANGE_CUSTOM_TAB;
556 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
557 s->ac = AC_RANGE_DEFAULT_TAB;
560 switch(avctx->pix_fmt) {
561 case AV_PIX_FMT_YUV444P9:
562 case AV_PIX_FMT_YUV422P9:
563 case AV_PIX_FMT_YUV420P9:
564 case AV_PIX_FMT_YUVA444P9:
565 case AV_PIX_FMT_YUVA422P9:
566 case AV_PIX_FMT_YUVA420P9:
567 if (!avctx->bits_per_raw_sample)
568 s->bits_per_raw_sample = 9;
569 case AV_PIX_FMT_GRAY10:
570 case AV_PIX_FMT_YUV444P10:
571 case AV_PIX_FMT_YUV420P10:
572 case AV_PIX_FMT_YUV422P10:
573 case AV_PIX_FMT_YUVA444P10:
574 case AV_PIX_FMT_YUVA422P10:
575 case AV_PIX_FMT_YUVA420P10:
576 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
577 s->bits_per_raw_sample = 10;
578 case AV_PIX_FMT_GRAY12:
579 case AV_PIX_FMT_YUV444P12:
580 case AV_PIX_FMT_YUV420P12:
581 case AV_PIX_FMT_YUV422P12:
582 s->packed_at_lsb = 1;
583 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
584 s->bits_per_raw_sample = 12;
585 case AV_PIX_FMT_GRAY16:
586 case AV_PIX_FMT_YUV444P16:
587 case AV_PIX_FMT_YUV422P16:
588 case AV_PIX_FMT_YUV420P16:
589 case AV_PIX_FMT_YUVA444P16:
590 case AV_PIX_FMT_YUVA422P16:
591 case AV_PIX_FMT_YUVA420P16:
592 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
593 s->bits_per_raw_sample = 16;
594 } else if (!s->bits_per_raw_sample) {
595 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
597 if (s->bits_per_raw_sample <= 8) {
598 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
599 return AVERROR_INVALIDDATA;
601 s->version = FFMAX(s->version, 1);
602 case AV_PIX_FMT_GRAY8:
604 case AV_PIX_FMT_YUV444P:
605 case AV_PIX_FMT_YUV440P:
606 case AV_PIX_FMT_YUV422P:
607 case AV_PIX_FMT_YUV420P:
608 case AV_PIX_FMT_YUV411P:
609 case AV_PIX_FMT_YUV410P:
610 case AV_PIX_FMT_YUVA444P:
611 case AV_PIX_FMT_YUVA422P:
612 case AV_PIX_FMT_YUVA420P:
613 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
615 s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
616 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
617 s->bits_per_raw_sample = 8;
618 else if (!s->bits_per_raw_sample)
619 s->bits_per_raw_sample = 8;
621 case AV_PIX_FMT_RGB32:
624 s->chroma_planes = 1;
625 s->bits_per_raw_sample = 8;
627 case AV_PIX_FMT_RGB48:
629 s->chroma_planes = 1;
630 s->bits_per_raw_sample = 16;
632 s->version = FFMAX(s->version, 1);
634 case AV_PIX_FMT_0RGB32:
636 s->chroma_planes = 1;
637 s->bits_per_raw_sample = 8;
639 case AV_PIX_FMT_GBRP9:
640 if (!avctx->bits_per_raw_sample)
641 s->bits_per_raw_sample = 9;
642 case AV_PIX_FMT_GBRP10:
643 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
644 s->bits_per_raw_sample = 10;
645 case AV_PIX_FMT_GBRP12:
646 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
647 s->bits_per_raw_sample = 12;
648 case AV_PIX_FMT_GBRP14:
649 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
650 s->bits_per_raw_sample = 14;
651 case AV_PIX_FMT_GBRP16:
652 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
653 s->bits_per_raw_sample = 16;
654 else if (!s->bits_per_raw_sample)
655 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
657 s->chroma_planes = 1;
658 if (s->bits_per_raw_sample >= 16) {
661 s->version = FFMAX(s->version, 1);
664 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
665 return AVERROR(ENOSYS);
667 av_assert0(s->bits_per_raw_sample >= 8);
669 if (s->bits_per_raw_sample > 8) {
670 if (s->ac == AC_GOLOMB_RICE) {
671 av_log(avctx, AV_LOG_INFO,
672 "bits_per_raw_sample > 8, forcing range coder\n");
673 s->ac = AC_RANGE_CUSTOM_TAB;
676 if (s->transparency) {
677 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
679 #if FF_API_PRIVATE_OPT
680 FF_DISABLE_DEPRECATION_WARNINGS
681 if (avctx->context_model)
682 s->context_model = avctx->context_model;
683 if (avctx->context_model > 1U) {
684 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
685 return AVERROR(EINVAL);
687 FF_ENABLE_DEPRECATION_WARNINGS
690 if (s->ac == AC_RANGE_CUSTOM_TAB) {
691 for (i = 1; i < 256; i++)
692 s->state_transition[i] = ver2_state[i];
695 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
696 for (i = 1; i < 256; i++)
697 s->state_transition[i] = c.one_state[i];
700 for (i = 0; i < 256; i++) {
701 s->quant_table_count = 2;
702 if (s->bits_per_raw_sample <= 8) {
703 s->quant_tables[0][0][i]= quant11[i];
704 s->quant_tables[0][1][i]= 11*quant11[i];
705 s->quant_tables[0][2][i]= 11*11*quant11[i];
706 s->quant_tables[1][0][i]= quant11[i];
707 s->quant_tables[1][1][i]= 11*quant11[i];
708 s->quant_tables[1][2][i]= 11*11*quant5 [i];
709 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
710 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
712 s->quant_tables[0][0][i]= quant9_10bit[i];
713 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
714 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
715 s->quant_tables[1][0][i]= quant9_10bit[i];
716 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
717 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
718 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
719 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
722 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
723 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
724 memcpy(s->quant_table, s->quant_tables[s->context_model],
725 sizeof(s->quant_table));
727 for (i = 0; i < s->plane_count; i++) {
728 PlaneContext *const p = &s->plane[i];
730 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
731 p->quant_table_index = s->context_model;
732 p->context_count = s->context_count[p->quant_table_index];
735 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
738 #if FF_API_CODED_FRAME
739 FF_DISABLE_DEPRECATION_WARNINGS
740 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
741 FF_ENABLE_DEPRECATION_WARNINGS
744 if (!s->transparency)
746 if (!s->chroma_planes && s->version > 3)
749 ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
753 s->picture_number = 0;
755 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
756 for (i = 0; i < s->quant_table_count; i++) {
757 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
758 sizeof(*s->rc_stat2[i]));
760 return AVERROR(ENOMEM);
763 if (avctx->stats_in) {
764 char *p = avctx->stats_in;
765 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
769 return AVERROR(ENOMEM);
771 av_assert0(s->version >= 2);
774 for (j = 0; j < 256; j++)
775 for (i = 0; i < 2; i++) {
776 s->rc_stat[j][i] = strtol(p, &next, 0);
778 av_log(avctx, AV_LOG_ERROR,
779 "2Pass file invalid at %d %d [%s]\n", j, i, p);
780 av_freep(&best_state);
781 return AVERROR_INVALIDDATA;
785 for (i = 0; i < s->quant_table_count; i++)
786 for (j = 0; j < s->context_count[i]; j++) {
787 for (k = 0; k < 32; k++)
788 for (m = 0; m < 2; m++) {
789 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
791 av_log(avctx, AV_LOG_ERROR,
792 "2Pass file invalid at %d %d %d %d [%s]\n",
794 av_freep(&best_state);
795 return AVERROR_INVALIDDATA;
800 gob_count = strtol(p, &next, 0);
801 if (next == p || gob_count <= 0) {
802 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
803 av_freep(&best_state);
804 return AVERROR_INVALIDDATA;
807 while (*p == '\n' || *p == ' ')
812 if (s->ac == AC_RANGE_CUSTOM_TAB)
813 sort_stt(s, s->state_transition);
815 find_best_state(best_state, s->state_transition);
817 for (i = 0; i < s->quant_table_count; i++) {
818 for (k = 0; k < 32; k++) {
821 for (j = 0; j < s->context_count[i]; j++) {
823 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
825 p = 256.0 * b / (a + b);
826 s->initial_states[i][jp][k] =
827 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
828 for(jp++; jp<j; jp++)
829 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
832 a += s->rc_stat2[i][j][k][0];
833 b += s->rc_stat2[i][j][k][1];
835 p = 256.0 * b / (a + b);
837 s->initial_states[i][j][k] =
838 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
842 av_freep(&best_state);
845 if (s->version > 1) {
846 int plane_count = 1 + 2*s->chroma_planes + s->transparency;
847 int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
848 int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
849 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
851 s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
853 for (; s->num_v_slices < 32; s->num_v_slices++) {
854 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
855 int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
856 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
857 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
859 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
861 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
865 av_log(avctx, AV_LOG_ERROR,
866 "Unsupported number %d of slices requested, please specify a "
867 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
869 return AVERROR(ENOSYS);
871 if ((ret = write_extradata(s)) < 0)
875 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
877 s->slice_count = s->max_slice_count;
878 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
881 #define STATS_OUT_SIZE 1024 * 1024 * 6
882 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
883 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
884 if (!avctx->stats_out)
885 return AVERROR(ENOMEM);
886 for (i = 0; i < s->quant_table_count; i++)
887 for (j = 0; j < s->max_slice_count; j++) {
888 FFV1Context *sf = s->slice_context[j];
889 av_assert0(!sf->rc_stat2[i]);
890 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
891 sizeof(*sf->rc_stat2[i]));
892 if (!sf->rc_stat2[i])
893 return AVERROR(ENOMEM);
900 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
902 RangeCoder *c = &fs->c;
903 uint8_t state[CONTEXT_SIZE];
905 memset(state, 128, sizeof(state));
907 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
908 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
909 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
910 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
911 for (j=0; j<f->plane_count; j++) {
912 put_symbol(c, state, f->plane[j].quant_table_index, 0);
913 av_assert0(f->plane[j].quant_table_index == f->context_model);
915 if (!f->picture.f->interlaced_frame)
916 put_symbol(c, state, 3, 0);
918 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
919 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
920 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
921 if (f->version > 3) {
922 put_rac(c, state, fs->slice_coding_mode == 1);
923 if (fs->slice_coding_mode == 1)
924 ff_ffv1_clear_slice_state(f, fs);
925 put_symbol(c, state, fs->slice_coding_mode, 0);
926 if (fs->slice_coding_mode != 1) {
927 put_symbol(c, state, fs->slice_rct_by_coef, 0);
928 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
933 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
935 #define NB_Y_COEFF 15
936 static const int rct_y_coeff[15][2] = {
938 {1, 1}, // R + 2G + B
949 {1, 2}, // R + G + 2B
950 {2, 1}, // 2R + G + B
955 int stat[NB_Y_COEFF] = {0};
956 int x, y, i, p, best;
958 int lbd = fs->bits_per_raw_sample <= 8;
960 for (y = 0; y < h; y++) {
961 int lastr=0, lastg=0, lastb=0;
962 for (p = 0; p < 3; p++)
963 sample[p] = fs->sample_buffer + p*w;
965 for (x = 0; x < w; x++) {
969 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
972 r = (v >> 16) & 0xFF;
974 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
975 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
976 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
983 int bg = ag - sample[0][x];
984 int bb = ab - sample[1][x];
985 int br = ar - sample[2][x];
990 for (i = 0; i<NB_Y_COEFF; i++) {
991 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1006 for (i=1; i<NB_Y_COEFF; i++) {
1007 if (stat[i] < stat[best])
1011 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1012 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1015 static int encode_slice(AVCodecContext *c, void *arg)
1017 FFV1Context *fs = *(void **)arg;
1018 FFV1Context *f = fs->avctx->priv_data;
1019 int width = fs->slice_width;
1020 int height = fs->slice_height;
1021 int x = fs->slice_x;
1022 int y = fs->slice_y;
1023 const AVFrame *const p = f->picture.f;
1024 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1026 RangeCoder c_bak = fs->c;
1027 const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1028 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1029 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL};
1031 fs->slice_coding_mode = 0;
1032 if (f->version > 3) {
1033 choose_rct_params(fs, planes, p->linesize, width, height);
1035 fs->slice_rct_by_coef = 1;
1036 fs->slice_rct_ry_coef = 1;
1041 ff_ffv1_clear_slice_state(f, fs);
1042 if (f->version > 2) {
1043 encode_slice_header(f, fs);
1045 if (fs->ac == AC_GOLOMB_RICE) {
1047 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1048 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1049 init_put_bits(&fs->pb,
1050 fs->c.bytestream_start + fs->ac_byte_count,
1051 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1054 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1055 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1056 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1057 const int cx = x >> f->chroma_h_shift;
1058 const int cy = y >> f->chroma_v_shift;
1060 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1062 if (f->chroma_planes) {
1063 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1064 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1066 if (fs->transparency)
1067 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1068 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1069 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1070 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1071 } else if (f->use32bit) {
1072 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1074 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1079 av_assert0(fs->slice_coding_mode == 0);
1080 if (fs->version < 4 || !fs->ac) {
1081 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1084 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1085 fs->slice_coding_mode = 1;
1093 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1094 const AVFrame *pict, int *got_packet)
1096 FFV1Context *f = avctx->priv_data;
1097 RangeCoder *const c = &f->slice_context[0]->c;
1098 AVFrame *const p = f->picture.f;
1099 uint8_t keystate = 128;
1102 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1103 + avctx->width*avctx->height*37LL*4;
1106 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1108 char *p = avctx->stats_out;
1109 char *end = p + STATS_OUT_SIZE;
1111 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1112 for (i = 0; i < f->quant_table_count; i++)
1113 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1115 av_assert0(f->slice_count == f->max_slice_count);
1116 for (j = 0; j < f->slice_count; j++) {
1117 FFV1Context *fs = f->slice_context[j];
1118 for (i = 0; i < 256; i++) {
1119 f->rc_stat[i][0] += fs->rc_stat[i][0];
1120 f->rc_stat[i][1] += fs->rc_stat[i][1];
1122 for (i = 0; i < f->quant_table_count; i++) {
1123 for (k = 0; k < f->context_count[i]; k++)
1124 for (m = 0; m < 32; m++) {
1125 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1126 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1131 for (j = 0; j < 256; j++) {
1132 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1133 f->rc_stat[j][0], f->rc_stat[j][1]);
1136 snprintf(p, end - p, "\n");
1138 for (i = 0; i < f->quant_table_count; i++) {
1139 for (j = 0; j < f->context_count[i]; j++)
1140 for (m = 0; m < 32; m++) {
1141 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1142 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1146 snprintf(p, end - p, "%d\n", f->gob_count);
1152 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1154 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1155 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1156 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1159 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1162 ff_init_range_encoder(c, pkt->data, pkt->size);
1163 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1166 if ((ret = av_frame_ref(p, pict)) < 0)
1168 #if FF_API_CODED_FRAME
1169 FF_DISABLE_DEPRECATION_WARNINGS
1170 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1171 FF_ENABLE_DEPRECATION_WARNINGS
1174 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1175 put_rac(c, &keystate, 1);
1180 put_rac(c, &keystate, 0);
1184 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1186 for (i = 1; i < 256; i++) {
1187 c->one_state[i] = f->state_transition[i];
1188 c->zero_state[256 - i] = 256 - c->one_state[i];
1192 for (i = 0; i < f->slice_count; i++) {
1193 FFV1Context *fs = f->slice_context[i];
1194 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1195 int len = pkt->size / f->slice_count;
1197 ff_init_range_encoder(&fs->c, start, len);
1199 av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1200 av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1201 fs->c.bytestream_end = fs->c.bytestream_start + len;
1204 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1205 f->slice_count, sizeof(void *));
1208 for (i = 0; i < f->slice_count; i++) {
1209 FFV1Context *fs = f->slice_context[i];
1212 if (fs->ac != AC_GOLOMB_RICE) {
1213 uint8_t state = 129;
1214 put_rac(&fs->c, &state, 0);
1215 bytes = ff_rac_terminate(&fs->c);
1217 flush_put_bits(&fs->pb); // FIXME: nicer padding
1218 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1220 if (i > 0 || f->version > 2) {
1221 av_assert0(bytes < pkt->size / f->slice_count);
1222 memmove(buf_p, fs->c.bytestream_start, bytes);
1223 av_assert0(bytes < (1 << 24));
1224 AV_WB24(buf_p + bytes, bytes);
1230 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1231 AV_WL32(buf_p + bytes, v);
1237 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1238 avctx->stats_out[0] = '\0';
1240 #if FF_API_CODED_FRAME
1241 FF_DISABLE_DEPRECATION_WARNINGS
1242 avctx->coded_frame->key_frame = f->key_frame;
1243 FF_ENABLE_DEPRECATION_WARNINGS
1246 f->picture_number++;
1247 pkt->size = buf_p - pkt->data;
1249 pkt->dts = pict->pts;
1250 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1256 static av_cold int encode_close(AVCodecContext *avctx)
1258 ff_ffv1_close(avctx);
1262 #define OFFSET(x) offsetof(FFV1Context, x)
1263 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1264 static const AVOption options[] = {
1265 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1266 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1267 { .i64 = 0 }, -2, 2, VE, "coder" },
1268 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1269 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1270 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1271 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1272 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1273 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1274 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1275 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1276 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1277 { .i64 = 0 }, 0, 1, VE },
1282 static const AVClass ffv1_class = {
1283 .class_name = "ffv1 encoder",
1284 .item_name = av_default_item_name,
1286 .version = LIBAVUTIL_VERSION_INT,
1289 #if FF_API_CODER_TYPE
1290 static const AVCodecDefault ffv1_defaults[] = {
1296 AVCodec ff_ffv1_encoder = {
1298 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1299 .type = AVMEDIA_TYPE_VIDEO,
1300 .id = AV_CODEC_ID_FFV1,
1301 .priv_data_size = sizeof(FFV1Context),
1302 .init = encode_init,
1303 .encode2 = encode_frame,
1304 .close = encode_close,
1305 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1306 .pix_fmts = (const enum AVPixelFormat[]) {
1307 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1308 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1309 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1310 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1311 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1312 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1313 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1314 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1315 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1316 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1317 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1319 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1320 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1324 #if FF_API_CODER_TYPE
1325 .defaults = ffv1_defaults,
1327 .priv_class = &ffv1_class,