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/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 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
533 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
535 put_symbol(c, state, f->version, 0);
536 if (f->version > 2) {
538 f->minor_version = 4;
539 put_symbol(c, state, f->minor_version, 0);
542 put_symbol(c, state, f->ac, 0);
544 for (i = 1; i < 256; i++)
545 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
547 put_symbol(c, state, f->colorspace, 0); // YUV cs type
548 put_symbol(c, state, f->bits_per_raw_sample, 0);
549 put_rac(c, state, f->chroma_planes);
550 put_symbol(c, state, f->chroma_h_shift, 0);
551 put_symbol(c, state, f->chroma_v_shift, 0);
552 put_rac(c, state, f->transparency);
553 put_symbol(c, state, f->num_h_slices - 1, 0);
554 put_symbol(c, state, f->num_v_slices - 1, 0);
556 put_symbol(c, state, f->quant_table_count, 0);
557 for (i = 0; i < f->quant_table_count; i++)
558 write_quant_tables(c, f->quant_tables[i]);
560 for (i = 0; i < f->quant_table_count; i++) {
561 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
562 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
564 if (j < f->context_count[i] * CONTEXT_SIZE) {
565 put_rac(c, state, 1);
566 for (j = 0; j < f->context_count[i]; j++)
567 for (k = 0; k < CONTEXT_SIZE; k++) {
568 int pred = j ? f->initial_states[i][j - 1][k] : 128;
569 put_symbol(c, state2[k],
570 (int8_t)(f->initial_states[i][j][k] - pred), 1);
573 put_rac(c, state, 0);
577 if (f->version > 2) {
578 put_symbol(c, state, f->ec, 0);
579 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
582 f->avctx->extradata_size = ff_rac_terminate(c);
583 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
584 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
585 f->avctx->extradata_size += 4;
590 static int sort_stt(FFV1Context *s, uint8_t stt[256])
592 int i, i2, changed, print = 0;
596 for (i = 12; i < 244; i++) {
597 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
599 #define COST(old, new) \
600 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
601 s->rc_stat[old][1] * -log2((new) / 256.0)
603 #define COST2(old, new) \
604 COST(old, new) + COST(256 - (old), 256 - (new))
606 double size0 = COST2(i, i) + COST2(i2, i2);
607 double sizeX = COST2(i, i2) + COST2(i2, i);
608 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
610 FFSWAP(int, stt[i], stt[i2]);
611 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
612 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
614 FFSWAP(int, stt[256 - i], stt[256 - i2]);
615 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
616 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
618 for (j = 1; j < 256; j++) {
621 else if (stt[j] == i2)
624 if (stt[256 - j] == 256 - i)
625 stt[256 - j] = 256 - i2;
626 else if (stt[256 - j] == 256 - i2)
627 stt[256 - j] = 256 - i;
638 static av_cold int encode_init(AVCodecContext *avctx)
640 FFV1Context *s = avctx->priv_data;
641 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
644 if ((ret = ffv1_common_init(avctx)) < 0)
649 if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
650 s->version = FFMAX(s->version, 2);
652 if (avctx->level == 3 || (s->version==2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
657 s->ec = (s->version >= 3);
660 if (s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
661 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
662 return AVERROR_INVALIDDATA;
665 s->ac = avctx->coder_type > 0 ? 2 : 0;
668 switch(avctx->pix_fmt) {
669 case AV_PIX_FMT_YUV444P9:
670 case AV_PIX_FMT_YUV422P9:
671 case AV_PIX_FMT_YUV420P9:
672 if (!avctx->bits_per_raw_sample)
673 s->bits_per_raw_sample = 9;
674 case AV_PIX_FMT_YUV444P10:
675 case AV_PIX_FMT_YUV420P10:
676 case AV_PIX_FMT_YUV422P10:
677 s->packed_at_lsb = 1;
678 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
679 s->bits_per_raw_sample = 10;
680 case AV_PIX_FMT_GRAY16:
681 case AV_PIX_FMT_YUV444P16:
682 case AV_PIX_FMT_YUV422P16:
683 case AV_PIX_FMT_YUV420P16:
684 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
685 s->bits_per_raw_sample = 16;
686 } else if (!s->bits_per_raw_sample) {
687 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
689 if (s->bits_per_raw_sample <= 8) {
690 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
691 return AVERROR_INVALIDDATA;
693 if (!s->ac && avctx->coder_type == -1) {
694 av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
698 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
699 return AVERROR(ENOSYS);
701 s->version = FFMAX(s->version, 1);
702 case AV_PIX_FMT_GRAY8:
703 case AV_PIX_FMT_YUV444P:
704 case AV_PIX_FMT_YUV440P:
705 case AV_PIX_FMT_YUV422P:
706 case AV_PIX_FMT_YUV420P:
707 case AV_PIX_FMT_YUV411P:
708 case AV_PIX_FMT_YUV410P:
709 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
712 case AV_PIX_FMT_YUVA444P:
713 case AV_PIX_FMT_YUVA422P:
714 case AV_PIX_FMT_YUVA420P:
715 s->chroma_planes = 1;
719 case AV_PIX_FMT_RGB32:
722 s->chroma_planes = 1;
724 case AV_PIX_FMT_0RGB32:
726 s->chroma_planes = 1;
728 case AV_PIX_FMT_GBRP9:
729 if (!avctx->bits_per_raw_sample)
730 s->bits_per_raw_sample = 9;
731 case AV_PIX_FMT_GBRP10:
732 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
733 s->bits_per_raw_sample = 10;
734 case AV_PIX_FMT_GBRP12:
735 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
736 s->bits_per_raw_sample = 12;
737 case AV_PIX_FMT_GBRP14:
738 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
739 s->bits_per_raw_sample = 14;
740 else if (!s->bits_per_raw_sample)
741 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
743 s->chroma_planes = 1;
744 s->version = FFMAX(s->version, 1);
747 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
748 return AVERROR(ENOSYS);
750 if (s->transparency) {
751 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
753 if (avctx->context_model > 1U) {
754 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
755 return AVERROR(EINVAL);
759 for (i = 1; i < 256; i++)
760 s->state_transition[i] = ver2_state[i];
762 for (i = 0; i < 256; i++) {
763 s->quant_table_count = 2;
764 if (s->bits_per_raw_sample <= 8) {
765 s->quant_tables[0][0][i]= quant11[i];
766 s->quant_tables[0][1][i]= 11*quant11[i];
767 s->quant_tables[0][2][i]= 11*11*quant11[i];
768 s->quant_tables[1][0][i]= quant11[i];
769 s->quant_tables[1][1][i]= 11*quant11[i];
770 s->quant_tables[1][2][i]= 11*11*quant5 [i];
771 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
772 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
774 s->quant_tables[0][0][i]= quant9_10bit[i];
775 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
776 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
777 s->quant_tables[1][0][i]= quant9_10bit[i];
778 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
779 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
780 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
781 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
784 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
785 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
786 memcpy(s->quant_table, s->quant_tables[avctx->context_model],
787 sizeof(s->quant_table));
789 for (i = 0; i < s->plane_count; i++) {
790 PlaneContext *const p = &s->plane[i];
792 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
793 p->quant_table_index = avctx->context_model;
794 p->context_count = s->context_count[p->quant_table_index];
797 if ((ret = ffv1_allocate_initial_states(s)) < 0)
800 if (!s->transparency)
802 if (!s->chroma_planes && s->version > 3)
805 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
806 s->picture_number = 0;
808 if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
809 for (i = 0; i < s->quant_table_count; i++) {
810 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
811 sizeof(*s->rc_stat2[i]));
813 return AVERROR(ENOMEM);
816 if (avctx->stats_in) {
817 char *p = avctx->stats_in;
818 uint8_t best_state[256][256];
822 av_assert0(s->version >= 2);
825 for (j = 0; j < 256; j++)
826 for (i = 0; i < 2; i++) {
827 s->rc_stat[j][i] = strtol(p, &next, 0);
829 av_log(avctx, AV_LOG_ERROR,
830 "2Pass file invalid at %d %d [%s]\n", j, i, p);
831 return AVERROR_INVALIDDATA;
835 for (i = 0; i < s->quant_table_count; i++)
836 for (j = 0; j < s->context_count[i]; j++) {
837 for (k = 0; k < 32; k++)
838 for (m = 0; m < 2; m++) {
839 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
841 av_log(avctx, AV_LOG_ERROR,
842 "2Pass file invalid at %d %d %d %d [%s]\n",
844 return AVERROR_INVALIDDATA;
849 gob_count = strtol(p, &next, 0);
850 if (next == p || gob_count <= 0) {
851 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
852 return AVERROR_INVALIDDATA;
855 while (*p == '\n' || *p == ' ')
860 sort_stt(s, s->state_transition);
862 find_best_state(best_state, s->state_transition);
864 for (i = 0; i < s->quant_table_count; i++) {
865 for (k = 0; k < 32; k++) {
868 for (j = 0; j < s->context_count[i]; j++) {
870 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
872 p = 256.0 * b / (a + b);
873 s->initial_states[i][jp][k] =
874 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
875 for(jp++; jp<j; jp++)
876 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
879 a += s->rc_stat2[i][j][k][0];
880 b += s->rc_stat2[i][j][k][1];
882 p = 256.0 * b / (a + b);
884 s->initial_states[i][j][k] =
885 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
891 if (s->version > 1) {
892 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
893 for (; s->num_v_slices < 9; s->num_v_slices++) {
894 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
895 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
899 av_log(avctx, AV_LOG_ERROR,
900 "Unsupported number %d of slices requested, please specify a "
901 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
903 return AVERROR(ENOSYS);
908 if ((ret = ffv1_init_slice_contexts(s)) < 0)
910 if ((ret = ffv1_init_slices_state(s)) < 0)
913 #define STATS_OUT_SIZE 1024 * 1024 * 6
914 if (avctx->flags & CODEC_FLAG_PASS1) {
915 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
916 if (!avctx->stats_out)
917 return AVERROR(ENOMEM);
918 for (i = 0; i < s->quant_table_count; i++)
919 for (j = 0; j < s->slice_count; j++) {
920 FFV1Context *sf = s->slice_context[j];
921 av_assert0(!sf->rc_stat2[i]);
922 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
923 sizeof(*sf->rc_stat2[i]));
924 if (!sf->rc_stat2[i])
925 return AVERROR(ENOMEM);
932 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
934 RangeCoder *c = &fs->c;
935 uint8_t state[CONTEXT_SIZE];
937 memset(state, 128, sizeof(state));
939 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
940 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
941 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
942 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
943 for (j=0; j<f->plane_count; j++) {
944 put_symbol(c, state, f->plane[j].quant_table_index, 0);
945 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
947 if (!f->picture.f->interlaced_frame)
948 put_symbol(c, state, 3, 0);
950 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
951 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
952 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
955 static int encode_slice(AVCodecContext *c, void *arg)
957 FFV1Context *fs = *(void **)arg;
958 FFV1Context *f = fs->avctx->priv_data;
959 int width = fs->slice_width;
960 int height = fs->slice_height;
963 AVFrame *const p = f->picture.f;
964 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
967 ffv1_clear_slice_state(f, fs);
968 if (f->version > 2) {
969 encode_slice_header(f, fs);
973 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
974 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
975 init_put_bits(&fs->pb,
976 fs->c.bytestream_start + fs->ac_byte_count,
977 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
980 if (f->colorspace == 0) {
981 const int chroma_width = FF_CEIL_RSHIFT(width, f->chroma_h_shift);
982 const int chroma_height = FF_CEIL_RSHIFT(height, f->chroma_v_shift);
983 const int cx = x >> f->chroma_h_shift;
984 const int cy = y >> f->chroma_v_shift;
986 encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
988 if (f->chroma_planes) {
989 encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
990 encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
992 if (fs->transparency)
993 encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
995 uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
996 p->data[1] + ps*x + y*p->linesize[1],
997 p->data[2] + ps*x + y*p->linesize[2]};
998 encode_rgb_frame(fs, planes, width, height, p->linesize);
1005 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1006 const AVFrame *pict, int *got_packet)
1008 FFV1Context *f = avctx->priv_data;
1009 RangeCoder *const c = &f->slice_context[0]->c;
1010 AVFrame *const p = f->picture.f;
1012 uint8_t keystate = 128;
1016 if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1017 + FF_MIN_BUFFER_SIZE)) < 0)
1020 ff_init_range_encoder(c, pkt->data, pkt->size);
1021 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1024 if ((ret = av_frame_ref(p, pict)) < 0)
1026 p->pict_type = AV_PICTURE_TYPE_I;
1028 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1029 put_rac(c, &keystate, 1);
1034 put_rac(c, &keystate, 0);
1040 for (i = 1; i < 256; i++) {
1041 c->one_state[i] = f->state_transition[i];
1042 c->zero_state[256 - i] = 256 - c->one_state[i];
1046 for (i = 1; i < f->slice_count; i++) {
1047 FFV1Context *fs = f->slice_context[i];
1048 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1049 int len = pkt->size / f->slice_count;
1050 ff_init_range_encoder(&fs->c, start, len);
1052 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1053 f->slice_count, sizeof(void *));
1056 for (i = 0; i < f->slice_count; i++) {
1057 FFV1Context *fs = f->slice_context[i];
1061 uint8_t state = 129;
1062 put_rac(&fs->c, &state, 0);
1063 bytes = ff_rac_terminate(&fs->c);
1065 flush_put_bits(&fs->pb); // FIXME: nicer padding
1066 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1068 if (i > 0 || f->version > 2) {
1069 av_assert0(bytes < pkt->size / f->slice_count);
1070 memmove(buf_p, fs->c.bytestream_start, bytes);
1071 av_assert0(bytes < (1 << 24));
1072 AV_WB24(buf_p + bytes, bytes);
1078 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1079 AV_WL32(buf_p + bytes, v);
1085 if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
1087 char *p = avctx->stats_out;
1088 char *end = p + STATS_OUT_SIZE;
1090 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1091 for (i = 0; i < f->quant_table_count; i++)
1092 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1094 for (j = 0; j < f->slice_count; j++) {
1095 FFV1Context *fs = f->slice_context[j];
1096 for (i = 0; i < 256; i++) {
1097 f->rc_stat[i][0] += fs->rc_stat[i][0];
1098 f->rc_stat[i][1] += fs->rc_stat[i][1];
1100 for (i = 0; i < f->quant_table_count; i++) {
1101 for (k = 0; k < f->context_count[i]; k++)
1102 for (m = 0; m < 32; m++) {
1103 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1104 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1109 for (j = 0; j < 256; j++) {
1110 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1111 f->rc_stat[j][0], f->rc_stat[j][1]);
1114 snprintf(p, end - p, "\n");
1116 for (i = 0; i < f->quant_table_count; i++) {
1117 for (j = 0; j < f->context_count[i]; j++)
1118 for (m = 0; m < 32; m++) {
1119 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1120 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1124 snprintf(p, end - p, "%d\n", f->gob_count);
1125 } else if (avctx->flags & CODEC_FLAG_PASS1)
1126 avctx->stats_out[0] = '\0';
1128 f->picture_number++;
1129 pkt->size = buf_p - pkt->data;
1130 pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
1136 #define OFFSET(x) offsetof(FFV1Context, x)
1137 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1138 static const AVOption options[] = {
1139 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1143 static const AVClass ffv1_class = {
1144 .class_name = "ffv1 encoder",
1145 .item_name = av_default_item_name,
1147 .version = LIBAVUTIL_VERSION_INT,
1150 static const AVCodecDefault ffv1_defaults[] = {
1155 AVCodec ff_ffv1_encoder = {
1157 .type = AVMEDIA_TYPE_VIDEO,
1158 .id = AV_CODEC_ID_FFV1,
1159 .priv_data_size = sizeof(FFV1Context),
1160 .init = encode_init,
1161 .encode2 = encode_frame,
1162 .close = ffv1_close,
1163 .capabilities = CODEC_CAP_SLICE_THREADS,
1164 .pix_fmts = (const enum AVPixelFormat[]) {
1165 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1166 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1167 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1168 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1169 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1170 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1171 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1175 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1176 .defaults = ffv1_defaults,
1177 .priv_class = &ffv1_class,