lavc: AV-prefix all codec flags
[libav.git] / libavcodec / ffv1enc.c
CommitLineData
71f7b22d
LB
1/*
2 * FFV1 encoder for libavcodec
3 *
0f13cd31 4 * Copyright (c) 2003-2012 Michael Niedermayer <michaelni@gmx.at>
71f7b22d
LB
5 *
6 * This file is part of Libav.
7 *
8 * Libav 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.
12 *
13 * Libav 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.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23/**
24 * @file
25 * FF Video Codec 1 (a lossless codec) encoder
26 */
27
6fee1b90 28#include "libavutil/attributes.h"
71f7b22d 29#include "libavutil/avassert.h"
0f13cd31
LB
30#include "libavutil/pixdesc.h"
31#include "libavutil/crc.h"
32#include "libavutil/opt.h"
33#include "libavutil/imgutils.h"
71f7b22d 34#include "avcodec.h"
0f13cd31 35#include "internal.h"
71f7b22d
LB
36#include "get_bits.h"
37#include "put_bits.h"
71f7b22d
LB
38#include "rangecoder.h"
39#include "golomb.h"
40#include "mathops.h"
41#include "ffv1.h"
42
43static void find_best_state(uint8_t best_state[256][256],
44 const uint8_t one_state[256])
45{
46 int i, j, k, m;
47 double l2tab[256];
48
49 for (i = 1; i < 256; i++)
50 l2tab[i] = log2(i / 256.0);
51
52 for (i = 0; i < 256; i++) {
53 double best_len[256];
54 double p = i / 256.0;
55
56 for (j = 0; j < 256; j++)
57 best_len[j] = 1 << 30;
58
59 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
60 double occ[256] = { 0 };
61 double len = 0;
62 occ[j] = 1.0;
63 for (k = 0; k < 256; k++) {
64 double newocc[256] = { 0 };
0f13cd31 65 for (m = 1; m < 256; m++)
71f7b22d
LB
66 if (occ[m]) {
67 len -= occ[m] * (p * l2tab[m] +
68 (1 - p) * l2tab[256 - m]);
69 }
70 if (len < best_len[k]) {
71 best_len[k] = len;
72 best_state[i][k] = j;
73 }
6abe7eda 74 for (m = 1; m < 256; m++)
71f7b22d
LB
75 if (occ[m]) {
76 newocc[one_state[m]] += occ[m] * p;
77 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
78 }
79 memcpy(occ, newocc, sizeof(occ));
80 }
81 }
82 }
83}
84
85static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
86 uint8_t *state, int v,
87 int is_signed,
88 uint64_t rc_stat[256][2],
89 uint64_t rc_stat2[32][2])
90{
91 int i;
92
93#define put_rac(C, S, B) \
94 do { \
95 if (rc_stat) { \
96 rc_stat[*(S)][B]++; \
97 rc_stat2[(S) - state][B]++; \
98 } \
99 put_rac(C, S, B); \
100 } while (0)
101
102 if (v) {
103 const int a = FFABS(v);
104 const int e = av_log2(a);
105 put_rac(c, state + 0, 0);
106 if (e <= 9) {
107 for (i = 0; i < e; i++)
108 put_rac(c, state + 1 + i, 1); // 1..10
109 put_rac(c, state + 1 + i, 0);
110
111 for (i = e - 1; i >= 0; i--)
112 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
113
114 if (is_signed)
115 put_rac(c, state + 11 + e, v < 0); // 11..21
116 } else {
117 for (i = 0; i < e; i++)
118 put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
119 put_rac(c, state + 1 + 9, 0);
120
121 for (i = e - 1; i >= 0; i--)
122 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
123
124 if (is_signed)
125 put_rac(c, state + 11 + 10, v < 0); // 11..21
126 }
127 } else {
128 put_rac(c, state + 0, 1);
129 }
130#undef put_rac
131}
132
133static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
134 int v, int is_signed)
135{
136 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
137}
138
139static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
140 int v, int bits)
141{
142 int i, k, code;
143 v = fold(v - state->bias, bits);
144
145 i = state->count;
146 k = 0;
147 while (i < state->error_sum) { // FIXME: optimize
148 k++;
149 i += i;
150 }
151
0f13cd31 152 assert(k <= 13);
71f7b22d
LB
153
154#if 0 // JPEG LS
155 if (k == 0 && 2 * state->drift <= -state->count)
156 code = v ^ (-1);
157 else
158 code = v;
159#else
160 code = v ^ ((2 * state->drift + state->count) >> 31);
161#endif
162
6a85dfc8 163 ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
71f7b22d
LB
164 state->bias, state->error_sum, state->drift, state->count, k);
165 set_sr_golomb(pb, code, k, 12, bits);
166
167 update_vlc_state(state, v);
168}
169
170static av_always_inline int encode_line(FFV1Context *s, int w,
171 int16_t *sample[3],
172 int plane_index, int bits)
173{
174 PlaneContext *const p = &s->plane[plane_index];
175 RangeCoder *const c = &s->c;
176 int x;
177 int run_index = s->run_index;
178 int run_count = 0;
179 int run_mode = 0;
180
181 if (s->ac) {
182 if (c->bytestream_end - c->bytestream < w * 20) {
183 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4a2a4524 184 return AVERROR_INVALIDDATA;
71f7b22d
LB
185 }
186 } else {
187 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
188 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4a2a4524 189 return AVERROR_INVALIDDATA;
71f7b22d
LB
190 }
191 }
192
193 for (x = 0; x < w; x++) {
194 int diff, context;
195
196 context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
197 diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
198
199 if (context < 0) {
200 context = -context;
201 diff = -diff;
202 }
203
204 diff = fold(diff, bits);
205
206 if (s->ac) {
7c6eb0a1 207 if (s->flags & AV_CODEC_FLAG_PASS1) {
71f7b22d
LB
208 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
209 s->rc_stat2[p->quant_table_index][context]);
210 } else {
211 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
212 }
213 } else {
214 if (context == 0)
215 run_mode = 1;
216
217 if (run_mode) {
218 if (diff) {
219 while (run_count >= 1 << ff_log2_run[run_index]) {
220 run_count -= 1 << ff_log2_run[run_index];
221 run_index++;
222 put_bits(&s->pb, 1, 1);
223 }
224
225 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
226 if (run_index)
227 run_index--;
228 run_count = 0;
229 run_mode = 0;
230 if (diff > 0)
231 diff--;
232 } else {
233 run_count++;
234 }
235 }
236
6a85dfc8 237 ff_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
71f7b22d
LB
238 run_count, run_index, run_mode, x,
239 (int)put_bits_count(&s->pb));
240
241 if (run_mode == 0)
242 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
243 }
244 }
245 if (run_mode) {
246 while (run_count >= 1 << ff_log2_run[run_index]) {
247 run_count -= 1 << ff_log2_run[run_index];
248 run_index++;
249 put_bits(&s->pb, 1, 1);
250 }
251
252 if (run_count)
253 put_bits(&s->pb, 1, 1);
254 }
255 s->run_index = run_index;
256
257 return 0;
258}
259
260static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
261 int stride, int plane_index)
262{
263 int x, y, i;
264 const int ring_size = s->avctx->context_model ? 3 : 2;
265 int16_t *sample[3];
266 s->run_index = 0;
267
268 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
269
270 for (y = 0; y < h; y++) {
271 for (i = 0; i < ring_size; i++)
272 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
273
274 sample[0][-1] = sample[1][0];
275 sample[1][w] = sample[1][w - 1];
276// { START_TIMER
0f13cd31 277 if (s->bits_per_raw_sample <= 8) {
71f7b22d
LB
278 for (x = 0; x < w; x++)
279 sample[0][x] = src[x + stride * y];
280 encode_line(s, w, sample, plane_index, 8);
281 } else {
0f13cd31
LB
282 if (s->packed_at_lsb) {
283 for (x = 0; x < w; x++)
284 sample[0][x] = ((uint16_t *)(src + stride * y))[x];
285 } else {
286 for (x = 0; x < w; x++)
287 sample[0][x] =
288 ((uint16_t *)(src + stride * y))[x] >> (16 - s->bits_per_raw_sample);
289 }
290 encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
71f7b22d
LB
291 }
292// STOP_TIMER("encode line") }
293 }
294}
295
0352ff10
DB
296static void encode_rgb_frame(FFV1Context *s, const uint8_t *src[3],
297 int w, int h, const int stride[3])
71f7b22d
LB
298{
299 int x, y, p, i;
300 const int ring_size = s->avctx->context_model ? 3 : 2;
0f13cd31
LB
301 int16_t *sample[MAX_PLANES][3];
302 int lbd = s->avctx->bits_per_raw_sample <= 8;
303 int bits = s->avctx->bits_per_raw_sample > 0
304 ? s->avctx->bits_per_raw_sample
305 : 8;
306 int offset = 1 << bits;
307
71f7b22d
LB
308 s->run_index = 0;
309
0f13cd31
LB
310 memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
311 (w + 6) * sizeof(*s->sample_buffer));
71f7b22d
LB
312
313 for (y = 0; y < h; y++) {
314 for (i = 0; i < ring_size; i++)
0f13cd31
LB
315 for (p = 0; p < MAX_PLANES; p++)
316 sample[p][i] = s->sample_buffer + p * ring_size *
317 (w + 6) +
71f7b22d
LB
318 ((h + i - y) % ring_size) * (w + 6) + 3;
319
320 for (x = 0; x < w; x++) {
0f13cd31
LB
321 int b, g, r, av_uninit(a);
322 if (lbd) {
0352ff10 323 unsigned v = *((const uint32_t *)(src[0] + x * 4 + stride[0] * y));
0f13cd31
LB
324 b = v & 0xFF;
325 g = (v >> 8) & 0xFF;
326 r = (v >> 16) & 0xFF;
327 a = v >> 24;
328 } else {
0352ff10
DB
329 b = *((const uint16_t *)(src[0] + x * 2 + stride[0] * y));
330 g = *((const uint16_t *)(src[1] + x * 2 + stride[1] * y));
331 r = *((const uint16_t *)(src[2] + x * 2 + stride[2] * y));
0f13cd31 332 }
71f7b22d
LB
333
334 b -= g;
335 r -= g;
336 g += (b + r) >> 2;
0f13cd31
LB
337 b += offset;
338 r += offset;
71f7b22d
LB
339
340 sample[0][0][x] = g;
341 sample[1][0][x] = b;
342 sample[2][0][x] = r;
0f13cd31 343 sample[3][0][x] = a;
71f7b22d 344 }
0f13cd31 345 for (p = 0; p < 3 + s->transparency; p++) {
71f7b22d
LB
346 sample[p][0][-1] = sample[p][1][0];
347 sample[p][1][w] = sample[p][1][w - 1];
0f13cd31
LB
348 if (lbd)
349 encode_line(s, w, sample[p], (p + 1) / 2, 9);
350 else
351 encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
71f7b22d
LB
352 }
353 }
354}
355
0f13cd31 356
71f7b22d
LB
357static void write_quant_table(RangeCoder *c, int16_t *quant_table)
358{
359 int last = 0;
360 int i;
361 uint8_t state[CONTEXT_SIZE];
362 memset(state, 128, sizeof(state));
363
364 for (i = 1; i < 128; i++)
365 if (quant_table[i] != quant_table[i - 1]) {
366 put_symbol(c, state, i - last - 1, 0);
367 last = i;
368 }
369 put_symbol(c, state, i - last - 1, 0);
370}
371
372static void write_quant_tables(RangeCoder *c,
373 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
374{
375 int i;
376 for (i = 0; i < 5; i++)
377 write_quant_table(c, quant_table[i]);
378}
379
380static void write_header(FFV1Context *f)
381{
382 uint8_t state[CONTEXT_SIZE];
383 int i, j;
384 RangeCoder *const c = &f->slice_context[0]->c;
385
386 memset(state, 128, sizeof(state));
387
388 if (f->version < 2) {
389 put_symbol(c, state, f->version, 0);
390 put_symbol(c, state, f->ac, 0);
391 if (f->ac > 1) {
392 for (i = 1; i < 256; i++)
393 put_symbol(c, state,
394 f->state_transition[i] - c->one_state[i], 1);
395 }
396 put_symbol(c, state, f->colorspace, 0); // YUV cs type
397 if (f->version > 0)
0f13cd31
LB
398 put_symbol(c, state, f->bits_per_raw_sample, 0);
399 put_rac(c, state, f->chroma_planes);
71f7b22d
LB
400 put_symbol(c, state, f->chroma_h_shift, 0);
401 put_symbol(c, state, f->chroma_v_shift, 0);
0f13cd31 402 put_rac(c, state, f->transparency);
71f7b22d
LB
403
404 write_quant_tables(c, f->quant_table);
0f13cd31 405 } else if (f->version < 3) {
71f7b22d
LB
406 put_symbol(c, state, f->slice_count, 0);
407 for (i = 0; i < f->slice_count; i++) {
408 FFV1Context *fs = f->slice_context[i];
409 put_symbol(c, state,
410 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
411 put_symbol(c, state,
412 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
413 put_symbol(c, state,
414 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
415 0);
416 put_symbol(c, state,
417 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
418 0);
419 for (j = 0; j < f->plane_count; j++) {
420 put_symbol(c, state, f->plane[j].quant_table_index, 0);
421 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
422 }
423 }
424 }
425}
426
0f13cd31 427static int write_extradata(FFV1Context *f)
71f7b22d
LB
428{
429 RangeCoder *const c = &f->c;
430 uint8_t state[CONTEXT_SIZE];
431 int i, j, k;
432 uint8_t state2[32][CONTEXT_SIZE];
0f13cd31 433 unsigned v;
71f7b22d
LB
434
435 memset(state2, 128, sizeof(state2));
436 memset(state, 128, sizeof(state));
437
0f13cd31
LB
438 f->avctx->extradata_size = 10000 + 4 +
439 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
440 f->avctx->extradata = av_malloc(f->avctx->extradata_size);
71f7b22d
LB
441 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
442 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
443
444 put_symbol(c, state, f->version, 0);
0f13cd31
LB
445 if (f->version > 2) {
446 if (f->version == 3)
447 f->minor_version = 2;
448 put_symbol(c, state, f->minor_version, 0);
449 }
450
71f7b22d
LB
451 put_symbol(c, state, f->ac, 0);
452 if (f->ac > 1)
453 for (i = 1; i < 256; i++)
454 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
0f13cd31 455
71f7b22d 456 put_symbol(c, state, f->colorspace, 0); // YUV cs type
0f13cd31
LB
457 put_symbol(c, state, f->bits_per_raw_sample, 0);
458 put_rac(c, state, f->chroma_planes);
71f7b22d
LB
459 put_symbol(c, state, f->chroma_h_shift, 0);
460 put_symbol(c, state, f->chroma_v_shift, 0);
0f13cd31 461 put_rac(c, state, f->transparency);
71f7b22d
LB
462 put_symbol(c, state, f->num_h_slices - 1, 0);
463 put_symbol(c, state, f->num_v_slices - 1, 0);
464
465 put_symbol(c, state, f->quant_table_count, 0);
466 for (i = 0; i < f->quant_table_count; i++)
467 write_quant_tables(c, f->quant_tables[i]);
468
469 for (i = 0; i < f->quant_table_count; i++) {
470 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
471 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
472 break;
473 if (j < f->context_count[i] * CONTEXT_SIZE) {
474 put_rac(c, state, 1);
475 for (j = 0; j < f->context_count[i]; j++)
476 for (k = 0; k < CONTEXT_SIZE; k++) {
477 int pred = j ? f->initial_states[i][j - 1][k] : 128;
478 put_symbol(c, state2[k],
479 (int8_t)(f->initial_states[i][j][k] - pred), 1);
480 }
481 } else {
482 put_rac(c, state, 0);
483 }
484 }
485
0f13cd31
LB
486 if (f->version > 2) {
487 put_symbol(c, state, f->ec, 0);
488 }
489
71f7b22d
LB
490 f->avctx->extradata_size = ff_rac_terminate(c);
491
0f13cd31
LB
492 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0,
493 f->avctx->extradata, f->avctx->extradata_size);
494 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
495 f->avctx->extradata_size += 4;
496
71f7b22d
LB
497 return 0;
498}
499
500static int sort_stt(FFV1Context *s, uint8_t stt[256])
501{
502 int i, i2, changed, print = 0;
503
504 do {
505 changed = 0;
506 for (i = 12; i < 244; i++) {
507 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
508
509#define COST(old, new) \
510 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
511 s->rc_stat[old][1] * -log2((new) / 256.0)
512
513#define COST2(old, new) \
514 COST(old, new) + COST(256 - (old), 256 - (new))
515
516 double size0 = COST2(i, i) + COST2(i2, i2);
517 double sizeX = COST2(i, i2) + COST2(i2, i);
518 if (sizeX < size0 && i != 128 && i2 != 128) {
519 int j;
520 FFSWAP(int, stt[i], stt[i2]);
521 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
522 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
523 if (i != 256 - i2) {
524 FFSWAP(int, stt[256 - i], stt[256 - i2]);
525 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
526 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
527 }
528 for (j = 1; j < 256; j++) {
529 if (stt[j] == i)
530 stt[j] = i2;
531 else if (stt[j] == i2)
532 stt[j] = i;
533 if (i != 256 - i2) {
534 if (stt[256 - j] == 256 - i)
535 stt[256 - j] = 256 - i2;
536 else if (stt[256 - j] == 256 - i2)
537 stt[256 - j] = 256 - i;
538 }
539 }
540 print = changed = 1;
541 }
542 }
543 }
544 } while (changed);
545 return print;
546}
547
6fee1b90 548static av_cold int init_slices_state(FFV1Context *f)
0f13cd31
LB
549{
550 int i, ret;
551 for (i = 0; i < f->slice_count; i++) {
552 FFV1Context *fs = f->slice_context[i];
553 if ((ret = ffv1_init_slice_state(f, fs)) < 0)
554 return AVERROR(ENOMEM);
555 }
556 return 0;
557}
558
71f7b22d
LB
559static av_cold int ffv1_encode_init(AVCodecContext *avctx)
560{
561 FFV1Context *s = avctx->priv_data;
0f13cd31 562 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
4a2a4524 563 int i, j, k, m, ret;
71f7b22d
LB
564
565 ffv1_common_init(avctx);
566
567 s->version = 0;
0f13cd31 568
7c6eb0a1 569 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
0f13cd31
LB
570 avctx->slices > 1)
571 s->version = FFMAX(s->version, 2);
572
573 if (avctx->level == 3) {
574 s->version = 3;
575 }
576
577 if (s->ec < 0) {
578 s->ec = (s->version >= 3);
579 }
580
581 if (s->version >= 2 &&
582 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
583 av_log(avctx, AV_LOG_ERROR,
584 "Version %d requested, please set -strict experimental in "
585 "order to enable it\n",
586 s->version);
587 return AVERROR(ENOSYS);
588 }
589
590 s->ac = avctx->coder_type > 0 ? 2 : 0;
591
592 s->plane_count = 3;
593 switch (avctx->pix_fmt) {
594 case AV_PIX_FMT_YUV444P9:
595 case AV_PIX_FMT_YUV422P9:
596 case AV_PIX_FMT_YUV420P9:
597 if (!avctx->bits_per_raw_sample)
598 s->bits_per_raw_sample = 9;
599 case AV_PIX_FMT_YUV444P10:
600 case AV_PIX_FMT_YUV420P10:
601 case AV_PIX_FMT_YUV422P10:
602 s->packed_at_lsb = 1;
603 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
604 s->bits_per_raw_sample = 10;
605 case AV_PIX_FMT_GRAY16:
606 case AV_PIX_FMT_YUV444P16:
607 case AV_PIX_FMT_YUV422P16:
608 case AV_PIX_FMT_YUV420P16:
609 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
610 s->bits_per_raw_sample = 16;
611 } else if (!s->bits_per_raw_sample) {
612 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
613 }
614 if (s->bits_per_raw_sample <= 8) {
615 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
616 return AVERROR_INVALIDDATA;
617 }
618 if (!s->ac && avctx->coder_type == -1) {
619 av_log(avctx, AV_LOG_INFO,
620 "bits_per_raw_sample > 8, forcing coder 1\n");
621 s->ac = 2;
622 }
623 if (!s->ac) {
624 av_log(
625 avctx, AV_LOG_ERROR,
626 "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
627 return AVERROR_INVALIDDATA;
628 }
629 s->version = FFMAX(s->version, 1);
630 case AV_PIX_FMT_GRAY8:
631 case AV_PIX_FMT_YUV444P:
632 case AV_PIX_FMT_YUV440P:
633 case AV_PIX_FMT_YUV422P:
634 case AV_PIX_FMT_YUV420P:
635 case AV_PIX_FMT_YUV411P:
636 case AV_PIX_FMT_YUV410P:
637 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
638 s->colorspace = 0;
639 break;
640 case AV_PIX_FMT_YUVA444P:
641 case AV_PIX_FMT_YUVA422P:
642 case AV_PIX_FMT_YUVA420P:
643 s->chroma_planes = 1;
644 s->colorspace = 0;
645 s->transparency = 1;
646 break;
647 case AV_PIX_FMT_RGB32:
648 s->colorspace = 1;
649 s->transparency = 1;
650 break;
651 case AV_PIX_FMT_GBRP9:
652 if (!avctx->bits_per_raw_sample)
653 s->bits_per_raw_sample = 9;
654 case AV_PIX_FMT_GBRP10:
655 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
656 s->bits_per_raw_sample = 10;
657 case AV_PIX_FMT_GBRP16:
658 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
659 s->bits_per_raw_sample = 16;
660 else if (!s->bits_per_raw_sample)
661 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
662 s->colorspace = 1;
663 s->chroma_planes = 1;
664 s->version = FFMAX(s->version, 1);
665 break;
666 default:
667 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
668 return AVERROR_INVALIDDATA;
669 }
670 if (s->transparency) {
671 av_log(
672 avctx, AV_LOG_WARNING,
673 "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
674 }
675 if (avctx->context_model > 1U) {
676 av_log(avctx, AV_LOG_ERROR,
677 "Invalid context model %d, valid values are 0 and 1\n",
678 avctx->context_model);
679 return AVERROR(EINVAL);
680 }
71f7b22d
LB
681
682 if (s->ac > 1)
683 for (i = 1; i < 256; i++)
684 s->state_transition[i] = ffv1_ver2_state[i];
685
71f7b22d
LB
686 for (i = 0; i < 256; i++) {
687 s->quant_table_count = 2;
0f13cd31 688 if (s->bits_per_raw_sample <= 8) {
71f7b22d
LB
689 s->quant_tables[0][0][i] = ffv1_quant11[i];
690 s->quant_tables[0][1][i] = ffv1_quant11[i] * 11;
691 s->quant_tables[0][2][i] = ffv1_quant11[i] * 11 * 11;
692 s->quant_tables[1][0][i] = ffv1_quant11[i];
693 s->quant_tables[1][1][i] = ffv1_quant11[i] * 11;
694 s->quant_tables[1][2][i] = ffv1_quant5[i] * 11 * 11;
695 s->quant_tables[1][3][i] = ffv1_quant5[i] * 5 * 11 * 11;
696 s->quant_tables[1][4][i] = ffv1_quant5[i] * 5 * 5 * 11 * 11;
697 } else {
698 s->quant_tables[0][0][i] = ffv1_quant9_10bit[i];
699 s->quant_tables[0][1][i] = ffv1_quant9_10bit[i] * 11;
700 s->quant_tables[0][2][i] = ffv1_quant9_10bit[i] * 11 * 11;
701 s->quant_tables[1][0][i] = ffv1_quant9_10bit[i];
702 s->quant_tables[1][1][i] = ffv1_quant9_10bit[i] * 11;
703 s->quant_tables[1][2][i] = ffv1_quant5_10bit[i] * 11 * 11;
704 s->quant_tables[1][3][i] = ffv1_quant5_10bit[i] * 5 * 11 * 11;
705 s->quant_tables[1][4][i] = ffv1_quant5_10bit[i] * 5 * 5 * 11 * 11;
706 }
707 }
708 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
709 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
710 memcpy(s->quant_table, s->quant_tables[avctx->context_model],
711 sizeof(s->quant_table));
712
713 for (i = 0; i < s->plane_count; i++) {
714 PlaneContext *const p = &s->plane[i];
715
716 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
717 p->quant_table_index = avctx->context_model;
718 p->context_count = s->context_count[p->quant_table_index];
719 }
720
0f13cd31
LB
721 if ((ret = ffv1_allocate_initial_states(s)) < 0)
722 return ret;
71f7b22d 723
40cf1bba
VG
724#if FF_API_CODED_FRAME
725FF_DISABLE_DEPRECATION_WARNINGS
a6064b12 726 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
40cf1bba
VG
727FF_ENABLE_DEPRECATION_WARNINGS
728#endif
a6064b12 729
0f13cd31
LB
730 if (!s->transparency)
731 s->plane_count = 2;
732
c1a02e88
LB
733 av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift,
734 &s->chroma_v_shift);
71f7b22d
LB
735
736 s->picture_number = 0;
737
7c6eb0a1 738 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
71f7b22d
LB
739 for (i = 0; i < s->quant_table_count; i++) {
740 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
741 sizeof(*s->rc_stat2[i]));
742 if (!s->rc_stat2[i])
743 return AVERROR(ENOMEM);
744 }
745 }
746 if (avctx->stats_in) {
747 char *p = avctx->stats_in;
748 uint8_t best_state[256][256];
749 int gob_count = 0;
750 char *next;
751
752 av_assert0(s->version >= 2);
753
754 for (;; ) {
755 for (j = 0; j < 256; j++)
756 for (i = 0; i < 2; i++) {
757 s->rc_stat[j][i] = strtol(p, &next, 0);
758 if (next == p) {
759 av_log(avctx, AV_LOG_ERROR,
760 "2Pass file invalid at %d %d [%s]\n", j, i, p);
4a2a4524 761 return AVERROR_INVALIDDATA;
71f7b22d
LB
762 }
763 p = next;
764 }
765 for (i = 0; i < s->quant_table_count; i++)
766 for (j = 0; j < s->context_count[i]; j++) {
767 for (k = 0; k < 32; k++)
768 for (m = 0; m < 2; m++) {
769 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
770 if (next == p) {
771 av_log(avctx, AV_LOG_ERROR,
772 "2Pass file invalid at %d %d %d %d [%s]\n",
773 i, j, k, m, p);
4a2a4524 774 return AVERROR_INVALIDDATA;
71f7b22d
LB
775 }
776 p = next;
777 }
778 }
779 gob_count = strtol(p, &next, 0);
0f13cd31 780 if (next == p || gob_count <= 0) {
71f7b22d 781 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
4a2a4524 782 return AVERROR_INVALIDDATA;
71f7b22d
LB
783 }
784 p = next;
785 while (*p == '\n' || *p == ' ')
786 p++;
787 if (p[0] == 0)
788 break;
789 }
790 sort_stt(s, s->state_transition);
791
792 find_best_state(best_state, s->state_transition);
793
794 for (i = 0; i < s->quant_table_count; i++) {
795 for (j = 0; j < s->context_count[i]; j++)
796 for (k = 0; k < 32; k++) {
797 double p = 128;
798 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1]) {
799 p = 256.0 * s->rc_stat2[i][j][k][1] /
800 (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1]);
801 }
802 s->initial_states[i][j][k] =
803 best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0] +
804 s->rc_stat2[i][j][k][1]) /
805 gob_count, 0, 255)];
806 }
807 }
808 }
809
810 if (s->version > 1) {
0f13cd31
LB
811 for (s->num_v_slices = 2; s->num_v_slices < 9; s->num_v_slices++)
812 for (s->num_h_slices = s->num_v_slices;
813 s->num_h_slices < 2 * s->num_v_slices; s->num_h_slices++)
814 if (avctx->slices == s->num_h_slices * s->num_v_slices &&
815 avctx->slices <= 64 || !avctx->slices)
816 goto slices_ok;
817 av_log(avctx, AV_LOG_ERROR,
818 "Unsupported number %d of slices requested, please specify a "
819 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
820 avctx->slices);
821 return AVERROR(ENOSYS);
822slices_ok:
823 write_extradata(s);
71f7b22d
LB
824 }
825
4a2a4524
LB
826 if ((ret = ffv1_init_slice_contexts(s)) < 0)
827 return ret;
0f13cd31 828 if ((ret = init_slices_state(s)) < 0)
4a2a4524 829 return ret;
71f7b22d
LB
830
831#define STATS_OUT_SIZE 1024 * 1024 * 6
7c6eb0a1 832 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
71f7b22d
LB
833 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
834 for (i = 0; i < s->quant_table_count; i++)
835 for (j = 0; j < s->slice_count; j++) {
836 FFV1Context *sf = s->slice_context[j];
837 av_assert0(!sf->rc_stat2[i]);
838 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
839 sizeof(*sf->rc_stat2[i]));
840 if (!sf->rc_stat2[i])
841 return AVERROR(ENOMEM);
842 }
843 }
844
845 return 0;
846}
847
0f13cd31
LB
848static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
849{
850 RangeCoder *c = &fs->c;
851 uint8_t state[CONTEXT_SIZE];
852 int j;
853 memset(state, 128, sizeof(state));
854
855 put_symbol(c, state, (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
856 put_symbol(c, state, (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
857 put_symbol(c, state, (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
858 0);
859 put_symbol(c, state,
860 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
861 0);
862 for (j = 0; j < f->plane_count; j++) {
863 put_symbol(c, state, f->plane[j].quant_table_index, 0);
864 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
865 }
75c1ed2e 866 if (!f->frame->interlaced_frame)
0f13cd31
LB
867 put_symbol(c, state, 3, 0);
868 else
75c1ed2e
VG
869 put_symbol(c, state, 1 + !f->frame->top_field_first, 0);
870 put_symbol(c, state, f->frame->sample_aspect_ratio.num, 0);
871 put_symbol(c, state, f->frame->sample_aspect_ratio.den, 0);
0f13cd31
LB
872}
873
71f7b22d
LB
874static int encode_slice(AVCodecContext *c, void *arg)
875{
876 FFV1Context *fs = *(void **)arg;
877 FFV1Context *f = fs->avctx->priv_data;
878 int width = fs->slice_width;
879 int height = fs->slice_height;
880 int x = fs->slice_x;
881 int y = fs->slice_y;
a6064b12 882 const AVFrame *const p = f->frame;
e6c4ac7b 883 const int ps = (av_pix_fmt_desc_get(c->pix_fmt)->flags & AV_PIX_FMT_FLAG_PLANAR)
0f13cd31
LB
884 ? (f->bits_per_raw_sample > 8) + 1
885 : 4;
886
10a9149d 887 if (f->key_frame)
0f13cd31
LB
888 ffv1_clear_slice_state(f, fs);
889 if (f->version > 2) {
890 encode_slice_header(f, fs);
891 }
892 if (!fs->ac) {
893 if (f->version > 2)
894 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
895 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate( &fs->c) : 0;
896 init_put_bits(&fs->pb, fs->c.bytestream_start + fs->ac_byte_count,
897 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
898 }
71f7b22d
LB
899
900 if (f->colorspace == 0) {
901 const int chroma_width = -((-width) >> f->chroma_h_shift);
902 const int chroma_height = -((-height) >> f->chroma_v_shift);
903 const int cx = x >> f->chroma_h_shift;
904 const int cy = y >> f->chroma_v_shift;
905
0f13cd31 906 encode_plane(fs, p->data[0] + ps * x + y * p->linesize[0],
71f7b22d
LB
907 width, height, p->linesize[0], 0);
908
0f13cd31
LB
909 if (f->chroma_planes) {
910 encode_plane(fs, p->data[1] + ps * cx + cy * p->linesize[1],
911 chroma_width, chroma_height, p->linesize[1], 1);
912 encode_plane(fs, p->data[2] + ps * cx + cy * p->linesize[2],
913 chroma_width, chroma_height, p->linesize[2], 1);
914 }
915 if (fs->transparency)
916 encode_plane(fs, p->data[3] + ps * x + y * p->linesize[3], width,
917 height, p->linesize[3], 2);
71f7b22d 918 } else {
0352ff10
DB
919 const uint8_t *planes[3] = { p->data[0] + ps * x + y * p->linesize[0],
920 p->data[1] + ps * x + y * p->linesize[1],
921 p->data[2] + ps * x + y * p->linesize[2] };
0f13cd31 922 encode_rgb_frame(fs, planes, width, height, p->linesize);
71f7b22d
LB
923 }
924 emms_c();
925
926 return 0;
927}
928
929static int ffv1_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
0f13cd31 930 const AVFrame *pict, int *got_packet)
71f7b22d
LB
931{
932 FFV1Context *f = avctx->priv_data;
933 RangeCoder *const c = &f->slice_context[0]->c;
71f7b22d
LB
934 int used_count = 0;
935 uint8_t keystate = 128;
936 uint8_t *buf_p;
937 int i, ret;
938
a6064b12
AK
939 f->frame = pict;
940
0f13cd31
LB
941 if ((ret = ff_alloc_packet(pkt, avctx->width * avctx->height *
942 ((8 * 2 + 1 + 1) * 4) / 8 +
943 FF_MIN_BUFFER_SIZE)) < 0) {
71f7b22d
LB
944 av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
945 return ret;
946 }
947
948 ff_init_range_encoder(c, pkt->data, pkt->size);
949 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
950
71f7b22d
LB
951 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
952 put_rac(c, &keystate, 1);
10a9149d 953 f->key_frame = 1;
71f7b22d
LB
954 f->gob_count++;
955 write_header(f);
71f7b22d
LB
956 } else {
957 put_rac(c, &keystate, 0);
10a9149d 958 f->key_frame = 0;
71f7b22d
LB
959 }
960
0f13cd31 961 if (f->ac > 1) {
71f7b22d
LB
962 int i;
963 for (i = 1; i < 256; i++) {
964 c->one_state[i] = f->state_transition[i];
965 c->zero_state[256 - i] = 256 - c->one_state[i];
966 }
967 }
968
969 for (i = 1; i < f->slice_count; i++) {
970 FFV1Context *fs = f->slice_context[i];
0f13cd31
LB
971 uint8_t *start = pkt->data +
972 (pkt->size - used_count) * (int64_t)i / f->slice_count;
973 int len = pkt->size / f->slice_count;
974 ff_init_range_encoder(&fs->c, start, len);
71f7b22d
LB
975 }
976 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
977 f->slice_count, sizeof(void *));
978
979 buf_p = pkt->data;
980 for (i = 0; i < f->slice_count; i++) {
981 FFV1Context *fs = f->slice_context[i];
982 int bytes;
983
984 if (fs->ac) {
0f13cd31 985 uint8_t state = 129;
71f7b22d
LB
986 put_rac(&fs->c, &state, 0);
987 bytes = ff_rac_terminate(&fs->c);
988 } else {
989 flush_put_bits(&fs->pb); // FIXME: nicer padding
0f13cd31 990 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
71f7b22d 991 }
0f13cd31 992 if (i > 0 || f->version > 2) {
71f7b22d 993 av_assert0(bytes < pkt->size / f->slice_count);
0f13cd31 994 memmove(buf_p, fs->c.bytestream_start, bytes);
71f7b22d
LB
995 av_assert0(bytes < (1 << 24));
996 AV_WB24(buf_p + bytes, bytes);
997 bytes += 3;
998 }
0f13cd31
LB
999 if (f->ec) {
1000 unsigned v;
1001 buf_p[bytes++] = 0;
1002 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1003 AV_WL32(buf_p + bytes, v);
1004 bytes += 4;
1005 }
71f7b22d
LB
1006 buf_p += bytes;
1007 }
1008
7c6eb0a1 1009 if ((avctx->flags & AV_CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
71f7b22d
LB
1010 int j, k, m;
1011 char *p = avctx->stats_out;
1012 char *end = p + STATS_OUT_SIZE;
1013
1014 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1015 for (i = 0; i < f->quant_table_count; i++)
1016 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1017
1018 for (j = 0; j < f->slice_count; j++) {
1019 FFV1Context *fs = f->slice_context[j];
1020 for (i = 0; i < 256; i++) {
1021 f->rc_stat[i][0] += fs->rc_stat[i][0];
1022 f->rc_stat[i][1] += fs->rc_stat[i][1];
1023 }
1024 for (i = 0; i < f->quant_table_count; i++) {
1025 for (k = 0; k < f->context_count[i]; k++)
1026 for (m = 0; m < 32; m++) {
1027 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1028 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1029 }
1030 }
1031 }
1032
1033 for (j = 0; j < 256; j++) {
1034 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1035 f->rc_stat[j][0], f->rc_stat[j][1]);
1036 p += strlen(p);
1037 }
1038 snprintf(p, end - p, "\n");
1039
1040 for (i = 0; i < f->quant_table_count; i++) {
1041 for (j = 0; j < f->context_count[i]; j++)
1042 for (m = 0; m < 32; m++) {
1043 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1044 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1045 p += strlen(p);
1046 }
1047 }
1048 snprintf(p, end - p, "%d\n", f->gob_count);
7c6eb0a1 1049 } else if (avctx->flags & AV_CODEC_FLAG_PASS1)
71f7b22d
LB
1050 avctx->stats_out[0] = '\0';
1051
40cf1bba
VG
1052#if FF_API_CODED_FRAME
1053FF_DISABLE_DEPRECATION_WARNINGS
10a9149d 1054 avctx->coded_frame->key_frame = f->key_frame;
40cf1bba
VG
1055FF_ENABLE_DEPRECATION_WARNINGS
1056#endif
10a9149d 1057
71f7b22d
LB
1058 f->picture_number++;
1059 pkt->size = buf_p - pkt->data;
10a9149d 1060 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
71f7b22d
LB
1061 *got_packet = 1;
1062
1063 return 0;
1064}
1065
a6064b12
AK
1066static av_cold int ffv1_encode_close(AVCodecContext *avctx)
1067{
a6064b12
AK
1068 ffv1_close(avctx);
1069 return 0;
1070}
1071
0f13cd31
LB
1072#define OFFSET(x) offsetof(FFV1Context, x)
1073#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1074static const AVOption options[] = {
1075 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT,
1076 { .i64 = -1 }, -1, 1, VE },
1077 { NULL }
1078};
1079
1080static const AVClass class = {
1081 .class_name = "ffv1 encoder",
1082 .item_name = av_default_item_name,
1083 .option = options,
1084 .version = LIBAVUTIL_VERSION_INT,
1085};
1086
1087static const AVCodecDefault ffv1_defaults[] = {
1088 { "coder", "-1" },
1089 { NULL },
1090};
1091
71f7b22d
LB
1092AVCodec ff_ffv1_encoder = {
1093 .name = "ffv1",
b2bed932 1094 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
71f7b22d
LB
1095 .type = AVMEDIA_TYPE_VIDEO,
1096 .id = AV_CODEC_ID_FFV1,
1097 .priv_data_size = sizeof(FFV1Context),
1098 .init = ffv1_encode_init,
1099 .encode2 = ffv1_encode_frame,
a6064b12 1100 .close = ffv1_encode_close,
71f7b22d
LB
1101 .capabilities = CODEC_CAP_SLICE_THREADS,
1102 .pix_fmts = (const enum AVPixelFormat[]) {
1103 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
1104 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
0f13cd31
LB
1105 AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
1106 AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
71f7b22d
LB
1107 AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
1108 AV_PIX_FMT_RGB32,
0f13cd31
LB
1109 AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1110 AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
1111 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8,
71f7b22d 1112 AV_PIX_FMT_NONE
0f13cd31 1113
71f7b22d 1114 },
0f13cd31
LB
1115 .defaults = ffv1_defaults,
1116 .priv_class = &class,
71f7b22d 1117};