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 };
158 for (k = 0; k < 256; k++) {
159 double newocc[256] = { 0 };
160 for (m = 1; m < 256; m++)
162 len -=occ[m]*( p *l2tab[ m]
163 + (1-p)*l2tab[256-m]);
165 if (len < best_len[k]) {
167 best_state[i][k] = j;
169 for (m = 1; m < 256; m++)
171 newocc[ one_state[ m]] += occ[m] * p;
172 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
174 memcpy(occ, newocc, sizeof(occ));
180 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
181 uint8_t *state, int v,
183 uint64_t rc_stat[256][2],
184 uint64_t rc_stat2[32][2])
188 #define put_rac(C, S, B) \
191 rc_stat[*(S)][B]++; \
192 rc_stat2[(S) - state][B]++; \
198 const int a = FFABS(v);
199 const int e = av_log2(a);
200 put_rac(c, state + 0, 0);
202 for (i = 0; i < e; i++)
203 put_rac(c, state + 1 + i, 1); // 1..10
204 put_rac(c, state + 1 + i, 0);
206 for (i = e - 1; i >= 0; i--)
207 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
210 put_rac(c, state + 11 + e, v < 0); // 11..21
212 for (i = 0; i < e; i++)
213 put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
214 put_rac(c, state + 1 + 9, 0);
216 for (i = e - 1; i >= 0; i--)
217 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
220 put_rac(c, state + 11 + 10, v < 0); // 11..21
223 put_rac(c, state + 0, 1);
228 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
229 int v, int is_signed)
231 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
235 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
239 v = fold(v - state->bias, bits);
243 while (i < state->error_sum) { // FIXME: optimize
251 if (k == 0 && 2 * state->drift <= -state->count)
256 code = v ^ ((2 * state->drift + state->count) >> 31);
259 av_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
260 state->bias, state->error_sum, state->drift, state->count, k);
261 set_sr_golomb(pb, code, k, 12, bits);
263 update_vlc_state(state, v);
266 static av_always_inline int encode_line(FFV1Context *s, int w,
268 int plane_index, int bits)
270 PlaneContext *const p = &s->plane[plane_index];
271 RangeCoder *const c = &s->c;
273 int run_index = s->run_index;
278 if (c->bytestream_end - c->bytestream < w * 35) {
279 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
280 return AVERROR_INVALIDDATA;
283 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
284 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
285 return AVERROR_INVALIDDATA;
289 if (s->slice_coding_mode == 1) {
290 for (x = 0; x < w; x++) {
292 int v = sample[0][x];
293 for (i = bits-1; i>=0; i--) {
295 put_rac(c, &state, (v>>i) & 1);
301 for (x = 0; x < w; x++) {
304 context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
305 diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
312 diff = fold(diff, bits);
315 if (s->flags & CODEC_FLAG_PASS1) {
316 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
317 s->rc_stat2[p->quant_table_index][context]);
319 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
327 while (run_count >= 1 << ff_log2_run[run_index]) {
328 run_count -= 1 << ff_log2_run[run_index];
330 put_bits(&s->pb, 1, 1);
333 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
345 av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
346 run_count, run_index, run_mode, x,
347 (int)put_bits_count(&s->pb));
350 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
354 while (run_count >= 1 << ff_log2_run[run_index]) {
355 run_count -= 1 << ff_log2_run[run_index];
357 put_bits(&s->pb, 1, 1);
361 put_bits(&s->pb, 1, 1);
363 s->run_index = run_index;
368 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
369 int stride, int plane_index)
372 const int ring_size = s->avctx->context_model ? 3 : 2;
376 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
378 for (y = 0; y < h; y++) {
379 for (i = 0; i < ring_size; i++)
380 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
382 sample[0][-1]= sample[1][0 ];
383 sample[1][ w]= sample[1][w-1];
385 if (s->bits_per_raw_sample <= 8) {
386 for (x = 0; x < w; x++)
387 sample[0][x] = src[x + stride * y];
388 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
391 if (s->packed_at_lsb) {
392 for (x = 0; x < w; x++) {
393 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
396 for (x = 0; x < w; x++) {
397 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
400 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
403 // STOP_TIMER("encode line") }
408 static int encode_rgb_frame(FFV1Context *s, const uint8_t *src[3],
409 int w, int h, const int stride[3])
412 const int ring_size = s->avctx->context_model ? 3 : 2;
413 int16_t *sample[4][3];
414 int lbd = s->bits_per_raw_sample <= 8;
415 int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
416 int offset = 1 << bits;
420 memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
421 (w + 6) * sizeof(*s->sample_buffer));
423 for (y = 0; y < h; y++) {
424 for (i = 0; i < ring_size; i++)
425 for (p = 0; p < MAX_PLANES; p++)
426 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
428 for (x = 0; x < w; x++) {
429 int b, g, r, av_uninit(a);
431 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
434 r = (v >> 16) & 0xFF;
437 b = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
438 g = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
439 r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
442 if (s->slice_coding_mode != 1) {
445 g += (b * s->slice_rct_by_coef + r * s->slice_rct_ry_coef) >> 2;
455 for (p = 0; p < 3 + s->transparency; p++) {
457 sample[p][0][-1] = sample[p][1][0 ];
458 sample[p][1][ w] = sample[p][1][w-1];
459 if (lbd && s->slice_coding_mode == 0)
460 ret = encode_line(s, w, sample[p], (p + 1) / 2, 9);
462 ret = encode_line(s, w, sample[p], (p + 1) / 2, bits + (s->slice_coding_mode != 1));
470 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
474 uint8_t state[CONTEXT_SIZE];
475 memset(state, 128, sizeof(state));
477 for (i = 1; i < 128; i++)
478 if (quant_table[i] != quant_table[i - 1]) {
479 put_symbol(c, state, i - last - 1, 0);
482 put_symbol(c, state, i - last - 1, 0);
485 static void write_quant_tables(RangeCoder *c,
486 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
489 for (i = 0; i < 5; i++)
490 write_quant_table(c, quant_table[i]);
493 static void write_header(FFV1Context *f)
495 uint8_t state[CONTEXT_SIZE];
497 RangeCoder *const c = &f->slice_context[0]->c;
499 memset(state, 128, sizeof(state));
501 if (f->version < 2) {
502 put_symbol(c, state, f->version, 0);
503 put_symbol(c, state, f->ac, 0);
505 for (i = 1; i < 256; i++)
507 f->state_transition[i] - c->one_state[i], 1);
509 put_symbol(c, state, f->colorspace, 0); //YUV cs type
511 put_symbol(c, state, f->bits_per_raw_sample, 0);
512 put_rac(c, state, f->chroma_planes);
513 put_symbol(c, state, f->chroma_h_shift, 0);
514 put_symbol(c, state, f->chroma_v_shift, 0);
515 put_rac(c, state, f->transparency);
517 write_quant_tables(c, f->quant_table);
518 } else if (f->version < 3) {
519 put_symbol(c, state, f->slice_count, 0);
520 for (i = 0; i < f->slice_count; i++) {
521 FFV1Context *fs = f->slice_context[i];
523 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
525 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
527 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
530 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
532 for (j = 0; j < f->plane_count; j++) {
533 put_symbol(c, state, f->plane[j].quant_table_index, 0);
534 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
540 static int write_extradata(FFV1Context *f)
542 RangeCoder *const c = &f->c;
543 uint8_t state[CONTEXT_SIZE];
545 uint8_t state2[32][CONTEXT_SIZE];
548 memset(state2, 128, sizeof(state2));
549 memset(state, 128, sizeof(state));
551 f->avctx->extradata_size = 10000 + 4 +
552 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
553 f->avctx->extradata = av_malloc(f->avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
554 if (!f->avctx->extradata)
555 return AVERROR(ENOMEM);
556 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
557 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
559 put_symbol(c, state, f->version, 0);
560 if (f->version > 2) {
561 if (f->version == 3) {
562 f->micro_version = 4;
563 } else if (f->version == 4)
564 f->micro_version = 2;
565 put_symbol(c, state, f->micro_version, 0);
568 put_symbol(c, state, f->ac, 0);
570 for (i = 1; i < 256; i++)
571 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
573 put_symbol(c, state, f->colorspace, 0); // YUV cs type
574 put_symbol(c, state, f->bits_per_raw_sample, 0);
575 put_rac(c, state, f->chroma_planes);
576 put_symbol(c, state, f->chroma_h_shift, 0);
577 put_symbol(c, state, f->chroma_v_shift, 0);
578 put_rac(c, state, f->transparency);
579 put_symbol(c, state, f->num_h_slices - 1, 0);
580 put_symbol(c, state, f->num_v_slices - 1, 0);
582 put_symbol(c, state, f->quant_table_count, 0);
583 for (i = 0; i < f->quant_table_count; i++)
584 write_quant_tables(c, f->quant_tables[i]);
586 for (i = 0; i < f->quant_table_count; i++) {
587 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
588 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
590 if (j < f->context_count[i] * CONTEXT_SIZE) {
591 put_rac(c, state, 1);
592 for (j = 0; j < f->context_count[i]; j++)
593 for (k = 0; k < CONTEXT_SIZE; k++) {
594 int pred = j ? f->initial_states[i][j - 1][k] : 128;
595 put_symbol(c, state2[k],
596 (int8_t)(f->initial_states[i][j][k] - pred), 1);
599 put_rac(c, state, 0);
603 if (f->version > 2) {
604 put_symbol(c, state, f->ec, 0);
605 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
608 f->avctx->extradata_size = ff_rac_terminate(c);
609 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
610 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
611 f->avctx->extradata_size += 4;
616 static int sort_stt(FFV1Context *s, uint8_t stt[256])
618 int i, i2, changed, print = 0;
622 for (i = 12; i < 244; i++) {
623 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
625 #define COST(old, new) \
626 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
627 s->rc_stat[old][1] * -log2((new) / 256.0)
629 #define COST2(old, new) \
630 COST(old, new) + COST(256 - (old), 256 - (new))
632 double size0 = COST2(i, i) + COST2(i2, i2);
633 double sizeX = COST2(i, i2) + COST2(i2, i);
634 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
636 FFSWAP(int, stt[i], stt[i2]);
637 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
638 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
640 FFSWAP(int, stt[256 - i], stt[256 - i2]);
641 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
642 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
644 for (j = 1; j < 256; j++) {
647 else if (stt[j] == i2)
650 if (stt[256 - j] == 256 - i)
651 stt[256 - j] = 256 - i2;
652 else if (stt[256 - j] == 256 - i2)
653 stt[256 - j] = 256 - i;
664 static av_cold int encode_init(AVCodecContext *avctx)
666 FFV1Context *s = avctx->priv_data;
667 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
670 if ((ret = ffv1_common_init(avctx)) < 0)
675 if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
676 s->version = FFMAX(s->version, 2);
678 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
679 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
680 s->version = FFMAX(s->version, 2);
682 if (avctx->level <= 0 && s->version == 2) {
685 if (avctx->level >= 0 && avctx->level <= 4)
686 s->version = FFMAX(s->version, avctx->level);
689 s->ec = (s->version >= 3);
692 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
693 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
694 return AVERROR_INVALIDDATA;
697 s->ac = avctx->coder_type > 0 ? 2 : 0;
700 switch(avctx->pix_fmt) {
701 case AV_PIX_FMT_YUV444P9:
702 case AV_PIX_FMT_YUV422P9:
703 case AV_PIX_FMT_YUV420P9:
704 case AV_PIX_FMT_YUVA444P9:
705 case AV_PIX_FMT_YUVA422P9:
706 case AV_PIX_FMT_YUVA420P9:
707 if (!avctx->bits_per_raw_sample)
708 s->bits_per_raw_sample = 9;
709 case AV_PIX_FMT_YUV444P10:
710 case AV_PIX_FMT_YUV420P10:
711 case AV_PIX_FMT_YUV422P10:
712 case AV_PIX_FMT_YUVA444P10:
713 case AV_PIX_FMT_YUVA422P10:
714 case AV_PIX_FMT_YUVA420P10:
715 s->packed_at_lsb = 1;
716 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
717 s->bits_per_raw_sample = 10;
718 case AV_PIX_FMT_GRAY16:
719 case AV_PIX_FMT_YUV444P16:
720 case AV_PIX_FMT_YUV422P16:
721 case AV_PIX_FMT_YUV420P16:
722 case AV_PIX_FMT_YUVA444P16:
723 case AV_PIX_FMT_YUVA422P16:
724 case AV_PIX_FMT_YUVA420P16:
725 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
726 s->bits_per_raw_sample = 16;
727 } else if (!s->bits_per_raw_sample) {
728 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
730 if (s->bits_per_raw_sample <= 8) {
731 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
732 return AVERROR_INVALIDDATA;
734 if (!s->ac && avctx->coder_type == -1) {
735 av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
739 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
740 return AVERROR(ENOSYS);
742 s->version = FFMAX(s->version, 1);
743 case AV_PIX_FMT_GRAY8:
744 case AV_PIX_FMT_YUV444P:
745 case AV_PIX_FMT_YUV440P:
746 case AV_PIX_FMT_YUV422P:
747 case AV_PIX_FMT_YUV420P:
748 case AV_PIX_FMT_YUV411P:
749 case AV_PIX_FMT_YUV410P:
750 case AV_PIX_FMT_YUVA444P:
751 case AV_PIX_FMT_YUVA422P:
752 case AV_PIX_FMT_YUVA420P:
753 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
755 s->transparency = desc->nb_components == 4;
757 case AV_PIX_FMT_RGB32:
760 s->chroma_planes = 1;
762 case AV_PIX_FMT_0RGB32:
764 s->chroma_planes = 1;
766 case AV_PIX_FMT_GBRP9:
767 if (!avctx->bits_per_raw_sample)
768 s->bits_per_raw_sample = 9;
769 case AV_PIX_FMT_GBRP10:
770 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
771 s->bits_per_raw_sample = 10;
772 case AV_PIX_FMT_GBRP12:
773 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
774 s->bits_per_raw_sample = 12;
775 case AV_PIX_FMT_GBRP14:
776 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
777 s->bits_per_raw_sample = 14;
778 else if (!s->bits_per_raw_sample)
779 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
781 s->chroma_planes = 1;
782 s->version = FFMAX(s->version, 1);
784 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
785 return AVERROR(ENOSYS);
789 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
790 return AVERROR(ENOSYS);
792 if (s->transparency) {
793 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
795 if (avctx->context_model > 1U) {
796 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
797 return AVERROR(EINVAL);
801 for (i = 1; i < 256; i++)
802 s->state_transition[i] = ver2_state[i];
804 for (i = 0; i < 256; i++) {
805 s->quant_table_count = 2;
806 if (s->bits_per_raw_sample <= 8) {
807 s->quant_tables[0][0][i]= quant11[i];
808 s->quant_tables[0][1][i]= 11*quant11[i];
809 s->quant_tables[0][2][i]= 11*11*quant11[i];
810 s->quant_tables[1][0][i]= quant11[i];
811 s->quant_tables[1][1][i]= 11*quant11[i];
812 s->quant_tables[1][2][i]= 11*11*quant5 [i];
813 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
814 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
816 s->quant_tables[0][0][i]= quant9_10bit[i];
817 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
818 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
819 s->quant_tables[1][0][i]= quant9_10bit[i];
820 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
821 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
822 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
823 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
826 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
827 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
828 memcpy(s->quant_table, s->quant_tables[avctx->context_model],
829 sizeof(s->quant_table));
831 for (i = 0; i < s->plane_count; i++) {
832 PlaneContext *const p = &s->plane[i];
834 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
835 p->quant_table_index = avctx->context_model;
836 p->context_count = s->context_count[p->quant_table_index];
839 if ((ret = ffv1_allocate_initial_states(s)) < 0)
842 avctx->coded_frame = av_frame_alloc();
843 if (!avctx->coded_frame)
844 return AVERROR(ENOMEM);
846 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
848 if (!s->transparency)
850 if (!s->chroma_planes && s->version > 3)
853 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
854 s->picture_number = 0;
856 if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
857 for (i = 0; i < s->quant_table_count; i++) {
858 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
859 sizeof(*s->rc_stat2[i]));
861 return AVERROR(ENOMEM);
864 if (avctx->stats_in) {
865 char *p = avctx->stats_in;
866 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
870 return AVERROR(ENOMEM);
872 av_assert0(s->version >= 2);
875 for (j = 0; j < 256; j++)
876 for (i = 0; i < 2; i++) {
877 s->rc_stat[j][i] = strtol(p, &next, 0);
879 av_log(avctx, AV_LOG_ERROR,
880 "2Pass file invalid at %d %d [%s]\n", j, i, p);
881 av_freep(&best_state);
882 return AVERROR_INVALIDDATA;
886 for (i = 0; i < s->quant_table_count; i++)
887 for (j = 0; j < s->context_count[i]; j++) {
888 for (k = 0; k < 32; k++)
889 for (m = 0; m < 2; m++) {
890 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
892 av_log(avctx, AV_LOG_ERROR,
893 "2Pass file invalid at %d %d %d %d [%s]\n",
895 av_freep(&best_state);
896 return AVERROR_INVALIDDATA;
901 gob_count = strtol(p, &next, 0);
902 if (next == p || gob_count <= 0) {
903 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
904 av_freep(&best_state);
905 return AVERROR_INVALIDDATA;
908 while (*p == '\n' || *p == ' ')
913 sort_stt(s, s->state_transition);
915 find_best_state(best_state, s->state_transition);
917 for (i = 0; i < s->quant_table_count; i++) {
918 for (k = 0; k < 32; k++) {
921 for (j = 0; j < s->context_count[i]; j++) {
923 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
925 p = 256.0 * b / (a + b);
926 s->initial_states[i][jp][k] =
927 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
928 for(jp++; jp<j; jp++)
929 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
932 a += s->rc_stat2[i][j][k][0];
933 b += s->rc_stat2[i][j][k][1];
935 p = 256.0 * b / (a + b);
937 s->initial_states[i][j][k] =
938 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
942 av_freep(&best_state);
945 if (s->version > 1) {
946 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
947 for (; s->num_v_slices < 9; s->num_v_slices++) {
948 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
949 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
953 av_log(avctx, AV_LOG_ERROR,
954 "Unsupported number %d of slices requested, please specify a "
955 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
957 return AVERROR(ENOSYS);
959 if ((ret = write_extradata(s)) < 0)
963 if ((ret = ffv1_init_slice_contexts(s)) < 0)
965 if ((ret = ffv1_init_slices_state(s)) < 0)
968 #define STATS_OUT_SIZE 1024 * 1024 * 6
969 if (avctx->flags & CODEC_FLAG_PASS1) {
970 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
971 if (!avctx->stats_out)
972 return AVERROR(ENOMEM);
973 for (i = 0; i < s->quant_table_count; i++)
974 for (j = 0; j < s->slice_count; j++) {
975 FFV1Context *sf = s->slice_context[j];
976 av_assert0(!sf->rc_stat2[i]);
977 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
978 sizeof(*sf->rc_stat2[i]));
979 if (!sf->rc_stat2[i])
980 return AVERROR(ENOMEM);
987 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
989 RangeCoder *c = &fs->c;
990 uint8_t state[CONTEXT_SIZE];
992 memset(state, 128, sizeof(state));
994 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
995 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
996 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
997 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
998 for (j=0; j<f->plane_count; j++) {
999 put_symbol(c, state, f->plane[j].quant_table_index, 0);
1000 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
1002 if (!f->picture.f->interlaced_frame)
1003 put_symbol(c, state, 3, 0);
1005 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
1006 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
1007 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
1008 if (f->version > 3) {
1009 put_rac(c, state, fs->slice_coding_mode == 1);
1010 if (fs->slice_coding_mode == 1)
1011 ffv1_clear_slice_state(f, fs);
1012 put_symbol(c, state, fs->slice_coding_mode, 0);
1013 if (fs->slice_coding_mode != 1) {
1014 put_symbol(c, state, fs->slice_rct_by_coef, 0);
1015 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
1020 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
1022 #define NB_Y_COEFF 15
1023 static const int rct_y_coeff[15][2] = {
1025 {1, 1}, // R + 2G + B
1036 {1, 2}, // R + G + 2B
1037 {2, 1}, // 2R + G + B
1042 int stat[NB_Y_COEFF] = {0};
1043 int x, y, i, p, best;
1045 int lbd = fs->bits_per_raw_sample <= 8;
1047 for (y = 0; y < h; y++) {
1048 int lastr=0, lastg=0, lastb=0;
1049 for (p = 0; p < 3; p++)
1050 sample[p] = fs->sample_buffer + p*w;
1052 for (x = 0; x < w; x++) {
1056 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1058 g = (v >> 8) & 0xFF;
1059 r = (v >> 16) & 0xFF;
1061 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1062 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1063 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1070 int bg = ag - sample[0][x];
1071 int bb = ab - sample[1][x];
1072 int br = ar - sample[2][x];
1077 for (i = 0; i<NB_Y_COEFF; i++) {
1078 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1093 for (i=1; i<NB_Y_COEFF; i++) {
1094 if (stat[i] < stat[best])
1098 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1099 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1102 static int encode_slice(AVCodecContext *c, void *arg)
1104 FFV1Context *fs = *(void **)arg;
1105 FFV1Context *f = fs->avctx->priv_data;
1106 int width = fs->slice_width;
1107 int height = fs->slice_height;
1108 int x = fs->slice_x;
1109 int y = fs->slice_y;
1110 const AVFrame *const p = f->picture.f;
1111 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
1113 RangeCoder c_bak = fs->c;
1114 const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1115 p->data[1] + ps*x + y*p->linesize[1],
1116 p->data[2] + ps*x + y*p->linesize[2]};
1118 fs->slice_coding_mode = 0;
1119 if (f->version > 3) {
1120 choose_rct_params(fs, planes, p->linesize, width, height);
1122 fs->slice_rct_by_coef = 1;
1123 fs->slice_rct_ry_coef = 1;
1127 if (c->coded_frame->key_frame)
1128 ffv1_clear_slice_state(f, fs);
1129 if (f->version > 2) {
1130 encode_slice_header(f, fs);
1134 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1135 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1136 init_put_bits(&fs->pb,
1137 fs->c.bytestream_start + fs->ac_byte_count,
1138 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1141 if (f->colorspace == 0) {
1142 const int chroma_width = FF_CEIL_RSHIFT(width, f->chroma_h_shift);
1143 const int chroma_height = FF_CEIL_RSHIFT(height, f->chroma_v_shift);
1144 const int cx = x >> f->chroma_h_shift;
1145 const int cy = y >> f->chroma_v_shift;
1147 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1149 if (f->chroma_planes) {
1150 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1151 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1153 if (fs->transparency)
1154 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1156 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1161 av_assert0(fs->slice_coding_mode == 0);
1162 if (fs->version < 4 || !fs->ac) {
1163 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1166 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1167 fs->slice_coding_mode = 1;
1175 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1176 const AVFrame *pict, int *got_packet)
1178 FFV1Context *f = avctx->priv_data;
1179 RangeCoder *const c = &f->slice_context[0]->c;
1180 AVFrame *const p = f->picture.f;
1182 uint8_t keystate = 128;
1185 int64_t maxsize = FF_MIN_BUFFER_SIZE
1186 + avctx->width*avctx->height*35LL*4;
1189 if (avctx->flags & CODEC_FLAG_PASS1) {
1191 char *p = avctx->stats_out;
1192 char *end = p + STATS_OUT_SIZE;
1194 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1195 for (i = 0; i < f->quant_table_count; i++)
1196 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1198 for (j = 0; j < f->slice_count; j++) {
1199 FFV1Context *fs = f->slice_context[j];
1200 for (i = 0; i < 256; i++) {
1201 f->rc_stat[i][0] += fs->rc_stat[i][0];
1202 f->rc_stat[i][1] += fs->rc_stat[i][1];
1204 for (i = 0; i < f->quant_table_count; i++) {
1205 for (k = 0; k < f->context_count[i]; k++)
1206 for (m = 0; m < 32; m++) {
1207 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1208 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1213 for (j = 0; j < 256; j++) {
1214 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1215 f->rc_stat[j][0], f->rc_stat[j][1]);
1218 snprintf(p, end - p, "\n");
1220 for (i = 0; i < f->quant_table_count; i++) {
1221 for (j = 0; j < f->context_count[i]; j++)
1222 for (m = 0; m < 32; m++) {
1223 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1224 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1228 snprintf(p, end - p, "%d\n", f->gob_count);
1234 maxsize = FF_MIN_BUFFER_SIZE + avctx->width*avctx->height*3LL*4;
1236 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize)) < 0)
1239 ff_init_range_encoder(c, pkt->data, pkt->size);
1240 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1243 if ((ret = av_frame_ref(p, pict)) < 0)
1245 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1247 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1248 put_rac(c, &keystate, 1);
1249 avctx->coded_frame->key_frame = 1;
1253 put_rac(c, &keystate, 0);
1254 avctx->coded_frame->key_frame = 0;
1259 for (i = 1; i < 256; i++) {
1260 c->one_state[i] = f->state_transition[i];
1261 c->zero_state[256 - i] = 256 - c->one_state[i];
1265 for (i = 1; i < f->slice_count; i++) {
1266 FFV1Context *fs = f->slice_context[i];
1267 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1268 int len = pkt->size / f->slice_count;
1269 ff_init_range_encoder(&fs->c, start, len);
1271 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1272 f->slice_count, sizeof(void *));
1275 for (i = 0; i < f->slice_count; i++) {
1276 FFV1Context *fs = f->slice_context[i];
1280 uint8_t state = 129;
1281 put_rac(&fs->c, &state, 0);
1282 bytes = ff_rac_terminate(&fs->c);
1284 flush_put_bits(&fs->pb); // FIXME: nicer padding
1285 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1287 if (i > 0 || f->version > 2) {
1288 av_assert0(bytes < pkt->size / f->slice_count);
1289 memmove(buf_p, fs->c.bytestream_start, bytes);
1290 av_assert0(bytes < (1 << 24));
1291 AV_WB24(buf_p + bytes, bytes);
1297 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1298 AV_WL32(buf_p + bytes, v);
1304 if (avctx->flags & CODEC_FLAG_PASS1)
1305 avctx->stats_out[0] = '\0';
1307 f->picture_number++;
1308 pkt->size = buf_p - pkt->data;
1310 pkt->dts = pict->pts;
1311 pkt->flags |= AV_PKT_FLAG_KEY * avctx->coded_frame->key_frame;
1317 static av_cold int encode_close(AVCodecContext *avctx)
1319 av_frame_free(&avctx->coded_frame);
1324 #define OFFSET(x) offsetof(FFV1Context, x)
1325 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1326 static const AVOption options[] = {
1327 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1331 static const AVClass ffv1_class = {
1332 .class_name = "ffv1 encoder",
1333 .item_name = av_default_item_name,
1335 .version = LIBAVUTIL_VERSION_INT,
1338 static const AVCodecDefault ffv1_defaults[] = {
1343 AVCodec ff_ffv1_encoder = {
1345 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1346 .type = AVMEDIA_TYPE_VIDEO,
1347 .id = AV_CODEC_ID_FFV1,
1348 .priv_data_size = sizeof(FFV1Context),
1349 .init = encode_init,
1350 .encode2 = encode_frame,
1351 .close = encode_close,
1352 .capabilities = CODEC_CAP_SLICE_THREADS | CODEC_CAP_DELAY,
1353 .pix_fmts = (const enum AVPixelFormat[]) {
1354 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1355 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1356 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1357 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1358 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1359 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1360 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1361 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1362 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1363 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1367 .defaults = ffv1_defaults,
1368 .priv_class = &ffv1_class,