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 FF_API_CODED_FRAME
749 FF_DISABLE_DEPRECATION_WARNINGS
750 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
751 FF_ENABLE_DEPRECATION_WARNINGS
754 if (!s->transparency)
756 if (!s->chroma_planes && s->version > 3)
759 ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
763 s->picture_number = 0;
765 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
766 for (i = 0; i < s->quant_table_count; i++) {
767 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
768 sizeof(*s->rc_stat2[i]));
770 return AVERROR(ENOMEM);
773 if (avctx->stats_in) {
774 char *p = avctx->stats_in;
775 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
779 return AVERROR(ENOMEM);
781 av_assert0(s->version >= 2);
784 for (j = 0; j < 256; j++)
785 for (i = 0; i < 2; i++) {
786 s->rc_stat[j][i] = strtol(p, &next, 0);
788 av_log(avctx, AV_LOG_ERROR,
789 "2Pass file invalid at %d %d [%s]\n", j, i, p);
790 av_freep(&best_state);
791 return AVERROR_INVALIDDATA;
795 for (i = 0; i < s->quant_table_count; i++)
796 for (j = 0; j < s->context_count[i]; j++) {
797 for (k = 0; k < 32; k++)
798 for (m = 0; m < 2; m++) {
799 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
801 av_log(avctx, AV_LOG_ERROR,
802 "2Pass file invalid at %d %d %d %d [%s]\n",
804 av_freep(&best_state);
805 return AVERROR_INVALIDDATA;
810 gob_count = strtol(p, &next, 0);
811 if (next == p || gob_count <= 0) {
812 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
813 av_freep(&best_state);
814 return AVERROR_INVALIDDATA;
817 while (*p == '\n' || *p == ' ')
822 if (s->ac == AC_RANGE_CUSTOM_TAB)
823 sort_stt(s, s->state_transition);
825 find_best_state(best_state, s->state_transition);
827 for (i = 0; i < s->quant_table_count; i++) {
828 for (k = 0; k < 32; k++) {
831 for (j = 0; j < s->context_count[i]; j++) {
833 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
835 p = 256.0 * b / (a + b);
836 s->initial_states[i][jp][k] =
837 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
838 for(jp++; jp<j; jp++)
839 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
842 a += s->rc_stat2[i][j][k][0];
843 b += s->rc_stat2[i][j][k][1];
845 p = 256.0 * b / (a + b);
847 s->initial_states[i][j][k] =
848 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
852 av_freep(&best_state);
855 if (s->version > 1) {
856 int plane_count = 1 + 2*s->chroma_planes + s->transparency;
857 int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
858 int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
859 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
861 s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
863 for (; s->num_v_slices < 32; s->num_v_slices++) {
864 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
865 int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
866 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
867 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
869 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
871 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
875 av_log(avctx, AV_LOG_ERROR,
876 "Unsupported number %d of slices requested, please specify a "
877 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
879 return AVERROR(ENOSYS);
881 if ((ret = write_extradata(s)) < 0)
885 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
887 s->slice_count = s->max_slice_count;
888 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
891 #define STATS_OUT_SIZE 1024 * 1024 * 6
892 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
893 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
894 if (!avctx->stats_out)
895 return AVERROR(ENOMEM);
896 for (i = 0; i < s->quant_table_count; i++)
897 for (j = 0; j < s->max_slice_count; j++) {
898 FFV1Context *sf = s->slice_context[j];
899 av_assert0(!sf->rc_stat2[i]);
900 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
901 sizeof(*sf->rc_stat2[i]));
902 if (!sf->rc_stat2[i])
903 return AVERROR(ENOMEM);
910 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
912 RangeCoder *c = &fs->c;
913 uint8_t state[CONTEXT_SIZE];
915 memset(state, 128, sizeof(state));
917 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
918 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
919 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
920 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
921 for (j=0; j<f->plane_count; j++) {
922 put_symbol(c, state, f->plane[j].quant_table_index, 0);
923 av_assert0(f->plane[j].quant_table_index == f->context_model);
925 if (!f->picture.f->interlaced_frame)
926 put_symbol(c, state, 3, 0);
928 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
929 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
930 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
931 if (f->version > 3) {
932 put_rac(c, state, fs->slice_coding_mode == 1);
933 if (fs->slice_coding_mode == 1)
934 ff_ffv1_clear_slice_state(f, fs);
935 put_symbol(c, state, fs->slice_coding_mode, 0);
936 if (fs->slice_coding_mode != 1) {
937 put_symbol(c, state, fs->slice_rct_by_coef, 0);
938 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
943 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
945 #define NB_Y_COEFF 15
946 static const int rct_y_coeff[15][2] = {
948 {1, 1}, // R + 2G + B
959 {1, 2}, // R + G + 2B
960 {2, 1}, // 2R + G + B
965 int stat[NB_Y_COEFF] = {0};
966 int x, y, i, p, best;
968 int lbd = fs->bits_per_raw_sample <= 8;
970 for (y = 0; y < h; y++) {
971 int lastr=0, lastg=0, lastb=0;
972 for (p = 0; p < 3; p++)
973 sample[p] = fs->sample_buffer + p*w;
975 for (x = 0; x < w; x++) {
979 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
982 r = (v >> 16) & 0xFF;
984 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
985 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
986 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
993 int bg = ag - sample[0][x];
994 int bb = ab - sample[1][x];
995 int br = ar - sample[2][x];
1000 for (i = 0; i<NB_Y_COEFF; i++) {
1001 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1016 for (i=1; i<NB_Y_COEFF; i++) {
1017 if (stat[i] < stat[best])
1021 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1022 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1025 static int encode_slice(AVCodecContext *c, void *arg)
1027 FFV1Context *fs = *(void **)arg;
1028 FFV1Context *f = fs->avctx->priv_data;
1029 int width = fs->slice_width;
1030 int height = fs->slice_height;
1031 int x = fs->slice_x;
1032 int y = fs->slice_y;
1033 const AVFrame *const p = f->picture.f;
1034 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1036 RangeCoder c_bak = fs->c;
1037 const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1038 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1039 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1040 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1042 fs->slice_coding_mode = 0;
1043 if (f->version > 3) {
1044 choose_rct_params(fs, planes, p->linesize, width, height);
1046 fs->slice_rct_by_coef = 1;
1047 fs->slice_rct_ry_coef = 1;
1052 ff_ffv1_clear_slice_state(f, fs);
1053 if (f->version > 2) {
1054 encode_slice_header(f, fs);
1056 if (fs->ac == AC_GOLOMB_RICE) {
1057 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1058 init_put_bits(&fs->pb,
1059 fs->c.bytestream_start + fs->ac_byte_count,
1060 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1063 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1064 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1065 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1066 const int cx = x >> f->chroma_h_shift;
1067 const int cy = y >> f->chroma_v_shift;
1069 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1071 if (f->chroma_planes) {
1072 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1073 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1075 if (fs->transparency)
1076 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1077 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1078 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1079 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1080 } else if (f->use32bit) {
1081 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1083 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1088 av_assert0(fs->slice_coding_mode == 0);
1089 if (fs->version < 4 || !fs->ac) {
1090 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1093 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1094 fs->slice_coding_mode = 1;
1102 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1103 const AVFrame *pict, int *got_packet)
1105 FFV1Context *f = avctx->priv_data;
1106 RangeCoder *const c = &f->slice_context[0]->c;
1107 AVFrame *const p = f->picture.f;
1108 uint8_t keystate = 128;
1111 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1112 + avctx->width*avctx->height*37LL*4;
1115 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1117 char *p = avctx->stats_out;
1118 char *end = p + STATS_OUT_SIZE;
1120 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1121 for (i = 0; i < f->quant_table_count; i++)
1122 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1124 av_assert0(f->slice_count == f->max_slice_count);
1125 for (j = 0; j < f->slice_count; j++) {
1126 FFV1Context *fs = f->slice_context[j];
1127 for (i = 0; i < 256; i++) {
1128 f->rc_stat[i][0] += fs->rc_stat[i][0];
1129 f->rc_stat[i][1] += fs->rc_stat[i][1];
1131 for (i = 0; i < f->quant_table_count; i++) {
1132 for (k = 0; k < f->context_count[i]; k++)
1133 for (m = 0; m < 32; m++) {
1134 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1135 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1140 for (j = 0; j < 256; j++) {
1141 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1142 f->rc_stat[j][0], f->rc_stat[j][1]);
1145 snprintf(p, end - p, "\n");
1147 for (i = 0; i < f->quant_table_count; i++) {
1148 for (j = 0; j < f->context_count[i]; j++)
1149 for (m = 0; m < 32; m++) {
1150 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1151 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1155 snprintf(p, end - p, "%d\n", f->gob_count);
1161 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1163 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1164 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1165 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1168 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1171 ff_init_range_encoder(c, pkt->data, pkt->size);
1172 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1175 if ((ret = av_frame_ref(p, pict)) < 0)
1177 #if FF_API_CODED_FRAME
1178 FF_DISABLE_DEPRECATION_WARNINGS
1179 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1180 FF_ENABLE_DEPRECATION_WARNINGS
1183 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1184 put_rac(c, &keystate, 1);
1189 put_rac(c, &keystate, 0);
1193 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1195 for (i = 1; i < 256; i++) {
1196 c->one_state[i] = f->state_transition[i];
1197 c->zero_state[256 - i] = 256 - c->one_state[i];
1201 for (i = 0; i < f->slice_count; i++) {
1202 FFV1Context *fs = f->slice_context[i];
1203 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1204 int len = pkt->size / f->slice_count;
1206 ff_init_range_encoder(&fs->c, start, len);
1208 av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1209 av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1210 fs->c.bytestream_end = fs->c.bytestream_start + len;
1213 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1214 f->slice_count, sizeof(void *));
1217 for (i = 0; i < f->slice_count; i++) {
1218 FFV1Context *fs = f->slice_context[i];
1221 if (fs->ac != AC_GOLOMB_RICE) {
1222 bytes = ff_rac_terminate(&fs->c, 1);
1224 flush_put_bits(&fs->pb); // FIXME: nicer padding
1225 bytes = fs->ac_byte_count + put_bytes_output(&fs->pb);
1227 if (i > 0 || f->version > 2) {
1228 av_assert0(bytes < pkt->size / f->slice_count);
1229 memmove(buf_p, fs->c.bytestream_start, bytes);
1230 av_assert0(bytes < (1 << 24));
1231 AV_WB24(buf_p + bytes, bytes);
1237 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1238 AV_WL32(buf_p + bytes, v);
1244 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1245 avctx->stats_out[0] = '\0';
1247 #if FF_API_CODED_FRAME
1248 FF_DISABLE_DEPRECATION_WARNINGS
1249 avctx->coded_frame->key_frame = f->key_frame;
1250 FF_ENABLE_DEPRECATION_WARNINGS
1253 f->picture_number++;
1254 pkt->size = buf_p - pkt->data;
1256 pkt->dts = pict->pts;
1257 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1263 static av_cold int encode_close(AVCodecContext *avctx)
1265 ff_ffv1_close(avctx);
1269 #define OFFSET(x) offsetof(FFV1Context, x)
1270 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1271 static const AVOption options[] = {
1272 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1273 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1274 { .i64 = 0 }, -2, 2, VE, "coder" },
1275 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1276 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1277 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1278 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1279 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1280 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1281 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1282 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1283 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1284 { .i64 = 0 }, 0, 1, VE },
1289 static const AVClass ffv1_class = {
1290 .class_name = "ffv1 encoder",
1291 .item_name = av_default_item_name,
1293 .version = LIBAVUTIL_VERSION_INT,
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,
1318 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1320 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1321 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1322 AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1324 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1325 AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1329 .priv_class = &ffv1_class,
1330 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,