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