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
256 if (k == 0 && 2 * state->drift <= -state->count)
261 code = v ^ ((2 * state->drift + state->count) >> 31);
264 ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
265 state->bias, state->error_sum, state->drift, state->count, k);
266 set_sr_golomb(pb, code, k, 12, bits);
268 update_vlc_state(state, v);
272 #define RENAME(name) name
273 #include "ffv1enc_template.c"
278 #define RENAME(name) name ## 32
279 #include "ffv1enc_template.c"
281 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
282 int stride, int plane_index, int pixel_stride)
285 const int ring_size = s->context_model ? 3 : 2;
289 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
291 for (y = 0; y < h; y++) {
292 for (i = 0; i < ring_size; i++)
293 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
295 sample[0][-1]= sample[1][0 ];
296 sample[1][ w]= sample[1][w-1];
298 if (s->bits_per_raw_sample <= 8) {
299 for (x = 0; x < w; x++)
300 sample[0][x] = src[x * pixel_stride + stride * y];
301 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
304 if (s->packed_at_lsb) {
305 for (x = 0; x < w; x++) {
306 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
309 for (x = 0; x < w; x++) {
310 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
313 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
316 // STOP_TIMER("encode line") }
321 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
325 uint8_t state[CONTEXT_SIZE];
326 memset(state, 128, sizeof(state));
328 for (i = 1; i < 128; i++)
329 if (quant_table[i] != quant_table[i - 1]) {
330 put_symbol(c, state, i - last - 1, 0);
333 put_symbol(c, state, i - last - 1, 0);
336 static void write_quant_tables(RangeCoder *c,
337 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
340 for (i = 0; i < 5; i++)
341 write_quant_table(c, quant_table[i]);
344 static void write_header(FFV1Context *f)
346 uint8_t state[CONTEXT_SIZE];
348 RangeCoder *const c = &f->slice_context[0]->c;
350 memset(state, 128, sizeof(state));
352 if (f->version < 2) {
353 put_symbol(c, state, f->version, 0);
354 put_symbol(c, state, f->ac, 0);
355 if (f->ac == AC_RANGE_CUSTOM_TAB) {
356 for (i = 1; i < 256; i++)
358 f->state_transition[i] - c->one_state[i], 1);
360 put_symbol(c, state, f->colorspace, 0); //YUV cs type
362 put_symbol(c, state, f->bits_per_raw_sample, 0);
363 put_rac(c, state, f->chroma_planes);
364 put_symbol(c, state, f->chroma_h_shift, 0);
365 put_symbol(c, state, f->chroma_v_shift, 0);
366 put_rac(c, state, f->transparency);
368 write_quant_tables(c, f->quant_table);
369 } else if (f->version < 3) {
370 put_symbol(c, state, f->slice_count, 0);
371 for (i = 0; i < f->slice_count; i++) {
372 FFV1Context *fs = f->slice_context[i];
374 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
376 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
378 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
381 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
383 for (j = 0; j < f->plane_count; j++) {
384 put_symbol(c, state, f->plane[j].quant_table_index, 0);
385 av_assert0(f->plane[j].quant_table_index == f->context_model);
391 static int write_extradata(FFV1Context *f)
393 RangeCoder *const c = &f->c;
394 uint8_t state[CONTEXT_SIZE];
396 uint8_t state2[32][CONTEXT_SIZE];
399 memset(state2, 128, sizeof(state2));
400 memset(state, 128, sizeof(state));
402 f->avctx->extradata_size = 10000 + 4 +
403 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
404 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
405 if (!f->avctx->extradata)
406 return AVERROR(ENOMEM);
407 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
408 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
410 put_symbol(c, state, f->version, 0);
411 if (f->version > 2) {
412 if (f->version == 3) {
413 f->micro_version = 4;
414 } else if (f->version == 4)
415 f->micro_version = 2;
416 put_symbol(c, state, f->micro_version, 0);
419 put_symbol(c, state, f->ac, 0);
420 if (f->ac == AC_RANGE_CUSTOM_TAB)
421 for (i = 1; i < 256; i++)
422 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
424 put_symbol(c, state, f->colorspace, 0); // YUV cs type
425 put_symbol(c, state, f->bits_per_raw_sample, 0);
426 put_rac(c, state, f->chroma_planes);
427 put_symbol(c, state, f->chroma_h_shift, 0);
428 put_symbol(c, state, f->chroma_v_shift, 0);
429 put_rac(c, state, f->transparency);
430 put_symbol(c, state, f->num_h_slices - 1, 0);
431 put_symbol(c, state, f->num_v_slices - 1, 0);
433 put_symbol(c, state, f->quant_table_count, 0);
434 for (i = 0; i < f->quant_table_count; i++)
435 write_quant_tables(c, f->quant_tables[i]);
437 for (i = 0; i < f->quant_table_count; i++) {
438 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
439 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
441 if (j < f->context_count[i] * CONTEXT_SIZE) {
442 put_rac(c, state, 1);
443 for (j = 0; j < f->context_count[i]; j++)
444 for (k = 0; k < CONTEXT_SIZE; k++) {
445 int pred = j ? f->initial_states[i][j - 1][k] : 128;
446 put_symbol(c, state2[k],
447 (int8_t)(f->initial_states[i][j][k] - pred), 1);
450 put_rac(c, state, 0);
454 if (f->version > 2) {
455 put_symbol(c, state, f->ec, 0);
456 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
459 f->avctx->extradata_size = ff_rac_terminate(c);
460 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
461 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
462 f->avctx->extradata_size += 4;
467 static int sort_stt(FFV1Context *s, uint8_t stt[256])
469 int i, i2, changed, print = 0;
473 for (i = 12; i < 244; i++) {
474 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
476 #define COST(old, new) \
477 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
478 s->rc_stat[old][1] * -log2((new) / 256.0)
480 #define COST2(old, new) \
481 COST(old, new) + COST(256 - (old), 256 - (new))
483 double size0 = COST2(i, i) + COST2(i2, i2);
484 double sizeX = COST2(i, i2) + COST2(i2, i);
485 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
487 FFSWAP(int, stt[i], stt[i2]);
488 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
489 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
491 FFSWAP(int, stt[256 - i], stt[256 - i2]);
492 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
493 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
495 for (j = 1; j < 256; j++) {
498 else if (stt[j] == i2)
501 if (stt[256 - j] == 256 - i)
502 stt[256 - j] = 256 - i2;
503 else if (stt[256 - j] == 256 - i2)
504 stt[256 - j] = 256 - i;
515 static av_cold int encode_init(AVCodecContext *avctx)
517 FFV1Context *s = avctx->priv_data;
518 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
521 if ((ret = ff_ffv1_common_init(avctx)) < 0)
526 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
528 s->version = FFMAX(s->version, 2);
530 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
531 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
532 s->version = FFMAX(s->version, 2);
534 if (avctx->level <= 0 && s->version == 2) {
537 if (avctx->level >= 0 && avctx->level <= 4) {
538 if (avctx->level < s->version) {
539 av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
540 return AVERROR(EINVAL);
542 s->version = avctx->level;
546 s->ec = (s->version >= 3);
549 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
550 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
551 return AVERROR_INVALIDDATA;
554 #if FF_API_CODER_TYPE
555 FF_DISABLE_DEPRECATION_WARNINGS
556 if (avctx->coder_type != -1)
557 s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
559 FF_ENABLE_DEPRECATION_WARNINGS
561 if (s->ac == 1) // Compatbility with common command line usage
562 s->ac = AC_RANGE_CUSTOM_TAB;
563 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
564 s->ac = AC_RANGE_DEFAULT_TAB;
567 switch(avctx->pix_fmt) {
568 case AV_PIX_FMT_YUV444P9:
569 case AV_PIX_FMT_YUV422P9:
570 case AV_PIX_FMT_YUV420P9:
571 case AV_PIX_FMT_YUVA444P9:
572 case AV_PIX_FMT_YUVA422P9:
573 case AV_PIX_FMT_YUVA420P9:
574 if (!avctx->bits_per_raw_sample)
575 s->bits_per_raw_sample = 9;
576 case AV_PIX_FMT_YUV444P10:
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 s->packed_at_lsb = 1;
583 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
584 s->bits_per_raw_sample = 10;
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;
1093 uint8_t keystate = 128;
1096 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1097 + avctx->width*avctx->height*37LL*4;
1100 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1102 char *p = avctx->stats_out;
1103 char *end = p + STATS_OUT_SIZE;
1105 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1106 for (i = 0; i < f->quant_table_count; i++)
1107 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1109 av_assert0(f->slice_count == f->max_slice_count);
1110 for (j = 0; j < f->slice_count; j++) {
1111 FFV1Context *fs = f->slice_context[j];
1112 for (i = 0; i < 256; i++) {
1113 f->rc_stat[i][0] += fs->rc_stat[i][0];
1114 f->rc_stat[i][1] += fs->rc_stat[i][1];
1116 for (i = 0; i < f->quant_table_count; i++) {
1117 for (k = 0; k < f->context_count[i]; k++)
1118 for (m = 0; m < 32; m++) {
1119 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1120 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1125 for (j = 0; j < 256; j++) {
1126 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1127 f->rc_stat[j][0], f->rc_stat[j][1]);
1130 snprintf(p, end - p, "\n");
1132 for (i = 0; i < f->quant_table_count; i++) {
1133 for (j = 0; j < f->context_count[i]; j++)
1134 for (m = 0; m < 32; m++) {
1135 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1136 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1140 snprintf(p, end - p, "%d\n", f->gob_count);
1146 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1148 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1151 ff_init_range_encoder(c, pkt->data, pkt->size);
1152 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1155 if ((ret = av_frame_ref(p, pict)) < 0)
1157 #if FF_API_CODED_FRAME
1158 FF_DISABLE_DEPRECATION_WARNINGS
1159 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1160 FF_ENABLE_DEPRECATION_WARNINGS
1163 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1164 put_rac(c, &keystate, 1);
1169 put_rac(c, &keystate, 0);
1173 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1175 for (i = 1; i < 256; i++) {
1176 c->one_state[i] = f->state_transition[i];
1177 c->zero_state[256 - i] = 256 - c->one_state[i];
1181 for (i = 1; i < f->slice_count; i++) {
1182 FFV1Context *fs = f->slice_context[i];
1183 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1184 int len = pkt->size / f->slice_count;
1185 ff_init_range_encoder(&fs->c, start, len);
1187 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1188 f->slice_count, sizeof(void *));
1191 for (i = 0; i < f->slice_count; i++) {
1192 FFV1Context *fs = f->slice_context[i];
1195 if (fs->ac != AC_GOLOMB_RICE) {
1196 uint8_t state = 129;
1197 put_rac(&fs->c, &state, 0);
1198 bytes = ff_rac_terminate(&fs->c);
1200 flush_put_bits(&fs->pb); // FIXME: nicer padding
1201 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1203 if (i > 0 || f->version > 2) {
1204 av_assert0(bytes < pkt->size / f->slice_count);
1205 memmove(buf_p, fs->c.bytestream_start, bytes);
1206 av_assert0(bytes < (1 << 24));
1207 AV_WB24(buf_p + bytes, bytes);
1213 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1214 AV_WL32(buf_p + bytes, v);
1220 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1221 avctx->stats_out[0] = '\0';
1223 #if FF_API_CODED_FRAME
1224 FF_DISABLE_DEPRECATION_WARNINGS
1225 avctx->coded_frame->key_frame = f->key_frame;
1226 FF_ENABLE_DEPRECATION_WARNINGS
1229 f->picture_number++;
1230 pkt->size = buf_p - pkt->data;
1232 pkt->dts = pict->pts;
1233 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1239 static av_cold int encode_close(AVCodecContext *avctx)
1241 ff_ffv1_close(avctx);
1245 #define OFFSET(x) offsetof(FFV1Context, x)
1246 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1247 static const AVOption options[] = {
1248 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1249 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1250 { .i64 = 0 }, -2, 2, VE, "coder" },
1251 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1252 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1253 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1254 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1255 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1256 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1257 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1258 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1259 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1260 { .i64 = 0 }, 0, 1, VE },
1265 static const AVClass ffv1_class = {
1266 .class_name = "ffv1 encoder",
1267 .item_name = av_default_item_name,
1269 .version = LIBAVUTIL_VERSION_INT,
1272 #if FF_API_CODER_TYPE
1273 static const AVCodecDefault ffv1_defaults[] = {
1279 AVCodec ff_ffv1_encoder = {
1281 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1282 .type = AVMEDIA_TYPE_VIDEO,
1283 .id = AV_CODEC_ID_FFV1,
1284 .priv_data_size = sizeof(FFV1Context),
1285 .init = encode_init,
1286 .encode2 = encode_frame,
1287 .close = encode_close,
1288 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1289 .pix_fmts = (const enum AVPixelFormat[]) {
1290 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1291 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1292 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1293 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1294 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1295 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1296 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1297 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1298 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1299 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1301 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1305 #if FF_API_CODER_TYPE
1306 .defaults = ffv1_defaults,
1308 .priv_class = &ffv1_class,