summaryrefslogtreecommitdiff
path: root/libavcodec/ffv1enc.c (plain)
blob: 7f31606775e4a1b3770278833cbd865ef0d14678
1/*
2 * FFV1 encoder
3 *
4 * Copyright (c) 2003-2013 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * This file is part of FFmpeg.
7 *
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.
12 *
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.
17 *
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
21 */
22
23/**
24 * @file
25 * FF Video Codec 1 (a lossless codec) encoder
26 */
27
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"
35
36#include "avcodec.h"
37#include "internal.h"
38#include "put_bits.h"
39#include "rangecoder.h"
40#include "golomb.h"
41#include "mathops.h"
42#include "ffv1.h"
43
44static const int8_t quant5_10bit[256] = {
45 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
48 1, 1, 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, -2,
57 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
60 -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
61};
62
63static const int8_t quant5[256] = {
64 0, 1, 1, 1, 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, -2, -2, -2,
79 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
80};
81
82static const int8_t quant9_10bit[256] = {
83 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
84 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
85 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
86 3, 3, 3, 3, 3, 3, 3, 3, 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, -4, -4, -4, -4, -4, -4, -4,
95 -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
96 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
97 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
98 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
99};
100
101static const int8_t quant11[256] = {
102 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
103 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
104 4, 4, 4, 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, -5, -5,
115 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
116 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
117 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
118};
119
120static const uint8_t ver2_state[256] = {
121 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
122 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
123 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
124 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
125 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
126 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
127 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
128 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
129 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
130 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
131 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
132 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
133 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
134 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
135 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
136 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
137};
138
139static void find_best_state(uint8_t best_state[256][256],
140 const uint8_t one_state[256])
141{
142 int i, j, k, m;
143 double l2tab[256];
144
145 for (i = 1; i < 256; i++)
146 l2tab[i] = log2(i / 256.0);
147
148 for (i = 0; i < 256; i++) {
149 double best_len[256];
150 double p = i / 256.0;
151
152 for (j = 0; j < 256; j++)
153 best_len[j] = 1 << 30;
154
155 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
156 double occ[256] = { 0 };
157 double len = 0;
158 occ[j] = 1.0;
159
160 if (!one_state[j])
161 continue;
162
163 for (k = 0; k < 256; k++) {
164 double newocc[256] = { 0 };
165 for (m = 1; m < 256; m++)
166 if (occ[m]) {
167 len -=occ[m]*( p *l2tab[ m]
168 + (1-p)*l2tab[256-m]);
169 }
170 if (len < best_len[k]) {
171 best_len[k] = len;
172 best_state[i][k] = j;
173 }
174 for (m = 1; m < 256; m++)
175 if (occ[m]) {
176 newocc[ one_state[ m]] += occ[m] * p;
177 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
178 }
179 memcpy(occ, newocc, sizeof(occ));
180 }
181 }
182 }
183}
184
185static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
186 uint8_t *state, int v,
187 int is_signed,
188 uint64_t rc_stat[256][2],
189 uint64_t rc_stat2[32][2])
190{
191 int i;
192
193#define put_rac(C, S, B) \
194 do { \
195 if (rc_stat) { \
196 rc_stat[*(S)][B]++; \
197 rc_stat2[(S) - state][B]++; \
198 } \
199 put_rac(C, S, B); \
200 } while (0)
201
202 if (v) {
203 const int a = FFABS(v);
204 const int e = av_log2(a);
205 put_rac(c, state + 0, 0);
206 if (e <= 9) {
207 for (i = 0; i < e; i++)
208 put_rac(c, state + 1 + i, 1); // 1..10
209 put_rac(c, state + 1 + i, 0);
210
211 for (i = e - 1; i >= 0; i--)
212 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
213
214 if (is_signed)
215 put_rac(c, state + 11 + e, v < 0); // 11..21
216 } else {
217 for (i = 0; i < e; i++)
218 put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
219 put_rac(c, state + 1 + 9, 0);
220
221 for (i = e - 1; i >= 0; i--)
222 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
223
224 if (is_signed)
225 put_rac(c, state + 11 + 10, v < 0); // 11..21
226 }
227 } else {
228 put_rac(c, state + 0, 1);
229 }
230#undef put_rac
231}
232
233static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
234 int v, int is_signed)
235{
236 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
237}
238
239
240static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
241 int v, int bits)
242{
243 int i, k, code;
244 v = fold(v - state->bias, bits);
245
246 i = state->count;
247 k = 0;
248 while (i < state->error_sum) { // FIXME: optimize
249 k++;
250 i += i;
251 }
252
253 av_assert2(k <= 13);
254
255 code = v ^ ((2 * state->drift + state->count) >> 31);
256
257 ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
258 state->bias, state->error_sum, state->drift, state->count, k);
259 set_sr_golomb(pb, code, k, 12, bits);
260
261 update_vlc_state(state, v);
262}
263
264#define TYPE int16_t
265#define RENAME(name) name
266#include "ffv1enc_template.c"
267#undef TYPE
268#undef RENAME
269
270#define TYPE int32_t
271#define RENAME(name) name ## 32
272#include "ffv1enc_template.c"
273
274static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
275 int stride, int plane_index, int pixel_stride)
276{
277 int x, y, i, ret;
278 const int ring_size = s->context_model ? 3 : 2;
279 int16_t *sample[3];
280 s->run_index = 0;
281
282 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
283
284 for (y = 0; y < h; y++) {
285 for (i = 0; i < ring_size; i++)
286 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
287
288 sample[0][-1]= sample[1][0 ];
289 sample[1][ w]= sample[1][w-1];
290// { START_TIMER
291 if (s->bits_per_raw_sample <= 8) {
292 for (x = 0; x < w; x++)
293 sample[0][x] = src[x * pixel_stride + stride * y];
294 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
295 return ret;
296 } else {
297 if (s->packed_at_lsb) {
298 for (x = 0; x < w; x++) {
299 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
300 }
301 } else {
302 for (x = 0; x < w; x++) {
303 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
304 }
305 }
306 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
307 return ret;
308 }
309// STOP_TIMER("encode line") }
310 }
311 return 0;
312}
313
314static void write_quant_table(RangeCoder *c, int16_t *quant_table)
315{
316 int last = 0;
317 int i;
318 uint8_t state[CONTEXT_SIZE];
319 memset(state, 128, sizeof(state));
320
321 for (i = 1; i < 128; i++)
322 if (quant_table[i] != quant_table[i - 1]) {
323 put_symbol(c, state, i - last - 1, 0);
324 last = i;
325 }
326 put_symbol(c, state, i - last - 1, 0);
327}
328
329static void write_quant_tables(RangeCoder *c,
330 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
331{
332 int i;
333 for (i = 0; i < 5; i++)
334 write_quant_table(c, quant_table[i]);
335}
336
337static void write_header(FFV1Context *f)
338{
339 uint8_t state[CONTEXT_SIZE];
340 int i, j;
341 RangeCoder *const c = &f->slice_context[0]->c;
342
343 memset(state, 128, sizeof(state));
344
345 if (f->version < 2) {
346 put_symbol(c, state, f->version, 0);
347 put_symbol(c, state, f->ac, 0);
348 if (f->ac == AC_RANGE_CUSTOM_TAB) {
349 for (i = 1; i < 256; i++)
350 put_symbol(c, state,
351 f->state_transition[i] - c->one_state[i], 1);
352 }
353 put_symbol(c, state, f->colorspace, 0); //YUV cs type
354 if (f->version > 0)
355 put_symbol(c, state, f->bits_per_raw_sample, 0);
356 put_rac(c, state, f->chroma_planes);
357 put_symbol(c, state, f->chroma_h_shift, 0);
358 put_symbol(c, state, f->chroma_v_shift, 0);
359 put_rac(c, state, f->transparency);
360
361 write_quant_tables(c, f->quant_table);
362 } else if (f->version < 3) {
363 put_symbol(c, state, f->slice_count, 0);
364 for (i = 0; i < f->slice_count; i++) {
365 FFV1Context *fs = f->slice_context[i];
366 put_symbol(c, state,
367 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
368 put_symbol(c, state,
369 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
370 put_symbol(c, state,
371 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
372 0);
373 put_symbol(c, state,
374 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
375 0);
376 for (j = 0; j < f->plane_count; j++) {
377 put_symbol(c, state, f->plane[j].quant_table_index, 0);
378 av_assert0(f->plane[j].quant_table_index == f->context_model);
379 }
380 }
381 }
382}
383
384static int write_extradata(FFV1Context *f)
385{
386 RangeCoder *const c = &f->c;
387 uint8_t state[CONTEXT_SIZE];
388 int i, j, k;
389 uint8_t state2[32][CONTEXT_SIZE];
390 unsigned v;
391
392 memset(state2, 128, sizeof(state2));
393 memset(state, 128, sizeof(state));
394
395 f->avctx->extradata_size = 10000 + 4 +
396 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
397 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
398 if (!f->avctx->extradata)
399 return AVERROR(ENOMEM);
400 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
401 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
402
403 put_symbol(c, state, f->version, 0);
404 if (f->version > 2) {
405 if (f->version == 3) {
406 f->micro_version = 4;
407 } else if (f->version == 4)
408 f->micro_version = 2;
409 put_symbol(c, state, f->micro_version, 0);
410 }
411
412 put_symbol(c, state, f->ac, 0);
413 if (f->ac == AC_RANGE_CUSTOM_TAB)
414 for (i = 1; i < 256; i++)
415 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
416
417 put_symbol(c, state, f->colorspace, 0); // YUV cs type
418 put_symbol(c, state, f->bits_per_raw_sample, 0);
419 put_rac(c, state, f->chroma_planes);
420 put_symbol(c, state, f->chroma_h_shift, 0);
421 put_symbol(c, state, f->chroma_v_shift, 0);
422 put_rac(c, state, f->transparency);
423 put_symbol(c, state, f->num_h_slices - 1, 0);
424 put_symbol(c, state, f->num_v_slices - 1, 0);
425
426 put_symbol(c, state, f->quant_table_count, 0);
427 for (i = 0; i < f->quant_table_count; i++)
428 write_quant_tables(c, f->quant_tables[i]);
429
430 for (i = 0; i < f->quant_table_count; i++) {
431 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
432 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
433 break;
434 if (j < f->context_count[i] * CONTEXT_SIZE) {
435 put_rac(c, state, 1);
436 for (j = 0; j < f->context_count[i]; j++)
437 for (k = 0; k < CONTEXT_SIZE; k++) {
438 int pred = j ? f->initial_states[i][j - 1][k] : 128;
439 put_symbol(c, state2[k],
440 (int8_t)(f->initial_states[i][j][k] - pred), 1);
441 }
442 } else {
443 put_rac(c, state, 0);
444 }
445 }
446
447 if (f->version > 2) {
448 put_symbol(c, state, f->ec, 0);
449 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
450 }
451
452 f->avctx->extradata_size = ff_rac_terminate(c);
453 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
454 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
455 f->avctx->extradata_size += 4;
456
457 return 0;
458}
459
460static int sort_stt(FFV1Context *s, uint8_t stt[256])
461{
462 int i, i2, changed, print = 0;
463
464 do {
465 changed = 0;
466 for (i = 12; i < 244; i++) {
467 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
468
469#define COST(old, new) \
470 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
471 s->rc_stat[old][1] * -log2((new) / 256.0)
472
473#define COST2(old, new) \
474 COST(old, new) + COST(256 - (old), 256 - (new))
475
476 double size0 = COST2(i, i) + COST2(i2, i2);
477 double sizeX = COST2(i, i2) + COST2(i2, i);
478 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
479 int j;
480 FFSWAP(int, stt[i], stt[i2]);
481 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
482 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
483 if (i != 256 - i2) {
484 FFSWAP(int, stt[256 - i], stt[256 - i2]);
485 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
486 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
487 }
488 for (j = 1; j < 256; j++) {
489 if (stt[j] == i)
490 stt[j] = i2;
491 else if (stt[j] == i2)
492 stt[j] = i;
493 if (i != 256 - i2) {
494 if (stt[256 - j] == 256 - i)
495 stt[256 - j] = 256 - i2;
496 else if (stt[256 - j] == 256 - i2)
497 stt[256 - j] = 256 - i;
498 }
499 }
500 print = changed = 1;
501 }
502 }
503 }
504 } while (changed);
505 return print;
506}
507
508static av_cold int encode_init(AVCodecContext *avctx)
509{
510 FFV1Context *s = avctx->priv_data;
511 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
512 int i, j, k, m, ret;
513
514 if ((ret = ff_ffv1_common_init(avctx)) < 0)
515 return ret;
516
517 s->version = 0;
518
519 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
520 avctx->slices > 1)
521 s->version = FFMAX(s->version, 2);
522
523 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
524 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
525 s->version = FFMAX(s->version, 2);
526
527 if (avctx->level <= 0 && s->version == 2) {
528 s->version = 3;
529 }
530 if (avctx->level >= 0 && avctx->level <= 4) {
531 if (avctx->level < s->version) {
532 av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
533 return AVERROR(EINVAL);
534 }
535 s->version = avctx->level;
536 }
537
538 if (s->ec < 0) {
539 s->ec = (s->version >= 3);
540 }
541
542 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
543 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
544 return AVERROR_INVALIDDATA;
545 }
546
547#if FF_API_CODER_TYPE
548FF_DISABLE_DEPRECATION_WARNINGS
549 if (avctx->coder_type != -1)
550 s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
551 else
552FF_ENABLE_DEPRECATION_WARNINGS
553#endif
554 if (s->ac == 1) // Compatbility with common command line usage
555 s->ac = AC_RANGE_CUSTOM_TAB;
556 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
557 s->ac = AC_RANGE_DEFAULT_TAB;
558
559 s->plane_count = 3;
560 switch(avctx->pix_fmt) {
561 case AV_PIX_FMT_YUV444P9:
562 case AV_PIX_FMT_YUV422P9:
563 case AV_PIX_FMT_YUV420P9:
564 case AV_PIX_FMT_YUVA444P9:
565 case AV_PIX_FMT_YUVA422P9:
566 case AV_PIX_FMT_YUVA420P9:
567 if (!avctx->bits_per_raw_sample)
568 s->bits_per_raw_sample = 9;
569 case AV_PIX_FMT_GRAY10:
570 case AV_PIX_FMT_YUV444P10:
571 case AV_PIX_FMT_YUV420P10:
572 case AV_PIX_FMT_YUV422P10:
573 case AV_PIX_FMT_YUVA444P10:
574 case AV_PIX_FMT_YUVA422P10:
575 case AV_PIX_FMT_YUVA420P10:
576 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
577 s->bits_per_raw_sample = 10;
578 case AV_PIX_FMT_GRAY12:
579 case AV_PIX_FMT_YUV444P12:
580 case AV_PIX_FMT_YUV420P12:
581 case AV_PIX_FMT_YUV422P12:
582 s->packed_at_lsb = 1;
583 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
584 s->bits_per_raw_sample = 12;
585 case AV_PIX_FMT_GRAY16:
586 case AV_PIX_FMT_YUV444P16:
587 case AV_PIX_FMT_YUV422P16:
588 case AV_PIX_FMT_YUV420P16:
589 case AV_PIX_FMT_YUVA444P16:
590 case AV_PIX_FMT_YUVA422P16:
591 case AV_PIX_FMT_YUVA420P16:
592 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
593 s->bits_per_raw_sample = 16;
594 } else if (!s->bits_per_raw_sample) {
595 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
596 }
597 if (s->bits_per_raw_sample <= 8) {
598 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
599 return AVERROR_INVALIDDATA;
600 }
601 s->version = FFMAX(s->version, 1);
602 case AV_PIX_FMT_GRAY8:
603 case AV_PIX_FMT_YA8:
604 case AV_PIX_FMT_YUV444P:
605 case AV_PIX_FMT_YUV440P:
606 case AV_PIX_FMT_YUV422P:
607 case AV_PIX_FMT_YUV420P:
608 case AV_PIX_FMT_YUV411P:
609 case AV_PIX_FMT_YUV410P:
610 case AV_PIX_FMT_YUVA444P:
611 case AV_PIX_FMT_YUVA422P:
612 case AV_PIX_FMT_YUVA420P:
613 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
614 s->colorspace = 0;
615 s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
616 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
617 s->bits_per_raw_sample = 8;
618 else if (!s->bits_per_raw_sample)
619 s->bits_per_raw_sample = 8;
620 break;
621 case AV_PIX_FMT_RGB32:
622 s->colorspace = 1;
623 s->transparency = 1;
624 s->chroma_planes = 1;
625 s->bits_per_raw_sample = 8;
626 break;
627 case AV_PIX_FMT_RGB48:
628 s->colorspace = 1;
629 s->chroma_planes = 1;
630 s->bits_per_raw_sample = 16;
631 s->use32bit = 1;
632 s->version = FFMAX(s->version, 1);
633 if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
634 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
635 return AVERROR_INVALIDDATA;
636 }
637 break;
638 case AV_PIX_FMT_0RGB32:
639 s->colorspace = 1;
640 s->chroma_planes = 1;
641 s->bits_per_raw_sample = 8;
642 break;
643 case AV_PIX_FMT_GBRP9:
644 if (!avctx->bits_per_raw_sample)
645 s->bits_per_raw_sample = 9;
646 case AV_PIX_FMT_GBRP10:
647 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
648 s->bits_per_raw_sample = 10;
649 case AV_PIX_FMT_GBRP12:
650 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
651 s->bits_per_raw_sample = 12;
652 case AV_PIX_FMT_GBRP14:
653 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
654 s->bits_per_raw_sample = 14;
655 case AV_PIX_FMT_GBRP16:
656 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
657 s->bits_per_raw_sample = 16;
658 else if (!s->bits_per_raw_sample)
659 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
660 s->colorspace = 1;
661 s->chroma_planes = 1;
662 if (s->bits_per_raw_sample >= 16) {
663 s->use32bit = 1;
664 if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
665 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
666 return AVERROR_INVALIDDATA;
667 }
668 }
669 s->version = FFMAX(s->version, 1);
670 break;
671 default:
672 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
673 return AVERROR(ENOSYS);
674 }
675 av_assert0(s->bits_per_raw_sample >= 8);
676
677 if (s->bits_per_raw_sample > 8) {
678 if (s->ac == AC_GOLOMB_RICE) {
679 av_log(avctx, AV_LOG_INFO,
680 "bits_per_raw_sample > 8, forcing range coder\n");
681 s->ac = AC_RANGE_CUSTOM_TAB;
682 }
683 }
684 if (s->transparency) {
685 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
686 }
687#if FF_API_PRIVATE_OPT
688FF_DISABLE_DEPRECATION_WARNINGS
689 if (avctx->context_model)
690 s->context_model = avctx->context_model;
691 if (avctx->context_model > 1U) {
692 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
693 return AVERROR(EINVAL);
694 }
695FF_ENABLE_DEPRECATION_WARNINGS
696#endif
697
698 if (s->ac == AC_RANGE_CUSTOM_TAB) {
699 for (i = 1; i < 256; i++)
700 s->state_transition[i] = ver2_state[i];
701 } else {
702 RangeCoder c;
703 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
704 for (i = 1; i < 256; i++)
705 s->state_transition[i] = c.one_state[i];
706 }
707
708 for (i = 0; i < 256; i++) {
709 s->quant_table_count = 2;
710 if (s->bits_per_raw_sample <= 8) {
711 s->quant_tables[0][0][i]= quant11[i];
712 s->quant_tables[0][1][i]= 11*quant11[i];
713 s->quant_tables[0][2][i]= 11*11*quant11[i];
714 s->quant_tables[1][0][i]= quant11[i];
715 s->quant_tables[1][1][i]= 11*quant11[i];
716 s->quant_tables[1][2][i]= 11*11*quant5 [i];
717 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
718 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
719 } else {
720 s->quant_tables[0][0][i]= quant9_10bit[i];
721 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
722 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
723 s->quant_tables[1][0][i]= quant9_10bit[i];
724 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
725 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
726 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
727 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
728 }
729 }
730 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
731 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
732 memcpy(s->quant_table, s->quant_tables[s->context_model],
733 sizeof(s->quant_table));
734
735 for (i = 0; i < s->plane_count; i++) {
736 PlaneContext *const p = &s->plane[i];
737
738 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
739 p->quant_table_index = s->context_model;
740 p->context_count = s->context_count[p->quant_table_index];
741 }
742
743 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
744 return ret;
745
746#if FF_API_CODED_FRAME
747FF_DISABLE_DEPRECATION_WARNINGS
748 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
749FF_ENABLE_DEPRECATION_WARNINGS
750#endif
751
752 if (!s->transparency)
753 s->plane_count = 2;
754 if (!s->chroma_planes && s->version > 3)
755 s->plane_count--;
756
757 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
758 s->picture_number = 0;
759
760 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
761 for (i = 0; i < s->quant_table_count; i++) {
762 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
763 sizeof(*s->rc_stat2[i]));
764 if (!s->rc_stat2[i])
765 return AVERROR(ENOMEM);
766 }
767 }
768 if (avctx->stats_in) {
769 char *p = avctx->stats_in;
770 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
771 int gob_count = 0;
772 char *next;
773 if (!best_state)
774 return AVERROR(ENOMEM);
775
776 av_assert0(s->version >= 2);
777
778 for (;;) {
779 for (j = 0; j < 256; j++)
780 for (i = 0; i < 2; i++) {
781 s->rc_stat[j][i] = strtol(p, &next, 0);
782 if (next == p) {
783 av_log(avctx, AV_LOG_ERROR,
784 "2Pass file invalid at %d %d [%s]\n", j, i, p);
785 av_freep(&best_state);
786 return AVERROR_INVALIDDATA;
787 }
788 p = next;
789 }
790 for (i = 0; i < s->quant_table_count; i++)
791 for (j = 0; j < s->context_count[i]; j++) {
792 for (k = 0; k < 32; k++)
793 for (m = 0; m < 2; m++) {
794 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
795 if (next == p) {
796 av_log(avctx, AV_LOG_ERROR,
797 "2Pass file invalid at %d %d %d %d [%s]\n",
798 i, j, k, m, p);
799 av_freep(&best_state);
800 return AVERROR_INVALIDDATA;
801 }
802 p = next;
803 }
804 }
805 gob_count = strtol(p, &next, 0);
806 if (next == p || gob_count <= 0) {
807 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
808 av_freep(&best_state);
809 return AVERROR_INVALIDDATA;
810 }
811 p = next;
812 while (*p == '\n' || *p == ' ')
813 p++;
814 if (p[0] == 0)
815 break;
816 }
817 if (s->ac == AC_RANGE_CUSTOM_TAB)
818 sort_stt(s, s->state_transition);
819
820 find_best_state(best_state, s->state_transition);
821
822 for (i = 0; i < s->quant_table_count; i++) {
823 for (k = 0; k < 32; k++) {
824 double a=0, b=0;
825 int jp = 0;
826 for (j = 0; j < s->context_count[i]; j++) {
827 double p = 128;
828 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
829 if (a+b)
830 p = 256.0 * b / (a + b);
831 s->initial_states[i][jp][k] =
832 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
833 for(jp++; jp<j; jp++)
834 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
835 a=b=0;
836 }
837 a += s->rc_stat2[i][j][k][0];
838 b += s->rc_stat2[i][j][k][1];
839 if (a+b) {
840 p = 256.0 * b / (a + b);
841 }
842 s->initial_states[i][j][k] =
843 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
844 }
845 }
846 }
847 av_freep(&best_state);
848 }
849
850 if (s->version > 1) {
851 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
852 for (; s->num_v_slices < 9; s->num_v_slices++) {
853 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
854 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
855 goto slices_ok;
856 }
857 }
858 av_log(avctx, AV_LOG_ERROR,
859 "Unsupported number %d of slices requested, please specify a "
860 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
861 avctx->slices);
862 return AVERROR(ENOSYS);
863slices_ok:
864 if ((ret = write_extradata(s)) < 0)
865 return ret;
866 }
867
868 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
869 return ret;
870 s->slice_count = s->max_slice_count;
871 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
872 return ret;
873
874#define STATS_OUT_SIZE 1024 * 1024 * 6
875 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
876 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
877 if (!avctx->stats_out)
878 return AVERROR(ENOMEM);
879 for (i = 0; i < s->quant_table_count; i++)
880 for (j = 0; j < s->max_slice_count; j++) {
881 FFV1Context *sf = s->slice_context[j];
882 av_assert0(!sf->rc_stat2[i]);
883 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
884 sizeof(*sf->rc_stat2[i]));
885 if (!sf->rc_stat2[i])
886 return AVERROR(ENOMEM);
887 }
888 }
889
890 return 0;
891}
892
893static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
894{
895 RangeCoder *c = &fs->c;
896 uint8_t state[CONTEXT_SIZE];
897 int j;
898 memset(state, 128, sizeof(state));
899
900 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
901 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
902 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
903 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
904 for (j=0; j<f->plane_count; j++) {
905 put_symbol(c, state, f->plane[j].quant_table_index, 0);
906 av_assert0(f->plane[j].quant_table_index == f->context_model);
907 }
908 if (!f->picture.f->interlaced_frame)
909 put_symbol(c, state, 3, 0);
910 else
911 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
912 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
913 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
914 if (f->version > 3) {
915 put_rac(c, state, fs->slice_coding_mode == 1);
916 if (fs->slice_coding_mode == 1)
917 ff_ffv1_clear_slice_state(f, fs);
918 put_symbol(c, state, fs->slice_coding_mode, 0);
919 if (fs->slice_coding_mode != 1) {
920 put_symbol(c, state, fs->slice_rct_by_coef, 0);
921 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
922 }
923 }
924}
925
926static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
927{
928#define NB_Y_COEFF 15
929 static const int rct_y_coeff[15][2] = {
930 {0, 0}, // 4G
931 {1, 1}, // R + 2G + B
932 {2, 2}, // 2R + 2B
933 {0, 2}, // 2G + 2B
934 {2, 0}, // 2R + 2G
935 {4, 0}, // 4R
936 {0, 4}, // 4B
937
938 {0, 3}, // 1G + 3B
939 {3, 0}, // 3R + 1G
940 {3, 1}, // 3R + B
941 {1, 3}, // R + 3B
942 {1, 2}, // R + G + 2B
943 {2, 1}, // 2R + G + B
944 {0, 1}, // 3G + B
945 {1, 0}, // R + 3G
946 };
947
948 int stat[NB_Y_COEFF] = {0};
949 int x, y, i, p, best;
950 int16_t *sample[3];
951 int lbd = fs->bits_per_raw_sample <= 8;
952
953 for (y = 0; y < h; y++) {
954 int lastr=0, lastg=0, lastb=0;
955 for (p = 0; p < 3; p++)
956 sample[p] = fs->sample_buffer + p*w;
957
958 for (x = 0; x < w; x++) {
959 int b, g, r;
960 int ab, ag, ar;
961 if (lbd) {
962 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
963 b = v & 0xFF;
964 g = (v >> 8) & 0xFF;
965 r = (v >> 16) & 0xFF;
966 } else {
967 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
968 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
969 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
970 }
971
972 ar = r - lastr;
973 ag = g - lastg;
974 ab = b - lastb;
975 if (x && y) {
976 int bg = ag - sample[0][x];
977 int bb = ab - sample[1][x];
978 int br = ar - sample[2][x];
979
980 br -= bg;
981 bb -= bg;
982
983 for (i = 0; i<NB_Y_COEFF; i++) {
984 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
985 }
986
987 }
988 sample[0][x] = ag;
989 sample[1][x] = ab;
990 sample[2][x] = ar;
991
992 lastr = r;
993 lastg = g;
994 lastb = b;
995 }
996 }
997
998 best = 0;
999 for (i=1; i<NB_Y_COEFF; i++) {
1000 if (stat[i] < stat[best])
1001 best = i;
1002 }
1003
1004 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1005 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1006}
1007
1008static int encode_slice(AVCodecContext *c, void *arg)
1009{
1010 FFV1Context *fs = *(void **)arg;
1011 FFV1Context *f = fs->avctx->priv_data;
1012 int width = fs->slice_width;
1013 int height = fs->slice_height;
1014 int x = fs->slice_x;
1015 int y = fs->slice_y;
1016 const AVFrame *const p = f->picture.f;
1017 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1018 int ret;
1019 RangeCoder c_bak = fs->c;
1020 const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1021 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1022 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL};
1023
1024 fs->slice_coding_mode = 0;
1025 if (f->version > 3) {
1026 choose_rct_params(fs, planes, p->linesize, width, height);
1027 } else {
1028 fs->slice_rct_by_coef = 1;
1029 fs->slice_rct_ry_coef = 1;
1030 }
1031
1032retry:
1033 if (f->key_frame)
1034 ff_ffv1_clear_slice_state(f, fs);
1035 if (f->version > 2) {
1036 encode_slice_header(f, fs);
1037 }
1038 if (fs->ac == AC_GOLOMB_RICE) {
1039 if (f->version > 2)
1040 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1041 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1042 init_put_bits(&fs->pb,
1043 fs->c.bytestream_start + fs->ac_byte_count,
1044 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1045 }
1046
1047 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1048 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1049 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1050 const int cx = x >> f->chroma_h_shift;
1051 const int cy = y >> f->chroma_v_shift;
1052
1053 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1054
1055 if (f->chroma_planes) {
1056 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1057 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1058 }
1059 if (fs->transparency)
1060 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1061 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1062 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1063 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1064 } else if (f->use32bit) {
1065 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1066 } else {
1067 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1068 }
1069 emms_c();
1070
1071 if (ret < 0) {
1072 av_assert0(fs->slice_coding_mode == 0);
1073 if (fs->version < 4 || !fs->ac) {
1074 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1075 return ret;
1076 }
1077 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1078 fs->slice_coding_mode = 1;
1079 fs->c = c_bak;
1080 goto retry;
1081 }
1082
1083 return 0;
1084}
1085
1086static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1087 const AVFrame *pict, int *got_packet)
1088{
1089 FFV1Context *f = avctx->priv_data;
1090 RangeCoder *const c = &f->slice_context[0]->c;
1091 AVFrame *const p = f->picture.f;
1092 uint8_t keystate = 128;
1093 uint8_t *buf_p;
1094 int i, ret;
1095 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1096 + avctx->width*avctx->height*37LL*4;
1097
1098 if(!pict) {
1099 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1100 int j, k, m;
1101 char *p = avctx->stats_out;
1102 char *end = p + STATS_OUT_SIZE;
1103
1104 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1105 for (i = 0; i < f->quant_table_count; i++)
1106 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1107
1108 av_assert0(f->slice_count == f->max_slice_count);
1109 for (j = 0; j < f->slice_count; j++) {
1110 FFV1Context *fs = f->slice_context[j];
1111 for (i = 0; i < 256; i++) {
1112 f->rc_stat[i][0] += fs->rc_stat[i][0];
1113 f->rc_stat[i][1] += fs->rc_stat[i][1];
1114 }
1115 for (i = 0; i < f->quant_table_count; i++) {
1116 for (k = 0; k < f->context_count[i]; k++)
1117 for (m = 0; m < 32; m++) {
1118 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1119 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1120 }
1121 }
1122 }
1123
1124 for (j = 0; j < 256; j++) {
1125 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1126 f->rc_stat[j][0], f->rc_stat[j][1]);
1127 p += strlen(p);
1128 }
1129 snprintf(p, end - p, "\n");
1130
1131 for (i = 0; i < f->quant_table_count; i++) {
1132 for (j = 0; j < f->context_count[i]; j++)
1133 for (m = 0; m < 32; m++) {
1134 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1135 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1136 p += strlen(p);
1137 }
1138 }
1139 snprintf(p, end - p, "%d\n", f->gob_count);
1140 }
1141 return 0;
1142 }
1143
1144 if (f->version > 3)
1145 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1146
1147 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1148 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1149 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1150 }
1151
1152 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1153 return ret;
1154
1155 ff_init_range_encoder(c, pkt->data, pkt->size);
1156 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1157
1158 av_frame_unref(p);
1159 if ((ret = av_frame_ref(p, pict)) < 0)
1160 return ret;
1161#if FF_API_CODED_FRAME
1162FF_DISABLE_DEPRECATION_WARNINGS
1163 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1164FF_ENABLE_DEPRECATION_WARNINGS
1165#endif
1166
1167 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1168 put_rac(c, &keystate, 1);
1169 f->key_frame = 1;
1170 f->gob_count++;
1171 write_header(f);
1172 } else {
1173 put_rac(c, &keystate, 0);
1174 f->key_frame = 0;
1175 }
1176
1177 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1178 int i;
1179 for (i = 1; i < 256; i++) {
1180 c->one_state[i] = f->state_transition[i];
1181 c->zero_state[256 - i] = 256 - c->one_state[i];
1182 }
1183 }
1184
1185 for (i = 0; i < f->slice_count; i++) {
1186 FFV1Context *fs = f->slice_context[i];
1187 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1188 int len = pkt->size / f->slice_count;
1189 if (i) {
1190 ff_init_range_encoder(&fs->c, start, len);
1191 } else {
1192 av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1193 av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1194 fs->c.bytestream_end = fs->c.bytestream_start + len;
1195 }
1196 }
1197 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1198 f->slice_count, sizeof(void *));
1199
1200 buf_p = pkt->data;
1201 for (i = 0; i < f->slice_count; i++) {
1202 FFV1Context *fs = f->slice_context[i];
1203 int bytes;
1204
1205 if (fs->ac != AC_GOLOMB_RICE) {
1206 uint8_t state = 129;
1207 put_rac(&fs->c, &state, 0);
1208 bytes = ff_rac_terminate(&fs->c);
1209 } else {
1210 flush_put_bits(&fs->pb); // FIXME: nicer padding
1211 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1212 }
1213 if (i > 0 || f->version > 2) {
1214 av_assert0(bytes < pkt->size / f->slice_count);
1215 memmove(buf_p, fs->c.bytestream_start, bytes);
1216 av_assert0(bytes < (1 << 24));
1217 AV_WB24(buf_p + bytes, bytes);
1218 bytes += 3;
1219 }
1220 if (f->ec) {
1221 unsigned v;
1222 buf_p[bytes++] = 0;
1223 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1224 AV_WL32(buf_p + bytes, v);
1225 bytes += 4;
1226 }
1227 buf_p += bytes;
1228 }
1229
1230 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1231 avctx->stats_out[0] = '\0';
1232
1233#if FF_API_CODED_FRAME
1234FF_DISABLE_DEPRECATION_WARNINGS
1235 avctx->coded_frame->key_frame = f->key_frame;
1236FF_ENABLE_DEPRECATION_WARNINGS
1237#endif
1238
1239 f->picture_number++;
1240 pkt->size = buf_p - pkt->data;
1241 pkt->pts =
1242 pkt->dts = pict->pts;
1243 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1244 *got_packet = 1;
1245
1246 return 0;
1247}
1248
1249static av_cold int encode_close(AVCodecContext *avctx)
1250{
1251 ff_ffv1_close(avctx);
1252 return 0;
1253}
1254
1255#define OFFSET(x) offsetof(FFV1Context, x)
1256#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1257static const AVOption options[] = {
1258 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1259 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1260 { .i64 = 0 }, -2, 2, VE, "coder" },
1261 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1262 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1263 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1264 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1265 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1266 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1267 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1268 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1269 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1270 { .i64 = 0 }, 0, 1, VE },
1271
1272 { NULL }
1273};
1274
1275static const AVClass ffv1_class = {
1276 .class_name = "ffv1 encoder",
1277 .item_name = av_default_item_name,
1278 .option = options,
1279 .version = LIBAVUTIL_VERSION_INT,
1280};
1281
1282#if FF_API_CODER_TYPE
1283static const AVCodecDefault ffv1_defaults[] = {
1284 { "coder", "-1" },
1285 { NULL },
1286};
1287#endif
1288
1289AVCodec ff_ffv1_encoder = {
1290 .name = "ffv1",
1291 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1292 .type = AVMEDIA_TYPE_VIDEO,
1293 .id = AV_CODEC_ID_FFV1,
1294 .priv_data_size = sizeof(FFV1Context),
1295 .init = encode_init,
1296 .encode2 = encode_frame,
1297 .close = encode_close,
1298 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1299 .pix_fmts = (const enum AVPixelFormat[]) {
1300 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1301 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1302 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1303 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1304 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1305 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1306 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1307 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1308 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1309 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1310 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1311 AV_PIX_FMT_YA8,
1312 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1313 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1314 AV_PIX_FMT_NONE
1315
1316 },
1317#if FF_API_CODER_TYPE
1318 .defaults = ffv1_defaults,
1319#endif
1320 .priv_class = &ffv1_class,
1321};
1322
generated by cgit at 2024-05-17 03:05:56 (GMT)