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 = 0; 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 * 20) {
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 for (x = 0; x < w; x++) {
292 context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
293 diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
300 diff = fold(diff, bits);
303 if (s->flags & CODEC_FLAG_PASS1) {
304 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
305 s->rc_stat2[p->quant_table_index][context]);
307 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
315 while (run_count >= 1 << ff_log2_run[run_index]) {
316 run_count -= 1 << ff_log2_run[run_index];
318 put_bits(&s->pb, 1, 1);
321 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
333 av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
334 run_count, run_index, run_mode, x,
335 (int)put_bits_count(&s->pb));
338 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
342 while (run_count >= 1 << ff_log2_run[run_index]) {
343 run_count -= 1 << ff_log2_run[run_index];
345 put_bits(&s->pb, 1, 1);
349 put_bits(&s->pb, 1, 1);
351 s->run_index = run_index;
356 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
357 int stride, int plane_index)
360 const int ring_size = s->avctx->context_model ? 3 : 2;
364 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
366 for (y = 0; y < h; y++) {
367 for (i = 0; i < ring_size; i++)
368 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
370 sample[0][-1]= sample[1][0 ];
371 sample[1][ w]= sample[1][w-1];
373 if (s->bits_per_raw_sample <= 8) {
374 for (x = 0; x < w; x++)
375 sample[0][x] = src[x + stride * y];
376 encode_line(s, w, sample, plane_index, 8);
378 if (s->packed_at_lsb) {
379 for (x = 0; x < w; x++) {
380 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
383 for (x = 0; x < w; x++) {
384 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
387 encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
389 // STOP_TIMER("encode line") }
393 static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3])
396 const int ring_size = s->avctx->context_model ? 3 : 2;
397 int16_t *sample[4][3];
398 int lbd = s->bits_per_raw_sample <= 8;
399 int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
400 int offset = 1 << bits;
404 memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
405 (w + 6) * sizeof(*s->sample_buffer));
407 for (y = 0; y < h; y++) {
408 for (i = 0; i < ring_size; i++)
409 for (p = 0; p < MAX_PLANES; p++)
410 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
412 for (x = 0; x < w; x++) {
413 int b, g, r, av_uninit(a);
415 unsigned v = *((uint32_t*)(src[0] + x*4 + stride[0]*y));
418 r = (v >> 16) & 0xFF;
421 b = *((uint16_t*)(src[0] + x*2 + stride[0]*y));
422 g = *((uint16_t*)(src[1] + x*2 + stride[1]*y));
423 r = *((uint16_t*)(src[2] + x*2 + stride[2]*y));
437 for (p = 0; p < 3 + s->transparency; p++) {
438 sample[p][0][-1] = sample[p][1][0 ];
439 sample[p][1][ w] = sample[p][1][w-1];
441 encode_line(s, w, sample[p], (p + 1) / 2, 9);
443 encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
448 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
452 uint8_t state[CONTEXT_SIZE];
453 memset(state, 128, sizeof(state));
455 for (i = 1; i < 128; i++)
456 if (quant_table[i] != quant_table[i - 1]) {
457 put_symbol(c, state, i - last - 1, 0);
460 put_symbol(c, state, i - last - 1, 0);
463 static void write_quant_tables(RangeCoder *c,
464 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
467 for (i = 0; i < 5; i++)
468 write_quant_table(c, quant_table[i]);
471 static void write_header(FFV1Context *f)
473 uint8_t state[CONTEXT_SIZE];
475 RangeCoder *const c = &f->slice_context[0]->c;
477 memset(state, 128, sizeof(state));
479 if (f->version < 2) {
480 put_symbol(c, state, f->version, 0);
481 put_symbol(c, state, f->ac, 0);
483 for (i = 1; i < 256; i++)
485 f->state_transition[i] - c->one_state[i], 1);
487 put_symbol(c, state, f->colorspace, 0); //YUV cs type
489 put_symbol(c, state, f->bits_per_raw_sample, 0);
490 put_rac(c, state, f->chroma_planes);
491 put_symbol(c, state, f->chroma_h_shift, 0);
492 put_symbol(c, state, f->chroma_v_shift, 0);
493 put_rac(c, state, f->transparency);
495 write_quant_tables(c, f->quant_table);
496 } else if (f->version < 3) {
497 put_symbol(c, state, f->slice_count, 0);
498 for (i = 0; i < f->slice_count; i++) {
499 FFV1Context *fs = f->slice_context[i];
501 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
503 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
505 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
508 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
510 for (j = 0; j < f->plane_count; j++) {
511 put_symbol(c, state, f->plane[j].quant_table_index, 0);
512 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
518 static int write_extradata(FFV1Context *f)
520 RangeCoder *const c = &f->c;
521 uint8_t state[CONTEXT_SIZE];
523 uint8_t state2[32][CONTEXT_SIZE];
526 memset(state2, 128, sizeof(state2));
527 memset(state, 128, sizeof(state));
529 f->avctx->extradata_size = 10000 + 4 +
530 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
531 f->avctx->extradata = av_malloc(f->avctx->extradata_size);
532 if (!f->avctx->extradata)
533 return AVERROR(ENOMEM);
534 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
535 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
537 put_symbol(c, state, f->version, 0);
538 if (f->version > 2) {
540 f->micro_version = 4;
541 put_symbol(c, state, f->micro_version, 0);
544 put_symbol(c, state, f->ac, 0);
546 for (i = 1; i < 256; i++)
547 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
549 put_symbol(c, state, f->colorspace, 0); // YUV cs type
550 put_symbol(c, state, f->bits_per_raw_sample, 0);
551 put_rac(c, state, f->chroma_planes);
552 put_symbol(c, state, f->chroma_h_shift, 0);
553 put_symbol(c, state, f->chroma_v_shift, 0);
554 put_rac(c, state, f->transparency);
555 put_symbol(c, state, f->num_h_slices - 1, 0);
556 put_symbol(c, state, f->num_v_slices - 1, 0);
558 put_symbol(c, state, f->quant_table_count, 0);
559 for (i = 0; i < f->quant_table_count; i++)
560 write_quant_tables(c, f->quant_tables[i]);
562 for (i = 0; i < f->quant_table_count; i++) {
563 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
564 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
566 if (j < f->context_count[i] * CONTEXT_SIZE) {
567 put_rac(c, state, 1);
568 for (j = 0; j < f->context_count[i]; j++)
569 for (k = 0; k < CONTEXT_SIZE; k++) {
570 int pred = j ? f->initial_states[i][j - 1][k] : 128;
571 put_symbol(c, state2[k],
572 (int8_t)(f->initial_states[i][j][k] - pred), 1);
575 put_rac(c, state, 0);
579 if (f->version > 2) {
580 put_symbol(c, state, f->ec, 0);
581 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
584 f->avctx->extradata_size = ff_rac_terminate(c);
585 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
586 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
587 f->avctx->extradata_size += 4;
592 static int sort_stt(FFV1Context *s, uint8_t stt[256])
594 int i, i2, changed, print = 0;
598 for (i = 12; i < 244; i++) {
599 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
601 #define COST(old, new) \
602 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
603 s->rc_stat[old][1] * -log2((new) / 256.0)
605 #define COST2(old, new) \
606 COST(old, new) + COST(256 - (old), 256 - (new))
608 double size0 = COST2(i, i) + COST2(i2, i2);
609 double sizeX = COST2(i, i2) + COST2(i2, i);
610 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
612 FFSWAP(int, stt[i], stt[i2]);
613 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
614 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
616 FFSWAP(int, stt[256 - i], stt[256 - i2]);
617 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
618 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
620 for (j = 1; j < 256; j++) {
623 else if (stt[j] == i2)
626 if (stt[256 - j] == 256 - i)
627 stt[256 - j] = 256 - i2;
628 else if (stt[256 - j] == 256 - i2)
629 stt[256 - j] = 256 - i;
640 static av_cold int encode_init(AVCodecContext *avctx)
642 FFV1Context *s = avctx->priv_data;
643 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
646 if ((ret = ffv1_common_init(avctx)) < 0)
651 if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
652 s->version = FFMAX(s->version, 2);
654 if (avctx->level == 3 || (avctx->level <= 0 && s->version == 2)) {
659 s->ec = (s->version >= 3);
662 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
663 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
664 return AVERROR_INVALIDDATA;
667 s->ac = avctx->coder_type > 0 ? 2 : 0;
670 switch(avctx->pix_fmt) {
671 case AV_PIX_FMT_YUV444P9:
672 case AV_PIX_FMT_YUV422P9:
673 case AV_PIX_FMT_YUV420P9:
674 if (!avctx->bits_per_raw_sample)
675 s->bits_per_raw_sample = 9;
676 case AV_PIX_FMT_YUV444P10:
677 case AV_PIX_FMT_YUV420P10:
678 case AV_PIX_FMT_YUV422P10:
679 s->packed_at_lsb = 1;
680 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
681 s->bits_per_raw_sample = 10;
682 case AV_PIX_FMT_GRAY16:
683 case AV_PIX_FMT_YUV444P16:
684 case AV_PIX_FMT_YUV422P16:
685 case AV_PIX_FMT_YUV420P16:
686 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
687 s->bits_per_raw_sample = 16;
688 } else if (!s->bits_per_raw_sample) {
689 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
691 if (s->bits_per_raw_sample <= 8) {
692 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
693 return AVERROR_INVALIDDATA;
695 if (!s->ac && avctx->coder_type == -1) {
696 av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
700 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
701 return AVERROR(ENOSYS);
703 s->version = FFMAX(s->version, 1);
704 case AV_PIX_FMT_GRAY8:
705 case AV_PIX_FMT_YUV444P:
706 case AV_PIX_FMT_YUV440P:
707 case AV_PIX_FMT_YUV422P:
708 case AV_PIX_FMT_YUV420P:
709 case AV_PIX_FMT_YUV411P:
710 case AV_PIX_FMT_YUV410P:
711 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
714 case AV_PIX_FMT_YUVA444P:
715 case AV_PIX_FMT_YUVA422P:
716 case AV_PIX_FMT_YUVA420P:
717 s->chroma_planes = 1;
721 case AV_PIX_FMT_RGB32:
724 s->chroma_planes = 1;
726 case AV_PIX_FMT_0RGB32:
728 s->chroma_planes = 1;
730 case AV_PIX_FMT_GBRP9:
731 if (!avctx->bits_per_raw_sample)
732 s->bits_per_raw_sample = 9;
733 case AV_PIX_FMT_GBRP10:
734 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
735 s->bits_per_raw_sample = 10;
736 case AV_PIX_FMT_GBRP12:
737 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
738 s->bits_per_raw_sample = 12;
739 case AV_PIX_FMT_GBRP14:
740 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
741 s->bits_per_raw_sample = 14;
742 else if (!s->bits_per_raw_sample)
743 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
745 s->chroma_planes = 1;
746 s->version = FFMAX(s->version, 1);
749 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
750 return AVERROR(ENOSYS);
752 if (s->transparency) {
753 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
755 if (avctx->context_model > 1U) {
756 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
757 return AVERROR(EINVAL);
761 for (i = 1; i < 256; i++)
762 s->state_transition[i] = ver2_state[i];
764 for (i = 0; i < 256; i++) {
765 s->quant_table_count = 2;
766 if (s->bits_per_raw_sample <= 8) {
767 s->quant_tables[0][0][i]= quant11[i];
768 s->quant_tables[0][1][i]= 11*quant11[i];
769 s->quant_tables[0][2][i]= 11*11*quant11[i];
770 s->quant_tables[1][0][i]= quant11[i];
771 s->quant_tables[1][1][i]= 11*quant11[i];
772 s->quant_tables[1][2][i]= 11*11*quant5 [i];
773 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
774 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
776 s->quant_tables[0][0][i]= quant9_10bit[i];
777 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
778 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
779 s->quant_tables[1][0][i]= quant9_10bit[i];
780 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
781 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
782 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
783 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
786 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
787 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
788 memcpy(s->quant_table, s->quant_tables[avctx->context_model],
789 sizeof(s->quant_table));
791 for (i = 0; i < s->plane_count; i++) {
792 PlaneContext *const p = &s->plane[i];
794 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
795 p->quant_table_index = avctx->context_model;
796 p->context_count = s->context_count[p->quant_table_index];
799 if ((ret = ffv1_allocate_initial_states(s)) < 0)
802 if (!s->transparency)
804 if (!s->chroma_planes && s->version > 3)
807 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
808 s->picture_number = 0;
810 if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
811 for (i = 0; i < s->quant_table_count; i++) {
812 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
813 sizeof(*s->rc_stat2[i]));
815 return AVERROR(ENOMEM);
818 if (avctx->stats_in) {
819 char *p = avctx->stats_in;
820 uint8_t best_state[256][256];
824 av_assert0(s->version >= 2);
827 for (j = 0; j < 256; j++)
828 for (i = 0; i < 2; i++) {
829 s->rc_stat[j][i] = strtol(p, &next, 0);
831 av_log(avctx, AV_LOG_ERROR,
832 "2Pass file invalid at %d %d [%s]\n", j, i, p);
833 return AVERROR_INVALIDDATA;
837 for (i = 0; i < s->quant_table_count; i++)
838 for (j = 0; j < s->context_count[i]; j++) {
839 for (k = 0; k < 32; k++)
840 for (m = 0; m < 2; m++) {
841 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
843 av_log(avctx, AV_LOG_ERROR,
844 "2Pass file invalid at %d %d %d %d [%s]\n",
846 return AVERROR_INVALIDDATA;
851 gob_count = strtol(p, &next, 0);
852 if (next == p || gob_count <= 0) {
853 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
854 return AVERROR_INVALIDDATA;
857 while (*p == '\n' || *p == ' ')
862 sort_stt(s, s->state_transition);
864 find_best_state(best_state, s->state_transition);
866 for (i = 0; i < s->quant_table_count; i++) {
867 for (k = 0; k < 32; k++) {
870 for (j = 0; j < s->context_count[i]; j++) {
872 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
874 p = 256.0 * b / (a + b);
875 s->initial_states[i][jp][k] =
876 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
877 for(jp++; jp<j; jp++)
878 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
881 a += s->rc_stat2[i][j][k][0];
882 b += s->rc_stat2[i][j][k][1];
884 p = 256.0 * b / (a + b);
886 s->initial_states[i][j][k] =
887 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
893 if (s->version > 1) {
894 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
895 for (; s->num_v_slices < 9; s->num_v_slices++) {
896 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
897 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
901 av_log(avctx, AV_LOG_ERROR,
902 "Unsupported number %d of slices requested, please specify a "
903 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
905 return AVERROR(ENOSYS);
907 if ((ret = write_extradata(s)) < 0)
911 if ((ret = ffv1_init_slice_contexts(s)) < 0)
913 if ((ret = ffv1_init_slices_state(s)) < 0)
916 #define STATS_OUT_SIZE 1024 * 1024 * 6
917 if (avctx->flags & CODEC_FLAG_PASS1) {
918 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
919 if (!avctx->stats_out)
920 return AVERROR(ENOMEM);
921 for (i = 0; i < s->quant_table_count; i++)
922 for (j = 0; j < s->slice_count; j++) {
923 FFV1Context *sf = s->slice_context[j];
924 av_assert0(!sf->rc_stat2[i]);
925 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
926 sizeof(*sf->rc_stat2[i]));
927 if (!sf->rc_stat2[i])
928 return AVERROR(ENOMEM);
935 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
937 RangeCoder *c = &fs->c;
938 uint8_t state[CONTEXT_SIZE];
940 memset(state, 128, sizeof(state));
942 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
943 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
944 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
945 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
946 for (j=0; j<f->plane_count; j++) {
947 put_symbol(c, state, f->plane[j].quant_table_index, 0);
948 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
950 if (!f->picture.f->interlaced_frame)
951 put_symbol(c, state, 3, 0);
953 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
954 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
955 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
958 static int encode_slice(AVCodecContext *c, void *arg)
960 FFV1Context *fs = *(void **)arg;
961 FFV1Context *f = fs->avctx->priv_data;
962 int width = fs->slice_width;
963 int height = fs->slice_height;
966 AVFrame *const p = f->picture.f;
967 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
970 ffv1_clear_slice_state(f, fs);
971 if (f->version > 2) {
972 encode_slice_header(f, fs);
976 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
977 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
978 init_put_bits(&fs->pb,
979 fs->c.bytestream_start + fs->ac_byte_count,
980 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
983 if (f->colorspace == 0) {
984 const int chroma_width = FF_CEIL_RSHIFT(width, f->chroma_h_shift);
985 const int chroma_height = FF_CEIL_RSHIFT(height, f->chroma_v_shift);
986 const int cx = x >> f->chroma_h_shift;
987 const int cy = y >> f->chroma_v_shift;
989 encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
991 if (f->chroma_planes) {
992 encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
993 encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
995 if (fs->transparency)
996 encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
998 uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
999 p->data[1] + ps*x + y*p->linesize[1],
1000 p->data[2] + ps*x + y*p->linesize[2]};
1001 encode_rgb_frame(fs, planes, width, height, p->linesize);
1008 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1009 const AVFrame *pict, int *got_packet)
1011 FFV1Context *f = avctx->priv_data;
1012 RangeCoder *const c = &f->slice_context[0]->c;
1013 AVFrame *const p = f->picture.f;
1015 uint8_t keystate = 128;
1019 if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1020 + FF_MIN_BUFFER_SIZE)) < 0)
1023 ff_init_range_encoder(c, pkt->data, pkt->size);
1024 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1027 if ((ret = av_frame_ref(p, pict)) < 0)
1029 p->pict_type = AV_PICTURE_TYPE_I;
1031 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1032 put_rac(c, &keystate, 1);
1037 put_rac(c, &keystate, 0);
1043 for (i = 1; i < 256; i++) {
1044 c->one_state[i] = f->state_transition[i];
1045 c->zero_state[256 - i] = 256 - c->one_state[i];
1049 for (i = 1; i < f->slice_count; i++) {
1050 FFV1Context *fs = f->slice_context[i];
1051 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1052 int len = pkt->size / f->slice_count;
1053 ff_init_range_encoder(&fs->c, start, len);
1055 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1056 f->slice_count, sizeof(void *));
1059 for (i = 0; i < f->slice_count; i++) {
1060 FFV1Context *fs = f->slice_context[i];
1064 uint8_t state = 129;
1065 put_rac(&fs->c, &state, 0);
1066 bytes = ff_rac_terminate(&fs->c);
1068 flush_put_bits(&fs->pb); // FIXME: nicer padding
1069 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1071 if (i > 0 || f->version > 2) {
1072 av_assert0(bytes < pkt->size / f->slice_count);
1073 memmove(buf_p, fs->c.bytestream_start, bytes);
1074 av_assert0(bytes < (1 << 24));
1075 AV_WB24(buf_p + bytes, bytes);
1081 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1082 AV_WL32(buf_p + bytes, v);
1088 if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
1090 char *p = avctx->stats_out;
1091 char *end = p + STATS_OUT_SIZE;
1093 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1094 for (i = 0; i < f->quant_table_count; i++)
1095 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1097 for (j = 0; j < f->slice_count; j++) {
1098 FFV1Context *fs = f->slice_context[j];
1099 for (i = 0; i < 256; i++) {
1100 f->rc_stat[i][0] += fs->rc_stat[i][0];
1101 f->rc_stat[i][1] += fs->rc_stat[i][1];
1103 for (i = 0; i < f->quant_table_count; i++) {
1104 for (k = 0; k < f->context_count[i]; k++)
1105 for (m = 0; m < 32; m++) {
1106 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1107 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1112 for (j = 0; j < 256; j++) {
1113 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1114 f->rc_stat[j][0], f->rc_stat[j][1]);
1117 snprintf(p, end - p, "\n");
1119 for (i = 0; i < f->quant_table_count; i++) {
1120 for (j = 0; j < f->context_count[i]; j++)
1121 for (m = 0; m < 32; m++) {
1122 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1123 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1127 snprintf(p, end - p, "%d\n", f->gob_count);
1128 } else if (avctx->flags & CODEC_FLAG_PASS1)
1129 avctx->stats_out[0] = '\0';
1131 f->picture_number++;
1132 pkt->size = buf_p - pkt->data;
1133 pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
1139 #define OFFSET(x) offsetof(FFV1Context, x)
1140 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1141 static const AVOption options[] = {
1142 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1146 static const AVClass ffv1_class = {
1147 .class_name = "ffv1 encoder",
1148 .item_name = av_default_item_name,
1150 .version = LIBAVUTIL_VERSION_INT,
1153 static const AVCodecDefault ffv1_defaults[] = {
1158 AVCodec ff_ffv1_encoder = {
1160 .type = AVMEDIA_TYPE_VIDEO,
1161 .id = AV_CODEC_ID_FFV1,
1162 .priv_data_size = sizeof(FFV1Context),
1163 .init = encode_init,
1164 .encode2 = encode_frame,
1165 .close = ffv1_close,
1166 .capabilities = CODEC_CAP_SLICE_THREADS,
1167 .pix_fmts = (const enum AVPixelFormat[]) {
1168 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1169 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1170 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1171 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1172 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1173 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1174 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1178 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1179 .defaults = ffv1_defaults,
1180 .priv_class = &ffv1_class,