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"
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
255 if (k == 0 && 2 * state->drift <= -state->count)
260 code = v ^ ((2 * state->drift + state->count) >> 31);
263 ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
264 state->bias, state->error_sum, state->drift, state->count, k);
265 set_sr_golomb(pb, code, k, 12, bits);
267 update_vlc_state(state, v);
270 static av_always_inline int encode_line(FFV1Context *s, int w,
272 int plane_index, int bits)
274 PlaneContext *const p = &s->plane[plane_index];
275 RangeCoder *const c = &s->c;
277 int run_index = s->run_index;
281 if (s->ac != AC_GOLOMB_RICE) {
282 if (c->bytestream_end - c->bytestream < w * 35) {
283 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
284 return AVERROR_INVALIDDATA;
287 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
288 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
289 return AVERROR_INVALIDDATA;
293 if (s->slice_coding_mode == 1) {
294 for (x = 0; x < w; x++) {
296 int v = sample[0][x];
297 for (i = bits-1; i>=0; i--) {
299 put_rac(c, &state, (v>>i) & 1);
305 for (x = 0; x < w; x++) {
308 context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
309 diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
316 diff = fold(diff, bits);
318 if (s->ac != AC_GOLOMB_RICE) {
319 if (s->flags & AV_CODEC_FLAG_PASS1) {
320 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
321 s->rc_stat2[p->quant_table_index][context]);
323 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
331 while (run_count >= 1 << ff_log2_run[run_index]) {
332 run_count -= 1 << ff_log2_run[run_index];
334 put_bits(&s->pb, 1, 1);
337 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
349 ff_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
350 run_count, run_index, run_mode, x,
351 (int)put_bits_count(&s->pb));
354 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
358 while (run_count >= 1 << ff_log2_run[run_index]) {
359 run_count -= 1 << ff_log2_run[run_index];
361 put_bits(&s->pb, 1, 1);
365 put_bits(&s->pb, 1, 1);
367 s->run_index = run_index;
372 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
373 int stride, int plane_index, int pixel_stride)
376 const int ring_size = s->context_model ? 3 : 2;
380 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
382 for (y = 0; y < h; y++) {
383 for (i = 0; i < ring_size; i++)
384 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
386 sample[0][-1]= sample[1][0 ];
387 sample[1][ w]= sample[1][w-1];
389 if (s->bits_per_raw_sample <= 8) {
390 for (x = 0; x < w; x++)
391 sample[0][x] = src[x * pixel_stride + stride * y];
392 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
395 if (s->packed_at_lsb) {
396 for (x = 0; x < w; x++) {
397 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
400 for (x = 0; x < w; x++) {
401 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
404 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
407 // STOP_TIMER("encode line") }
412 static int encode_rgb_frame(FFV1Context *s, const uint8_t *src[3],
413 int w, int h, const int stride[3])
416 const int ring_size = s->context_model ? 3 : 2;
417 int16_t *sample[4][3];
418 int lbd = s->bits_per_raw_sample <= 8;
419 int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
420 int offset = 1 << bits;
424 memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
425 (w + 6) * sizeof(*s->sample_buffer));
427 for (y = 0; y < h; y++) {
428 for (i = 0; i < ring_size; i++)
429 for (p = 0; p < MAX_PLANES; p++)
430 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
432 for (x = 0; x < w; x++) {
433 int b, g, r, av_uninit(a);
435 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
438 r = (v >> 16) & 0xFF;
441 b = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
442 g = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
443 r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
446 if (s->slice_coding_mode != 1) {
449 g += (b * s->slice_rct_by_coef + r * s->slice_rct_ry_coef) >> 2;
459 for (p = 0; p < 3 + s->transparency; p++) {
461 sample[p][0][-1] = sample[p][1][0 ];
462 sample[p][1][ w] = sample[p][1][w-1];
463 if (lbd && s->slice_coding_mode == 0)
464 ret = encode_line(s, w, sample[p], (p + 1) / 2, 9);
466 ret = encode_line(s, w, sample[p], (p + 1) / 2, bits + (s->slice_coding_mode != 1));
474 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
478 uint8_t state[CONTEXT_SIZE];
479 memset(state, 128, sizeof(state));
481 for (i = 1; i < 128; i++)
482 if (quant_table[i] != quant_table[i - 1]) {
483 put_symbol(c, state, i - last - 1, 0);
486 put_symbol(c, state, i - last - 1, 0);
489 static void write_quant_tables(RangeCoder *c,
490 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
493 for (i = 0; i < 5; i++)
494 write_quant_table(c, quant_table[i]);
497 static void write_header(FFV1Context *f)
499 uint8_t state[CONTEXT_SIZE];
501 RangeCoder *const c = &f->slice_context[0]->c;
503 memset(state, 128, sizeof(state));
505 if (f->version < 2) {
506 put_symbol(c, state, f->version, 0);
507 put_symbol(c, state, f->ac, 0);
508 if (f->ac == AC_RANGE_CUSTOM_TAB) {
509 for (i = 1; i < 256; i++)
511 f->state_transition[i] - c->one_state[i], 1);
513 put_symbol(c, state, f->colorspace, 0); //YUV cs type
515 put_symbol(c, state, f->bits_per_raw_sample, 0);
516 put_rac(c, state, f->chroma_planes);
517 put_symbol(c, state, f->chroma_h_shift, 0);
518 put_symbol(c, state, f->chroma_v_shift, 0);
519 put_rac(c, state, f->transparency);
521 write_quant_tables(c, f->quant_table);
522 } else if (f->version < 3) {
523 put_symbol(c, state, f->slice_count, 0);
524 for (i = 0; i < f->slice_count; i++) {
525 FFV1Context *fs = f->slice_context[i];
527 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
529 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
531 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
534 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
536 for (j = 0; j < f->plane_count; j++) {
537 put_symbol(c, state, f->plane[j].quant_table_index, 0);
538 av_assert0(f->plane[j].quant_table_index == f->context_model);
544 static int write_extradata(FFV1Context *f)
546 RangeCoder *const c = &f->c;
547 uint8_t state[CONTEXT_SIZE];
549 uint8_t state2[32][CONTEXT_SIZE];
552 memset(state2, 128, sizeof(state2));
553 memset(state, 128, sizeof(state));
555 f->avctx->extradata_size = 10000 + 4 +
556 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
557 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
558 if (!f->avctx->extradata)
559 return AVERROR(ENOMEM);
560 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
561 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
563 put_symbol(c, state, f->version, 0);
564 if (f->version > 2) {
565 if (f->version == 3) {
566 f->micro_version = 4;
567 } else if (f->version == 4)
568 f->micro_version = 2;
569 put_symbol(c, state, f->micro_version, 0);
572 put_symbol(c, state, f->ac, 0);
573 if (f->ac == AC_RANGE_CUSTOM_TAB)
574 for (i = 1; i < 256; i++)
575 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
577 put_symbol(c, state, f->colorspace, 0); // YUV cs type
578 put_symbol(c, state, f->bits_per_raw_sample, 0);
579 put_rac(c, state, f->chroma_planes);
580 put_symbol(c, state, f->chroma_h_shift, 0);
581 put_symbol(c, state, f->chroma_v_shift, 0);
582 put_rac(c, state, f->transparency);
583 put_symbol(c, state, f->num_h_slices - 1, 0);
584 put_symbol(c, state, f->num_v_slices - 1, 0);
586 put_symbol(c, state, f->quant_table_count, 0);
587 for (i = 0; i < f->quant_table_count; i++)
588 write_quant_tables(c, f->quant_tables[i]);
590 for (i = 0; i < f->quant_table_count; i++) {
591 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
592 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
594 if (j < f->context_count[i] * CONTEXT_SIZE) {
595 put_rac(c, state, 1);
596 for (j = 0; j < f->context_count[i]; j++)
597 for (k = 0; k < CONTEXT_SIZE; k++) {
598 int pred = j ? f->initial_states[i][j - 1][k] : 128;
599 put_symbol(c, state2[k],
600 (int8_t)(f->initial_states[i][j][k] - pred), 1);
603 put_rac(c, state, 0);
607 if (f->version > 2) {
608 put_symbol(c, state, f->ec, 0);
609 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
612 f->avctx->extradata_size = ff_rac_terminate(c);
613 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
614 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
615 f->avctx->extradata_size += 4;
620 static int sort_stt(FFV1Context *s, uint8_t stt[256])
622 int i, i2, changed, print = 0;
626 for (i = 12; i < 244; i++) {
627 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
629 #define COST(old, new) \
630 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
631 s->rc_stat[old][1] * -log2((new) / 256.0)
633 #define COST2(old, new) \
634 COST(old, new) + COST(256 - (old), 256 - (new))
636 double size0 = COST2(i, i) + COST2(i2, i2);
637 double sizeX = COST2(i, i2) + COST2(i2, i);
638 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
640 FFSWAP(int, stt[i], stt[i2]);
641 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
642 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
644 FFSWAP(int, stt[256 - i], stt[256 - i2]);
645 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
646 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
648 for (j = 1; j < 256; j++) {
651 else if (stt[j] == i2)
654 if (stt[256 - j] == 256 - i)
655 stt[256 - j] = 256 - i2;
656 else if (stt[256 - j] == 256 - i2)
657 stt[256 - j] = 256 - i;
668 static av_cold int encode_init(AVCodecContext *avctx)
670 FFV1Context *s = avctx->priv_data;
671 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
674 if ((ret = ff_ffv1_common_init(avctx)) < 0)
679 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
681 s->version = FFMAX(s->version, 2);
683 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
684 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
685 s->version = FFMAX(s->version, 2);
687 if (avctx->level <= 0 && s->version == 2) {
690 if (avctx->level >= 0 && avctx->level <= 4) {
691 if (avctx->level < s->version) {
692 av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
693 return AVERROR(EINVAL);
695 s->version = avctx->level;
699 s->ec = (s->version >= 3);
702 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
703 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
704 return AVERROR_INVALIDDATA;
707 #if FF_API_CODER_TYPE
708 FF_DISABLE_DEPRECATION_WARNINGS
709 if (avctx->coder_type != -1)
710 s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
712 FF_ENABLE_DEPRECATION_WARNINGS
714 if (s->ac == 1) // Compatbility with common command line usage
715 s->ac = AC_RANGE_CUSTOM_TAB;
716 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
717 s->ac = AC_RANGE_DEFAULT_TAB;
720 switch(avctx->pix_fmt) {
721 case AV_PIX_FMT_YUV444P9:
722 case AV_PIX_FMT_YUV422P9:
723 case AV_PIX_FMT_YUV420P9:
724 case AV_PIX_FMT_YUVA444P9:
725 case AV_PIX_FMT_YUVA422P9:
726 case AV_PIX_FMT_YUVA420P9:
727 if (!avctx->bits_per_raw_sample)
728 s->bits_per_raw_sample = 9;
729 case AV_PIX_FMT_YUV444P10:
730 case AV_PIX_FMT_YUV420P10:
731 case AV_PIX_FMT_YUV422P10:
732 case AV_PIX_FMT_YUVA444P10:
733 case AV_PIX_FMT_YUVA422P10:
734 case AV_PIX_FMT_YUVA420P10:
735 s->packed_at_lsb = 1;
736 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
737 s->bits_per_raw_sample = 10;
738 case AV_PIX_FMT_GRAY16:
739 case AV_PIX_FMT_YUV444P16:
740 case AV_PIX_FMT_YUV422P16:
741 case AV_PIX_FMT_YUV420P16:
742 case AV_PIX_FMT_YUVA444P16:
743 case AV_PIX_FMT_YUVA422P16:
744 case AV_PIX_FMT_YUVA420P16:
745 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
746 s->bits_per_raw_sample = 16;
747 } else if (!s->bits_per_raw_sample) {
748 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
750 if (s->bits_per_raw_sample <= 8) {
751 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
752 return AVERROR_INVALIDDATA;
754 if (s->ac == AC_GOLOMB_RICE) {
755 av_log(avctx, AV_LOG_INFO,
756 "bits_per_raw_sample > 8, forcing range coder\n");
757 s->ac = AC_RANGE_CUSTOM_TAB;
759 s->version = FFMAX(s->version, 1);
760 case AV_PIX_FMT_GRAY8:
762 case AV_PIX_FMT_YUV444P:
763 case AV_PIX_FMT_YUV440P:
764 case AV_PIX_FMT_YUV422P:
765 case AV_PIX_FMT_YUV420P:
766 case AV_PIX_FMT_YUV411P:
767 case AV_PIX_FMT_YUV410P:
768 case AV_PIX_FMT_YUVA444P:
769 case AV_PIX_FMT_YUVA422P:
770 case AV_PIX_FMT_YUVA420P:
771 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
773 s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
774 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
775 s->bits_per_raw_sample = 8;
776 else if (!s->bits_per_raw_sample)
777 s->bits_per_raw_sample = 8;
779 case AV_PIX_FMT_RGB32:
782 s->chroma_planes = 1;
783 if (!avctx->bits_per_raw_sample)
784 s->bits_per_raw_sample = 8;
786 case AV_PIX_FMT_0RGB32:
788 s->chroma_planes = 1;
789 if (!avctx->bits_per_raw_sample)
790 s->bits_per_raw_sample = 8;
792 case AV_PIX_FMT_GBRP9:
793 if (!avctx->bits_per_raw_sample)
794 s->bits_per_raw_sample = 9;
795 case AV_PIX_FMT_GBRP10:
796 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
797 s->bits_per_raw_sample = 10;
798 case AV_PIX_FMT_GBRP12:
799 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
800 s->bits_per_raw_sample = 12;
801 case AV_PIX_FMT_GBRP14:
802 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
803 s->bits_per_raw_sample = 14;
804 else if (!s->bits_per_raw_sample)
805 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
807 s->chroma_planes = 1;
808 s->version = FFMAX(s->version, 1);
809 if (s->ac == AC_GOLOMB_RICE) {
810 av_log(avctx, AV_LOG_INFO,
811 "bits_per_raw_sample > 8, forcing coder 1\n");
812 s->ac = AC_RANGE_CUSTOM_TAB;
816 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
817 return AVERROR(ENOSYS);
819 av_assert0(s->bits_per_raw_sample >= 8);
821 if (s->transparency) {
822 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
824 #if FF_API_PRIVATE_OPT
825 FF_DISABLE_DEPRECATION_WARNINGS
826 if (avctx->context_model)
827 s->context_model = avctx->context_model;
828 if (avctx->context_model > 1U) {
829 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
830 return AVERROR(EINVAL);
832 FF_ENABLE_DEPRECATION_WARNINGS
835 if (s->ac == AC_RANGE_CUSTOM_TAB) {
836 for (i = 1; i < 256; i++)
837 s->state_transition[i] = ver2_state[i];
840 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
841 for (i = 1; i < 256; i++)
842 s->state_transition[i] = c.one_state[i];
845 for (i = 0; i < 256; i++) {
846 s->quant_table_count = 2;
847 if (s->bits_per_raw_sample <= 8) {
848 s->quant_tables[0][0][i]= quant11[i];
849 s->quant_tables[0][1][i]= 11*quant11[i];
850 s->quant_tables[0][2][i]= 11*11*quant11[i];
851 s->quant_tables[1][0][i]= quant11[i];
852 s->quant_tables[1][1][i]= 11*quant11[i];
853 s->quant_tables[1][2][i]= 11*11*quant5 [i];
854 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
855 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
857 s->quant_tables[0][0][i]= quant9_10bit[i];
858 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
859 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
860 s->quant_tables[1][0][i]= quant9_10bit[i];
861 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
862 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
863 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
864 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
867 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
868 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
869 memcpy(s->quant_table, s->quant_tables[s->context_model],
870 sizeof(s->quant_table));
872 for (i = 0; i < s->plane_count; i++) {
873 PlaneContext *const p = &s->plane[i];
875 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
876 p->quant_table_index = s->context_model;
877 p->context_count = s->context_count[p->quant_table_index];
880 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
883 #if FF_API_CODED_FRAME
884 FF_DISABLE_DEPRECATION_WARNINGS
885 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
886 FF_ENABLE_DEPRECATION_WARNINGS
889 if (!s->transparency)
891 if (!s->chroma_planes && s->version > 3)
894 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
895 s->picture_number = 0;
897 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
898 for (i = 0; i < s->quant_table_count; i++) {
899 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
900 sizeof(*s->rc_stat2[i]));
902 return AVERROR(ENOMEM);
905 if (avctx->stats_in) {
906 char *p = avctx->stats_in;
907 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
911 return AVERROR(ENOMEM);
913 av_assert0(s->version >= 2);
916 for (j = 0; j < 256; j++)
917 for (i = 0; i < 2; i++) {
918 s->rc_stat[j][i] = strtol(p, &next, 0);
920 av_log(avctx, AV_LOG_ERROR,
921 "2Pass file invalid at %d %d [%s]\n", j, i, p);
922 av_freep(&best_state);
923 return AVERROR_INVALIDDATA;
927 for (i = 0; i < s->quant_table_count; i++)
928 for (j = 0; j < s->context_count[i]; j++) {
929 for (k = 0; k < 32; k++)
930 for (m = 0; m < 2; m++) {
931 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
933 av_log(avctx, AV_LOG_ERROR,
934 "2Pass file invalid at %d %d %d %d [%s]\n",
936 av_freep(&best_state);
937 return AVERROR_INVALIDDATA;
942 gob_count = strtol(p, &next, 0);
943 if (next == p || gob_count <= 0) {
944 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
945 av_freep(&best_state);
946 return AVERROR_INVALIDDATA;
949 while (*p == '\n' || *p == ' ')
954 if (s->ac == AC_RANGE_CUSTOM_TAB)
955 sort_stt(s, s->state_transition);
957 find_best_state(best_state, s->state_transition);
959 for (i = 0; i < s->quant_table_count; i++) {
960 for (k = 0; k < 32; k++) {
963 for (j = 0; j < s->context_count[i]; j++) {
965 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
967 p = 256.0 * b / (a + b);
968 s->initial_states[i][jp][k] =
969 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
970 for(jp++; jp<j; jp++)
971 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
974 a += s->rc_stat2[i][j][k][0];
975 b += s->rc_stat2[i][j][k][1];
977 p = 256.0 * b / (a + b);
979 s->initial_states[i][j][k] =
980 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
984 av_freep(&best_state);
987 if (s->version > 1) {
988 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
989 for (; s->num_v_slices < 9; s->num_v_slices++) {
990 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
991 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
995 av_log(avctx, AV_LOG_ERROR,
996 "Unsupported number %d of slices requested, please specify a "
997 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
999 return AVERROR(ENOSYS);
1001 if ((ret = write_extradata(s)) < 0)
1005 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
1007 s->slice_count = s->max_slice_count;
1008 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
1011 #define STATS_OUT_SIZE 1024 * 1024 * 6
1012 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1013 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
1014 if (!avctx->stats_out)
1015 return AVERROR(ENOMEM);
1016 for (i = 0; i < s->quant_table_count; i++)
1017 for (j = 0; j < s->max_slice_count; j++) {
1018 FFV1Context *sf = s->slice_context[j];
1019 av_assert0(!sf->rc_stat2[i]);
1020 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
1021 sizeof(*sf->rc_stat2[i]));
1022 if (!sf->rc_stat2[i])
1023 return AVERROR(ENOMEM);
1030 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
1032 RangeCoder *c = &fs->c;
1033 uint8_t state[CONTEXT_SIZE];
1035 memset(state, 128, sizeof(state));
1037 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
1038 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
1039 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
1040 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
1041 for (j=0; j<f->plane_count; j++) {
1042 put_symbol(c, state, f->plane[j].quant_table_index, 0);
1043 av_assert0(f->plane[j].quant_table_index == f->context_model);
1045 if (!f->picture.f->interlaced_frame)
1046 put_symbol(c, state, 3, 0);
1048 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
1049 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
1050 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
1051 if (f->version > 3) {
1052 put_rac(c, state, fs->slice_coding_mode == 1);
1053 if (fs->slice_coding_mode == 1)
1054 ff_ffv1_clear_slice_state(f, fs);
1055 put_symbol(c, state, fs->slice_coding_mode, 0);
1056 if (fs->slice_coding_mode != 1) {
1057 put_symbol(c, state, fs->slice_rct_by_coef, 0);
1058 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
1063 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
1065 #define NB_Y_COEFF 15
1066 static const int rct_y_coeff[15][2] = {
1068 {1, 1}, // R + 2G + B
1079 {1, 2}, // R + G + 2B
1080 {2, 1}, // 2R + G + B
1085 int stat[NB_Y_COEFF] = {0};
1086 int x, y, i, p, best;
1088 int lbd = fs->bits_per_raw_sample <= 8;
1090 for (y = 0; y < h; y++) {
1091 int lastr=0, lastg=0, lastb=0;
1092 for (p = 0; p < 3; p++)
1093 sample[p] = fs->sample_buffer + p*w;
1095 for (x = 0; x < w; x++) {
1099 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1101 g = (v >> 8) & 0xFF;
1102 r = (v >> 16) & 0xFF;
1104 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1105 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1106 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1113 int bg = ag - sample[0][x];
1114 int bb = ab - sample[1][x];
1115 int br = ar - sample[2][x];
1120 for (i = 0; i<NB_Y_COEFF; i++) {
1121 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1136 for (i=1; i<NB_Y_COEFF; i++) {
1137 if (stat[i] < stat[best])
1141 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1142 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1145 static int encode_slice(AVCodecContext *c, void *arg)
1147 FFV1Context *fs = *(void **)arg;
1148 FFV1Context *f = fs->avctx->priv_data;
1149 int width = fs->slice_width;
1150 int height = fs->slice_height;
1151 int x = fs->slice_x;
1152 int y = fs->slice_y;
1153 const AVFrame *const p = f->picture.f;
1154 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1156 RangeCoder c_bak = fs->c;
1157 const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1158 p->data[1] + ps*x + y*p->linesize[1],
1159 p->data[2] + ps*x + y*p->linesize[2]};
1161 fs->slice_coding_mode = 0;
1162 if (f->version > 3) {
1163 choose_rct_params(fs, planes, p->linesize, width, height);
1165 fs->slice_rct_by_coef = 1;
1166 fs->slice_rct_ry_coef = 1;
1171 ff_ffv1_clear_slice_state(f, fs);
1172 if (f->version > 2) {
1173 encode_slice_header(f, fs);
1175 if (fs->ac == AC_GOLOMB_RICE) {
1177 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1178 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1179 init_put_bits(&fs->pb,
1180 fs->c.bytestream_start + fs->ac_byte_count,
1181 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1184 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1185 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1186 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1187 const int cx = x >> f->chroma_h_shift;
1188 const int cy = y >> f->chroma_v_shift;
1190 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1192 if (f->chroma_planes) {
1193 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1194 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1196 if (fs->transparency)
1197 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1198 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1199 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1200 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1202 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1207 av_assert0(fs->slice_coding_mode == 0);
1208 if (fs->version < 4 || !fs->ac) {
1209 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1212 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1213 fs->slice_coding_mode = 1;
1221 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1222 const AVFrame *pict, int *got_packet)
1224 FFV1Context *f = avctx->priv_data;
1225 RangeCoder *const c = &f->slice_context[0]->c;
1226 AVFrame *const p = f->picture.f;
1228 uint8_t keystate = 128;
1231 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1232 + avctx->width*avctx->height*35LL*4;
1235 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1237 char *p = avctx->stats_out;
1238 char *end = p + STATS_OUT_SIZE;
1240 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1241 for (i = 0; i < f->quant_table_count; i++)
1242 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1244 av_assert0(f->slice_count == f->max_slice_count);
1245 for (j = 0; j < f->slice_count; j++) {
1246 FFV1Context *fs = f->slice_context[j];
1247 for (i = 0; i < 256; i++) {
1248 f->rc_stat[i][0] += fs->rc_stat[i][0];
1249 f->rc_stat[i][1] += fs->rc_stat[i][1];
1251 for (i = 0; i < f->quant_table_count; i++) {
1252 for (k = 0; k < f->context_count[i]; k++)
1253 for (m = 0; m < 32; m++) {
1254 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1255 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1260 for (j = 0; j < 256; j++) {
1261 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1262 f->rc_stat[j][0], f->rc_stat[j][1]);
1265 snprintf(p, end - p, "\n");
1267 for (i = 0; i < f->quant_table_count; i++) {
1268 for (j = 0; j < f->context_count[i]; j++)
1269 for (m = 0; m < 32; m++) {
1270 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1271 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1275 snprintf(p, end - p, "%d\n", f->gob_count);
1281 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1283 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1286 ff_init_range_encoder(c, pkt->data, pkt->size);
1287 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1290 if ((ret = av_frame_ref(p, pict)) < 0)
1292 #if FF_API_CODED_FRAME
1293 FF_DISABLE_DEPRECATION_WARNINGS
1294 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1295 FF_ENABLE_DEPRECATION_WARNINGS
1298 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1299 put_rac(c, &keystate, 1);
1304 put_rac(c, &keystate, 0);
1308 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1310 for (i = 1; i < 256; i++) {
1311 c->one_state[i] = f->state_transition[i];
1312 c->zero_state[256 - i] = 256 - c->one_state[i];
1316 for (i = 1; i < f->slice_count; i++) {
1317 FFV1Context *fs = f->slice_context[i];
1318 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1319 int len = pkt->size / f->slice_count;
1320 ff_init_range_encoder(&fs->c, start, len);
1322 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1323 f->slice_count, sizeof(void *));
1326 for (i = 0; i < f->slice_count; i++) {
1327 FFV1Context *fs = f->slice_context[i];
1330 if (fs->ac != AC_GOLOMB_RICE) {
1331 uint8_t state = 129;
1332 put_rac(&fs->c, &state, 0);
1333 bytes = ff_rac_terminate(&fs->c);
1335 flush_put_bits(&fs->pb); // FIXME: nicer padding
1336 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1338 if (i > 0 || f->version > 2) {
1339 av_assert0(bytes < pkt->size / f->slice_count);
1340 memmove(buf_p, fs->c.bytestream_start, bytes);
1341 av_assert0(bytes < (1 << 24));
1342 AV_WB24(buf_p + bytes, bytes);
1348 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1349 AV_WL32(buf_p + bytes, v);
1355 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1356 avctx->stats_out[0] = '\0';
1358 #if FF_API_CODED_FRAME
1359 FF_DISABLE_DEPRECATION_WARNINGS
1360 avctx->coded_frame->key_frame = f->key_frame;
1361 FF_ENABLE_DEPRECATION_WARNINGS
1364 f->picture_number++;
1365 pkt->size = buf_p - pkt->data;
1367 pkt->dts = pict->pts;
1368 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1374 static av_cold int encode_close(AVCodecContext *avctx)
1376 ff_ffv1_close(avctx);
1380 #define OFFSET(x) offsetof(FFV1Context, x)
1381 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1382 static const AVOption options[] = {
1383 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1384 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1385 { .i64 = 0 }, -2, 2, VE, "coder" },
1386 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1387 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1388 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1389 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1390 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1391 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1392 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1393 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1394 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1395 { .i64 = 0 }, 0, 1, VE },
1400 static const AVClass ffv1_class = {
1401 .class_name = "ffv1 encoder",
1402 .item_name = av_default_item_name,
1404 .version = LIBAVUTIL_VERSION_INT,
1407 #if FF_API_CODER_TYPE
1408 static const AVCodecDefault ffv1_defaults[] = {
1414 AVCodec ff_ffv1_encoder = {
1416 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1417 .type = AVMEDIA_TYPE_VIDEO,
1418 .id = AV_CODEC_ID_FFV1,
1419 .priv_data_size = sizeof(FFV1Context),
1420 .init = encode_init,
1421 .encode2 = encode_frame,
1422 .close = encode_close,
1423 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1424 .pix_fmts = (const enum AVPixelFormat[]) {
1425 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1426 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1427 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1428 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1429 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1430 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1431 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1432 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1433 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1434 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1439 #if FF_API_CODER_TYPE
1440 .defaults = ffv1_defaults,
1442 .priv_class = &ffv1_class,