FFmpeg
Loading...
Searching...
No Matches
ffv1enc.c
Go to the documentation of this file.
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/mem.h"
32#include "libavutil/opt.h"
33#include "libavutil/pixdesc.h"
34#include "libavutil/qsort.h"
35
36#include "avcodec.h"
37#include "encode.h"
38#include "codec_internal.h"
39#include "put_bits.h"
40#include "put_golomb.h"
41#include "rangecoder.h"
42#include "ffv1.h"
43#include "ffv1enc.h"
44
45static const int8_t quant5_10bit[256] = {
46 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
49 1, 1, 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, -2,
58 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
61 -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
62};
63
64static const int8_t quant5[256] = {
65 0, 1, 1, 1, 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, -2, -2, -2,
80 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
81};
82
83static const int8_t quant9_10bit[256] = {
84 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
85 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
86 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
87 3, 3, 3, 3, 3, 3, 3, 3, 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, -4, -4, -4, -4, -4, -4, -4,
96 -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
97 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
98 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
99 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
100};
101
102static const int8_t quant11[256] = {
103 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
104 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
105 4, 4, 4, 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, -5, -5,
116 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
117 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
118 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
119};
120
121static const uint8_t ver2_state[256] = {
122 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
123 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
124 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
125 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
126 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
127 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
128 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
129 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
130 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
131 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
132 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
133 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
134 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
135 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
136 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
137 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
138};
139
140static void find_best_state(uint8_t best_state[256][256],
141 const uint8_t one_state[256])
142{
143 int i, j, k, m;
144 uint32_t l2tab[256];
145
146 for (i = 1; i < 256; i++)
147 l2tab[i] = -log2(i / 256.0) * ((1U << 31) / 8);
148
149 for (i = 0; i < 256; i++) {
150 uint64_t best_len[256];
151
152 for (j = 0; j < 256; j++)
153 best_len[j] = UINT64_MAX;
154
155 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
156 uint32_t occ[256] = { 0 };
157 uint64_t len = 0;
158 occ[j] = UINT32_MAX;
159
160 if (!one_state[j])
161 continue;
162
163 for (k = 0; k < 256; k++) {
164 uint32_t newocc[256] = { 0 };
165 for (m = 1; m < 256; m++)
166 if (occ[m]) {
167 len += (occ[m]*(( i *(uint64_t)l2tab[ m]
168 + (256-i)*(uint64_t)l2tab[256-m])>>8)) >> 8;
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] * (uint64_t) i >> 8;
177 newocc[256 - one_state[256 - m]] += occ[m] * (uint64_t)(256 - i) >> 8;
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 unsigned a = is_signed ? FFABS(v) : 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 <= 16);
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 *f, FFV1SliceContext *sc,
275 const uint8_t *src, int w, int h,
276 int stride, int plane_index, int remap_index, int pixel_stride, int ac)
277{
278 int x, y, i, ret;
279 const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
280 const int ring_size = f->context_model ? 3 : 2;
281 int16_t *sample[3];
282 sc->run_index = 0;
283
284 sample[2] = sc->sample_buffer; // dummy to avoid UB pointer arithmetic
285
286 memset(sc->sample_buffer, 0, ring_size * (w + 6) * sizeof(*sc->sample_buffer));
287
288 for (y = 0; y < h; y++) {
289 for (i = 0; i < ring_size; i++)
290 sample[i] = sc->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
291
292 sample[0][-1]= sample[1][0 ];
293 sample[1][ w]= sample[1][w-1];
294
295 if (f->bits_per_raw_sample <= 8) {
296 for (x = 0; x < w; x++)
297 sample[0][x] = src[x * pixel_stride + stride * y];
298 if (sc->remap)
299 for (x = 0; x < w; x++)
300 sample[0][x] = sc->fltmap[remap_index][ sample[0][x] ];
301
302 if((ret = encode_line(f, sc, f->avctx, w, sample, plane_index, 8, ac, pass1)) < 0)
303 return ret;
304 } else {
305 if (f->packed_at_lsb) {
306 for (x = 0; x < w; x++) {
307 sample[0][x] = ((uint16_t*)(src + stride*y))[x * pixel_stride];
308 }
309 } else {
310 for (x = 0; x < w; x++) {
311 sample[0][x] = ((uint16_t*)(src + stride*y))[x * pixel_stride] >> (16 - f->bits_per_raw_sample);
312 }
313 }
314 if (sc->remap)
315 for (x = 0; x < w; x++)
316 sample[0][x] = sc->fltmap[remap_index][ (uint16_t)sample[0][x] ];
317
318 if((ret = encode_line(f, sc, f->avctx, w, sample, plane_index, f->bits_per_raw_sample, ac, pass1)) < 0)
319 return ret;
320 }
321 }
322 return 0;
323}
324
325static void load_plane(FFV1Context *f, FFV1SliceContext *sc,
326 const uint8_t *src, int w, int h,
327 int stride, int remap_index, int pixel_stride)
328{
329 int x, y;
330
331 memset(sc->fltmap[remap_index], 0, 65536 * sizeof(*sc->fltmap[remap_index]));
332
333 for (y = 0; y < h; y++) {
334 if (f->bits_per_raw_sample <= 8) {
335 for (x = 0; x < w; x++)
336 sc->fltmap[remap_index][ src[x * pixel_stride + stride * y] ] = 1;
337 } else {
338 if (f->packed_at_lsb) {
339 for (x = 0; x < w; x++)
340 sc->fltmap[remap_index][ ((uint16_t*)(src + stride*y))[x * pixel_stride] ] = 1;
341 } else {
342 for (x = 0; x < w; x++)
343 sc->fltmap[remap_index][ ((uint16_t*)(src + stride*y))[x * pixel_stride] >> (16 - f->bits_per_raw_sample) ] = 1;
344 }
345 }
346 }
347}
348
349static void write_quant_table(RangeCoder *c, int16_t *quant_table)
350{
351 int last = 0;
352 int i;
353 uint8_t state[CONTEXT_SIZE];
354 memset(state, 128, sizeof(state));
355
356 for (i = 1; i < MAX_QUANT_TABLE_SIZE/2; i++)
357 if (quant_table[i] != quant_table[i - 1]) {
358 put_symbol(c, state, i - last - 1, 0);
359 last = i;
360 }
361 put_symbol(c, state, i - last - 1, 0);
362}
363
364static void write_quant_tables(RangeCoder *c,
365 int16_t quant_table[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE])
366{
367 int i;
368 for (i = 0; i < 5; i++)
369 write_quant_table(c, quant_table[i]);
370}
371
372static int contains_non_128(uint8_t (*initial_state)[CONTEXT_SIZE],
373 int nb_contexts)
374{
375 if (!initial_state)
376 return 0;
377 for (int i = 0; i < nb_contexts; i++)
378 for (int j = 0; j < CONTEXT_SIZE; j++)
379 if (initial_state[i][j] != 128)
380 return 1;
381 return 0;
382}
383
384static void write_header(FFV1Context *f)
385{
386 uint8_t state[CONTEXT_SIZE];
387 int i, j;
388 RangeCoder *const c = &f->slices[0].c;
389
390 memset(state, 128, sizeof(state));
391
392 if (f->version < 2) {
393 put_symbol(c, state, f->version, 0);
394 put_symbol(c, state, f->ac, 0);
395 if (f->ac == AC_RANGE_CUSTOM_TAB) {
396 for (i = 1; i < 256; i++)
397 put_symbol(c, state,
398 f->state_transition[i] - c->one_state[i], 1);
399 }
400 put_symbol(c, state, f->colorspace, 0); //YUV cs type
401 if (f->version > 0)
402 put_symbol(c, state, f->bits_per_raw_sample, 0);
403 put_rac(c, state, f->chroma_planes);
404 put_symbol(c, state, f->chroma_h_shift, 0);
405 put_symbol(c, state, f->chroma_v_shift, 0);
406 put_rac(c, state, f->transparency);
407
408 write_quant_tables(c, f->quant_tables[f->context_model]);
409 } else if (f->version < 3) {
410 put_symbol(c, state, f->slice_count, 0);
411 for (i = 0; i < f->slice_count; i++) {
412 FFV1SliceContext *fs = &f->slices[i];
413 put_symbol(c, state,
414 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
415 put_symbol(c, state,
416 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
417 put_symbol(c, state,
418 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
419 0);
420 put_symbol(c, state,
421 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
422 0);
423 for (j = 0; j < f->plane_count; j++) {
424 put_symbol(c, state, fs->plane[j].quant_table_index, 0);
425 av_assert0(fs->plane[j].quant_table_index == f->context_model);
426 }
427 }
428 }
429}
430
431static void set_micro_version(FFV1Context *f)
432{
433 f->combined_version = f->version << 16;
434 if (f->version > 2) {
435 if (f->version == 3) {
436 f->micro_version = 4;
437 } else if (f->version == 4) {
438 f->micro_version = 10;
439 } else
440 av_assert0(0);
441
442 f->combined_version += f->micro_version;
443 } else
444 av_assert0(f->micro_version == 0);
445}
446
447av_cold int ff_ffv1_write_extradata(AVCodecContext *avctx)
448{
449 FFV1Context *f = avctx->priv_data;
450
451 RangeCoder c;
452 uint8_t state[CONTEXT_SIZE];
453 int i, j, k;
454 uint8_t state2[32][CONTEXT_SIZE];
455 unsigned v;
456
457 memset(state2, 128, sizeof(state2));
458 memset(state, 128, sizeof(state));
459
460 f->avctx->extradata_size = 10000 + 4 +
461 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
462 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
463 if (!f->avctx->extradata)
464 return AVERROR(ENOMEM);
465 ff_init_range_encoder(&c, f->avctx->extradata, f->avctx->extradata_size);
466 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
467
468 put_symbol(&c, state, f->version, 0);
469 if (f->version > 2)
470 put_symbol(&c, state, f->micro_version, 0);
471
472 put_symbol(&c, state, f->ac, 0);
473 if (f->ac == AC_RANGE_CUSTOM_TAB)
474 for (i = 1; i < 256; i++)
475 put_symbol(&c, state, f->state_transition[i] - c.one_state[i], 1);
476
477 put_symbol(&c, state, f->colorspace, 0); // YUV cs type
478 put_symbol(&c, state, f->bits_per_raw_sample, 0);
479 put_rac(&c, state, f->chroma_planes);
480 put_symbol(&c, state, f->chroma_h_shift, 0);
481 put_symbol(&c, state, f->chroma_v_shift, 0);
482 put_rac(&c, state, f->transparency);
483 if (f->colorspace == 2)
484 put_symbol(&c, state, f->bayer_order, 0); /* 0 = RGGB */
485 put_symbol(&c, state, f->num_h_slices - 1, 0);
486 put_symbol(&c, state, f->num_v_slices - 1, 0);
487
488 put_symbol(&c, state, f->quant_table_count, 0);
489 for (i = 0; i < f->quant_table_count; i++)
490 write_quant_tables(&c, f->quant_tables[i]);
491
492 for (i = 0; i < f->quant_table_count; i++) {
493 if (contains_non_128(f->initial_states[i], f->context_count[i])) {
494 put_rac(&c, state, 1);
495 for (j = 0; j < f->context_count[i]; j++)
496 for (k = 0; k < CONTEXT_SIZE; k++) {
497 int pred = j ? f->initial_states[i][j - 1][k] : 128;
498 put_symbol(&c, state2[k],
499 (int8_t)(f->initial_states[i][j][k] - pred), 1);
500 }
501 } else {
502 put_rac(&c, state, 0);
503 }
504 }
505
506 if (f->version > 2) {
507 put_symbol(&c, state, f->ec, 0);
508 put_symbol(&c, state, f->intra = (f->avctx->gop_size < 2), 0);
509 if (f->combined_version >= 0x40004)
510 put_symbol(&c, state, f->flt, 0);
511 }
512
513 f->avctx->extradata_size = ff_rac_terminate(&c, 0);
514 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, f->avctx->extradata, f->avctx->extradata_size) ^ (f->crcref ? 0x8CD88196 : 0);
515 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
516 f->avctx->extradata_size += 4;
517
518 return 0;
519}
520
521static int sort_stt(FFV1Context *s, uint8_t stt[256])
522{
523 int i, i2, changed, print = 0;
524
525 do {
526 changed = 0;
527 for (i = 12; i < 244; i++) {
528 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
529
530#define COST(old, new) \
531 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
532 s->rc_stat[old][1] * -log2((new) / 256.0)
533
534#define COST2(old, new) \
535 COST(old, new) + COST(256 - (old), 256 - (new))
536
537 double size0 = COST2(i, i) + COST2(i2, i2);
538 double sizeX = COST2(i, i2) + COST2(i2, i);
539 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
540 int j;
541 FFSWAP(int, stt[i], stt[i2]);
542 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
543 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
544 if (i != 256 - i2) {
545 FFSWAP(int, stt[256 - i], stt[256 - i2]);
546 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
547 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
548 }
549 for (j = 1; j < 256; j++) {
550 if (stt[j] == i)
551 stt[j] = i2;
552 else if (stt[j] == i2)
553 stt[j] = i;
554 if (i != 256 - i2) {
555 if (stt[256 - j] == 256 - i)
556 stt[256 - j] = 256 - i2;
557 else if (stt[256 - j] == 256 - i2)
558 stt[256 - j] = 256 - i;
559 }
560 }
561 print = changed = 1;
562 }
563 }
564 }
565 } while (changed);
566 return print;
567}
568
569
570int ff_ffv1_encode_determine_slices(AVCodecContext *avctx)
571{
572 FFV1Context *s = avctx->priv_data;
573 int plane_count = 1 + 2*s->chroma_planes + s->bayer + s->transparency;
574 int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->bayer ? 1 : s->chroma_h_shift);
575 int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->bayer ? 1 : s->chroma_v_shift);
576 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
577 s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
578 for (; s->num_v_slices <= 32; s->num_v_slices++) {
579 for (s->num_h_slices = s->num_v_slices; s->num_h_slices <= 2*s->num_v_slices; s->num_h_slices++) {
580 int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
581 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
582 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
583 continue;
584 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
585 continue;
586 if (s->version < 4)
587 if ( ff_need_new_slices(avctx->width , s->num_h_slices, s->chroma_h_shift)
588 ||ff_need_new_slices(avctx->height, s->num_v_slices, s->chroma_v_shift))
589 continue;
590 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES)
591 return 0;
592 if (maxw*maxh > 360*288)
593 continue;
594 if (!avctx->slices)
595 return 0;
596 }
597 }
598 av_log(avctx, AV_LOG_ERROR,
599 "Unsupported number %d of slices requested, please specify a "
600 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
601 avctx->slices);
602 return AVERROR(ENOSYS);
603}
604
605av_cold int ff_ffv1_encode_init(AVCodecContext *avctx)
606{
607 FFV1Context *s = avctx->priv_data;
608 int i, j, k, m, ret;
609
610 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
611 avctx->slices > 1)
612 s->version = FFMAX(s->version, 2);
613
614 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) && s->ac == AC_GOLOMB_RICE) {
615 av_log(avctx, AV_LOG_ERROR, "2 Pass mode is not possible with golomb coding\n");
616 return AVERROR(EINVAL);
617 }
618
619 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
620 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
621 s->version = FFMAX(s->version, 2);
622
623 if (avctx->level <= 0 && s->version == 2) {
624 s->version = 3;
625 }
626 if (avctx->level >= 0 && avctx->level <= 4) {
627 if (avctx->level < s->version) {
628 av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
629 return AVERROR(EINVAL);
630 }
631 s->version = avctx->level;
632 } else if (s->version < 3)
633 s->version = 3;
634
635 if (s->ec < 0) {
636 if (s->version >= 4) {
637 s->ec = 2;
638 } else if (s->version >= 3) {
639 s->ec = 1;
640 } else
641 s->ec = 0;
642 }
643
644 // CRC requires version 3+
645 if (s->ec == 1)
646 s->version = FFMAX(s->version, 3);
647 if (s->ec == 2) {
648 s->version = FFMAX(s->version, 4);
649 s->crcref = 0x7a8c4079;
650 }
651
652 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
653 av_log(avctx, AV_LOG_ERROR, "Version 2 or 4 needed for requested features but version 2 or 4 is experimental and not enabled\n");
654 return AVERROR_INVALIDDATA;
655 }
656
657 if (s->ac == AC_RANGE_CUSTOM_TAB) {
658 for (i = 1; i < 256; i++)
659 s->state_transition[i] = ver2_state[i];
660 } else {
661 RangeCoder c;
662 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
663 for (i = 1; i < 256; i++)
664 s->state_transition[i] = c.one_state[i];
665 }
666
667 for (i = 0; i < 256; i++) {
668 s->quant_table_count = 2;
669 if ((s->qtable == -1 && s->bits_per_raw_sample <= 8) || s->qtable == 1) {
670 s->quant_tables[0][0][i]= quant11[i];
671 s->quant_tables[0][1][i]= 11*quant11[i];
672 s->quant_tables[0][2][i]= 11*11*quant11[i];
673 s->quant_tables[1][0][i]= quant11[i];
674 s->quant_tables[1][1][i]= 11*quant11[i];
675 s->quant_tables[1][2][i]= 11*11*quant5 [i];
676 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
677 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
678 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
679 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
680 } else {
681 s->quant_tables[0][0][i]= quant9_10bit[i];
682 s->quant_tables[0][1][i]= 9*quant9_10bit[i];
683 s->quant_tables[0][2][i]= 9*9*quant9_10bit[i];
684 s->quant_tables[1][0][i]= quant9_10bit[i];
685 s->quant_tables[1][1][i]= 9*quant9_10bit[i];
686 s->quant_tables[1][2][i]= 9*9*quant5_10bit[i];
687 s->quant_tables[1][3][i]= 5*9*9*quant5_10bit[i];
688 s->quant_tables[1][4][i]= 5*5*9*9*quant5_10bit[i];
689 s->context_count[0] = (9 * 9 * 9 + 1) / 2;
690 s->context_count[1] = (9 * 9 * 5 * 5 * 5 + 1) / 2;
691 }
692 }
693
694 /* Small context set: only the two nearest gradients, coarsely quantized.
695 * With many slices there is too little data per slice for large context
696 * sets to adapt, and this codes smaller while using a fraction of the
697 * state. */
698 if (s->context_model == 2) {
699 const int8_t *q5 = (s->qtable == -1 && s->bits_per_raw_sample <= 8) || s->qtable == 1 ?
700 quant5 : quant5_10bit;
701 s->quant_table_count = 3;
702 for (i = 0; i < 256; i++) {
703 s->quant_tables[2][0][i] = q5[i];
704 s->quant_tables[2][1][i] = 5*q5[i];
705 }
706 s->context_count[2] = (5 * 5 + 1) / 2;
707 }
708
709 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
710 return ret;
711
712 if (!s->transparency)
713 s->plane_count = 2;
714 if (!s->chroma_planes && s->version > 3)
715 s->plane_count--;
716 if (s->bayer)
717 s->plane_count = 3;
718
719 s->picture_number = 0;
720
721 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
722 for (i = 0; i < s->quant_table_count; i++) {
723 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
724 sizeof(*s->rc_stat2[i]));
725 if (!s->rc_stat2[i])
726 return AVERROR(ENOMEM);
727 }
728 }
729 if (avctx->stats_in) {
730 char *p = avctx->stats_in;
731 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
732 int gob_count = 0;
733 char *next;
734 if (!best_state)
735 return AVERROR(ENOMEM);
736
737 av_assert0(s->version >= 2);
738
739 for (;;) {
740 for (j = 0; j < 256; j++)
741 for (i = 0; i < 2; i++) {
742 s->rc_stat[j][i] = strtol(p, &next, 0);
743 if (next == p) {
744 av_log(avctx, AV_LOG_ERROR,
745 "2Pass file invalid at %d %d [%s]\n", j, i, p);
746 av_freep(&best_state);
747 return AVERROR_INVALIDDATA;
748 }
749 p = next;
750 }
751 for (i = 0; i < s->quant_table_count; i++)
752 for (j = 0; j < s->context_count[i]; j++) {
753 for (k = 0; k < 32; k++)
754 for (m = 0; m < 2; m++) {
755 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
756 if (next == p) {
757 av_log(avctx, AV_LOG_ERROR,
758 "2Pass file invalid at %d %d %d %d [%s]\n",
759 i, j, k, m, p);
760 av_freep(&best_state);
761 return AVERROR_INVALIDDATA;
762 }
763 p = next;
764 }
765 }
766 gob_count = strtol(p, &next, 0);
767 if (next == p || gob_count <= 0) {
768 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
769 av_freep(&best_state);
770 return AVERROR_INVALIDDATA;
771 }
772 p = next;
773 while (*p == '\n' || *p == ' ')
774 p++;
775 if (p[0] == 0)
776 break;
777 }
778 if (s->ac == AC_RANGE_CUSTOM_TAB)
779 sort_stt(s, s->state_transition);
780
781 find_best_state(best_state, s->state_transition);
782
783 for (i = 0; i < s->quant_table_count; i++) {
784 for (k = 0; k < 32; k++) {
785 double a=0, b=0;
786 int jp = 0;
787 for (j = 0; j < s->context_count[i]; j++) {
788 double p = 128;
789 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
790 if (a+b)
791 p = 256.0 * b / (a + b);
792 s->initial_states[i][jp][k] =
793 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
794 for(jp++; jp<j; jp++)
795 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
796 a=b=0;
797 }
798 a += s->rc_stat2[i][j][k][0];
799 b += s->rc_stat2[i][j][k][1];
800 if (a+b) {
801 p = 256.0 * b / (a + b);
802 }
803 s->initial_states[i][j][k] =
804 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
805 }
806 }
807 }
808 av_freep(&best_state);
809 }
810
811 if (s->version <= 1) {
812 /* Disable slices when the version doesn't support them */
813 s->num_h_slices = 1;
814 s->num_v_slices = 1;
815 }
816
817 set_micro_version(s);
818
819 return 0;
820}
821
822av_cold int ff_ffv1_encode_setup_plane_info(AVCodecContext *avctx,
823 enum AVPixelFormat pix_fmt)
824{
825 FFV1Context *s = avctx->priv_data;
826 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
827
828 s->bayer = 0;
829 s->plane_count = 3;
830 switch(pix_fmt) {
831 case AV_PIX_FMT_GRAY9:
832 case AV_PIX_FMT_YUV444P9:
833 case AV_PIX_FMT_YUV422P9:
834 case AV_PIX_FMT_YUV420P9:
835 case AV_PIX_FMT_YUVA444P9:
836 case AV_PIX_FMT_YUVA422P9:
837 case AV_PIX_FMT_YUVA420P9:
838 if (!avctx->bits_per_raw_sample)
839 s->bits_per_raw_sample = 9;
840 av_fallthrough;
841 case AV_PIX_FMT_GRAY10:
842 case AV_PIX_FMT_YUV444P10:
843 case AV_PIX_FMT_YUV440P10:
844 case AV_PIX_FMT_YUV420P10:
845 case AV_PIX_FMT_YUV422P10:
846 case AV_PIX_FMT_YUVA444P10:
847 case AV_PIX_FMT_YUVA422P10:
848 case AV_PIX_FMT_YUVA420P10:
849 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
850 s->bits_per_raw_sample = 10;
851 av_fallthrough;
852 case AV_PIX_FMT_GRAY12:
853 case AV_PIX_FMT_YUV444P12:
854 case AV_PIX_FMT_YUV440P12:
855 case AV_PIX_FMT_YUV420P12:
856 case AV_PIX_FMT_YUV422P12:
857 case AV_PIX_FMT_YUVA444P12:
858 case AV_PIX_FMT_YUVA422P12:
859 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
860 s->bits_per_raw_sample = 12;
861 av_fallthrough;
862 case AV_PIX_FMT_GRAY14:
863 case AV_PIX_FMT_YUV444P14:
864 case AV_PIX_FMT_YUV420P14:
865 case AV_PIX_FMT_YUV422P14:
866 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
867 s->bits_per_raw_sample = 14;
868 s->packed_at_lsb = 1;
869 av_fallthrough;
870 case AV_PIX_FMT_GRAY16:
871 case AV_PIX_FMT_P016:
872 case AV_PIX_FMT_P216:
873 case AV_PIX_FMT_P416:
874 case AV_PIX_FMT_YUV444P16:
875 case AV_PIX_FMT_YUV422P16:
876 case AV_PIX_FMT_YUV420P16:
877 case AV_PIX_FMT_YUVA444P16:
878 case AV_PIX_FMT_YUVA422P16:
879 case AV_PIX_FMT_YUVA420P16:
880 case AV_PIX_FMT_GRAYF16:
881 case AV_PIX_FMT_YAF16:
882 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
883 s->bits_per_raw_sample = 16;
884 } else if (!s->bits_per_raw_sample) {
885 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
886 }
887 if (s->bits_per_raw_sample <= 8) {
888 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
889 return AVERROR_INVALIDDATA;
890 }
891 s->version = FFMAX(s->version, 1);
892 av_fallthrough;
893 case AV_PIX_FMT_GRAY8:
894 case AV_PIX_FMT_YA8:
895 case AV_PIX_FMT_NV12:
896 case AV_PIX_FMT_NV16:
897 case AV_PIX_FMT_NV24:
898 case AV_PIX_FMT_YUV444P:
899 case AV_PIX_FMT_YUV440P:
900 case AV_PIX_FMT_YUV422P:
901 case AV_PIX_FMT_YUV420P:
902 case AV_PIX_FMT_YUV411P:
903 case AV_PIX_FMT_YUV410P:
904 case AV_PIX_FMT_YUVA444P:
905 case AV_PIX_FMT_YUVA422P:
906 case AV_PIX_FMT_YUVA420P:
907 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
908 s->colorspace = 0;
909 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
910 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
911 s->bits_per_raw_sample = 8;
912 else if (!s->bits_per_raw_sample)
913 s->bits_per_raw_sample = 8;
914 break;
915 case AV_PIX_FMT_RGB32:
916 s->colorspace = 1;
917 s->transparency = 1;
918 s->chroma_planes = 1;
919 s->bits_per_raw_sample = 8;
920 break;
921 case AV_PIX_FMT_RGBA64:
922 s->colorspace = 1;
923 s->transparency = 1;
924 s->chroma_planes = 1;
925 s->bits_per_raw_sample = 16;
926 s->use32bit = 1;
927 s->version = FFMAX(s->version, 1);
928 break;
929 case AV_PIX_FMT_RGB48:
930 s->colorspace = 1;
931 s->chroma_planes = 1;
932 s->bits_per_raw_sample = 16;
933 s->use32bit = 1;
934 s->version = FFMAX(s->version, 1);
935 break;
936 case AV_PIX_FMT_BAYER_RGGB16:
937 s->colorspace = 2;
938 s->chroma_planes = 1;
939 s->bits_per_raw_sample = 16;
940 s->use32bit = 1;
941 s->version = FFMAX(s->version, 4);
942 s->bayer = 1;
943 break;
944 case AV_PIX_FMT_GBRP:
945 case AV_PIX_FMT_0RGB32:
946 s->colorspace = 1;
947 s->chroma_planes = 1;
948 s->bits_per_raw_sample = 8;
949 break;
950 case AV_PIX_FMT_GBRP9:
951 if (!avctx->bits_per_raw_sample)
952 s->bits_per_raw_sample = 9;
953 av_fallthrough;
954 case AV_PIX_FMT_X2BGR10:
955 case AV_PIX_FMT_X2RGB10:
956 case AV_PIX_FMT_GBRP10:
957 case AV_PIX_FMT_GBRAP10:
958 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
959 s->bits_per_raw_sample = 10;
960 av_fallthrough;
961 case AV_PIX_FMT_GBRP12:
962 case AV_PIX_FMT_GBRAP12:
963 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
964 s->bits_per_raw_sample = 12;
965 av_fallthrough;
966 case AV_PIX_FMT_GBRP14:
967 case AV_PIX_FMT_GBRAP14:
968 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
969 s->bits_per_raw_sample = 14;
970 av_fallthrough;
971 case AV_PIX_FMT_GBRP16:
972 case AV_PIX_FMT_GBRAP16:
973 case AV_PIX_FMT_GBRPF16:
974 case AV_PIX_FMT_GBRAPF16:
975 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
976 s->bits_per_raw_sample = 16;
977 av_fallthrough;
978 case AV_PIX_FMT_GBRPF32:
979 case AV_PIX_FMT_GBRAPF32:
980 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
981 s->bits_per_raw_sample = 32;
982 else if (!s->bits_per_raw_sample)
983 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
984 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
985 s->colorspace = 1;
986 s->chroma_planes = 1;
987 if (s->bits_per_raw_sample >= 16) {
988 s->use32bit = 1;
989 }
990 s->version = FFMAX(s->version, 1);
991 break;
992 default:
993 av_log(avctx, AV_LOG_ERROR, "format %s not supported\n",
994 av_get_pix_fmt_name(pix_fmt));
995 return AVERROR(ENOSYS);
996 }
997 s->flt = !!(desc->flags & AV_PIX_FMT_FLAG_FLOAT);
998 if (s->flt || s->remap_mode > 0)
999 s->version = FFMAX(s->version, 4);
1000 av_assert0(s->bits_per_raw_sample >= 8);
1001
1002 if (s->remap_mode < 0)
1003 s->remap_mode = s->flt ? 2 : 0;
1004 if (s->remap_mode == 0 && s->bits_per_raw_sample == 32) {
1005 av_log(avctx, AV_LOG_ERROR, "32bit requires remap\n");
1006 return AVERROR(EINVAL);
1007 }
1008 if (s->remap_mode == 2 &&
1009 !((s->bits_per_raw_sample == 16 || s->bits_per_raw_sample == 32 || s->bits_per_raw_sample == 64) && s->flt)) {
1010 av_log(avctx, AV_LOG_ERROR, "remap 2 is for float16/32/64 only\n");
1011 return AVERROR(EINVAL);
1012 }
1013
1014 return av_pix_fmt_get_chroma_sub_sample(pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
1015}
1016
1017static av_cold int encode_init_internal(AVCodecContext *avctx)
1018{
1019 int ret;
1020 FFV1Context *s = avctx->priv_data;
1021
1022 if ((ret = ff_ffv1_common_init(avctx, s)) < 0)
1023 return ret;
1024
1025 if (s->ac == 1) // Compatibility with common command line usage
1026 s->ac = AC_RANGE_CUSTOM_TAB;
1027 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
1028 s->ac = AC_RANGE_DEFAULT_TAB;
1029
1030 ret = ff_ffv1_encode_setup_plane_info(avctx, avctx->pix_fmt);
1031 if (ret < 0)
1032 return ret;
1033
1034 if (s->bayer && (avctx->width & 1 || avctx->height & 1)) {
1035 av_log(avctx, AV_LOG_ERROR, "bayer requires even dimensions\n");
1036 return AVERROR(EINVAL);
1037 }
1038
1039 if (s->bits_per_raw_sample > (s->version > 3 ? 16 : 8) && !s->remap_mode) {
1040 if (s->ac == AC_GOLOMB_RICE) {
1041 av_log(avctx, AV_LOG_INFO,
1042 "high bits_per_raw_sample, forcing range coder\n");
1043 s->ac = AC_RANGE_CUSTOM_TAB;
1044 }
1045 }
1046
1047
1048 ret = ff_ffv1_encode_init(avctx);
1049 if (ret < 0)
1050 return ret;
1051
1052 if (s->version > 1) {
1053 if ((ret = ff_ffv1_encode_determine_slices(avctx)) < 0)
1054 return ret;
1055
1056 if ((ret = ff_ffv1_write_extradata(avctx)) < 0)
1057 return ret;
1058 }
1059
1060 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
1061 return ret;
1062 s->slice_count = s->max_slice_count;
1063
1064 for (int j = 0; j < s->slice_count; j++) {
1065 FFV1SliceContext *sc = &s->slices[j];
1066
1067 for (int i = 0; i < s->plane_count; i++) {
1068 PlaneContext *const p = &s->slices[j].plane[i];
1069
1070 p->quant_table_index = s->context_model;
1071 p->context_count = s->context_count[p->quant_table_index];
1072 }
1073 av_assert0(s->remap_mode >= 0);
1074 if (s->remap_mode) {
1075 for (int p = 0; p < 1 + 2*s->chroma_planes + s->transparency ; p++) {
1076 if (s->bits_per_raw_sample == 32) {
1077 sc->unit[p] = av_malloc_array(sc->slice_width, sc->slice_height * sizeof(**sc->unit));
1078 if (!sc->unit[p])
1079 return AVERROR(ENOMEM);
1080 sc->bitmap[p] = av_malloc_array(sc->slice_width * sc->slice_height, sizeof(*sc->bitmap[p]));
1081 if (!sc->bitmap[p])
1082 return AVERROR(ENOMEM);
1083 } else {
1084 sc->fltmap[p] = av_malloc_array(65536, sizeof(*sc->fltmap[p]));
1085 if (!sc->fltmap[p])
1086 return AVERROR(ENOMEM);
1087 }
1088 }
1089 }
1090
1091 ff_build_rac_states(&s->slices[j].c, 0.05 * (1LL << 32), 256 - 8);
1092
1093 s->slices[j].remap = s->remap_mode;
1094 }
1095
1096 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
1097 return ret;
1098
1099#define STATS_OUT_SIZE 1024 * 1024 * 6
1100 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1101 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
1102 if (!avctx->stats_out)
1103 return AVERROR(ENOMEM);
1104 for (int i = 0; i < s->quant_table_count; i++)
1105 for (int j = 0; j < s->max_slice_count; j++) {
1106 FFV1SliceContext *sc = &s->slices[j];
1107 av_assert0(!sc->rc_stat2[i]);
1108 sc->rc_stat2[i] = av_mallocz(s->context_count[i] *
1109 sizeof(*sc->rc_stat2[i]));
1110 if (!sc->rc_stat2[i])
1111 return AVERROR(ENOMEM);
1112 }
1113 }
1114
1115 return 0;
1116}
1117
1118static void encode_slice_header(FFV1Context *f, FFV1SliceContext *sc)
1119{
1120 RangeCoder *c = &sc->c;
1121 uint8_t state[CONTEXT_SIZE];
1122 int j;
1123 memset(state, 128, sizeof(state));
1124
1125 put_symbol(c, state, sc->sx, 0);
1126 put_symbol(c, state, sc->sy, 0);
1127 put_symbol(c, state, 0, 0);
1128 put_symbol(c, state, 0, 0);
1129 for (j=0; j<f->plane_count; j++) {
1130 put_symbol(c, state, sc->plane[j].quant_table_index, 0);
1131 av_assert0(sc->plane[j].quant_table_index == f->context_model);
1132 }
1133 if (!(f->cur_enc_frame->flags & AV_FRAME_FLAG_INTERLACED))
1134 put_symbol(c, state, 3, 0);
1135 else
1136 put_symbol(c, state, 1 + !(f->cur_enc_frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST), 0);
1137 put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.num, 0);
1138 put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.den, 0);
1139 if (f->version > 3) {
1140 put_rac(c, state, sc->slice_coding_mode == 1);
1141 if (sc->slice_coding_mode == 1)
1142 ff_ffv1_clear_slice_state(f, sc);
1143 put_symbol(c, state, sc->slice_coding_mode, 0);
1144 if (sc->slice_coding_mode != 1 && f->colorspace != 0) {
1145 put_symbol(c, state, sc->slice_rct_by_coef, 0);
1146 put_symbol(c, state, sc->slice_rct_ry_coef, 0);
1147 }
1148 put_symbol(c, state, sc->remap, 0);
1149 }
1150}
1151
1152static void choose_rct_params(const FFV1Context *f, FFV1SliceContext *sc,
1153 const uint8_t *src[3], const int stride[3], int w, int h)
1154{
1155#define NB_Y_COEFF 15
1156 static const int rct_y_coeff[15][2] = {
1157 {0, 0}, // 4G
1158 {1, 1}, // R + 2G + B
1159 {2, 2}, // 2R + 2B
1160 {0, 2}, // 2G + 2B
1161 {2, 0}, // 2R + 2G
1162 {4, 0}, // 4R
1163 {0, 4}, // 4B
1164
1165 {0, 3}, // 1G + 3B
1166 {3, 0}, // 3R + 1G
1167 {3, 1}, // 3R + B
1168 {1, 3}, // R + 3B
1169 {1, 2}, // R + G + 2B
1170 {2, 1}, // 2R + G + B
1171 {0, 1}, // 3G + B
1172 {1, 0}, // R + 3G
1173 };
1174
1175 int stat[NB_Y_COEFF] = {0};
1176 int x, y, i, p, best;
1177 int16_t *sample[3];
1178 int lbd = f->bits_per_raw_sample <= 8;
1179 int packed = !src[1];
1180 int transparency = f->transparency;
1181 int packed_size = (3 + transparency)*2;
1182
1183 for (y = 0; y < h; y++) {
1184 int lastr=0, lastg=0, lastb=0;
1185 for (p = 0; p < 3; p++)
1186 sample[p] = sc->sample_buffer + p*w;
1187
1188 for (x = 0; x < w; x++) {
1189 int b, g, r;
1190 int ab, ag, ar;
1191 if (lbd) {
1192 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1193 b = v & 0xFF;
1194 g = (v >> 8) & 0xFF;
1195 r = (v >> 16) & 0xFF;
1196 } else if (packed) {
1197 const uint16_t *p = ((const uint16_t*)(src[0] + x*packed_size + stride[0]*y));
1198 r = p[0];
1199 g = p[1];
1200 b = p[2];
1201 } else if (f->use32bit || transparency) {
1202 g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
1203 b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
1204 r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
1205 } else {
1206 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1207 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1208 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1209 }
1210
1211 ar = r - lastr;
1212 ag = g - lastg;
1213 ab = b - lastb;
1214 if (x && y) {
1215 int bg = ag - sample[0][x];
1216 int bb = ab - sample[1][x];
1217 int br = ar - sample[2][x];
1218
1219 br -= bg;
1220 bb -= bg;
1221
1222 for (i = 0; i<NB_Y_COEFF; i++) {
1223 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1224 }
1225
1226 }
1227 sample[0][x] = ag;
1228 sample[1][x] = ab;
1229 sample[2][x] = ar;
1230
1231 lastr = r;
1232 lastg = g;
1233 lastb = b;
1234 }
1235 }
1236
1237 best = 0;
1238 for (i=1; i<NB_Y_COEFF; i++) {
1239 if (stat[i] < stat[best])
1240 best = i;
1241 }
1242
1243 sc->slice_rct_by_coef = rct_y_coeff[best][1];
1244 sc->slice_rct_ry_coef = rct_y_coeff[best][0];
1245}
1246
1247static void choose_rct_params_bayer(const FFV1Context *f, FFV1SliceContext *sc,
1248 const uint8_t *src[4], const int stride[4],
1249 int w, int h)
1250{
1251 static const int rct_y_coeff[NB_Y_COEFF][2] = {
1252 { 0, 0 }, { 1, 1 }, { 2, 2 }, { 0, 2 }, { 2, 0 }, { 4, 0 }, { 0, 4 }, { 0, 3 },
1253 { 3, 0 }, { 3, 1 }, { 1, 3 }, { 1, 2 }, { 2, 1 }, { 0, 1 }, { 1, 0 },
1254 };
1255 int stat[NB_Y_COEFF] = {0};
1256 int16_t *sample[3];
1257 int i, best;
1258
1259 /* Walk in 2x2 blocks, build per-block gm/b/r, evaluate prediction-error */
1260 w >>= 1;
1261 for (i = 0; i < 3; i++)
1262 sample[i] = sc->sample_buffer + i*w;
1263
1264 for (int y = 0; y < h; y += 2) {
1265 int last_gm = 0, last_b = 0, last_r = 0;
1266 for (int x = 0; x < w; x++) {
1267 const uint16_t *l1 = (const uint16_t *)(src[0] + stride[0]*(y + 0) + x*2*2);
1268 const uint16_t *l2 = (const uint16_t *)(src[0] + stride[0]*(y + 1) + x*2*2);
1269 int r = l1[0];
1270 int gr = l1[1];
1271 int gb = l2[0];
1272 int b = l2[1];
1273 int gd = gr - gb;
1274 int gm = gb + (gd >> 1);
1275
1276 int agm = gm - last_gm;
1277 int ab = b - last_b;
1278 int ar = r - last_r;
1279
1280 if (x && y) {
1281 int bgm = agm - sample[0][x];
1282 int bb = ab - sample[1][x];
1283 int br = ar - sample[2][x];
1284
1285 br -= bgm;
1286 bb -= bgm;
1287
1288 for (i = 0; i < NB_Y_COEFF; i++)
1289 stat[i] += FFABS(bgm + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1]) >> 2));
1290 }
1291 sample[0][x] = agm;
1292 sample[1][x] = ab;
1293 sample[2][x] = ar;
1294
1295 last_gm = gm;
1296 last_b = b;
1297 last_r = r;
1298 }
1299 }
1300
1301 best = 0;
1302 for (i = 1; i < NB_Y_COEFF; i++)
1303 if (stat[i] < stat[best])
1304 best = i;
1305
1306 sc->slice_rct_by_coef = rct_y_coeff[best][1];
1307 sc->slice_rct_ry_coef = rct_y_coeff[best][0];
1308}
1309
1310static void encode_histogram_remap(FFV1Context *f, FFV1SliceContext *sc)
1311{
1312 int len = 1 << f->bits_per_raw_sample;
1313 int flip = sc->remap == 2 ? 0x7FFF : 0;
1314
1315 for (int p= 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
1316 int j = 0;
1317 int lu = 0;
1318 uint8_t state[2][32];
1319 int run = 0;
1320
1321 memset(state, 128, sizeof(state));
1322 put_symbol(&sc->c, state[0], 0, 0);
1323 memset(state, 128, sizeof(state));
1324 for (int i= 0; i<len; i++) {
1325 int ri = i ^ ((i&0x8000) ? 0 : flip);
1326 int u = sc->fltmap[p][ri];
1327 sc->fltmap[p][ri] = j;
1328 j+= u;
1329
1330 if (lu == u) {
1331 run ++;
1332 } else {
1333 put_symbol_inline(&sc->c, state[lu], run, 0, NULL, NULL);
1334 if (run == 0)
1335 lu = u;
1336 run = 0;
1337 }
1338 }
1339 if (run)
1340 put_symbol(&sc->c, state[lu], run, 0);
1341 sc->remap_count[p] = j;
1342 }
1343}
1344
1345static void load_rgb_float32_frame(FFV1Context *f, FFV1SliceContext *sc,
1346 const uint8_t *src[4],
1347 int w, int h, const int stride[4])
1348{
1349 int x, y;
1350 int transparency = f->transparency;
1351 int i = 0;
1352
1353 for (y = 0; y < h; y++) {
1354 for (x = 0; x < w; x++) {
1355 int b, g, r, av_uninit(a);
1356
1357 g = *((const uint32_t *)(src[0] + x*4 + stride[0]*y));
1358 b = *((const uint32_t *)(src[1] + x*4 + stride[1]*y));
1359 r = *((const uint32_t *)(src[2] + x*4 + stride[2]*y));
1360 if (transparency)
1361 a = *((const uint32_t *)(src[3] + x*4 + stride[3]*y));
1362
1363 if (sc->remap == 2) {
1364#define FLIP(f) (((f)&0x80000000) ? (f) : (f)^0x7FFFFFFF);
1365 g = FLIP(g);
1366 b = FLIP(b);
1367 r = FLIP(r);
1368 }
1369 // We cannot build a histogram as we do for 16bit, we need a bit of magic here
1370 // Its possible to reduce the memory needed at the cost of more dereferencing
1371 sc->unit[0][i].val = g;
1372 sc->unit[0][i].ndx = x + y*w;
1373
1374 sc->unit[1][i].val = b;
1375 sc->unit[1][i].ndx = x + y*w;
1376
1377 sc->unit[2][i].val = r;
1378 sc->unit[2][i].ndx = x + y*w;
1379
1380 if (transparency) {
1381 sc->unit[3][i].val = a;
1382 sc->unit[3][i].ndx = x + y*w;
1383 }
1384 i++;
1385 }
1386 }
1387
1388 //TODO switch to radix sort
1389#define CMP(A,B) ((A)->val - (int64_t)(B)->val)
1390 AV_QSORT(sc->unit[0], i, struct Unit, CMP);
1391 AV_QSORT(sc->unit[1], i, struct Unit, CMP);
1392 AV_QSORT(sc->unit[2], i, struct Unit, CMP);
1393 if (transparency)
1394 AV_QSORT(sc->unit[3], i, struct Unit, CMP);
1395}
1396
1397static int encode_float32_remap_segment(FFV1SliceContext *sc,
1398 int p, int mul_count, int *mul_tab, int update, int final)
1399{
1400 const int pixel_num = sc->slice_width * sc->slice_height;
1401 uint8_t state[2][3][32];
1402 int mul[4096+1];
1403 RangeCoder rc = sc->c;
1404 int lu = 0;
1405 int run = 0;
1406 int64_t last_val = -1;
1407 int compact_index = -1;
1408 int i = 0;
1409 int current_mul_index = -1;
1410 int run1final = 0;
1411 int run1start_i;
1412 int run1start_last_val;
1413 int run1start_mul_index;
1414
1415 memcpy(mul, mul_tab, sizeof(*mul_tab)*(mul_count+1));
1416 memset(state, 128, sizeof(state));
1417 put_symbol(&rc, state[0][0], mul_count, 0);
1418 memset(state, 128, sizeof(state));
1419
1420 for (; i < pixel_num+1; i++) {
1421 int current_mul = current_mul_index < 0 ? 1 : FFABS(mul[current_mul_index]);
1422 int64_t val;
1423 if (i == pixel_num) {
1424 if (last_val == 0xFFFFFFFF && (!run || run1final)) {
1425 break;
1426 } else {
1427 val = last_val + ((1LL<<32) - last_val + current_mul - 1) / current_mul * current_mul;
1428 av_assert2(val >= (1LL<<32));
1429 val += lu * current_mul; //ensure a run1 ends
1430 }
1431 } else
1432 val = sc->unit[p][i].val;
1433
1434 if (last_val != val) {
1435 int64_t delta = val - last_val;
1436 int64_t step = FFMAX(1, (delta + current_mul/2) / current_mul);
1437 av_assert2(last_val < val);
1438 av_assert2(current_mul > 0);
1439
1440 delta -= step*current_mul;
1441 av_assert2(delta <= current_mul/2);
1442 av_assert2(delta > -current_mul);
1443
1444 av_assert2(step > 0);
1445 if (lu) {
1446 if (!run) {
1447 run1start_i = i - 1;
1448 run1start_last_val = last_val;
1449 run1start_mul_index= current_mul_index;
1450 }
1451 if (step == 1) {
1452 if (run1final) {
1453 if (current_mul>1)
1454 put_symbol_inline(&rc, state[lu][1], delta, 1, NULL, NULL);
1455 }
1456 run ++;
1457 av_assert2(last_val + current_mul + delta == val);
1458 } else {
1459 if (run1final) {
1460 if (run == 0)
1461 lu ^= 1;
1462 i--; // we did not encode val so we need to backstep
1463 last_val += current_mul;
1464 } else {
1465 put_symbol_inline(&rc, state[lu][0], run, 0, NULL, NULL);
1466 i = run1start_i;
1467 last_val = run1start_last_val; // we could compute this instead of storing
1468 current_mul_index = run1start_mul_index;
1469 }
1470 run1final ^= 1;
1471
1472 run = 0;
1473 continue;
1474 }
1475 } else {
1476 av_assert2(run == 0);
1477 av_assert2(run1final == 0);
1478 put_symbol_inline(&rc, state[lu][0], step - 1, 0, NULL, NULL);
1479
1480 if (current_mul > 1)
1481 put_symbol_inline(&rc, state[lu][1], delta, 1, NULL, NULL);
1482 if (step == 1)
1483 lu ^= 1;
1484
1485 av_assert2(last_val + step * current_mul + delta == val);
1486 }
1487 last_val = val;
1488 current_mul_index = ((last_val + 1) * mul_count) >> 32;
1489 if (!run || run1final) {
1490 av_assert2(mul[ current_mul_index ]);
1491 if (mul[ current_mul_index ] < 0) {
1492 av_assert2(i < pixel_num);
1493 mul[ current_mul_index ] *= -1;
1494 put_symbol_inline(&rc, state[0][2], mul[ current_mul_index ], 0, NULL, NULL);
1495 }
1496 if (i < pixel_num)
1497 compact_index ++;
1498 }
1499 }
1500 if (!run || run1final)
1501 if (final && i < pixel_num)
1502 sc->bitmap[p][sc->unit[p][i].ndx] = compact_index;
1503 }
1504
1505 if (update) {
1506 sc->c = rc;
1507 sc->remap_count[p] = compact_index + 1;
1508 }
1509 return get_rac_count(&rc);
1510}
1511
1512static void encode_float32_remap(FFV1Context *f, FFV1SliceContext *sc,
1513 const uint8_t *src[4])
1514{
1515 int pixel_num = sc->slice_width * sc->slice_height;
1516 const int max_log2_mul_count = ((int[]){ 1, 1, 1, 9, 9, 10})[f->remap_optimizer];
1517 const int log2_mul_count_step = ((int[]){ 1, 1, 1, 9, 9, 1})[f->remap_optimizer];
1518 const int max_log2_mul = ((int[]){ 1, 8, 8, 9, 22, 22})[f->remap_optimizer];
1519 const int log2_mul_step = ((int[]){ 1, 8, 1, 1, 1, 1})[f->remap_optimizer];
1520 const int bruteforce_count = ((int[]){ 0, 0, 0, 1, 1, 1})[f->remap_optimizer];
1521 const int stair_mode = ((int[]){ 0, 0, 0, 1, 0, 0})[f->remap_optimizer];
1522 const int magic_log2 = ((int[]){ 1, 1, 1, 1, 0, 0})[f->remap_optimizer];
1523
1524 for (int p= 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
1525 int best_log2_mul_count = 0;
1526 float score_sum[11] = {0};
1527 int mul_all[11][1025];
1528
1529 for (int log2_mul_count= 0; log2_mul_count <= max_log2_mul_count; log2_mul_count += log2_mul_count_step) {
1530 float score_tab_all[1025][23] = {0};
1531 int64_t last_val = -1;
1532 int *mul_tab = mul_all[log2_mul_count];
1533 int last_mul_index = -1;
1534 int mul_count = 1 << log2_mul_count;
1535
1536 score_sum[log2_mul_count] = 2 * log2_mul_count;
1537 if (magic_log2)
1538 score_sum[log2_mul_count] = av_float2int((float)mul_count * mul_count);
1539 for (int i= 0; i<pixel_num; i++) {
1540 int64_t val = sc->unit[p][i].val;
1541 int mul_index = (val + 1LL)*mul_count >> 32;
1542 if (val != last_val) {
1543 float *score_tab = score_tab_all[(last_val + 1LL)*mul_count >> 32];
1544 av_assert2(last_val < val);
1545 for(int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1546 int64_t delta = val - last_val;
1547 int mul;
1548 int64_t cost;
1549
1550 if (last_val < 0) {
1551 mul = 1;
1552 } else if (stair_mode && mul_count == 512 && si == max_log2_mul ) {
1553 if (mul_index >= 0x378/8 && mul_index <= 23 + 0x378/8) {
1554 mul = (0x800080 >> (mul_index - 0x378/8));
1555 } else
1556 mul = 1;
1557 } else {
1558 mul = (0x10001LL)<<si >> 16;
1559 }
1560
1561 cost = FFMAX((delta + mul/2) / mul, 1);
1562 float score = 1;
1563 if (mul > 1) {
1564 score *= (FFABS(delta - cost*mul)+1);
1565 if (mul_count > 1)
1566 score *= score;
1567 }
1568 score *= cost;
1569 score *= score;
1570 if (mul_index != last_mul_index)
1571 score *= mul;
1572 if (magic_log2) {
1573 score_tab[si] += av_float2int(score);
1574 } else
1575 score_tab[si] += log2f(score);
1576 }
1577 }
1578 last_val = val;
1579 last_mul_index = mul_index;
1580 }
1581 for(int i= 0; i<mul_count; i++) {
1582 int best_index = 0;
1583 float *score_tab = score_tab_all[i];
1584 for(int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1585 if (score_tab[si] < score_tab[ best_index ])
1586 best_index = si;
1587 }
1588 if (stair_mode && mul_count == 512 && best_index == max_log2_mul ) {
1589 if (i >= 0x378/8 && i <= 23 + 0x378/8) {
1590 mul_tab[i] = -(0x800080 >> (i - 0x378/8));
1591 } else
1592 mul_tab[i] = -1;
1593 } else
1594 mul_tab[i] = -((0x10001LL)<<best_index >> 16);
1595 score_sum[log2_mul_count] += score_tab[ best_index ];
1596 }
1597 mul_tab[mul_count] = 1;
1598
1599 if (bruteforce_count)
1600 score_sum[log2_mul_count] = encode_float32_remap_segment(sc, p, mul_count, mul_all[log2_mul_count], 0, 0);
1601
1602 if (score_sum[log2_mul_count] < score_sum[best_log2_mul_count])
1603 best_log2_mul_count = log2_mul_count;
1604 }
1605
1606 encode_float32_remap_segment(sc, p, 1<<best_log2_mul_count, mul_all[best_log2_mul_count], 1, 1);
1607 }
1608}
1609
1610static int encode_float32_rgb_frame(FFV1Context *f, FFV1SliceContext *sc,
1611 const uint8_t *src[4],
1612 int w, int h, const int stride[4], int ac)
1613{
1614 int x, y, p, i;
1615 const int ring_size = f->context_model ? 3 : 2;
1616 int32_t *sample[4][3];
1617 const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
1618 int bits[4], offset;
1619 int transparency = f->transparency;
1620
1621 ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, NULL, f->bits_per_raw_sample);
1622
1623 sc->run_index = 0;
1624
1625 for (int p = 0; p < MAX_PLANES; ++p)
1626 sample[p][2] = sc->sample_buffer32; // dummy to avoid UB pointer arithmetic
1627
1628 memset(RENAME(sc->sample_buffer), 0, ring_size * MAX_PLANES *
1629 (w + 6) * sizeof(*RENAME(sc->sample_buffer)));
1630
1631 for (y = 0; y < h; y++) {
1632 for (i = 0; i < ring_size; i++)
1633 for (p = 0; p < MAX_PLANES; p++)
1634 sample[p][i]= RENAME(sc->sample_buffer) + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
1635
1636 for (x = 0; x < w; x++) {
1637 int b, g, r, av_uninit(a);
1638 g = sc->bitmap[0][x + w*y];
1639 b = sc->bitmap[1][x + w*y];
1640 r = sc->bitmap[2][x + w*y];
1641 if (transparency)
1642 a = sc->bitmap[3][x + w*y];
1643
1644 if (sc->slice_coding_mode != 1) {
1645 b -= g;
1646 r -= g;
1647 g += (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2;
1648 b += offset;
1649 r += offset;
1650 }
1651
1652 sample[0][0][x] = g;
1653 sample[1][0][x] = b;
1654 sample[2][0][x] = r;
1655 sample[3][0][x] = a;
1656 }
1657 for (p = 0; p < 3 + transparency; p++) {
1658 int ret;
1659 sample[p][0][-1] = sample[p][1][0 ];
1660 sample[p][1][ w] = sample[p][1][w-1];
1661 ret = encode_line32(f, sc, f->avctx, w, sample[p], (p + 1) / 2,
1662 bits[p], ac, pass1);
1663 if (ret < 0)
1664 return ret;
1665 }
1666 }
1667 return 0;
1668}
1669
1670static int encode_bayer_frame(FFV1Context *f, FFV1SliceContext *sc,
1671 const uint8_t *src[4],
1672 int w, int h, const int stride[4], int ac)
1673{
1674 const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
1675 const int ring_size = f->context_model ? 3 : 2;
1676 TYPE *sample[4][3];
1677
1678 int bits[4], offset;
1679 ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, NULL, f->bits_per_raw_sample);
1680
1681 w >>= 1;
1682
1683 sc->run_index = 0;
1684
1685 for (int p = 0; p < MAX_PLANES; ++p)
1686 sample[p][2] = RENAME(sc->sample_buffer);
1687
1688 memset(RENAME(sc->sample_buffer), 0, ring_size * MAX_PLANES *
1689 (w + 6) * sizeof(*RENAME(sc->sample_buffer)));
1690
1691 for (int y = 0; y < h; y += 2) {
1692 for (int i = 0; i < ring_size; i++)
1693 for (int p = 0; p < MAX_PLANES; p++)
1694 sample[p][i] = RENAME(sc->sample_buffer) + p*ring_size*(w+6) +
1695 ((h+i-y/2) % ring_size)*(w+6) + 3;
1696
1697 for (int x = 0; x < w; x++) {
1698 const uint16_t *l1 = ((const uint16_t*)(src[0] + stride[0]*(y + 0) + x*2*2));
1699 const uint16_t *l2 = ((const uint16_t*)(src[0] + stride[0]*(y + 1) + x*2*2));
1700
1701 int r, gr, gb, b;
1702 r = l1[0];
1703 gr = l1[1];
1704 gb = l2[0];
1705 b = l2[1];
1706
1707 if (sc->slice_coding_mode != 1) {
1708 /**
1709 * Bayer 2x2 RCT, based on:
1710 * "Reversible color transform for Bayer color filter array images", S. Poomrittigul et al,
1711 * APSIPA Transactions on Signal and Information Processing (2013) 2 (1): 1-10,
1712 * doi:10.1017/ATSIP.2013.6 */
1713 int gd = gr - gb;
1714 int gm = gb + (gd >> 1);
1715
1716 b -= gm;
1717 r -= gm;
1718 gm += (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2;
1719 b += offset;
1720 r += offset;
1721 gd += offset;
1722
1723 gr = gm;
1724 gb = gd;
1725 }
1726
1727 sample[0][0][x] = gr;
1728 sample[1][0][x] = gb;
1729 sample[2][0][x] = b;
1730 sample[3][0][x] = r;
1731 }
1732
1733 for (int p = 0; p < 4; p++) {
1734 int ret;
1735 sample[p][0][-1] = sample[p][1][0 ];
1736 sample[p][1][ w] = sample[p][1][w-1];
1737 /* Plane contexts: gm=0 (luma), b-gm/r-gm=1 (chroma diff from
1738 * green), gd=2 (own context - green-green diff has different
1739 * statistics from both luma and chroma). */
1740 ret = RENAME(encode_line)(f, sc, f->avctx, w, sample[p],
1741 p == 1 ? 2 : (p > 1),
1742 bits[p], ac, pass1);
1743 if (ret < 0)
1744 return ret;
1745 }
1746 }
1747
1748 return 0;
1749}
1750
1751static int encode_slice(AVCodecContext *c, void *arg)
1752{
1753 FFV1SliceContext *sc = arg;
1754 FFV1Context *f = c->priv_data;
1755 int width = sc->slice_width;
1756 int height = sc->slice_height;
1757 int x = sc->slice_x;
1758 int y = sc->slice_y;
1759 const AVFrame *const p = f->cur_enc_frame;
1760 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1761 int ret;
1762 RangeCoder c_bak = sc->c;
1763 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1764 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1765 const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1766 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1767 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1768 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1769 int ac = f->ac;
1770
1771 sc->slice_coding_mode = 0;
1772 if (f->version > 3 && f->colorspace == 1) {
1773 choose_rct_params(f, sc, planes, p->linesize, width, height);
1774 } else if (f->bayer) {
1775 choose_rct_params_bayer(f, sc, planes, p->linesize, width, height);
1776 } else {
1777 sc->slice_rct_by_coef = 1;
1778 sc->slice_rct_ry_coef = 1;
1779 }
1780
1781retry:
1782 if (f->key_frame)
1783 ff_ffv1_clear_slice_state(f, sc);
1784 if (f->version > 2) {
1785 encode_slice_header(f, sc);
1786 }
1787
1788 if (sc->remap) {
1789 //Both the 16bit and 32bit remap do exactly the same thing but with 16bits we can
1790 //Implement this using a "histogram" while for 32bit that would be gb sized, thus a more
1791 //complex implementation sorting pairs is used.
1792 if (f->bits_per_raw_sample != 32) {
1793 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8 && c->pix_fmt != AV_PIX_FMT_YAF16) {
1794 const int cx = x >> f->chroma_h_shift;
1795 const int cy = y >> f->chroma_v_shift;
1796
1797 //TODO decide on the order for the encoded remaps and loads. with golomb rice it
1798 // easier to have all range coded ones together, otherwise it may be nicer to handle each plane as a whole?
1799
1800 load_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1801
1802 if (f->chroma_planes) {
1803 load_plane(f, sc, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1804 load_plane(f, sc, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 2, 1);
1805 }
1806 if (f->transparency)
1807 load_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 3, 1);
1808 } else if (c->pix_fmt == AV_PIX_FMT_YA8 || c->pix_fmt == AV_PIX_FMT_YAF16) {
1809 load_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1810 load_plane(f, sc, p->data[0] + (ps>>1) + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1811 } else if (f->use32bit) {
1812 load_rgb_frame32(f, sc, planes, width, height, p->linesize);
1813 } else
1814 load_rgb_frame (f, sc, planes, width, height, p->linesize);
1815
1816 encode_histogram_remap(f, sc);
1817 } else {
1818 load_rgb_float32_frame(f, sc, planes, width, height, p->linesize);
1819 encode_float32_remap(f, sc, planes);
1820 }
1821 }
1822
1823 if (ac == AC_GOLOMB_RICE) {
1824 sc->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&sc->c, f->version > 2) : 0;
1825 init_put_bits(&sc->pb,
1826 sc->c.bytestream_start + sc->ac_byte_count,
1827 sc->c.bytestream_end - sc->c.bytestream_start - sc->ac_byte_count);
1828 }
1829
1830 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8 && c->pix_fmt != AV_PIX_FMT_YAF16) {
1831 const int cx = x >> f->chroma_h_shift;
1832 const int cy = y >> f->chroma_v_shift;
1833
1834 ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 1, ac);
1835
1836 if (f->chroma_planes) {
1837 ret |= encode_plane(f, sc, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1, 1, ac);
1838 ret |= encode_plane(f, sc, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 2, 1, ac);
1839 }
1840 if (f->transparency)
1841 ret |= encode_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 3, 1, ac);
1842 } else if (c->pix_fmt == AV_PIX_FMT_YA8 || c->pix_fmt == AV_PIX_FMT_YAF16) {
1843 ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 2, ac);
1844 ret |= encode_plane(f, sc, p->data[0] + (ps>>1) + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 1, 2, ac);
1845 } else if (f->bits_per_raw_sample == 32) {
1846 ret = encode_float32_rgb_frame(f, sc, planes, width, height, p->linesize, ac);
1847 } else if (f->bayer) {
1848 ret = encode_bayer_frame(f, sc, planes, width, height, p->linesize, ac);
1849 } else if (f->use32bit) {
1850 ret = encode_rgb_frame32(f, sc, planes, width, height, p->linesize, ac);
1851 } else {
1852 ret = encode_rgb_frame(f, sc, planes, width, height, p->linesize, ac);
1853 }
1854
1855 if (ac != AC_GOLOMB_RICE) {
1856 sc->ac_byte_count = ff_rac_terminate(&sc->c, 1);
1857 } else {
1858 flush_put_bits(&sc->pb); // FIXME: nicer padding
1859 sc->ac_byte_count += put_bytes_output(&sc->pb);
1860 }
1861
1862 if (ret < 0) {
1863 av_assert0(sc->slice_coding_mode == 0);
1864 if (f->version < 4) {
1865 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1866 return ret;
1867 }
1868 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1869 ac = 1;
1870 sc->slice_coding_mode = 1;
1871 sc->c = c_bak;
1872 goto retry;
1873 }
1874
1875 return 0;
1876}
1877
1878size_t ff_ffv1_encode_buffer_size(AVCodecContext *avctx)
1879{
1880 FFV1Context *f = avctx->priv_data;
1881
1882 int w = avctx->width + f->num_h_slices;
1883 int h = avctx->height + f->num_v_slices;
1884 size_t maxsize = w*h * (1 + f->transparency);
1885 if (f->chroma_planes)
1886 maxsize += AV_CEIL_RSHIFT(w, f->chroma_h_shift) * AV_CEIL_RSHIFT(h, f->chroma_v_shift) * 2;
1887 maxsize += f->slice_count * 800; //for slice header
1888 if (f->version > 3) {
1889 maxsize *= f->bits_per_raw_sample + 1;
1890 if (f->remap_mode)
1891 maxsize += f->slice_count * 70000 * (1 + 2*f->chroma_planes + f->bayer + f->transparency);
1892 } else {
1893 maxsize += f->slice_count * 2 * (avctx->width + avctx->height); //for bug with slices that code some pixels more than once
1894 maxsize *= 8*(2*f->bits_per_raw_sample + 5);
1895 }
1896 maxsize >>= 3;
1897 maxsize += FF_INPUT_BUFFER_MIN_SIZE;
1898
1899 return maxsize;
1900}
1901
1902static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1903 const AVFrame *pict, int *got_packet)
1904{
1905 FFV1Context *f = avctx->priv_data;
1906 RangeCoder *const c = &f->slices[0].c;
1907 uint8_t keystate = 128;
1908 uint8_t *buf_p;
1909 int i, ret;
1910 int64_t maxsize;
1911
1912 if(!pict) {
1913 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1914 int j, k, m;
1915 char *p = avctx->stats_out;
1916 char *end = p + STATS_OUT_SIZE;
1917
1918 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1919 for (i = 0; i < f->quant_table_count; i++)
1920 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1921
1922 av_assert0(f->slice_count == f->max_slice_count);
1923 for (j = 0; j < f->slice_count; j++) {
1924 const FFV1SliceContext *sc = &f->slices[j];
1925 for (i = 0; i < 256; i++) {
1926 f->rc_stat[i][0] += sc->rc_stat[i][0];
1927 f->rc_stat[i][1] += sc->rc_stat[i][1];
1928 }
1929 for (i = 0; i < f->quant_table_count; i++) {
1930 for (k = 0; k < f->context_count[i]; k++)
1931 for (m = 0; m < 32; m++) {
1932 f->rc_stat2[i][k][m][0] += sc->rc_stat2[i][k][m][0];
1933 f->rc_stat2[i][k][m][1] += sc->rc_stat2[i][k][m][1];
1934 }
1935 }
1936 }
1937
1938 for (j = 0; j < 256; j++) {
1939 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1940 f->rc_stat[j][0], f->rc_stat[j][1]);
1941 p += strlen(p);
1942 }
1943 snprintf(p, end - p, "\n");
1944
1945 for (i = 0; i < f->quant_table_count; i++) {
1946 for (j = 0; j < f->context_count[i]; j++)
1947 for (m = 0; m < 32; m++) {
1948 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1949 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1950 p += strlen(p);
1951 }
1952 }
1953 snprintf(p, end - p, "%d\n", f->gob_count);
1954 }
1955 return 0;
1956 }
1957
1958 /* Maximum packet size */
1959 maxsize = ff_ffv1_encode_buffer_size(avctx);
1960
1961 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1962 FFV1Context *f = avctx->priv_data;
1963 if (!f->maxsize_warned) {
1964 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1965 f->maxsize_warned++;
1966 }
1967 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1968 }
1969
1970 if ((ret = ff_alloc_packet(avctx, pkt, maxsize)) < 0)
1971 return ret;
1972
1973 ff_init_range_encoder(c, pkt->data, pkt->size);
1974 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1975
1976 f->cur_enc_frame = pict;
1977
1978 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1979 put_rac(c, &keystate, 1);
1980 f->key_frame = 1;
1981 f->gob_count++;
1982 write_header(f);
1983 } else {
1984 put_rac(c, &keystate, 0);
1985 f->key_frame = 0;
1986 }
1987
1988 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1989 int i;
1990 for (i = 1; i < 256; i++) {
1991 c->one_state[i] = f->state_transition[i];
1992 c->zero_state[256 - i] = 256 - c->one_state[i];
1993 }
1994 }
1995
1996 for (i = 0; i < f->slice_count; i++) {
1997 FFV1SliceContext *sc = &f->slices[i];
1998 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1999 int len = pkt->size / f->slice_count;
2000 if (i) {
2001 ff_init_range_encoder(&sc->c, start, len);
2002 } else {
2003 av_assert0(sc->c.bytestream_end >= sc->c.bytestream_start + len);
2004 av_assert0(sc->c.bytestream < sc->c.bytestream_start + len);
2005 sc->c.bytestream_end = sc->c.bytestream_start + len;
2006 }
2007 }
2008 avctx->execute(avctx, encode_slice, f->slices, NULL,
2009 f->slice_count, sizeof(*f->slices));
2010
2011 buf_p = pkt->data;
2012 for (i = 0; i < f->slice_count; i++) {
2013 FFV1SliceContext *sc = &f->slices[i];
2014 int bytes = sc->ac_byte_count;
2015 if (i > 0 || f->version > 2) {
2016 av_assert0(bytes < pkt->size / f->slice_count);
2017 memmove(buf_p, sc->c.bytestream_start, bytes);
2018 av_assert0(bytes < (1 << 24));
2019 AV_WB24(buf_p + bytes, bytes);
2020 bytes += 3;
2021 }
2022 if (f->ec) {
2023 unsigned v;
2024 buf_p[bytes++] = 0;
2025 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, buf_p, bytes) ^ (f->crcref ? 0x8CD88196 : 0);
2026 AV_WL32(buf_p + bytes, v);
2027 bytes += 4;
2028 }
2029 buf_p += bytes;
2030 }
2031
2032 if (avctx->flags & AV_CODEC_FLAG_PASS1)
2033 avctx->stats_out[0] = '\0';
2034
2035 f->picture_number++;
2036 pkt->size = buf_p - pkt->data;
2037 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
2038 *got_packet = 1;
2039
2040 return 0;
2041}
2042
2043static av_cold int encode_close(AVCodecContext *avctx)
2044{
2045 FFV1Context *const s = avctx->priv_data;
2046
2047 for (int j = 0; j < s->max_slice_count; j++) {
2048 FFV1SliceContext *sc = &s->slices[j];
2049
2050 for(int p = 0; p<4; p++) {
2051 av_freep(&sc->unit[p]);
2052 av_freep(&sc->bitmap[p]);
2053 }
2054 }
2055
2056 av_freep(&avctx->stats_out);
2057 ff_ffv1_close(s);
2058
2059 return 0;
2060}
2061
2062#define OFFSET(x) offsetof(FFV1Context, x)
2063#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
2064static const AVOption options[] = {
2065 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
2066 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
2067 { .i64 = 0 }, -2, 2, VE, .unit = "coder" },
2068 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
2069 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2070 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
2071 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2072 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
2073 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2074 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
2075 { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2076 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
2077 { .i64 = 0 }, 0, 2, VE },
2078 { "qtable", "Quantization table", OFFSET(qtable), AV_OPT_TYPE_INT,
2079 { .i64 = -1 }, -1, 2, VE , .unit = "qtable"},
2080 { "default", NULL, 0, AV_OPT_TYPE_CONST,
2081 { .i64 = QTABLE_DEFAULT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2082 { "8bit", NULL, 0, AV_OPT_TYPE_CONST,
2083 { .i64 = QTABLE_8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2084 { "greater8bit", NULL, 0, AV_OPT_TYPE_CONST,
2085 { .i64 = QTABLE_GT8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2086 { "remap_mode", "Remap Mode", OFFSET(remap_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE, .unit = "remap_mode" },
2087 { "auto", "Automatic", 0, AV_OPT_TYPE_CONST,
2088 { .i64 = -1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2089 { "off", "Disabled", 0, AV_OPT_TYPE_CONST,
2090 { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2091 { "dualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
2092 { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2093 { "flipdualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
2094 { .i64 = 2 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2095 { "remap_optimizer", "Remap Optimizer", OFFSET(remap_optimizer), AV_OPT_TYPE_INT, { .i64 = 3 }, 0, 5, VE, .unit = "remap_optimizer" },
2096
2097 { NULL }
2098};
2099
2100static const AVClass ffv1_class = {
2101 .class_name = "ffv1 encoder",
2102 .item_name = av_default_item_name,
2103 .option = options,
2104 .version = LIBAVUTIL_VERSION_INT,
2105};
2106
2107const FFCodec ff_ffv1_encoder = {
2108 .p.name = "ffv1",
2109 CODEC_LONG_NAME("FFmpeg video codec #1"),
2110 .p.type = AVMEDIA_TYPE_VIDEO,
2111 .p.id = AV_CODEC_ID_FFV1,
2112 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
2113 AV_CODEC_CAP_SLICE_THREADS |
2114 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
2115 .priv_data_size = sizeof(FFV1Context),
2116 .init = encode_init_internal,
2117 FF_CODEC_ENCODE_CB(encode_frame),
2118 .close = encode_close,
2119 CODEC_PIXFMTS(
2120 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
2121 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
2122 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
2123 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
2124 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
2125 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
2126 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
2127 AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA422P12,
2128 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
2129 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
2130 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
2131 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRAP14,
2132 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
2133 AV_PIX_FMT_YA8,
2134 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
2135 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
2136 AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
2137 AV_PIX_FMT_GRAY9,
2138 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
2139 AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
2140 AV_PIX_FMT_YAF16,
2141 AV_PIX_FMT_GRAYF16,
2142 AV_PIX_FMT_GBRPF16, AV_PIX_FMT_GBRPF32,
2143 AV_PIX_FMT_BAYER_RGGB16),
2144 .color_ranges = AVCOL_RANGE_MPEG,
2145 .p.priv_class = &ffv1_class,
2146 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
2147};
RENAME
#define RENAME(element)
Definition ac3enc_template.c:44
val
static double val(void *priv, double ch)
Definition aeval.c:77
update
static av_always_inline void update(AVFilterContext *ctx, AVFrame *insamples, int is_silence, int current_sample, int64_t nb_samples_notify, AVRational time_base)
Definition af_silencedetect.c:78
ff_ffv1_encoder
const FFCodec ff_ffv1_encoder
Definition ffv1enc.c:2107
VE
#define VE
Definition amfenc_av1.c:30
log2
#define log2(x)
Definition math.h:26
log2f
#define log2f(x)
Definition math.h:27
ring_size
static int ring_size(RingBuffer *ring)
Definition async.c:107
int32_t
int32_t
Definition audioconvert.c:58
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition avassert.h:68
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
avcodec.h
Libavcodec external API header.
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
f
#define f(width, name)
Definition cbs_vp8.c:236
s
#define s(width, name)
Definition cbs_vp9.c:198
fs
#define fs(width, name, subs,...)
Definition cbs_vp9.c:200
codec_internal.h
FF_CODEC_CAP_EOF_FLUSH
#define FF_CODEC_CAP_EOF_FLUSH
The encoder has AV_CODEC_CAP_DELAY set, but does not actually have delay - it only wants to be flushe...
Definition codec_internal.h:90
CODEC_PIXFMTS
#define CODEC_PIXFMTS(...)
Definition codec_internal.h:419
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition codec_internal.h:394
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition codec_internal.h:367
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition codec_internal.h:43
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition common.h:60
av_clip
#define av_clip
Definition common.h:100
av_clip_uint8
#define av_clip_uint8
Definition common.h:106
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition common.h:74
NULL
#define NULL
Definition coverity.c:32
int64_t
long long int64_t
Definition coverity.c:34
crc.h
Public header for CRC hash function implementation.
MAX_SLICES
#define MAX_SLICES
Definition d3d12va_hevc.c:33
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition dcaenc.c:354
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition defs.h:62
pkt
static AVPacket * pkt
Definition demux_decode.c:55
pix_fmt
static enum AVPixelFormat pix_fmt
Definition demux_decode.c:41
init
int(* init)(AVBSFContext *ctx)
Definition dts2pts.c:608
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition encode.c:62
FF_INPUT_BUFFER_MIN_SIZE
#define FF_INPUT_BUFFER_MIN_SIZE
Used by some encoders as upper bound for the length of headers.
Definition encode.h:34
state
static struct @346255127015250356166251341105367306144006377143 state
bits
static const uint8_t bits[8]
Definition fastaudio.c:100
encode_frame
static int encode_frame(OutputFile *of, OutputStream *ost, AVFrame *frame, AVPacket *pkt)
Definition ffmpeg_enc.c:683
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx, FFV1Context *s)
Definition ffv1.c:36
ff_ffv1_init_slices_state
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition ffv1.c:110
ff_need_new_slices
int ff_need_new_slices(int width, int num_h_slices, int chroma_shift)
Definition ffv1.c:120
ff_ffv1_close
av_cold void ff_ffv1_close(FFV1Context *s)
Definition ffv1.c:268
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition ffv1.c:185
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1SliceContext *sc)
Definition ffv1.c:200
ff_ffv1_compute_bits_per_plane
void ff_ffv1_compute_bits_per_plane(const FFV1Context *f, FFV1SliceContext *sc, int bits[4], int *offset, int mask[4], int bits_per_raw_sample)
Definition ffv1.c:224
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition ffv1.c:142
ffv1.h
FF Video Codec 1 (a lossless codec)
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition ffv1.h:45
MAX_PLANES
#define MAX_PLANES
Definition ffv1.h:44
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition ffv1.h:227
MAX_QUANT_TABLE_SIZE
#define MAX_QUANT_TABLE_SIZE
Definition ffv1.h:48
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition ffv1.h:52
AC_RANGE_DEFAULT_TAB_FORCE
#define AC_RANGE_DEFAULT_TAB_FORCE
Definition ffv1.h:55
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition ffv1.h:54
AC_RANGE_DEFAULT_TAB
#define AC_RANGE_DEFAULT_TAB
Definition ffv1.h:53
fold
static av_always_inline int fold(int diff, int bits)
Definition ffv1.h:216
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition ffv1.h:50
TYPE
#define TYPE
Definition ffv1dec.c:90
write_quant_tables
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE])
Definition ffv1enc.c:364
encode_float32_rgb_frame
static int encode_float32_rgb_frame(FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src[4], int w, int h, const int stride[4], int ac)
Definition ffv1enc.c:1610
ff_ffv1_encode_determine_slices
int ff_ffv1_encode_determine_slices(AVCodecContext *avctx)
Definition ffv1enc.c:570
write_quant_table
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition ffv1enc.c:349
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition ffv1enc.c:233
COST2
#define COST2(old, new)
contains_non_128
static int contains_non_128(uint8_t(*initial_state)[CONTEXT_SIZE], int nb_contexts)
Definition ffv1enc.c:372
encode_slice
static int encode_slice(AVCodecContext *c, void *arg)
Definition ffv1enc.c:1751
set_micro_version
static void set_micro_version(FFV1Context *f)
Definition ffv1enc.c:431
choose_rct_params_bayer
static void choose_rct_params_bayer(const FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src[4], const int stride[4], int w, int h)
Definition ffv1enc.c:1247
put_vlc_symbol
static void put_vlc_symbol(PutBitContext *pb, VlcState *const state, int v, int bits)
Definition ffv1enc.c:240
write_header
static void write_header(FFV1Context *f)
Definition ffv1enc.c:384
put_rac
#define put_rac(C, S, B)
ff_ffv1_encode_init
av_cold int ff_ffv1_encode_init(AVCodecContext *avctx)
Definition ffv1enc.c:605
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition ffv1enc.c:2043
quant9_10bit
static const int8_t quant9_10bit[256]
Definition ffv1enc.c:83
encode_float32_remap_segment
static int encode_float32_remap_segment(FFV1SliceContext *sc, int p, int mul_count, int *mul_tab, int update, int final)
Definition ffv1enc.c:1397
FLIP
#define FLIP(f)
quant5
static const int8_t quant5[256]
Definition ffv1enc.c:64
NB_Y_COEFF
#define NB_Y_COEFF
encode_bayer_frame
static int encode_bayer_frame(FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src[4], int w, int h, const int stride[4], int ac)
Definition ffv1enc.c:1670
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition ffv1enc.c:1902
RENAME
#define RENAME(name)
Definition ffv1enc.c:265
load_rgb_float32_frame
static void load_rgb_float32_frame(FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src[4], int w, int h, const int stride[4])
Definition ffv1enc.c:1345
quant5_10bit
static const int8_t quant5_10bit[256]
Definition ffv1enc.c:45
encode_histogram_remap
static void encode_histogram_remap(FFV1Context *f, FFV1SliceContext *sc)
Definition ffv1enc.c:1310
STATS_OUT_SIZE
#define STATS_OUT_SIZE
sort_stt
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition ffv1enc.c:521
choose_rct_params
static void choose_rct_params(const FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src[3], const int stride[3], int w, int h)
Definition ffv1enc.c:1152
ffv1_class
static const AVClass ffv1_class
Definition ffv1enc.c:2100
put_symbol_inline
static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2])
Definition ffv1enc.c:185
encode_init_internal
static av_cold int encode_init_internal(AVCodecContext *avctx)
Definition ffv1enc.c:1017
encode_slice_header
static void encode_slice_header(FFV1Context *f, FFV1SliceContext *sc)
Definition ffv1enc.c:1118
OFFSET
#define OFFSET(x)
Definition ffv1enc.c:2062
ff_ffv1_encode_buffer_size
size_t ff_ffv1_encode_buffer_size(AVCodecContext *avctx)
Definition ffv1enc.c:1878
CMP
#define CMP(A, B)
ff_ffv1_encode_setup_plane_info
av_cold int ff_ffv1_encode_setup_plane_info(AVCodecContext *avctx, enum AVPixelFormat pix_fmt)
Definition ffv1enc.c:822
quant11
static const int8_t quant11[256]
Definition ffv1enc.c:102
find_best_state
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256])
Definition ffv1enc.c:140
ff_ffv1_write_extradata
av_cold int ff_ffv1_write_extradata(AVCodecContext *avctx)
Definition ffv1enc.c:447
encode_float32_remap
static void encode_float32_remap(FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src[4])
Definition ffv1enc.c:1512
load_plane
static void load_plane(FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src, int w, int h, int stride, int remap_index, int pixel_stride)
Definition ffv1enc.c:325
encode_plane
static int encode_plane(FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src, int w, int h, int stride, int plane_index, int remap_index, int pixel_stride, int ac)
Definition ffv1enc.c:274
ver2_state
static const uint8_t ver2_state[256]
Definition ffv1enc.c:121
QTABLE_DEFAULT
@ QTABLE_DEFAULT
Definition ffv1enc.h:29
QTABLE_8BIT
@ QTABLE_8BIT
Definition ffv1enc.h:30
QTABLE_GT8BIT
@ QTABLE_GT8BIT
Definition ffv1enc.h:31
ffv1enc_template.c
sample
#define sample
Definition flacdsp_template.c:44
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition opt.h:298
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition opt.h:258
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition codec.h:147
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition avcodec.h:294
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition codec.h:79
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition codec.h:49
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition codec.h:102
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition avcodec.h:290
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition codec_id.h:83
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
Definition defs.h:40
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition packet.h:650
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition crc.c:389
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition crc.c:421
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition crc.h:52
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition error.h:61
AVERROR
#define AVERROR(e)
Definition error.h:45
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition frame.h:702
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition frame.h:707
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition log.h:231
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition log.h:221
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition log.c:241
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition version.h:85
a
int a
Definition h264pred_template.c:416
r
#define r
Definition input.c:42
b
#define b
Definition input.c:43
av_float2int
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
Definition intfloat.h:50
av_log2
#define av_log2
Definition intmath.h:84
quant_table
static const int16_t quant_table[64]
Definition intrax8.c:511
AV_WB24
#define AV_WB24(p, d)
Definition intreadwrite.h:446
AV_WL32
#define AV_WL32(p, v)
Definition intreadwrite.h:422
offset
unsigned offset
Definition libaomenc.c:763
u
#define u(width, name, range_min, range_max)
Definition cbs_apv.c:68
arg
const char * arg
Definition jacosubdec.c:65
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition rawdec.c:131
attributes.h
Macro definitions for various function/variable attributes.
av_always_inline
#define av_always_inline
Definition attributes.h:72
av_noinline
#define av_noinline
Definition attributes.h:97
av_fallthrough
#define av_fallthrough
Definition attributes.h:67
av_flatten
#define av_flatten
Definition attributes.h:123
av_uninit
#define av_uninit(x)
Definition attributes.h:187
av_cold
#define av_cold
Definition attributes.h:117
desc
const char * desc
Definition libsvtav1.c:83
planes
static const struct @257111027162314367033347246032313251342043035002 planes[]
w
uint8_t w
Definition llvidencdsp.c:39
FFSWAP
#define FFSWAP(type, a, b)
Definition macros.h:52
FFMIN
#define FFMIN(a, b)
Definition macros.h:49
FFMAX
#define FFMAX(a, b)
Definition macros.h:47
mem.h
Memory handling functions.
encode_line
static void encode_line(AVCodecContext *avctx, uint8_t **data, const uint8_t *line, int length)
Definition msrleenc.c:142
av_malloc
#define av_malloc(s)
Definition ops_static.c:52
opt.h
AVOptions.
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition pixdesc.c:3488
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition pixdesc.c:3380
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition pixdesc.c:3460
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition pixdesc.h:147
AV_PIX_FMT_FLAG_FLOAT
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition pixdesc.h:158
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition pixfmt.h:521
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition pixfmt.h:569
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition pixfmt.h:556
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition pixfmt.h:584
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition pixfmt.h:552
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition pixfmt.h:544
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition pixfmt.h:545
AV_PIX_FMT_GRAYF16
#define AV_PIX_FMT_GRAYF16
Definition pixfmt.h:587
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition pixfmt.h:551
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition pixfmt.h:524
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition pixfmt.h:571
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition pixfmt.h:563
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition pixfmt.h:543
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition pixfmt.h:766
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition pixfmt.h:598
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition pixfmt.h:601
AV_PIX_FMT_P216
#define AV_PIX_FMT_P216
Definition pixfmt.h:626
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition pixfmt.h:549
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition pixfmt.h:596
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition pixfmt.h:594
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition pixfmt.h:550
AV_PIX_FMT_GBRAP14
#define AV_PIX_FMT_GBRAP14
Definition pixfmt.h:570
AV_PIX_FMT_P016
#define AV_PIX_FMT_P016
Definition pixfmt.h:610
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition pixfmt.h:564
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition pixfmt.h:546
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition pixfmt.h:526
AV_PIX_FMT_GBRAPF16
#define AV_PIX_FMT_GBRAPF16
Definition pixfmt.h:583
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition pixfmt.h:535
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition pixfmt.h:565
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition pixfmt.h:542
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition pixfmt.h:531
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition pixfmt.h:593
AV_PIX_FMT_BAYER_RGGB16
#define AV_PIX_FMT_BAYER_RGGB16
Definition pixfmt.h:578
AV_PIX_FMT_YAF16
#define AV_PIX_FMT_YAF16
Definition pixfmt.h:590
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition pixfmt.h:597
AV_PIX_FMT_X2RGB10
#define AV_PIX_FMT_X2RGB10
Definition pixfmt.h:619
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition pixfmt.h:553
AVPixelFormat
AVPixelFormat
Pixel format.
Definition pixfmt.h:71
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition pixfmt.h:96
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition pixfmt.h:73
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition pixfmt.h:106
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition pixfmt.h:77
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition pixfmt.h:81
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition pixfmt.h:108
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition pixfmt.h:79
AV_PIX_FMT_NV24
@ AV_PIX_FMT_NV24
planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition pixfmt.h:371
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition pixfmt.h:80
AV_PIX_FMT_NV16
@ AV_PIX_FMT_NV16
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition pixfmt.h:198
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition pixfmt.h:78
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition pixfmt.h:174
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition pixfmt.h:173
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition pixfmt.h:165
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition pixfmt.h:140
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition pixfmt.h:599
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition pixfmt.h:554
AV_PIX_FMT_P416
#define AV_PIX_FMT_P416
Definition pixfmt.h:627
AV_PIX_FMT_X2BGR10
#define AV_PIX_FMT_X2BGR10
Definition pixfmt.h:620
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition pixfmt.h:525
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition pixfmt.h:527
AV_PIX_FMT_GBRPF16
#define AV_PIX_FMT_GBRPF16
Definition pixfmt.h:582
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition pixfmt.h:557
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition pixfmt.h:547
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition pixfmt.h:528
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition pixfmt.h:568
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition pixfmt.h:603
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition pixfmt.h:602
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition pixfmt.h:567
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition pixfmt.h:555
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition pixfmt.h:595
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition pixfmt.h:566
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition pixfmt.h:600
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition pixfmt.h:585
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition pixfmt.h:558
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition pixfmt.h:517
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition pixfmt.h:548
put_bits.h
bitstream writer API
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition put_bits.h:62
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition put_bits.h:153
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition put_bits.h:99
put_golomb.h
exp golomb vlc writing stuff
set_sr_golomb
static void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len)
write signed golomb rice code (ffv1).
Definition put_golomb.h:143
AV_QSORT
#define AV_QSORT(p, num, type, cmp)
Quicksort This sort is fast, and fully inplace but not stable and it is possible to construct input t...
Definition qsort.h:33
ff_rac_terminate
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
Definition rangecoder.c:109
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition rangecoder.c:68
ff_init_range_encoder
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition rangecoder.c:42
rangecoder.h
Range coder.
get_rac_count
static int get_rac_count(RangeCoder *c)
Definition rangecoder.h:79
pred
static const float pred[4]
Definition siprdata.h:259
code
const uint8_t * code
Definition spdifenc.c:433
AVClass
Describe the class of an AVClass context structure.
Definition log.h:76
AVCodecContext
main external API structure.
Definition avcodec.h:443
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition avcodec.h:643
AVCodecContext::width
int width
picture width / height.
Definition avcodec.h:604
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition avcodec.h:1330
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition avcodec.h:1376
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition avcodec.h:1338
AVCodecContext::level
int level
Encoding level descriptor.
Definition avcodec.h:1651
AVCodecContext::execute
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition avcodec.h:1614
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition avcodec.h:1576
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition avcodec.h:1021
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition avcodec.h:500
AVCodecContext::priv_data
void * priv_data
Definition avcodec.h:470
AVCodecContext::slices
int slices
Number of slices.
Definition avcodec.h:1037
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition pixdesc.h:40
AVFrame
This structure describes decoded (raw) audio or video data.
Definition frame.h:479
AVOption
AVOption.
Definition opt.h:428
AVPacket
This structure stores compressed data.
Definition packet.h:580
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition pixdesc.h:69
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition pixdesc.h:105
FFV1SliceContext::slice_rct_ry_coef
int slice_rct_ry_coef
Definition ffv1.h:86
FFV1SliceContext::sample_buffer
int16_t * sample_buffer
Definition ffv1.h:74
FFV1SliceContext::pb
PutBitContext pb
Definition ffv1.h:91
FFV1SliceContext::ac_byte_count
int ac_byte_count
number of bytes used for AC coding
Definition ffv1.h:94
FFV1SliceContext::bitmap
uint32_t * bitmap[4]
Definition ffv1.h:111
FFV1SliceContext::c
RangeCoder c
Definition ffv1.h:92
FFV1SliceContext::rc_stat
uint64_t rc_stat[256][2]
Definition ffv1.h:105
FFV1SliceContext::plane
PlaneContext * plane
Definition ffv1.h:90
FFV1SliceContext::fltmap
uint16_t * fltmap[4]
Definition ffv1.h:112
FFV1SliceContext::rc_stat2
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition ffv1.h:106
FFV1SliceContext::sample_buffer32
int32_t * sample_buffer32
Definition ffv1.h:75
FFV1SliceContext::run_index
int run_index
Definition ffv1.h:83
FFV1SliceContext::remap_count
int remap_count[4]
Definition ffv1.h:109
FFV1SliceContext::slice_height
int slice_height
Definition ffv1.h:78
FFV1SliceContext::slice_width
int slice_width
Definition ffv1.h:77
FFV1SliceContext::slice_coding_mode
int slice_coding_mode
Definition ffv1.h:84
FFV1SliceContext::unit
struct FFV1SliceContext::Unit * unit[4]
FFV1SliceContext::slice_rct_by_coef
int slice_rct_by_coef
Definition ffv1.h:85
PlaneContext::quant_table_index
int quant_table_index
Definition ffv1.h:65
RangeCoder::bytestream_start
uint8_t * bytestream_start
Definition rangecoder.h:42
RangeCoder::bytestream
uint8_t * bytestream
Definition rangecoder.h:43
RangeCoder::bytestream_end
uint8_t * bytestream_end
Definition rangecoder.h:44
run
uint8_t run
Definition svq3.c:207
stride
#define stride
Definition h264pred_template.c:536
av_malloc_array
#define av_malloc_array(a, b)
Definition tableprint_vlc.h:32
av_mallocz
#define av_mallocz(s)
Definition tableprint_vlc.h:31
ff_dlog
#define ff_dlog(a,...)
Definition tableprint_vlc.h:28
av_freep
#define av_freep(p)
Definition tableprint_vlc.h:35
av_log
#define av_log(a,...)
Definition tableprint_vlc.h:27
src
#define src
Definition vp8dsp.c:248
height
#define height
Definition dsp.h:89
width
#define width
Definition dsp.h:89
print
static void print(AVTreeNode *t, int depth)
Definition tree.c:45
size
int size
Definition twinvq_data.h:10344
g
const char * g
Definition vf_curves.c:128
delta
float delta
Definition vorbis_enc_data.h:430
len
int len
Definition vorbis_enc_data.h:426
h
h
Definition vp9dsp_template.c:2070
c
static double c[64]
Definition vsrc_mptestsrc.c:89
Generated on Sat Oct 3 2026 19:20:52 for FFmpeg by doxygen 1.13.2