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);
271 static av_always_inline int encode_line(FFV1Context *s, int w,
273 int plane_index, int bits)
275 PlaneContext *const p = &s->plane[plane_index];
276 RangeCoder *const c = &s->c;
278 int run_index = s->run_index;
282 if (s->ac != AC_GOLOMB_RICE) {
283 if (c->bytestream_end - c->bytestream < w * 35) {
284 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
285 return AVERROR_INVALIDDATA;
288 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
289 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
290 return AVERROR_INVALIDDATA;
294 if (s->slice_coding_mode == 1) {
295 for (x = 0; x < w; x++) {
297 int v = sample[0][x];
298 for (i = bits-1; i>=0; i--) {
300 put_rac(c, &state, (v>>i) & 1);
306 for (x = 0; x < w; x++) {
309 context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
310 diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
317 diff = fold(diff, bits);
319 if (s->ac != AC_GOLOMB_RICE) {
320 if (s->flags & AV_CODEC_FLAG_PASS1) {
321 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
322 s->rc_stat2[p->quant_table_index][context]);
324 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
332 while (run_count >= 1 << ff_log2_run[run_index]) {
333 run_count -= 1 << ff_log2_run[run_index];
335 put_bits(&s->pb, 1, 1);
338 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
350 ff_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
351 run_count, run_index, run_mode, x,
352 (int)put_bits_count(&s->pb));
355 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
359 while (run_count >= 1 << ff_log2_run[run_index]) {
360 run_count -= 1 << ff_log2_run[run_index];
362 put_bits(&s->pb, 1, 1);
366 put_bits(&s->pb, 1, 1);
368 s->run_index = run_index;
373 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
374 int stride, int plane_index, int pixel_stride)
377 const int ring_size = s->context_model ? 3 : 2;
381 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
383 for (y = 0; y < h; y++) {
384 for (i = 0; i < ring_size; i++)
385 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
387 sample[0][-1]= sample[1][0 ];
388 sample[1][ w]= sample[1][w-1];
390 if (s->bits_per_raw_sample <= 8) {
391 for (x = 0; x < w; x++)
392 sample[0][x] = src[x * pixel_stride + stride * y];
393 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
396 if (s->packed_at_lsb) {
397 for (x = 0; x < w; x++) {
398 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
401 for (x = 0; x < w; x++) {
402 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
405 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
408 // STOP_TIMER("encode line") }
413 static int encode_rgb_frame(FFV1Context *s, const uint8_t *src[3],
414 int w, int h, const int stride[3])
417 const int ring_size = s->context_model ? 3 : 2;
418 int16_t *sample[4][3];
419 int lbd = s->bits_per_raw_sample <= 8;
420 int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
421 int offset = 1 << bits;
425 memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
426 (w + 6) * sizeof(*s->sample_buffer));
428 for (y = 0; y < h; y++) {
429 for (i = 0; i < ring_size; i++)
430 for (p = 0; p < MAX_PLANES; p++)
431 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
433 for (x = 0; x < w; x++) {
434 int b, g, r, av_uninit(a);
436 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
439 r = (v >> 16) & 0xFF;
442 b = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
443 g = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
444 r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
447 if (s->slice_coding_mode != 1) {
450 g += (b * s->slice_rct_by_coef + r * s->slice_rct_ry_coef) >> 2;
460 for (p = 0; p < 3 + s->transparency; p++) {
462 sample[p][0][-1] = sample[p][1][0 ];
463 sample[p][1][ w] = sample[p][1][w-1];
464 if (lbd && s->slice_coding_mode == 0)
465 ret = encode_line(s, w, sample[p], (p + 1) / 2, 9);
467 ret = encode_line(s, w, sample[p], (p + 1) / 2, bits + (s->slice_coding_mode != 1));
475 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
479 uint8_t state[CONTEXT_SIZE];
480 memset(state, 128, sizeof(state));
482 for (i = 1; i < 128; i++)
483 if (quant_table[i] != quant_table[i - 1]) {
484 put_symbol(c, state, i - last - 1, 0);
487 put_symbol(c, state, i - last - 1, 0);
490 static void write_quant_tables(RangeCoder *c,
491 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
494 for (i = 0; i < 5; i++)
495 write_quant_table(c, quant_table[i]);
498 static void write_header(FFV1Context *f)
500 uint8_t state[CONTEXT_SIZE];
502 RangeCoder *const c = &f->slice_context[0]->c;
504 memset(state, 128, sizeof(state));
506 if (f->version < 2) {
507 put_symbol(c, state, f->version, 0);
508 put_symbol(c, state, f->ac, 0);
509 if (f->ac == AC_RANGE_CUSTOM_TAB) {
510 for (i = 1; i < 256; i++)
512 f->state_transition[i] - c->one_state[i], 1);
514 put_symbol(c, state, f->colorspace, 0); //YUV cs type
516 put_symbol(c, state, f->bits_per_raw_sample, 0);
517 put_rac(c, state, f->chroma_planes);
518 put_symbol(c, state, f->chroma_h_shift, 0);
519 put_symbol(c, state, f->chroma_v_shift, 0);
520 put_rac(c, state, f->transparency);
522 write_quant_tables(c, f->quant_table);
523 } else if (f->version < 3) {
524 put_symbol(c, state, f->slice_count, 0);
525 for (i = 0; i < f->slice_count; i++) {
526 FFV1Context *fs = f->slice_context[i];
528 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
530 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
532 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
535 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
537 for (j = 0; j < f->plane_count; j++) {
538 put_symbol(c, state, f->plane[j].quant_table_index, 0);
539 av_assert0(f->plane[j].quant_table_index == f->context_model);
545 static int write_extradata(FFV1Context *f)
547 RangeCoder *const c = &f->c;
548 uint8_t state[CONTEXT_SIZE];
550 uint8_t state2[32][CONTEXT_SIZE];
553 memset(state2, 128, sizeof(state2));
554 memset(state, 128, sizeof(state));
556 f->avctx->extradata_size = 10000 + 4 +
557 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
558 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
559 if (!f->avctx->extradata)
560 return AVERROR(ENOMEM);
561 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
562 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
564 put_symbol(c, state, f->version, 0);
565 if (f->version > 2) {
566 if (f->version == 3) {
567 f->micro_version = 4;
568 } else if (f->version == 4)
569 f->micro_version = 2;
570 put_symbol(c, state, f->micro_version, 0);
573 put_symbol(c, state, f->ac, 0);
574 if (f->ac == AC_RANGE_CUSTOM_TAB)
575 for (i = 1; i < 256; i++)
576 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
578 put_symbol(c, state, f->colorspace, 0); // YUV cs type
579 put_symbol(c, state, f->bits_per_raw_sample, 0);
580 put_rac(c, state, f->chroma_planes);
581 put_symbol(c, state, f->chroma_h_shift, 0);
582 put_symbol(c, state, f->chroma_v_shift, 0);
583 put_rac(c, state, f->transparency);
584 put_symbol(c, state, f->num_h_slices - 1, 0);
585 put_symbol(c, state, f->num_v_slices - 1, 0);
587 put_symbol(c, state, f->quant_table_count, 0);
588 for (i = 0; i < f->quant_table_count; i++)
589 write_quant_tables(c, f->quant_tables[i]);
591 for (i = 0; i < f->quant_table_count; i++) {
592 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
593 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
595 if (j < f->context_count[i] * CONTEXT_SIZE) {
596 put_rac(c, state, 1);
597 for (j = 0; j < f->context_count[i]; j++)
598 for (k = 0; k < CONTEXT_SIZE; k++) {
599 int pred = j ? f->initial_states[i][j - 1][k] : 128;
600 put_symbol(c, state2[k],
601 (int8_t)(f->initial_states[i][j][k] - pred), 1);
604 put_rac(c, state, 0);
608 if (f->version > 2) {
609 put_symbol(c, state, f->ec, 0);
610 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
613 f->avctx->extradata_size = ff_rac_terminate(c);
614 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
615 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
616 f->avctx->extradata_size += 4;
621 static int sort_stt(FFV1Context *s, uint8_t stt[256])
623 int i, i2, changed, print = 0;
627 for (i = 12; i < 244; i++) {
628 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
630 #define COST(old, new) \
631 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
632 s->rc_stat[old][1] * -log2((new) / 256.0)
634 #define COST2(old, new) \
635 COST(old, new) + COST(256 - (old), 256 - (new))
637 double size0 = COST2(i, i) + COST2(i2, i2);
638 double sizeX = COST2(i, i2) + COST2(i2, i);
639 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
641 FFSWAP(int, stt[i], stt[i2]);
642 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
643 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
645 FFSWAP(int, stt[256 - i], stt[256 - i2]);
646 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
647 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
649 for (j = 1; j < 256; j++) {
652 else if (stt[j] == i2)
655 if (stt[256 - j] == 256 - i)
656 stt[256 - j] = 256 - i2;
657 else if (stt[256 - j] == 256 - i2)
658 stt[256 - j] = 256 - i;
669 static av_cold int encode_init(AVCodecContext *avctx)
671 FFV1Context *s = avctx->priv_data;
672 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
675 if ((ret = ff_ffv1_common_init(avctx)) < 0)
680 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
682 s->version = FFMAX(s->version, 2);
684 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
685 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
686 s->version = FFMAX(s->version, 2);
688 if (avctx->level <= 0 && s->version == 2) {
691 if (avctx->level >= 0 && avctx->level <= 4) {
692 if (avctx->level < s->version) {
693 av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
694 return AVERROR(EINVAL);
696 s->version = avctx->level;
700 s->ec = (s->version >= 3);
703 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
704 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
705 return AVERROR_INVALIDDATA;
708 #if FF_API_CODER_TYPE
709 FF_DISABLE_DEPRECATION_WARNINGS
710 if (avctx->coder_type != -1)
711 s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
713 FF_ENABLE_DEPRECATION_WARNINGS
715 if (s->ac == 1) // Compatbility with common command line usage
716 s->ac = AC_RANGE_CUSTOM_TAB;
717 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
718 s->ac = AC_RANGE_DEFAULT_TAB;
721 switch(avctx->pix_fmt) {
722 case AV_PIX_FMT_YUV444P9:
723 case AV_PIX_FMT_YUV422P9:
724 case AV_PIX_FMT_YUV420P9:
725 case AV_PIX_FMT_YUVA444P9:
726 case AV_PIX_FMT_YUVA422P9:
727 case AV_PIX_FMT_YUVA420P9:
728 if (!avctx->bits_per_raw_sample)
729 s->bits_per_raw_sample = 9;
730 case AV_PIX_FMT_YUV444P10:
731 case AV_PIX_FMT_YUV420P10:
732 case AV_PIX_FMT_YUV422P10:
733 case AV_PIX_FMT_YUVA444P10:
734 case AV_PIX_FMT_YUVA422P10:
735 case AV_PIX_FMT_YUVA420P10:
736 s->packed_at_lsb = 1;
737 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
738 s->bits_per_raw_sample = 10;
739 case AV_PIX_FMT_GRAY16:
740 case AV_PIX_FMT_YUV444P16:
741 case AV_PIX_FMT_YUV422P16:
742 case AV_PIX_FMT_YUV420P16:
743 case AV_PIX_FMT_YUVA444P16:
744 case AV_PIX_FMT_YUVA422P16:
745 case AV_PIX_FMT_YUVA420P16:
746 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
747 s->bits_per_raw_sample = 16;
748 } else if (!s->bits_per_raw_sample) {
749 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
751 if (s->bits_per_raw_sample <= 8) {
752 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
753 return AVERROR_INVALIDDATA;
755 if (s->ac == AC_GOLOMB_RICE) {
756 av_log(avctx, AV_LOG_INFO,
757 "bits_per_raw_sample > 8, forcing range coder\n");
758 s->ac = AC_RANGE_CUSTOM_TAB;
760 s->version = FFMAX(s->version, 1);
761 case AV_PIX_FMT_GRAY8:
763 case AV_PIX_FMT_YUV444P:
764 case AV_PIX_FMT_YUV440P:
765 case AV_PIX_FMT_YUV422P:
766 case AV_PIX_FMT_YUV420P:
767 case AV_PIX_FMT_YUV411P:
768 case AV_PIX_FMT_YUV410P:
769 case AV_PIX_FMT_YUVA444P:
770 case AV_PIX_FMT_YUVA422P:
771 case AV_PIX_FMT_YUVA420P:
772 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
774 s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
775 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
776 s->bits_per_raw_sample = 8;
777 else if (!s->bits_per_raw_sample)
778 s->bits_per_raw_sample = 8;
780 case AV_PIX_FMT_RGB32:
783 s->chroma_planes = 1;
784 if (!avctx->bits_per_raw_sample)
785 s->bits_per_raw_sample = 8;
787 case AV_PIX_FMT_0RGB32:
789 s->chroma_planes = 1;
790 if (!avctx->bits_per_raw_sample)
791 s->bits_per_raw_sample = 8;
793 case AV_PIX_FMT_GBRP9:
794 if (!avctx->bits_per_raw_sample)
795 s->bits_per_raw_sample = 9;
796 case AV_PIX_FMT_GBRP10:
797 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
798 s->bits_per_raw_sample = 10;
799 case AV_PIX_FMT_GBRP12:
800 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
801 s->bits_per_raw_sample = 12;
802 case AV_PIX_FMT_GBRP14:
803 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
804 s->bits_per_raw_sample = 14;
805 else if (!s->bits_per_raw_sample)
806 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
808 s->chroma_planes = 1;
809 s->version = FFMAX(s->version, 1);
810 if (s->ac == AC_GOLOMB_RICE) {
811 av_log(avctx, AV_LOG_INFO,
812 "bits_per_raw_sample > 8, forcing coder 1\n");
813 s->ac = AC_RANGE_CUSTOM_TAB;
817 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
818 return AVERROR(ENOSYS);
820 av_assert0(s->bits_per_raw_sample >= 8);
822 if (s->transparency) {
823 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
825 #if FF_API_PRIVATE_OPT
826 FF_DISABLE_DEPRECATION_WARNINGS
827 if (avctx->context_model)
828 s->context_model = avctx->context_model;
829 if (avctx->context_model > 1U) {
830 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
831 return AVERROR(EINVAL);
833 FF_ENABLE_DEPRECATION_WARNINGS
836 if (s->ac == AC_RANGE_CUSTOM_TAB) {
837 for (i = 1; i < 256; i++)
838 s->state_transition[i] = ver2_state[i];
841 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
842 for (i = 1; i < 256; i++)
843 s->state_transition[i] = c.one_state[i];
846 for (i = 0; i < 256; i++) {
847 s->quant_table_count = 2;
848 if (s->bits_per_raw_sample <= 8) {
849 s->quant_tables[0][0][i]= quant11[i];
850 s->quant_tables[0][1][i]= 11*quant11[i];
851 s->quant_tables[0][2][i]= 11*11*quant11[i];
852 s->quant_tables[1][0][i]= quant11[i];
853 s->quant_tables[1][1][i]= 11*quant11[i];
854 s->quant_tables[1][2][i]= 11*11*quant5 [i];
855 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
856 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
858 s->quant_tables[0][0][i]= quant9_10bit[i];
859 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
860 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
861 s->quant_tables[1][0][i]= quant9_10bit[i];
862 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
863 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
864 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
865 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
868 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
869 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
870 memcpy(s->quant_table, s->quant_tables[s->context_model],
871 sizeof(s->quant_table));
873 for (i = 0; i < s->plane_count; i++) {
874 PlaneContext *const p = &s->plane[i];
876 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
877 p->quant_table_index = s->context_model;
878 p->context_count = s->context_count[p->quant_table_index];
881 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
884 #if FF_API_CODED_FRAME
885 FF_DISABLE_DEPRECATION_WARNINGS
886 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
887 FF_ENABLE_DEPRECATION_WARNINGS
890 if (!s->transparency)
892 if (!s->chroma_planes && s->version > 3)
895 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
896 s->picture_number = 0;
898 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
899 for (i = 0; i < s->quant_table_count; i++) {
900 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
901 sizeof(*s->rc_stat2[i]));
903 return AVERROR(ENOMEM);
906 if (avctx->stats_in) {
907 char *p = avctx->stats_in;
908 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
912 return AVERROR(ENOMEM);
914 av_assert0(s->version >= 2);
917 for (j = 0; j < 256; j++)
918 for (i = 0; i < 2; i++) {
919 s->rc_stat[j][i] = strtol(p, &next, 0);
921 av_log(avctx, AV_LOG_ERROR,
922 "2Pass file invalid at %d %d [%s]\n", j, i, p);
923 av_freep(&best_state);
924 return AVERROR_INVALIDDATA;
928 for (i = 0; i < s->quant_table_count; i++)
929 for (j = 0; j < s->context_count[i]; j++) {
930 for (k = 0; k < 32; k++)
931 for (m = 0; m < 2; m++) {
932 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
934 av_log(avctx, AV_LOG_ERROR,
935 "2Pass file invalid at %d %d %d %d [%s]\n",
937 av_freep(&best_state);
938 return AVERROR_INVALIDDATA;
943 gob_count = strtol(p, &next, 0);
944 if (next == p || gob_count <= 0) {
945 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
946 av_freep(&best_state);
947 return AVERROR_INVALIDDATA;
950 while (*p == '\n' || *p == ' ')
955 if (s->ac == AC_RANGE_CUSTOM_TAB)
956 sort_stt(s, s->state_transition);
958 find_best_state(best_state, s->state_transition);
960 for (i = 0; i < s->quant_table_count; i++) {
961 for (k = 0; k < 32; k++) {
964 for (j = 0; j < s->context_count[i]; j++) {
966 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
968 p = 256.0 * b / (a + b);
969 s->initial_states[i][jp][k] =
970 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
971 for(jp++; jp<j; jp++)
972 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
975 a += s->rc_stat2[i][j][k][0];
976 b += s->rc_stat2[i][j][k][1];
978 p = 256.0 * b / (a + b);
980 s->initial_states[i][j][k] =
981 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
985 av_freep(&best_state);
988 if (s->version > 1) {
989 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
990 for (; s->num_v_slices < 9; s->num_v_slices++) {
991 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
992 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
996 av_log(avctx, AV_LOG_ERROR,
997 "Unsupported number %d of slices requested, please specify a "
998 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
1000 return AVERROR(ENOSYS);
1002 if ((ret = write_extradata(s)) < 0)
1006 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
1008 s->slice_count = s->max_slice_count;
1009 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
1012 #define STATS_OUT_SIZE 1024 * 1024 * 6
1013 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1014 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
1015 if (!avctx->stats_out)
1016 return AVERROR(ENOMEM);
1017 for (i = 0; i < s->quant_table_count; i++)
1018 for (j = 0; j < s->max_slice_count; j++) {
1019 FFV1Context *sf = s->slice_context[j];
1020 av_assert0(!sf->rc_stat2[i]);
1021 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
1022 sizeof(*sf->rc_stat2[i]));
1023 if (!sf->rc_stat2[i])
1024 return AVERROR(ENOMEM);
1031 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
1033 RangeCoder *c = &fs->c;
1034 uint8_t state[CONTEXT_SIZE];
1036 memset(state, 128, sizeof(state));
1038 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
1039 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
1040 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
1041 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
1042 for (j=0; j<f->plane_count; j++) {
1043 put_symbol(c, state, f->plane[j].quant_table_index, 0);
1044 av_assert0(f->plane[j].quant_table_index == f->context_model);
1046 if (!f->picture.f->interlaced_frame)
1047 put_symbol(c, state, 3, 0);
1049 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
1050 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
1051 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
1052 if (f->version > 3) {
1053 put_rac(c, state, fs->slice_coding_mode == 1);
1054 if (fs->slice_coding_mode == 1)
1055 ff_ffv1_clear_slice_state(f, fs);
1056 put_symbol(c, state, fs->slice_coding_mode, 0);
1057 if (fs->slice_coding_mode != 1) {
1058 put_symbol(c, state, fs->slice_rct_by_coef, 0);
1059 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
1064 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
1066 #define NB_Y_COEFF 15
1067 static const int rct_y_coeff[15][2] = {
1069 {1, 1}, // R + 2G + B
1080 {1, 2}, // R + G + 2B
1081 {2, 1}, // 2R + G + B
1086 int stat[NB_Y_COEFF] = {0};
1087 int x, y, i, p, best;
1089 int lbd = fs->bits_per_raw_sample <= 8;
1091 for (y = 0; y < h; y++) {
1092 int lastr=0, lastg=0, lastb=0;
1093 for (p = 0; p < 3; p++)
1094 sample[p] = fs->sample_buffer + p*w;
1096 for (x = 0; x < w; x++) {
1100 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1102 g = (v >> 8) & 0xFF;
1103 r = (v >> 16) & 0xFF;
1105 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1106 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1107 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1114 int bg = ag - sample[0][x];
1115 int bb = ab - sample[1][x];
1116 int br = ar - sample[2][x];
1121 for (i = 0; i<NB_Y_COEFF; i++) {
1122 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1137 for (i=1; i<NB_Y_COEFF; i++) {
1138 if (stat[i] < stat[best])
1142 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1143 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1146 static int encode_slice(AVCodecContext *c, void *arg)
1148 FFV1Context *fs = *(void **)arg;
1149 FFV1Context *f = fs->avctx->priv_data;
1150 int width = fs->slice_width;
1151 int height = fs->slice_height;
1152 int x = fs->slice_x;
1153 int y = fs->slice_y;
1154 const AVFrame *const p = f->picture.f;
1155 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1157 RangeCoder c_bak = fs->c;
1158 const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1159 p->data[1] + ps*x + y*p->linesize[1],
1160 p->data[2] + ps*x + y*p->linesize[2]};
1162 fs->slice_coding_mode = 0;
1163 if (f->version > 3) {
1164 choose_rct_params(fs, planes, p->linesize, width, height);
1166 fs->slice_rct_by_coef = 1;
1167 fs->slice_rct_ry_coef = 1;
1172 ff_ffv1_clear_slice_state(f, fs);
1173 if (f->version > 2) {
1174 encode_slice_header(f, fs);
1176 if (fs->ac == AC_GOLOMB_RICE) {
1178 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1179 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1180 init_put_bits(&fs->pb,
1181 fs->c.bytestream_start + fs->ac_byte_count,
1182 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1185 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1186 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1187 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1188 const int cx = x >> f->chroma_h_shift;
1189 const int cy = y >> f->chroma_v_shift;
1191 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1193 if (f->chroma_planes) {
1194 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1195 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1197 if (fs->transparency)
1198 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1199 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1200 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1201 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1203 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1208 av_assert0(fs->slice_coding_mode == 0);
1209 if (fs->version < 4 || !fs->ac) {
1210 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1213 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1214 fs->slice_coding_mode = 1;
1222 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1223 const AVFrame *pict, int *got_packet)
1225 FFV1Context *f = avctx->priv_data;
1226 RangeCoder *const c = &f->slice_context[0]->c;
1227 AVFrame *const p = f->picture.f;
1229 uint8_t keystate = 128;
1232 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1233 + avctx->width*avctx->height*35LL*4;
1236 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1238 char *p = avctx->stats_out;
1239 char *end = p + STATS_OUT_SIZE;
1241 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1242 for (i = 0; i < f->quant_table_count; i++)
1243 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1245 av_assert0(f->slice_count == f->max_slice_count);
1246 for (j = 0; j < f->slice_count; j++) {
1247 FFV1Context *fs = f->slice_context[j];
1248 for (i = 0; i < 256; i++) {
1249 f->rc_stat[i][0] += fs->rc_stat[i][0];
1250 f->rc_stat[i][1] += fs->rc_stat[i][1];
1252 for (i = 0; i < f->quant_table_count; i++) {
1253 for (k = 0; k < f->context_count[i]; k++)
1254 for (m = 0; m < 32; m++) {
1255 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1256 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1261 for (j = 0; j < 256; j++) {
1262 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1263 f->rc_stat[j][0], f->rc_stat[j][1]);
1266 snprintf(p, end - p, "\n");
1268 for (i = 0; i < f->quant_table_count; i++) {
1269 for (j = 0; j < f->context_count[i]; j++)
1270 for (m = 0; m < 32; m++) {
1271 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1272 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1276 snprintf(p, end - p, "%d\n", f->gob_count);
1282 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1284 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1287 ff_init_range_encoder(c, pkt->data, pkt->size);
1288 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1291 if ((ret = av_frame_ref(p, pict)) < 0)
1293 #if FF_API_CODED_FRAME
1294 FF_DISABLE_DEPRECATION_WARNINGS
1295 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1296 FF_ENABLE_DEPRECATION_WARNINGS
1299 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1300 put_rac(c, &keystate, 1);
1305 put_rac(c, &keystate, 0);
1309 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1311 for (i = 1; i < 256; i++) {
1312 c->one_state[i] = f->state_transition[i];
1313 c->zero_state[256 - i] = 256 - c->one_state[i];
1317 for (i = 1; i < f->slice_count; i++) {
1318 FFV1Context *fs = f->slice_context[i];
1319 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1320 int len = pkt->size / f->slice_count;
1321 ff_init_range_encoder(&fs->c, start, len);
1323 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1324 f->slice_count, sizeof(void *));
1327 for (i = 0; i < f->slice_count; i++) {
1328 FFV1Context *fs = f->slice_context[i];
1331 if (fs->ac != AC_GOLOMB_RICE) {
1332 uint8_t state = 129;
1333 put_rac(&fs->c, &state, 0);
1334 bytes = ff_rac_terminate(&fs->c);
1336 flush_put_bits(&fs->pb); // FIXME: nicer padding
1337 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1339 if (i > 0 || f->version > 2) {
1340 av_assert0(bytes < pkt->size / f->slice_count);
1341 memmove(buf_p, fs->c.bytestream_start, bytes);
1342 av_assert0(bytes < (1 << 24));
1343 AV_WB24(buf_p + bytes, bytes);
1349 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1350 AV_WL32(buf_p + bytes, v);
1356 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1357 avctx->stats_out[0] = '\0';
1359 #if FF_API_CODED_FRAME
1360 FF_DISABLE_DEPRECATION_WARNINGS
1361 avctx->coded_frame->key_frame = f->key_frame;
1362 FF_ENABLE_DEPRECATION_WARNINGS
1365 f->picture_number++;
1366 pkt->size = buf_p - pkt->data;
1368 pkt->dts = pict->pts;
1369 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1375 static av_cold int encode_close(AVCodecContext *avctx)
1377 ff_ffv1_close(avctx);
1381 #define OFFSET(x) offsetof(FFV1Context, x)
1382 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1383 static const AVOption options[] = {
1384 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1385 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1386 { .i64 = 0 }, -2, 2, VE, "coder" },
1387 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1388 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1389 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1390 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1391 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1392 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1393 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1394 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1395 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1396 { .i64 = 0 }, 0, 1, VE },
1401 static const AVClass ffv1_class = {
1402 .class_name = "ffv1 encoder",
1403 .item_name = av_default_item_name,
1405 .version = LIBAVUTIL_VERSION_INT,
1408 #if FF_API_CODER_TYPE
1409 static const AVCodecDefault ffv1_defaults[] = {
1415 AVCodec ff_ffv1_encoder = {
1417 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1418 .type = AVMEDIA_TYPE_VIDEO,
1419 .id = AV_CODEC_ID_FFV1,
1420 .priv_data_size = sizeof(FFV1Context),
1421 .init = encode_init,
1422 .encode2 = encode_frame,
1423 .close = encode_close,
1424 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1425 .pix_fmts = (const enum AVPixelFormat[]) {
1426 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1427 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1428 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1429 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1430 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1431 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1432 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1433 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1434 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1435 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1440 #if FF_API_CODER_TYPE
1441 .defaults = ffv1_defaults,
1443 .priv_class = &ffv1_class,