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"
38 #include "rangecoder.h"
43 static const int8_t quant5_10bit[256] = {
44 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
45 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
48 2, 2, 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, -1,
57 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -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, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
62 static const int8_t quant5[256] = {
63 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
64 2, 2, 2, 2, 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, -1, -1, -1,
81 static const int8_t quant9_10bit[256] = {
82 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
83 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
84 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
85 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
86 4, 4, 4, 4, 4, 4, 4, 4, 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, -3, -3, -3, -3, -3, -3, -3,
95 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
96 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
97 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
100 static const int8_t quant11[256] = {
101 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
102 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
103 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
104 5, 5, 5, 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, -4, -4,
115 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
116 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
119 static const uint8_t ver2_state[256] = {
120 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
121 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
122 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
123 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
124 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
125 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
126 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
127 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
128 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
129 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
130 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
131 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
132 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
133 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
134 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
135 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
138 static void find_best_state(uint8_t best_state[256][256],
139 const uint8_t one_state[256])
144 for (i = 1; i < 256; i++)
145 l2tab[i] = log2(i / 256.0);
147 for (i = 0; i < 256; i++) {
148 double best_len[256];
149 double p = i / 256.0;
151 for (j = 0; j < 256; j++)
152 best_len[j] = 1 << 30;
154 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
155 double occ[256] = { 0 };
162 for (k = 0; k < 256; k++) {
163 double newocc[256] = { 0 };
164 for (m = 1; m < 256; m++)
166 len -=occ[m]*( p *l2tab[ m]
167 + (1-p)*l2tab[256-m]);
169 if (len < best_len[k]) {
171 best_state[i][k] = j;
173 for (m = 1; m < 256; m++)
175 newocc[ one_state[ m]] += occ[m] * p;
176 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
178 memcpy(occ, newocc, sizeof(occ));
184 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
185 uint8_t *state, int v,
187 uint64_t rc_stat[256][2],
188 uint64_t rc_stat2[32][2])
192 #define put_rac(C, S, B) \
195 rc_stat[*(S)][B]++; \
196 rc_stat2[(S) - state][B]++; \
202 const int a = FFABS(v);
203 const int e = av_log2(a);
204 put_rac(c, state + 0, 0);
206 for (i = 0; i < e; i++)
207 put_rac(c, state + 1 + i, 1); // 1..10
208 put_rac(c, state + 1 + i, 0);
210 for (i = e - 1; i >= 0; i--)
211 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
214 put_rac(c, state + 11 + e, v < 0); // 11..21
216 for (i = 0; i < e; i++)
217 put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
218 put_rac(c, state + 1 + 9, 0);
220 for (i = e - 1; i >= 0; i--)
221 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
224 put_rac(c, state + 11 + 10, v < 0); // 11..21
227 put_rac(c, state + 0, 1);
232 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
233 int v, int is_signed)
235 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
239 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
243 v = fold(v - state->bias, bits);
247 while (i < state->error_sum) { // FIXME: optimize
254 code = v ^ ((2 * state->drift + state->count) >> 31);
256 ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
257 state->bias, state->error_sum, state->drift, state->count, k);
258 set_sr_golomb(pb, code, k, 12, bits);
260 update_vlc_state(state, v);
264 #define RENAME(name) name
265 #include "ffv1enc_template.c"
270 #define RENAME(name) name ## 32
271 #include "ffv1enc_template.c"
273 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
274 int stride, int plane_index, int pixel_stride)
277 const int ring_size = s->context_model ? 3 : 2;
281 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
283 for (y = 0; y < h; y++) {
284 for (i = 0; i < ring_size; i++)
285 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
287 sample[0][-1]= sample[1][0 ];
288 sample[1][ w]= sample[1][w-1];
289 if (s->bits_per_raw_sample <= 8) {
290 for (x = 0; x < w; x++)
291 sample[0][x] = src[x * pixel_stride + stride * y];
292 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
295 if (s->packed_at_lsb) {
296 for (x = 0; x < w; x++) {
297 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
300 for (x = 0; x < w; x++) {
301 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
304 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
311 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
315 uint8_t state[CONTEXT_SIZE];
316 memset(state, 128, sizeof(state));
318 for (i = 1; i < 128; i++)
319 if (quant_table[i] != quant_table[i - 1]) {
320 put_symbol(c, state, i - last - 1, 0);
323 put_symbol(c, state, i - last - 1, 0);
326 static void write_quant_tables(RangeCoder *c,
327 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
330 for (i = 0; i < 5; i++)
331 write_quant_table(c, quant_table[i]);
334 static int contains_non_128(uint8_t (*initial_state)[CONTEXT_SIZE],
339 for (int i = 0; i < nb_contexts; i++)
340 for (int j = 0; j < CONTEXT_SIZE; j++)
341 if (initial_state[i][j] != 128)
346 static void write_header(FFV1Context *f)
348 uint8_t state[CONTEXT_SIZE];
350 RangeCoder *const c = &f->slice_context[0]->c;
352 memset(state, 128, sizeof(state));
354 if (f->version < 2) {
355 put_symbol(c, state, f->version, 0);
356 put_symbol(c, state, f->ac, 0);
357 if (f->ac == AC_RANGE_CUSTOM_TAB) {
358 for (i = 1; i < 256; i++)
360 f->state_transition[i] - c->one_state[i], 1);
362 put_symbol(c, state, f->colorspace, 0); //YUV cs type
364 put_symbol(c, state, f->bits_per_raw_sample, 0);
365 put_rac(c, state, f->chroma_planes);
366 put_symbol(c, state, f->chroma_h_shift, 0);
367 put_symbol(c, state, f->chroma_v_shift, 0);
368 put_rac(c, state, f->transparency);
370 write_quant_tables(c, f->quant_table);
371 } else if (f->version < 3) {
372 put_symbol(c, state, f->slice_count, 0);
373 for (i = 0; i < f->slice_count; i++) {
374 FFV1Context *fs = f->slice_context[i];
376 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
378 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
380 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
383 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
385 for (j = 0; j < f->plane_count; j++) {
386 put_symbol(c, state, f->plane[j].quant_table_index, 0);
387 av_assert0(f->plane[j].quant_table_index == f->context_model);
393 static int write_extradata(FFV1Context *f)
395 RangeCoder *const c = &f->c;
396 uint8_t state[CONTEXT_SIZE];
398 uint8_t state2[32][CONTEXT_SIZE];
401 memset(state2, 128, sizeof(state2));
402 memset(state, 128, sizeof(state));
404 f->avctx->extradata_size = 10000 + 4 +
405 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
406 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
407 if (!f->avctx->extradata)
408 return AVERROR(ENOMEM);
409 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
410 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
412 put_symbol(c, state, f->version, 0);
413 if (f->version > 2) {
414 if (f->version == 3) {
415 f->micro_version = 4;
416 } else if (f->version == 4)
417 f->micro_version = 2;
418 put_symbol(c, state, f->micro_version, 0);
421 put_symbol(c, state, f->ac, 0);
422 if (f->ac == AC_RANGE_CUSTOM_TAB)
423 for (i = 1; i < 256; i++)
424 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
426 put_symbol(c, state, f->colorspace, 0); // YUV cs type
427 put_symbol(c, state, f->bits_per_raw_sample, 0);
428 put_rac(c, state, f->chroma_planes);
429 put_symbol(c, state, f->chroma_h_shift, 0);
430 put_symbol(c, state, f->chroma_v_shift, 0);
431 put_rac(c, state, f->transparency);
432 put_symbol(c, state, f->num_h_slices - 1, 0);
433 put_symbol(c, state, f->num_v_slices - 1, 0);
435 put_symbol(c, state, f->quant_table_count, 0);
436 for (i = 0; i < f->quant_table_count; i++)
437 write_quant_tables(c, f->quant_tables[i]);
439 for (i = 0; i < f->quant_table_count; i++) {
440 if (contains_non_128(f->initial_states[i], f->context_count[i])) {
441 put_rac(c, state, 1);
442 for (j = 0; j < f->context_count[i]; j++)
443 for (k = 0; k < CONTEXT_SIZE; k++) {
444 int pred = j ? f->initial_states[i][j - 1][k] : 128;
445 put_symbol(c, state2[k],
446 (int8_t)(f->initial_states[i][j][k] - pred), 1);
449 put_rac(c, state, 0);
453 if (f->version > 2) {
454 put_symbol(c, state, f->ec, 0);
455 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
458 f->avctx->extradata_size = ff_rac_terminate(c, 0);
459 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
460 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
461 f->avctx->extradata_size += 4;
466 static int sort_stt(FFV1Context *s, uint8_t stt[256])
468 int i, i2, changed, print = 0;
472 for (i = 12; i < 244; i++) {
473 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
475 #define COST(old, new) \
476 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
477 s->rc_stat[old][1] * -log2((new) / 256.0)
479 #define COST2(old, new) \
480 COST(old, new) + COST(256 - (old), 256 - (new))
482 double size0 = COST2(i, i) + COST2(i2, i2);
483 double sizeX = COST2(i, i2) + COST2(i2, i);
484 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
486 FFSWAP(int, stt[i], stt[i2]);
487 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
488 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
490 FFSWAP(int, stt[256 - i], stt[256 - i2]);
491 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
492 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
494 for (j = 1; j < 256; j++) {
497 else if (stt[j] == i2)
500 if (stt[256 - j] == 256 - i)
501 stt[256 - j] = 256 - i2;
502 else if (stt[256 - j] == 256 - i2)
503 stt[256 - j] = 256 - i;
514 static av_cold int encode_init(AVCodecContext *avctx)
516 FFV1Context *s = avctx->priv_data;
517 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
520 if ((ret = ff_ffv1_common_init(avctx)) < 0)
525 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
527 s->version = FFMAX(s->version, 2);
529 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
530 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
531 s->version = FFMAX(s->version, 2);
533 if (avctx->level <= 0 && s->version == 2) {
536 if (avctx->level >= 0 && avctx->level <= 4) {
537 if (avctx->level < s->version) {
538 av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
539 return AVERROR(EINVAL);
541 s->version = avctx->level;
545 s->ec = (s->version >= 3);
548 // CRC requires version 3+
550 s->version = FFMAX(s->version, 3);
552 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
553 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
554 return AVERROR_INVALIDDATA;
557 if (s->ac == 1) // Compatbility with common command line usage
558 s->ac = AC_RANGE_CUSTOM_TAB;
559 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
560 s->ac = AC_RANGE_DEFAULT_TAB;
563 switch(avctx->pix_fmt) {
564 case AV_PIX_FMT_GRAY9:
565 case AV_PIX_FMT_YUV444P9:
566 case AV_PIX_FMT_YUV422P9:
567 case AV_PIX_FMT_YUV420P9:
568 case AV_PIX_FMT_YUVA444P9:
569 case AV_PIX_FMT_YUVA422P9:
570 case AV_PIX_FMT_YUVA420P9:
571 if (!avctx->bits_per_raw_sample)
572 s->bits_per_raw_sample = 9;
573 case AV_PIX_FMT_GRAY10:
574 case AV_PIX_FMT_YUV444P10:
575 case AV_PIX_FMT_YUV440P10:
576 case AV_PIX_FMT_YUV420P10:
577 case AV_PIX_FMT_YUV422P10:
578 case AV_PIX_FMT_YUVA444P10:
579 case AV_PIX_FMT_YUVA422P10:
580 case AV_PIX_FMT_YUVA420P10:
581 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
582 s->bits_per_raw_sample = 10;
583 case AV_PIX_FMT_GRAY12:
584 case AV_PIX_FMT_YUV444P12:
585 case AV_PIX_FMT_YUV440P12:
586 case AV_PIX_FMT_YUV420P12:
587 case AV_PIX_FMT_YUV422P12:
588 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
589 s->bits_per_raw_sample = 12;
590 case AV_PIX_FMT_YUV444P14:
591 case AV_PIX_FMT_YUV420P14:
592 case AV_PIX_FMT_YUV422P14:
593 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
594 s->bits_per_raw_sample = 14;
595 s->packed_at_lsb = 1;
596 case AV_PIX_FMT_GRAY16:
597 case AV_PIX_FMT_YUV444P16:
598 case AV_PIX_FMT_YUV422P16:
599 case AV_PIX_FMT_YUV420P16:
600 case AV_PIX_FMT_YUVA444P16:
601 case AV_PIX_FMT_YUVA422P16:
602 case AV_PIX_FMT_YUVA420P16:
603 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
604 s->bits_per_raw_sample = 16;
605 } else if (!s->bits_per_raw_sample) {
606 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
608 if (s->bits_per_raw_sample <= 8) {
609 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
610 return AVERROR_INVALIDDATA;
612 s->version = FFMAX(s->version, 1);
613 case AV_PIX_FMT_GRAY8:
615 case AV_PIX_FMT_YUV444P:
616 case AV_PIX_FMT_YUV440P:
617 case AV_PIX_FMT_YUV422P:
618 case AV_PIX_FMT_YUV420P:
619 case AV_PIX_FMT_YUV411P:
620 case AV_PIX_FMT_YUV410P:
621 case AV_PIX_FMT_YUVA444P:
622 case AV_PIX_FMT_YUVA422P:
623 case AV_PIX_FMT_YUVA420P:
624 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
626 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
627 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
628 s->bits_per_raw_sample = 8;
629 else if (!s->bits_per_raw_sample)
630 s->bits_per_raw_sample = 8;
632 case AV_PIX_FMT_RGB32:
635 s->chroma_planes = 1;
636 s->bits_per_raw_sample = 8;
638 case AV_PIX_FMT_RGBA64:
641 s->chroma_planes = 1;
642 s->bits_per_raw_sample = 16;
644 s->version = FFMAX(s->version, 1);
646 case AV_PIX_FMT_RGB48:
648 s->chroma_planes = 1;
649 s->bits_per_raw_sample = 16;
651 s->version = FFMAX(s->version, 1);
653 case AV_PIX_FMT_0RGB32:
655 s->chroma_planes = 1;
656 s->bits_per_raw_sample = 8;
658 case AV_PIX_FMT_GBRP9:
659 if (!avctx->bits_per_raw_sample)
660 s->bits_per_raw_sample = 9;
661 case AV_PIX_FMT_GBRP10:
662 case AV_PIX_FMT_GBRAP10:
663 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
664 s->bits_per_raw_sample = 10;
665 case AV_PIX_FMT_GBRP12:
666 case AV_PIX_FMT_GBRAP12:
667 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
668 s->bits_per_raw_sample = 12;
669 case AV_PIX_FMT_GBRP14:
670 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
671 s->bits_per_raw_sample = 14;
672 case AV_PIX_FMT_GBRP16:
673 case AV_PIX_FMT_GBRAP16:
674 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
675 s->bits_per_raw_sample = 16;
676 else if (!s->bits_per_raw_sample)
677 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
678 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
680 s->chroma_planes = 1;
681 if (s->bits_per_raw_sample >= 16) {
684 s->version = FFMAX(s->version, 1);
687 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
688 return AVERROR(ENOSYS);
690 av_assert0(s->bits_per_raw_sample >= 8);
692 if (s->bits_per_raw_sample > 8) {
693 if (s->ac == AC_GOLOMB_RICE) {
694 av_log(avctx, AV_LOG_INFO,
695 "bits_per_raw_sample > 8, forcing range coder\n");
696 s->ac = AC_RANGE_CUSTOM_TAB;
700 if (s->ac == AC_RANGE_CUSTOM_TAB) {
701 for (i = 1; i < 256; i++)
702 s->state_transition[i] = ver2_state[i];
705 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
706 for (i = 1; i < 256; i++)
707 s->state_transition[i] = c.one_state[i];
710 for (i = 0; i < 256; i++) {
711 s->quant_table_count = 2;
712 if (s->bits_per_raw_sample <= 8) {
713 s->quant_tables[0][0][i]= quant11[i];
714 s->quant_tables[0][1][i]= 11*quant11[i];
715 s->quant_tables[0][2][i]= 11*11*quant11[i];
716 s->quant_tables[1][0][i]= quant11[i];
717 s->quant_tables[1][1][i]= 11*quant11[i];
718 s->quant_tables[1][2][i]= 11*11*quant5 [i];
719 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
720 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
722 s->quant_tables[0][0][i]= quant9_10bit[i];
723 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
724 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
725 s->quant_tables[1][0][i]= quant9_10bit[i];
726 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
727 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
728 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
729 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
732 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
733 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
734 memcpy(s->quant_table, s->quant_tables[s->context_model],
735 sizeof(s->quant_table));
737 for (i = 0; i < s->plane_count; i++) {
738 PlaneContext *const p = &s->plane[i];
740 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
741 p->quant_table_index = s->context_model;
742 p->context_count = s->context_count[p->quant_table_index];
745 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
748 if (!s->transparency)
750 if (!s->chroma_planes && s->version > 3)
753 ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
757 s->picture_number = 0;
759 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
760 for (i = 0; i < s->quant_table_count; i++) {
761 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
762 sizeof(*s->rc_stat2[i]));
764 return AVERROR(ENOMEM);
767 if (avctx->stats_in) {
768 char *p = avctx->stats_in;
769 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
773 return AVERROR(ENOMEM);
775 av_assert0(s->version >= 2);
778 for (j = 0; j < 256; j++)
779 for (i = 0; i < 2; i++) {
780 s->rc_stat[j][i] = strtol(p, &next, 0);
782 av_log(avctx, AV_LOG_ERROR,
783 "2Pass file invalid at %d %d [%s]\n", j, i, p);
784 av_freep(&best_state);
785 return AVERROR_INVALIDDATA;
789 for (i = 0; i < s->quant_table_count; i++)
790 for (j = 0; j < s->context_count[i]; j++) {
791 for (k = 0; k < 32; k++)
792 for (m = 0; m < 2; m++) {
793 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
795 av_log(avctx, AV_LOG_ERROR,
796 "2Pass file invalid at %d %d %d %d [%s]\n",
798 av_freep(&best_state);
799 return AVERROR_INVALIDDATA;
804 gob_count = strtol(p, &next, 0);
805 if (next == p || gob_count <= 0) {
806 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
807 av_freep(&best_state);
808 return AVERROR_INVALIDDATA;
811 while (*p == '\n' || *p == ' ')
816 if (s->ac == AC_RANGE_CUSTOM_TAB)
817 sort_stt(s, s->state_transition);
819 find_best_state(best_state, s->state_transition);
821 for (i = 0; i < s->quant_table_count; i++) {
822 for (k = 0; k < 32; k++) {
825 for (j = 0; j < s->context_count[i]; j++) {
827 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
829 p = 256.0 * b / (a + b);
830 s->initial_states[i][jp][k] =
831 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
832 for(jp++; jp<j; jp++)
833 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
836 a += s->rc_stat2[i][j][k][0];
837 b += s->rc_stat2[i][j][k][1];
839 p = 256.0 * b / (a + b);
841 s->initial_states[i][j][k] =
842 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
846 av_freep(&best_state);
849 if (s->version > 1) {
850 int plane_count = 1 + 2*s->chroma_planes + s->transparency;
851 int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
852 int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
853 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
855 s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
857 for (; s->num_v_slices < 32; s->num_v_slices++) {
858 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
859 int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
860 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
861 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
863 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
865 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
869 av_log(avctx, AV_LOG_ERROR,
870 "Unsupported number %d of slices requested, please specify a "
871 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
873 return AVERROR(ENOSYS);
875 if ((ret = write_extradata(s)) < 0)
879 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
881 s->slice_count = s->max_slice_count;
882 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
885 #define STATS_OUT_SIZE 1024 * 1024 * 6
886 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
887 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
888 if (!avctx->stats_out)
889 return AVERROR(ENOMEM);
890 for (i = 0; i < s->quant_table_count; i++)
891 for (j = 0; j < s->max_slice_count; j++) {
892 FFV1Context *sf = s->slice_context[j];
893 av_assert0(!sf->rc_stat2[i]);
894 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
895 sizeof(*sf->rc_stat2[i]));
896 if (!sf->rc_stat2[i])
897 return AVERROR(ENOMEM);
904 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
906 RangeCoder *c = &fs->c;
907 uint8_t state[CONTEXT_SIZE];
909 memset(state, 128, sizeof(state));
911 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
912 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
913 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
914 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
915 for (j=0; j<f->plane_count; j++) {
916 put_symbol(c, state, f->plane[j].quant_table_index, 0);
917 av_assert0(f->plane[j].quant_table_index == f->context_model);
919 if (!f->picture.f->interlaced_frame)
920 put_symbol(c, state, 3, 0);
922 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
923 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
924 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
925 if (f->version > 3) {
926 put_rac(c, state, fs->slice_coding_mode == 1);
927 if (fs->slice_coding_mode == 1)
928 ff_ffv1_clear_slice_state(f, fs);
929 put_symbol(c, state, fs->slice_coding_mode, 0);
930 if (fs->slice_coding_mode != 1) {
931 put_symbol(c, state, fs->slice_rct_by_coef, 0);
932 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
937 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
939 #define NB_Y_COEFF 15
940 static const int rct_y_coeff[15][2] = {
942 {1, 1}, // R + 2G + B
953 {1, 2}, // R + G + 2B
954 {2, 1}, // 2R + G + B
959 int stat[NB_Y_COEFF] = {0};
960 int x, y, i, p, best;
962 int lbd = fs->bits_per_raw_sample <= 8;
964 for (y = 0; y < h; y++) {
965 int lastr=0, lastg=0, lastb=0;
966 for (p = 0; p < 3; p++)
967 sample[p] = fs->sample_buffer + p*w;
969 for (x = 0; x < w; x++) {
973 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
976 r = (v >> 16) & 0xFF;
978 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
979 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
980 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
987 int bg = ag - sample[0][x];
988 int bb = ab - sample[1][x];
989 int br = ar - sample[2][x];
994 for (i = 0; i<NB_Y_COEFF; i++) {
995 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1010 for (i=1; i<NB_Y_COEFF; i++) {
1011 if (stat[i] < stat[best])
1015 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1016 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1019 static int encode_slice(AVCodecContext *c, void *arg)
1021 FFV1Context *fs = *(void **)arg;
1022 FFV1Context *f = fs->avctx->priv_data;
1023 int width = fs->slice_width;
1024 int height = fs->slice_height;
1025 int x = fs->slice_x;
1026 int y = fs->slice_y;
1027 const AVFrame *const p = f->picture.f;
1028 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1030 RangeCoder c_bak = fs->c;
1031 const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1032 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1033 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1034 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1036 fs->slice_coding_mode = 0;
1037 if (f->version > 3) {
1038 choose_rct_params(fs, planes, p->linesize, width, height);
1040 fs->slice_rct_by_coef = 1;
1041 fs->slice_rct_ry_coef = 1;
1046 ff_ffv1_clear_slice_state(f, fs);
1047 if (f->version > 2) {
1048 encode_slice_header(f, fs);
1050 if (fs->ac == AC_GOLOMB_RICE) {
1051 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1052 init_put_bits(&fs->pb,
1053 fs->c.bytestream_start + fs->ac_byte_count,
1054 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1057 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1058 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1059 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1060 const int cx = x >> f->chroma_h_shift;
1061 const int cy = y >> f->chroma_v_shift;
1063 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1065 if (f->chroma_planes) {
1066 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1067 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1069 if (fs->transparency)
1070 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1071 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1072 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1073 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1074 } else if (f->use32bit) {
1075 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1077 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1082 av_assert0(fs->slice_coding_mode == 0);
1083 if (fs->version < 4 || !fs->ac) {
1084 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1087 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1088 fs->slice_coding_mode = 1;
1096 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1097 const AVFrame *pict, int *got_packet)
1099 FFV1Context *f = avctx->priv_data;
1100 RangeCoder *const c = &f->slice_context[0]->c;
1101 AVFrame *const p = f->picture.f;
1102 uint8_t keystate = 128;
1105 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1106 + avctx->width*avctx->height*37LL*4;
1109 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1111 char *p = avctx->stats_out;
1112 char *end = p + STATS_OUT_SIZE;
1114 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1115 for (i = 0; i < f->quant_table_count; i++)
1116 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1118 av_assert0(f->slice_count == f->max_slice_count);
1119 for (j = 0; j < f->slice_count; j++) {
1120 FFV1Context *fs = f->slice_context[j];
1121 for (i = 0; i < 256; i++) {
1122 f->rc_stat[i][0] += fs->rc_stat[i][0];
1123 f->rc_stat[i][1] += fs->rc_stat[i][1];
1125 for (i = 0; i < f->quant_table_count; i++) {
1126 for (k = 0; k < f->context_count[i]; k++)
1127 for (m = 0; m < 32; m++) {
1128 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1129 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1134 for (j = 0; j < 256; j++) {
1135 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1136 f->rc_stat[j][0], f->rc_stat[j][1]);
1139 snprintf(p, end - p, "\n");
1141 for (i = 0; i < f->quant_table_count; i++) {
1142 for (j = 0; j < f->context_count[i]; j++)
1143 for (m = 0; m < 32; m++) {
1144 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1145 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1149 snprintf(p, end - p, "%d\n", f->gob_count);
1155 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1157 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1158 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1159 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1162 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1165 ff_init_range_encoder(c, pkt->data, pkt->size);
1166 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1169 if ((ret = av_frame_ref(p, pict)) < 0)
1172 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1173 put_rac(c, &keystate, 1);
1178 put_rac(c, &keystate, 0);
1182 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1184 for (i = 1; i < 256; i++) {
1185 c->one_state[i] = f->state_transition[i];
1186 c->zero_state[256 - i] = 256 - c->one_state[i];
1190 for (i = 0; i < f->slice_count; i++) {
1191 FFV1Context *fs = f->slice_context[i];
1192 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1193 int len = pkt->size / f->slice_count;
1195 ff_init_range_encoder(&fs->c, start, len);
1197 av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1198 av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1199 fs->c.bytestream_end = fs->c.bytestream_start + len;
1202 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1203 f->slice_count, sizeof(void *));
1206 for (i = 0; i < f->slice_count; i++) {
1207 FFV1Context *fs = f->slice_context[i];
1210 if (fs->ac != AC_GOLOMB_RICE) {
1211 bytes = ff_rac_terminate(&fs->c, 1);
1213 flush_put_bits(&fs->pb); // FIXME: nicer padding
1214 bytes = fs->ac_byte_count + put_bytes_output(&fs->pb);
1216 if (i > 0 || f->version > 2) {
1217 av_assert0(bytes < pkt->size / f->slice_count);
1218 memmove(buf_p, fs->c.bytestream_start, bytes);
1219 av_assert0(bytes < (1 << 24));
1220 AV_WB24(buf_p + bytes, bytes);
1226 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1227 AV_WL32(buf_p + bytes, v);
1233 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1234 avctx->stats_out[0] = '\0';
1236 f->picture_number++;
1237 pkt->size = buf_p - pkt->data;
1239 pkt->dts = pict->pts;
1240 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1246 static av_cold int encode_close(AVCodecContext *avctx)
1248 ff_ffv1_close(avctx);
1252 #define OFFSET(x) offsetof(FFV1Context, x)
1253 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1254 static const AVOption options[] = {
1255 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1256 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1257 { .i64 = 0 }, -2, 2, VE, "coder" },
1258 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1259 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1260 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1261 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1262 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1263 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1264 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1265 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1266 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1267 { .i64 = 0 }, 0, 1, VE },
1272 static const AVClass ffv1_class = {
1273 .class_name = "ffv1 encoder",
1274 .item_name = av_default_item_name,
1276 .version = LIBAVUTIL_VERSION_INT,
1279 const 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_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1296 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1297 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1298 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1299 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1300 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1301 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1303 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1304 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1305 AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1307 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1308 AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1312 .priv_class = &ffv1_class,
1313 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,