4 * Copyright (c) 2003-2012 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/avassert.h"
29 #include "libavutil/crc.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/timer.h"
37 #include "rangecoder.h"
42 static const int8_t quant5_10bit[256] = {
43 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
44 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
47 2, 2, 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, -1,
56 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -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, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
61 static const int8_t quant5[256] = {
62 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
63 2, 2, 2, 2, 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, -1, -1, -1,
80 static const int8_t quant9_10bit[256] = {
81 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
82 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
83 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
84 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
85 4, 4, 4, 4, 4, 4, 4, 4, 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, -3, -3, -3, -3, -3, -3, -3,
94 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
95 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
96 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
99 static const int8_t quant11[256] = {
100 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
101 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
102 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
103 5, 5, 5, 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, -4, -4,
114 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
115 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
118 static const uint8_t ver2_state[256] = {
119 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
120 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
121 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
122 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
123 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
124 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
125 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
126 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
127 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
128 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
129 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
130 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
131 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
132 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
133 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
134 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
137 static void find_best_state(uint8_t best_state[256][256],
138 const uint8_t one_state[256])
143 for (i = 1; i < 256; i++)
144 l2tab[i] = log2(i / 256.0);
146 for (i = 0; i < 256; i++) {
147 double best_len[256];
148 double p = i / 256.0;
150 for (j = 0; j < 256; j++)
151 best_len[j] = 1 << 30;
153 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
154 double occ[256] = { 0 };
157 for (k = 0; k < 256; k++) {
158 double newocc[256] = { 0 };
159 for (m = 1; m < 256; m++)
161 len -=occ[m]*( p *l2tab[ m]
162 + (1-p)*l2tab[256-m]);
164 if (len < best_len[k]) {
166 best_state[i][k] = j;
168 for (m = 0; m < 256; m++)
170 newocc[ one_state[ m]] += occ[m] * p;
171 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
173 memcpy(occ, newocc, sizeof(occ));
179 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
180 uint8_t *state, int v,
182 uint64_t rc_stat[256][2],
183 uint64_t rc_stat2[32][2])
187 #define put_rac(C, S, B) \
190 rc_stat[*(S)][B]++; \
191 rc_stat2[(S) - state][B]++; \
197 const int a = FFABS(v);
198 const int e = av_log2(a);
199 put_rac(c, state + 0, 0);
201 for (i = 0; i < e; i++)
202 put_rac(c, state + 1 + i, 1); // 1..10
203 put_rac(c, state + 1 + i, 0);
205 for (i = e - 1; i >= 0; i--)
206 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
209 put_rac(c, state + 11 + e, v < 0); // 11..21
211 for (i = 0; i < e; i++)
212 put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
213 put_rac(c, state + 1 + 9, 0);
215 for (i = e - 1; i >= 0; i--)
216 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
219 put_rac(c, state + 11 + 10, v < 0); // 11..21
222 put_rac(c, state + 0, 1);
227 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
228 int v, int is_signed)
230 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
234 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
238 v = fold(v - state->bias, bits);
242 while (i < state->error_sum) { // FIXME: optimize
250 if (k == 0 && 2 * state->drift <= -state->count)
255 code = v ^ ((2 * state->drift + state->count) >> 31);
258 av_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
259 state->bias, state->error_sum, state->drift, state->count, k);
260 set_sr_golomb(pb, code, k, 12, bits);
262 update_vlc_state(state, v);
265 static av_always_inline int encode_line(FFV1Context *s, int w,
267 int plane_index, int bits)
269 PlaneContext *const p = &s->plane[plane_index];
270 RangeCoder *const c = &s->c;
272 int run_index = s->run_index;
277 if (c->bytestream_end - c->bytestream < w * 20) {
278 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
279 return AVERROR_INVALIDDATA;
282 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
283 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
284 return AVERROR_INVALIDDATA;
288 for (x = 0; x < w; x++) {
291 context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
292 diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
299 diff = fold(diff, bits);
302 if (s->flags & CODEC_FLAG_PASS1) {
303 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
304 s->rc_stat2[p->quant_table_index][context]);
306 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
314 while (run_count >= 1 << ff_log2_run[run_index]) {
315 run_count -= 1 << ff_log2_run[run_index];
317 put_bits(&s->pb, 1, 1);
320 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
332 av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
333 run_count, run_index, run_mode, x,
334 (int)put_bits_count(&s->pb));
337 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
341 while (run_count >= 1 << ff_log2_run[run_index]) {
342 run_count -= 1 << ff_log2_run[run_index];
344 put_bits(&s->pb, 1, 1);
348 put_bits(&s->pb, 1, 1);
350 s->run_index = run_index;
355 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
356 int stride, int plane_index)
359 const int ring_size = s->avctx->context_model ? 3 : 2;
363 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
365 for (y = 0; y < h; y++) {
366 for (i = 0; i < ring_size; i++)
367 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
369 sample[0][-1]= sample[1][0 ];
370 sample[1][ w]= sample[1][w-1];
372 if (s->bits_per_raw_sample <= 8) {
373 for (x = 0; x < w; x++)
374 sample[0][x] = src[x + stride * y];
375 encode_line(s, w, sample, plane_index, 8);
377 if (s->packed_at_lsb) {
378 for (x = 0; x < w; x++) {
379 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
382 for (x = 0; x < w; x++) {
383 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
386 encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
388 // STOP_TIMER("encode line") }
392 static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3])
395 const int ring_size = s->avctx->context_model ? 3 : 2;
396 int16_t *sample[4][3];
397 int lbd = s->bits_per_raw_sample <= 8;
398 int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
399 int offset = 1 << bits;
403 memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
404 (w + 6) * sizeof(*s->sample_buffer));
406 for (y = 0; y < h; y++) {
407 for (i = 0; i < ring_size; i++)
408 for (p = 0; p < MAX_PLANES; p++)
409 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
411 for (x = 0; x < w; x++) {
412 int b, g, r, av_uninit(a);
414 unsigned v = *((uint32_t*)(src[0] + x*4 + stride[0]*y));
417 r = (v >> 16) & 0xFF;
420 b = *((uint16_t*)(src[0] + x*2 + stride[0]*y));
421 g = *((uint16_t*)(src[1] + x*2 + stride[1]*y));
422 r = *((uint16_t*)(src[2] + x*2 + stride[2]*y));
436 for (p = 0; p < 3 + s->transparency; p++) {
437 sample[p][0][-1] = sample[p][1][0 ];
438 sample[p][1][ w] = sample[p][1][w-1];
440 encode_line(s, w, sample[p], (p + 1) / 2, 9);
442 encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
447 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
451 uint8_t state[CONTEXT_SIZE];
452 memset(state, 128, sizeof(state));
454 for (i = 1; i < 128; i++)
455 if (quant_table[i] != quant_table[i - 1]) {
456 put_symbol(c, state, i - last - 1, 0);
459 put_symbol(c, state, i - last - 1, 0);
462 static void write_quant_tables(RangeCoder *c,
463 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
466 for (i = 0; i < 5; i++)
467 write_quant_table(c, quant_table[i]);
470 static void write_header(FFV1Context *f)
472 uint8_t state[CONTEXT_SIZE];
474 RangeCoder *const c = &f->slice_context[0]->c;
476 memset(state, 128, sizeof(state));
478 if (f->version < 2) {
479 put_symbol(c, state, f->version, 0);
480 put_symbol(c, state, f->ac, 0);
482 for (i = 1; i < 256; i++)
484 f->state_transition[i] - c->one_state[i], 1);
486 put_symbol(c, state, f->colorspace, 0); //YUV cs type
488 put_symbol(c, state, f->bits_per_raw_sample, 0);
489 put_rac(c, state, f->chroma_planes);
490 put_symbol(c, state, f->chroma_h_shift, 0);
491 put_symbol(c, state, f->chroma_v_shift, 0);
492 put_rac(c, state, f->transparency);
494 write_quant_tables(c, f->quant_table);
495 } else if (f->version < 3) {
496 put_symbol(c, state, f->slice_count, 0);
497 for (i = 0; i < f->slice_count; i++) {
498 FFV1Context *fs = f->slice_context[i];
500 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
502 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
504 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
507 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
509 for (j = 0; j < f->plane_count; j++) {
510 put_symbol(c, state, f->plane[j].quant_table_index, 0);
511 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
517 static int write_extradata(FFV1Context *f)
519 RangeCoder *const c = &f->c;
520 uint8_t state[CONTEXT_SIZE];
522 uint8_t state2[32][CONTEXT_SIZE];
525 memset(state2, 128, sizeof(state2));
526 memset(state, 128, sizeof(state));
528 f->avctx->extradata_size = 10000 + 4 +
529 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
530 f->avctx->extradata = av_malloc(f->avctx->extradata_size);
531 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
532 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
534 put_symbol(c, state, f->version, 0);
535 if (f->version > 2) {
537 f->minor_version = 3;
538 put_symbol(c, state, f->minor_version, 0);
541 put_symbol(c, state, f->ac, 0);
543 for (i = 1; i < 256; i++)
544 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
546 put_symbol(c, state, f->colorspace, 0); // YUV cs type
547 put_symbol(c, state, f->bits_per_raw_sample, 0);
548 put_rac(c, state, f->chroma_planes);
549 put_symbol(c, state, f->chroma_h_shift, 0);
550 put_symbol(c, state, f->chroma_v_shift, 0);
551 put_rac(c, state, f->transparency);
552 put_symbol(c, state, f->num_h_slices - 1, 0);
553 put_symbol(c, state, f->num_v_slices - 1, 0);
555 put_symbol(c, state, f->quant_table_count, 0);
556 for (i = 0; i < f->quant_table_count; i++)
557 write_quant_tables(c, f->quant_tables[i]);
559 for (i = 0; i < f->quant_table_count; i++) {
560 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
561 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
563 if (j < f->context_count[i] * CONTEXT_SIZE) {
564 put_rac(c, state, 1);
565 for (j = 0; j < f->context_count[i]; j++)
566 for (k = 0; k < CONTEXT_SIZE; k++) {
567 int pred = j ? f->initial_states[i][j - 1][k] : 128;
568 put_symbol(c, state2[k],
569 (int8_t)(f->initial_states[i][j][k] - pred), 1);
572 put_rac(c, state, 0);
576 if (f->version > 2) {
577 put_symbol(c, state, f->ec, 0);
578 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
581 f->avctx->extradata_size = ff_rac_terminate(c);
582 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
583 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
584 f->avctx->extradata_size += 4;
589 static int sort_stt(FFV1Context *s, uint8_t stt[256])
591 int i, i2, changed, print = 0;
595 for (i = 12; i < 244; i++) {
596 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
598 #define COST(old, new) \
599 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
600 s->rc_stat[old][1] * -log2((new) / 256.0)
602 #define COST2(old, new) \
603 COST(old, new) + COST(256 - (old), 256 - (new))
605 double size0 = COST2(i, i) + COST2(i2, i2);
606 double sizeX = COST2(i, i2) + COST2(i2, i);
607 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
609 FFSWAP(int, stt[i], stt[i2]);
610 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
611 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
613 FFSWAP(int, stt[256 - i], stt[256 - i2]);
614 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
615 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
617 for (j = 1; j < 256; j++) {
620 else if (stt[j] == i2)
623 if (stt[256 - j] == 256 - i)
624 stt[256 - j] = 256 - i2;
625 else if (stt[256 - j] == 256 - i2)
626 stt[256 - j] = 256 - i;
637 static av_cold int encode_init(AVCodecContext *avctx)
639 FFV1Context *s = avctx->priv_data;
640 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
643 ffv1_common_init(avctx);
647 if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
648 s->version = FFMAX(s->version, 2);
650 if (avctx->level == 3 || (s->version==2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
655 s->ec = (s->version >= 3);
658 if (s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
659 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
660 return AVERROR_INVALIDDATA;
663 s->ac = avctx->coder_type > 0 ? 2 : 0;
666 switch(avctx->pix_fmt) {
667 case AV_PIX_FMT_YUV444P9:
668 case AV_PIX_FMT_YUV422P9:
669 case AV_PIX_FMT_YUV420P9:
670 if (!avctx->bits_per_raw_sample)
671 s->bits_per_raw_sample = 9;
672 case AV_PIX_FMT_YUV444P10:
673 case AV_PIX_FMT_YUV420P10:
674 case AV_PIX_FMT_YUV422P10:
675 s->packed_at_lsb = 1;
676 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
677 s->bits_per_raw_sample = 10;
678 case AV_PIX_FMT_GRAY16:
679 case AV_PIX_FMT_YUV444P16:
680 case AV_PIX_FMT_YUV422P16:
681 case AV_PIX_FMT_YUV420P16:
682 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
683 s->bits_per_raw_sample = 16;
684 } else if (!s->bits_per_raw_sample) {
685 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
687 if (s->bits_per_raw_sample <= 8) {
688 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
689 return AVERROR_INVALIDDATA;
691 if (!s->ac && avctx->coder_type == -1) {
692 av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
696 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
697 return AVERROR(ENOSYS);
699 s->version = FFMAX(s->version, 1);
700 case AV_PIX_FMT_GRAY8:
701 case AV_PIX_FMT_YUV444P:
702 case AV_PIX_FMT_YUV440P:
703 case AV_PIX_FMT_YUV422P:
704 case AV_PIX_FMT_YUV420P:
705 case AV_PIX_FMT_YUV411P:
706 case AV_PIX_FMT_YUV410P:
707 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
710 case AV_PIX_FMT_YUVA444P:
711 case AV_PIX_FMT_YUVA422P:
712 case AV_PIX_FMT_YUVA420P:
713 s->chroma_planes = 1;
717 case AV_PIX_FMT_RGB32:
721 case AV_PIX_FMT_0RGB32:
724 case AV_PIX_FMT_GBRP9:
725 if (!avctx->bits_per_raw_sample)
726 s->bits_per_raw_sample = 9;
727 case AV_PIX_FMT_GBRP10:
728 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
729 s->bits_per_raw_sample = 10;
730 case AV_PIX_FMT_GBRP12:
731 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
732 s->bits_per_raw_sample = 12;
733 case AV_PIX_FMT_GBRP14:
734 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
735 s->bits_per_raw_sample = 14;
736 else if (!s->bits_per_raw_sample)
737 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
739 s->chroma_planes = 1;
740 s->version = FFMAX(s->version, 1);
743 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
744 return AVERROR(ENOSYS);
746 if (s->transparency) {
747 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
749 if (avctx->context_model > 1U) {
750 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
751 return AVERROR(EINVAL);
755 for (i = 1; i < 256; i++)
756 s->state_transition[i] = ver2_state[i];
758 for (i = 0; i < 256; i++) {
759 s->quant_table_count = 2;
760 if (s->bits_per_raw_sample <= 8) {
761 s->quant_tables[0][0][i]= quant11[i];
762 s->quant_tables[0][1][i]= 11*quant11[i];
763 s->quant_tables[0][2][i]= 11*11*quant11[i];
764 s->quant_tables[1][0][i]= quant11[i];
765 s->quant_tables[1][1][i]= 11*quant11[i];
766 s->quant_tables[1][2][i]= 11*11*quant5 [i];
767 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
768 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
770 s->quant_tables[0][0][i]= quant9_10bit[i];
771 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
772 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
773 s->quant_tables[1][0][i]= quant9_10bit[i];
774 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
775 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
776 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
777 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
780 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
781 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
782 memcpy(s->quant_table, s->quant_tables[avctx->context_model],
783 sizeof(s->quant_table));
785 for (i = 0; i < s->plane_count; i++) {
786 PlaneContext *const p = &s->plane[i];
788 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
789 p->quant_table_index = avctx->context_model;
790 p->context_count = s->context_count[p->quant_table_index];
793 if ((ret = ffv1_allocate_initial_states(s)) < 0)
796 avctx->coded_frame = &s->picture;
797 if (!s->transparency)
799 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
800 s->picture_number = 0;
802 if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
803 for (i = 0; i < s->quant_table_count; i++) {
804 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
805 sizeof(*s->rc_stat2[i]));
807 return AVERROR(ENOMEM);
810 if (avctx->stats_in) {
811 char *p = avctx->stats_in;
812 uint8_t best_state[256][256];
816 av_assert0(s->version >= 2);
819 for (j = 0; j < 256; j++)
820 for (i = 0; i < 2; i++) {
821 s->rc_stat[j][i] = strtol(p, &next, 0);
823 av_log(avctx, AV_LOG_ERROR,
824 "2Pass file invalid at %d %d [%s]\n", j, i, p);
825 return AVERROR_INVALIDDATA;
829 for (i = 0; i < s->quant_table_count; i++)
830 for (j = 0; j < s->context_count[i]; j++) {
831 for (k = 0; k < 32; k++)
832 for (m = 0; m < 2; m++) {
833 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
835 av_log(avctx, AV_LOG_ERROR,
836 "2Pass file invalid at %d %d %d %d [%s]\n",
838 return AVERROR_INVALIDDATA;
843 gob_count = strtol(p, &next, 0);
844 if (next == p || gob_count <= 0) {
845 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
846 return AVERROR_INVALIDDATA;
849 while (*p == '\n' || *p == ' ')
854 sort_stt(s, s->state_transition);
856 find_best_state(best_state, s->state_transition);
858 for (i = 0; i < s->quant_table_count; i++) {
859 for (k = 0; k < 32; k++) {
862 for (j = 0; j < s->context_count[i]; j++) {
864 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
866 p = 256.0 * b / (a + b);
867 s->initial_states[i][jp][k] =
868 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
869 for(jp++; jp<j; jp++)
870 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
873 a += s->rc_stat2[i][j][k][0];
874 b += s->rc_stat2[i][j][k][1];
876 p = 256.0 * b / (a + b);
878 s->initial_states[i][j][k] =
879 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
885 if (s->version > 1) {
886 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
887 for (; s->num_v_slices < 9; s->num_v_slices++) {
888 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
889 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
893 av_log(avctx, AV_LOG_ERROR,
894 "Unsupported number %d of slices requested, please specify a "
895 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
897 return AVERROR(ENOSYS);
902 if ((ret = ffv1_init_slice_contexts(s)) < 0)
904 if ((ret = ffv1_init_slices_state(s)) < 0)
907 #define STATS_OUT_SIZE 1024 * 1024 * 6
908 if (avctx->flags & CODEC_FLAG_PASS1) {
909 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
910 if (!avctx->stats_out)
911 return AVERROR(ENOMEM);
912 for (i = 0; i < s->quant_table_count; i++)
913 for (j = 0; j < s->slice_count; j++) {
914 FFV1Context *sf = s->slice_context[j];
915 av_assert0(!sf->rc_stat2[i]);
916 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
917 sizeof(*sf->rc_stat2[i]));
918 if (!sf->rc_stat2[i])
919 return AVERROR(ENOMEM);
926 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
928 RangeCoder *c = &fs->c;
929 uint8_t state[CONTEXT_SIZE];
931 memset(state, 128, sizeof(state));
933 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
934 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
935 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
936 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
937 for (j=0; j<f->plane_count; j++) {
938 put_symbol(c, state, f->plane[j].quant_table_index, 0);
939 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
941 if (!f->picture.interlaced_frame)
942 put_symbol(c, state, 3, 0);
944 put_symbol(c, state, 1 + !f->picture.top_field_first, 0);
945 put_symbol(c, state, f->picture.sample_aspect_ratio.num, 0);
946 put_symbol(c, state, f->picture.sample_aspect_ratio.den, 0);
949 static int encode_slice(AVCodecContext *c, void *arg)
951 FFV1Context *fs = *(void **)arg;
952 FFV1Context *f = fs->avctx->priv_data;
953 int width = fs->slice_width;
954 int height = fs->slice_height;
957 AVFrame *const p = &f->picture;
958 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
961 ffv1_clear_slice_state(f, fs);
962 if (f->version > 2) {
963 encode_slice_header(f, fs);
967 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
968 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
969 init_put_bits(&fs->pb,
970 fs->c.bytestream_start + fs->ac_byte_count,
971 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
974 if (f->colorspace == 0) {
975 const int chroma_width = -((-width) >> f->chroma_h_shift);
976 const int chroma_height = -((-height) >> f->chroma_v_shift);
977 const int cx = x >> f->chroma_h_shift;
978 const int cy = y >> f->chroma_v_shift;
980 encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
982 if (f->chroma_planes) {
983 encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
984 encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
986 if (fs->transparency)
987 encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
989 uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
990 p->data[1] + ps*x + y*p->linesize[1],
991 p->data[2] + ps*x + y*p->linesize[2]};
992 encode_rgb_frame(fs, planes, width, height, p->linesize);
999 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1000 const AVFrame *pict, int *got_packet)
1002 FFV1Context *f = avctx->priv_data;
1003 RangeCoder *const c = &f->slice_context[0]->c;
1004 AVFrame *const p = &f->picture;
1006 uint8_t keystate = 128;
1010 if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1011 + FF_MIN_BUFFER_SIZE)) < 0)
1014 ff_init_range_encoder(c, pkt->data, pkt->size);
1015 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1018 p->pict_type = AV_PICTURE_TYPE_I;
1020 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1021 put_rac(c, &keystate, 1);
1026 put_rac(c, &keystate, 0);
1032 for (i = 1; i < 256; i++) {
1033 c->one_state[i] = f->state_transition[i];
1034 c->zero_state[256 - i] = 256 - c->one_state[i];
1038 for (i = 1; i < f->slice_count; i++) {
1039 FFV1Context *fs = f->slice_context[i];
1040 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1041 int len = pkt->size / f->slice_count;
1042 ff_init_range_encoder(&fs->c, start, len);
1044 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1045 f->slice_count, sizeof(void *));
1048 for (i = 0; i < f->slice_count; i++) {
1049 FFV1Context *fs = f->slice_context[i];
1053 uint8_t state = 129;
1054 put_rac(&fs->c, &state, 0);
1055 bytes = ff_rac_terminate(&fs->c);
1057 flush_put_bits(&fs->pb); // FIXME: nicer padding
1058 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1060 if (i > 0 || f->version > 2) {
1061 av_assert0(bytes < pkt->size / f->slice_count);
1062 memmove(buf_p, fs->c.bytestream_start, bytes);
1063 av_assert0(bytes < (1 << 24));
1064 AV_WB24(buf_p + bytes, bytes);
1070 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1071 AV_WL32(buf_p + bytes, v);
1077 if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
1079 char *p = avctx->stats_out;
1080 char *end = p + STATS_OUT_SIZE;
1082 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1083 for (i = 0; i < f->quant_table_count; i++)
1084 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1086 for (j = 0; j < f->slice_count; j++) {
1087 FFV1Context *fs = f->slice_context[j];
1088 for (i = 0; i < 256; i++) {
1089 f->rc_stat[i][0] += fs->rc_stat[i][0];
1090 f->rc_stat[i][1] += fs->rc_stat[i][1];
1092 for (i = 0; i < f->quant_table_count; i++) {
1093 for (k = 0; k < f->context_count[i]; k++)
1094 for (m = 0; m < 32; m++) {
1095 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1096 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1101 for (j = 0; j < 256; j++) {
1102 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1103 f->rc_stat[j][0], f->rc_stat[j][1]);
1106 snprintf(p, end - p, "\n");
1108 for (i = 0; i < f->quant_table_count; i++) {
1109 for (j = 0; j < f->context_count[i]; j++)
1110 for (m = 0; m < 32; m++) {
1111 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1112 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1116 snprintf(p, end - p, "%d\n", f->gob_count);
1117 } else if (avctx->flags & CODEC_FLAG_PASS1)
1118 avctx->stats_out[0] = '\0';
1120 f->picture_number++;
1121 pkt->size = buf_p - pkt->data;
1122 pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
1128 #define OFFSET(x) offsetof(FFV1Context, x)
1129 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1130 static const AVOption options[] = {
1131 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1135 static const AVClass class = {
1136 .class_name = "ffv1 encoder",
1137 .item_name = av_default_item_name,
1139 .version = LIBAVUTIL_VERSION_INT,
1142 static const AVCodecDefault ffv1_defaults[] = {
1147 AVCodec ff_ffv1_encoder = {
1149 .type = AVMEDIA_TYPE_VIDEO,
1150 .id = AV_CODEC_ID_FFV1,
1151 .priv_data_size = sizeof(FFV1Context),
1152 .init = encode_init,
1153 .encode2 = encode_frame,
1154 .close = ffv1_close,
1155 .capabilities = CODEC_CAP_SLICE_THREADS,
1156 .pix_fmts = (const enum AVPixelFormat[]) {
1157 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1158 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1159 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1160 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1161 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1162 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1163 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1167 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1168 .defaults = ffv1_defaults,
1169 .priv_class = &class,