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_GRAY10:
577 case AV_PIX_FMT_YUV444P10:
578 case AV_PIX_FMT_YUV420P10:
579 case AV_PIX_FMT_YUV422P10:
580 case AV_PIX_FMT_YUVA444P10:
581 case AV_PIX_FMT_YUVA422P10:
582 case AV_PIX_FMT_YUVA420P10:
583 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
584 s->bits_per_raw_sample = 10;
585 case AV_PIX_FMT_GRAY12:
586 case AV_PIX_FMT_YUV444P12:
587 case AV_PIX_FMT_YUV420P12:
588 case AV_PIX_FMT_YUV422P12:
589 s->packed_at_lsb = 1;
590 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
591 s->bits_per_raw_sample = 12;
592 case AV_PIX_FMT_GRAY16:
593 case AV_PIX_FMT_YUV444P16:
594 case AV_PIX_FMT_YUV422P16:
595 case AV_PIX_FMT_YUV420P16:
596 case AV_PIX_FMT_YUVA444P16:
597 case AV_PIX_FMT_YUVA422P16:
598 case AV_PIX_FMT_YUVA420P16:
599 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
600 s->bits_per_raw_sample = 16;
601 } else if (!s->bits_per_raw_sample) {
602 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
604 if (s->bits_per_raw_sample <= 8) {
605 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
606 return AVERROR_INVALIDDATA;
608 s->version = FFMAX(s->version, 1);
609 case AV_PIX_FMT_GRAY8:
611 case AV_PIX_FMT_YUV444P:
612 case AV_PIX_FMT_YUV440P:
613 case AV_PIX_FMT_YUV422P:
614 case AV_PIX_FMT_YUV420P:
615 case AV_PIX_FMT_YUV411P:
616 case AV_PIX_FMT_YUV410P:
617 case AV_PIX_FMT_YUVA444P:
618 case AV_PIX_FMT_YUVA422P:
619 case AV_PIX_FMT_YUVA420P:
620 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
622 s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
623 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
624 s->bits_per_raw_sample = 8;
625 else if (!s->bits_per_raw_sample)
626 s->bits_per_raw_sample = 8;
628 case AV_PIX_FMT_RGB32:
631 s->chroma_planes = 1;
632 s->bits_per_raw_sample = 8;
634 case AV_PIX_FMT_RGB48:
636 s->chroma_planes = 1;
637 s->bits_per_raw_sample = 16;
639 s->version = FFMAX(s->version, 1);
640 if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
641 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
642 return AVERROR_INVALIDDATA;
645 case AV_PIX_FMT_0RGB32:
647 s->chroma_planes = 1;
648 s->bits_per_raw_sample = 8;
650 case AV_PIX_FMT_GBRP9:
651 if (!avctx->bits_per_raw_sample)
652 s->bits_per_raw_sample = 9;
653 case AV_PIX_FMT_GBRP10:
654 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
655 s->bits_per_raw_sample = 10;
656 case AV_PIX_FMT_GBRP12:
657 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
658 s->bits_per_raw_sample = 12;
659 case AV_PIX_FMT_GBRP14:
660 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
661 s->bits_per_raw_sample = 14;
662 case AV_PIX_FMT_GBRP16:
663 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
664 s->bits_per_raw_sample = 16;
665 else if (!s->bits_per_raw_sample)
666 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
668 s->chroma_planes = 1;
669 if (s->bits_per_raw_sample >= 16) {
671 if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
672 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
673 return AVERROR_INVALIDDATA;
676 s->version = FFMAX(s->version, 1);
679 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
680 return AVERROR(ENOSYS);
682 av_assert0(s->bits_per_raw_sample >= 8);
684 if (s->bits_per_raw_sample > 8) {
685 if (s->ac == AC_GOLOMB_RICE) {
686 av_log(avctx, AV_LOG_INFO,
687 "bits_per_raw_sample > 8, forcing range coder\n");
688 s->ac = AC_RANGE_CUSTOM_TAB;
691 if (s->transparency) {
692 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
694 #if FF_API_PRIVATE_OPT
695 FF_DISABLE_DEPRECATION_WARNINGS
696 if (avctx->context_model)
697 s->context_model = avctx->context_model;
698 if (avctx->context_model > 1U) {
699 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
700 return AVERROR(EINVAL);
702 FF_ENABLE_DEPRECATION_WARNINGS
705 if (s->ac == AC_RANGE_CUSTOM_TAB) {
706 for (i = 1; i < 256; i++)
707 s->state_transition[i] = ver2_state[i];
710 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
711 for (i = 1; i < 256; i++)
712 s->state_transition[i] = c.one_state[i];
715 for (i = 0; i < 256; i++) {
716 s->quant_table_count = 2;
717 if (s->bits_per_raw_sample <= 8) {
718 s->quant_tables[0][0][i]= quant11[i];
719 s->quant_tables[0][1][i]= 11*quant11[i];
720 s->quant_tables[0][2][i]= 11*11*quant11[i];
721 s->quant_tables[1][0][i]= quant11[i];
722 s->quant_tables[1][1][i]= 11*quant11[i];
723 s->quant_tables[1][2][i]= 11*11*quant5 [i];
724 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
725 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
727 s->quant_tables[0][0][i]= quant9_10bit[i];
728 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
729 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
730 s->quant_tables[1][0][i]= quant9_10bit[i];
731 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
732 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
733 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
734 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
737 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
738 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
739 memcpy(s->quant_table, s->quant_tables[s->context_model],
740 sizeof(s->quant_table));
742 for (i = 0; i < s->plane_count; i++) {
743 PlaneContext *const p = &s->plane[i];
745 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
746 p->quant_table_index = s->context_model;
747 p->context_count = s->context_count[p->quant_table_index];
750 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
753 #if FF_API_CODED_FRAME
754 FF_DISABLE_DEPRECATION_WARNINGS
755 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
756 FF_ENABLE_DEPRECATION_WARNINGS
759 if (!s->transparency)
761 if (!s->chroma_planes && s->version > 3)
764 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
765 s->picture_number = 0;
767 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
768 for (i = 0; i < s->quant_table_count; i++) {
769 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
770 sizeof(*s->rc_stat2[i]));
772 return AVERROR(ENOMEM);
775 if (avctx->stats_in) {
776 char *p = avctx->stats_in;
777 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
781 return AVERROR(ENOMEM);
783 av_assert0(s->version >= 2);
786 for (j = 0; j < 256; j++)
787 for (i = 0; i < 2; i++) {
788 s->rc_stat[j][i] = strtol(p, &next, 0);
790 av_log(avctx, AV_LOG_ERROR,
791 "2Pass file invalid at %d %d [%s]\n", j, i, p);
792 av_freep(&best_state);
793 return AVERROR_INVALIDDATA;
797 for (i = 0; i < s->quant_table_count; i++)
798 for (j = 0; j < s->context_count[i]; j++) {
799 for (k = 0; k < 32; k++)
800 for (m = 0; m < 2; m++) {
801 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
803 av_log(avctx, AV_LOG_ERROR,
804 "2Pass file invalid at %d %d %d %d [%s]\n",
806 av_freep(&best_state);
807 return AVERROR_INVALIDDATA;
812 gob_count = strtol(p, &next, 0);
813 if (next == p || gob_count <= 0) {
814 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
815 av_freep(&best_state);
816 return AVERROR_INVALIDDATA;
819 while (*p == '\n' || *p == ' ')
824 if (s->ac == AC_RANGE_CUSTOM_TAB)
825 sort_stt(s, s->state_transition);
827 find_best_state(best_state, s->state_transition);
829 for (i = 0; i < s->quant_table_count; i++) {
830 for (k = 0; k < 32; k++) {
833 for (j = 0; j < s->context_count[i]; j++) {
835 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
837 p = 256.0 * b / (a + b);
838 s->initial_states[i][jp][k] =
839 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
840 for(jp++; jp<j; jp++)
841 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
844 a += s->rc_stat2[i][j][k][0];
845 b += s->rc_stat2[i][j][k][1];
847 p = 256.0 * b / (a + b);
849 s->initial_states[i][j][k] =
850 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
854 av_freep(&best_state);
857 if (s->version > 1) {
858 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
859 for (; s->num_v_slices < 9; s->num_v_slices++) {
860 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
861 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !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,