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 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
695 return ret;
696
697 if (!s->transparency)
698 s->plane_count = 2;
699 if (!s->chroma_planes && s->version > 3)
700 s->plane_count--;
701 if (s->bayer)
702 s->plane_count = 3;
703
704 s->picture_number = 0;
705
706 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
707 for (i = 0; i < s->quant_table_count; i++) {
708 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
709 sizeof(*s->rc_stat2[i]));
710 if (!s->rc_stat2[i])
711 return AVERROR(ENOMEM);
712 }
713 }
714 if (avctx->stats_in) {
715 char *p = avctx->stats_in;
716 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
717 int gob_count = 0;
718 char *next;
719 if (!best_state)
720 return AVERROR(ENOMEM);
721
722 av_assert0(s->version >= 2);
723
724 for (;;) {
725 for (j = 0; j < 256; j++)
726 for (i = 0; i < 2; i++) {
727 s->rc_stat[j][i] = strtol(p, &next, 0);
728 if (next == p) {
729 av_log(avctx, AV_LOG_ERROR,
730 "2Pass file invalid at %d %d [%s]\n", j, i, p);
731 av_freep(&best_state);
732 return AVERROR_INVALIDDATA;
733 }
734 p = next;
735 }
736 for (i = 0; i < s->quant_table_count; i++)
737 for (j = 0; j < s->context_count[i]; j++) {
738 for (k = 0; k < 32; k++)
739 for (m = 0; m < 2; m++) {
740 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
741 if (next == p) {
742 av_log(avctx, AV_LOG_ERROR,
743 "2Pass file invalid at %d %d %d %d [%s]\n",
744 i, j, k, m, p);
745 av_freep(&best_state);
746 return AVERROR_INVALIDDATA;
747 }
748 p = next;
749 }
750 }
751 gob_count = strtol(p, &next, 0);
752 if (next == p || gob_count <= 0) {
753 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
754 av_freep(&best_state);
755 return AVERROR_INVALIDDATA;
756 }
757 p = next;
758 while (*p == '\n' || *p == ' ')
759 p++;
760 if (p[0] == 0)
761 break;
762 }
763 if (s->ac == AC_RANGE_CUSTOM_TAB)
764 sort_stt(s, s->state_transition);
765
766 find_best_state(best_state, s->state_transition);
767
768 for (i = 0; i < s->quant_table_count; i++) {
769 for (k = 0; k < 32; k++) {
770 double a=0, b=0;
771 int jp = 0;
772 for (j = 0; j < s->context_count[i]; j++) {
773 double p = 128;
774 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
775 if (a+b)
776 p = 256.0 * b / (a + b);
777 s->initial_states[i][jp][k] =
778 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
779 for(jp++; jp<j; jp++)
780 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
781 a=b=0;
782 }
783 a += s->rc_stat2[i][j][k][0];
784 b += s->rc_stat2[i][j][k][1];
785 if (a+b) {
786 p = 256.0 * b / (a + b);
787 }
788 s->initial_states[i][j][k] =
789 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
790 }
791 }
792 }
793 av_freep(&best_state);
794 }
795
796 if (s->version <= 1) {
797 /* Disable slices when the version doesn't support them */
798 s->num_h_slices = 1;
799 s->num_v_slices = 1;
800 }
801
802 set_micro_version(s);
803
804 return 0;
805}
806
807av_cold int ff_ffv1_encode_setup_plane_info(AVCodecContext *avctx,
808 enum AVPixelFormat pix_fmt)
809{
810 FFV1Context *s = avctx->priv_data;
811 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
812
813 s->bayer = 0;
814 s->plane_count = 3;
815 switch(pix_fmt) {
816 case AV_PIX_FMT_GRAY9:
817 case AV_PIX_FMT_YUV444P9:
818 case AV_PIX_FMT_YUV422P9:
819 case AV_PIX_FMT_YUV420P9:
820 case AV_PIX_FMT_YUVA444P9:
821 case AV_PIX_FMT_YUVA422P9:
822 case AV_PIX_FMT_YUVA420P9:
823 if (!avctx->bits_per_raw_sample)
824 s->bits_per_raw_sample = 9;
825 av_fallthrough;
826 case AV_PIX_FMT_GRAY10:
827 case AV_PIX_FMT_YUV444P10:
828 case AV_PIX_FMT_YUV440P10:
829 case AV_PIX_FMT_YUV420P10:
830 case AV_PIX_FMT_YUV422P10:
831 case AV_PIX_FMT_YUVA444P10:
832 case AV_PIX_FMT_YUVA422P10:
833 case AV_PIX_FMT_YUVA420P10:
834 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
835 s->bits_per_raw_sample = 10;
836 av_fallthrough;
837 case AV_PIX_FMT_GRAY12:
838 case AV_PIX_FMT_YUV444P12:
839 case AV_PIX_FMT_YUV440P12:
840 case AV_PIX_FMT_YUV420P12:
841 case AV_PIX_FMT_YUV422P12:
842 case AV_PIX_FMT_YUVA444P12:
843 case AV_PIX_FMT_YUVA422P12:
844 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
845 s->bits_per_raw_sample = 12;
846 av_fallthrough;
847 case AV_PIX_FMT_GRAY14:
848 case AV_PIX_FMT_YUV444P14:
849 case AV_PIX_FMT_YUV420P14:
850 case AV_PIX_FMT_YUV422P14:
851 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
852 s->bits_per_raw_sample = 14;
853 s->packed_at_lsb = 1;
854 av_fallthrough;
855 case AV_PIX_FMT_GRAY16:
856 case AV_PIX_FMT_P016:
857 case AV_PIX_FMT_P216:
858 case AV_PIX_FMT_P416:
859 case AV_PIX_FMT_YUV444P16:
860 case AV_PIX_FMT_YUV422P16:
861 case AV_PIX_FMT_YUV420P16:
862 case AV_PIX_FMT_YUVA444P16:
863 case AV_PIX_FMT_YUVA422P16:
864 case AV_PIX_FMT_YUVA420P16:
865 case AV_PIX_FMT_GRAYF16:
866 case AV_PIX_FMT_YAF16:
867 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
868 s->bits_per_raw_sample = 16;
869 } else if (!s->bits_per_raw_sample) {
870 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
871 }
872 if (s->bits_per_raw_sample <= 8) {
873 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
874 return AVERROR_INVALIDDATA;
875 }
876 s->version = FFMAX(s->version, 1);
877 av_fallthrough;
878 case AV_PIX_FMT_GRAY8:
879 case AV_PIX_FMT_YA8:
880 case AV_PIX_FMT_NV12:
881 case AV_PIX_FMT_NV16:
882 case AV_PIX_FMT_NV24:
883 case AV_PIX_FMT_YUV444P:
884 case AV_PIX_FMT_YUV440P:
885 case AV_PIX_FMT_YUV422P:
886 case AV_PIX_FMT_YUV420P:
887 case AV_PIX_FMT_YUV411P:
888 case AV_PIX_FMT_YUV410P:
889 case AV_PIX_FMT_YUVA444P:
890 case AV_PIX_FMT_YUVA422P:
891 case AV_PIX_FMT_YUVA420P:
892 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
893 s->colorspace = 0;
894 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
895 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
896 s->bits_per_raw_sample = 8;
897 else if (!s->bits_per_raw_sample)
898 s->bits_per_raw_sample = 8;
899 break;
900 case AV_PIX_FMT_RGB32:
901 s->colorspace = 1;
902 s->transparency = 1;
903 s->chroma_planes = 1;
904 s->bits_per_raw_sample = 8;
905 break;
906 case AV_PIX_FMT_RGBA64:
907 s->colorspace = 1;
908 s->transparency = 1;
909 s->chroma_planes = 1;
910 s->bits_per_raw_sample = 16;
911 s->use32bit = 1;
912 s->version = FFMAX(s->version, 1);
913 break;
914 case AV_PIX_FMT_RGB48:
915 s->colorspace = 1;
916 s->chroma_planes = 1;
917 s->bits_per_raw_sample = 16;
918 s->use32bit = 1;
919 s->version = FFMAX(s->version, 1);
920 break;
921 case AV_PIX_FMT_BAYER_RGGB16:
922 s->colorspace = 2;
923 s->chroma_planes = 1;
924 s->bits_per_raw_sample = 16;
925 s->use32bit = 1;
926 s->version = FFMAX(s->version, 4);
927 s->bayer = 1;
928 break;
929 case AV_PIX_FMT_GBRP:
930 case AV_PIX_FMT_0RGB32:
931 s->colorspace = 1;
932 s->chroma_planes = 1;
933 s->bits_per_raw_sample = 8;
934 break;
935 case AV_PIX_FMT_GBRP9:
936 if (!avctx->bits_per_raw_sample)
937 s->bits_per_raw_sample = 9;
938 av_fallthrough;
939 case AV_PIX_FMT_X2BGR10:
940 case AV_PIX_FMT_X2RGB10:
941 case AV_PIX_FMT_GBRP10:
942 case AV_PIX_FMT_GBRAP10:
943 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
944 s->bits_per_raw_sample = 10;
945 av_fallthrough;
946 case AV_PIX_FMT_GBRP12:
947 case AV_PIX_FMT_GBRAP12:
948 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
949 s->bits_per_raw_sample = 12;
950 av_fallthrough;
951 case AV_PIX_FMT_GBRP14:
952 case AV_PIX_FMT_GBRAP14:
953 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
954 s->bits_per_raw_sample = 14;
955 av_fallthrough;
956 case AV_PIX_FMT_GBRP16:
957 case AV_PIX_FMT_GBRAP16:
958 case AV_PIX_FMT_GBRPF16:
959 case AV_PIX_FMT_GBRAPF16:
960 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
961 s->bits_per_raw_sample = 16;
962 av_fallthrough;
963 case AV_PIX_FMT_GBRPF32:
964 case AV_PIX_FMT_GBRAPF32:
965 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
966 s->bits_per_raw_sample = 32;
967 else if (!s->bits_per_raw_sample)
968 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
969 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
970 s->colorspace = 1;
971 s->chroma_planes = 1;
972 if (s->bits_per_raw_sample >= 16) {
973 s->use32bit = 1;
974 }
975 s->version = FFMAX(s->version, 1);
976 break;
977 default:
978 av_log(avctx, AV_LOG_ERROR, "format %s not supported\n",
979 av_get_pix_fmt_name(pix_fmt));
980 return AVERROR(ENOSYS);
981 }
982 s->flt = !!(desc->flags & AV_PIX_FMT_FLAG_FLOAT);
983 if (s->flt || s->remap_mode > 0)
984 s->version = FFMAX(s->version, 4);
985 av_assert0(s->bits_per_raw_sample >= 8);
986
987 if (s->remap_mode < 0)
988 s->remap_mode = s->flt ? 2 : 0;
989 if (s->remap_mode == 0 && s->bits_per_raw_sample == 32) {
990 av_log(avctx, AV_LOG_ERROR, "32bit requires remap\n");
991 return AVERROR(EINVAL);
992 }
993 if (s->remap_mode == 2 &&
994 !((s->bits_per_raw_sample == 16 || s->bits_per_raw_sample == 32 || s->bits_per_raw_sample == 64) && s->flt)) {
995 av_log(avctx, AV_LOG_ERROR, "remap 2 is for float16/32/64 only\n");
996 return AVERROR(EINVAL);
997 }
998
999 return av_pix_fmt_get_chroma_sub_sample(pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
1000}
1001
1002static av_cold int encode_init_internal(AVCodecContext *avctx)
1003{
1004 int ret;
1005 FFV1Context *s = avctx->priv_data;
1006
1007 if ((ret = ff_ffv1_common_init(avctx, s)) < 0)
1008 return ret;
1009
1010 if (s->ac == 1) // Compatibility with common command line usage
1011 s->ac = AC_RANGE_CUSTOM_TAB;
1012 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
1013 s->ac = AC_RANGE_DEFAULT_TAB;
1014
1015 ret = ff_ffv1_encode_setup_plane_info(avctx, avctx->pix_fmt);
1016 if (ret < 0)
1017 return ret;
1018
1019 if (s->bayer && (avctx->width & 1 || avctx->height & 1)) {
1020 av_log(avctx, AV_LOG_ERROR, "bayer requires even dimensions\n");
1021 return AVERROR(EINVAL);
1022 }
1023
1024 if (s->bits_per_raw_sample > (s->version > 3 ? 16 : 8) && !s->remap_mode) {
1025 if (s->ac == AC_GOLOMB_RICE) {
1026 av_log(avctx, AV_LOG_INFO,
1027 "high bits_per_raw_sample, forcing range coder\n");
1028 s->ac = AC_RANGE_CUSTOM_TAB;
1029 }
1030 }
1031
1032
1033 ret = ff_ffv1_encode_init(avctx);
1034 if (ret < 0)
1035 return ret;
1036
1037 if (s->version > 1) {
1038 if ((ret = ff_ffv1_encode_determine_slices(avctx)) < 0)
1039 return ret;
1040
1041 if ((ret = ff_ffv1_write_extradata(avctx)) < 0)
1042 return ret;
1043 }
1044
1045 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
1046 return ret;
1047 s->slice_count = s->max_slice_count;
1048
1049 for (int j = 0; j < s->slice_count; j++) {
1050 FFV1SliceContext *sc = &s->slices[j];
1051
1052 for (int i = 0; i < s->plane_count; i++) {
1053 PlaneContext *const p = &s->slices[j].plane[i];
1054
1055 p->quant_table_index = s->context_model;
1056 p->context_count = s->context_count[p->quant_table_index];
1057 }
1058 av_assert0(s->remap_mode >= 0);
1059 if (s->remap_mode) {
1060 for (int p = 0; p < 1 + 2*s->chroma_planes + s->transparency ; p++) {
1061 if (s->bits_per_raw_sample == 32) {
1062 sc->unit[p] = av_malloc_array(sc->slice_width, sc->slice_height * sizeof(**sc->unit));
1063 if (!sc->unit[p])
1064 return AVERROR(ENOMEM);
1065 sc->bitmap[p] = av_malloc_array(sc->slice_width * sc->slice_height, sizeof(*sc->bitmap[p]));
1066 if (!sc->bitmap[p])
1067 return AVERROR(ENOMEM);
1068 } else {
1069 sc->fltmap[p] = av_malloc_array(65536, sizeof(*sc->fltmap[p]));
1070 if (!sc->fltmap[p])
1071 return AVERROR(ENOMEM);
1072 }
1073 }
1074 }
1075
1076 ff_build_rac_states(&s->slices[j].c, 0.05 * (1LL << 32), 256 - 8);
1077
1078 s->slices[j].remap = s->remap_mode;
1079 }
1080
1081 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
1082 return ret;
1083
1084#define STATS_OUT_SIZE 1024 * 1024 * 6
1085 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1086 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
1087 if (!avctx->stats_out)
1088 return AVERROR(ENOMEM);
1089 for (int i = 0; i < s->quant_table_count; i++)
1090 for (int j = 0; j < s->max_slice_count; j++) {
1091 FFV1SliceContext *sc = &s->slices[j];
1092 av_assert0(!sc->rc_stat2[i]);
1093 sc->rc_stat2[i] = av_mallocz(s->context_count[i] *
1094 sizeof(*sc->rc_stat2[i]));
1095 if (!sc->rc_stat2[i])
1096 return AVERROR(ENOMEM);
1097 }
1098 }
1099
1100 return 0;
1101}
1102
1103static void encode_slice_header(FFV1Context *f, FFV1SliceContext *sc)
1104{
1105 RangeCoder *c = &sc->c;
1106 uint8_t state[CONTEXT_SIZE];
1107 int j;
1108 memset(state, 128, sizeof(state));
1109
1110 put_symbol(c, state, sc->sx, 0);
1111 put_symbol(c, state, sc->sy, 0);
1112 put_symbol(c, state, 0, 0);
1113 put_symbol(c, state, 0, 0);
1114 for (j=0; j<f->plane_count; j++) {
1115 put_symbol(c, state, sc->plane[j].quant_table_index, 0);
1116 av_assert0(sc->plane[j].quant_table_index == f->context_model);
1117 }
1118 if (!(f->cur_enc_frame->flags & AV_FRAME_FLAG_INTERLACED))
1119 put_symbol(c, state, 3, 0);
1120 else
1121 put_symbol(c, state, 1 + !(f->cur_enc_frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST), 0);
1122 put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.num, 0);
1123 put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.den, 0);
1124 if (f->version > 3) {
1125 put_rac(c, state, sc->slice_coding_mode == 1);
1126 if (sc->slice_coding_mode == 1)
1127 ff_ffv1_clear_slice_state(f, sc);
1128 put_symbol(c, state, sc->slice_coding_mode, 0);
1129 if (sc->slice_coding_mode != 1 && f->colorspace != 0) {
1130 put_symbol(c, state, sc->slice_rct_by_coef, 0);
1131 put_symbol(c, state, sc->slice_rct_ry_coef, 0);
1132 }
1133 put_symbol(c, state, sc->remap, 0);
1134 }
1135}
1136
1137static void choose_rct_params(const FFV1Context *f, FFV1SliceContext *sc,
1138 const uint8_t *src[3], const int stride[3], int w, int h)
1139{
1140#define NB_Y_COEFF 15
1141 static const int rct_y_coeff[15][2] = {
1142 {0, 0}, // 4G
1143 {1, 1}, // R + 2G + B
1144 {2, 2}, // 2R + 2B
1145 {0, 2}, // 2G + 2B
1146 {2, 0}, // 2R + 2G
1147 {4, 0}, // 4R
1148 {0, 4}, // 4B
1149
1150 {0, 3}, // 1G + 3B
1151 {3, 0}, // 3R + 1G
1152 {3, 1}, // 3R + B
1153 {1, 3}, // R + 3B
1154 {1, 2}, // R + G + 2B
1155 {2, 1}, // 2R + G + B
1156 {0, 1}, // 3G + B
1157 {1, 0}, // R + 3G
1158 };
1159
1160 int stat[NB_Y_COEFF] = {0};
1161 int x, y, i, p, best;
1162 int16_t *sample[3];
1163 int lbd = f->bits_per_raw_sample <= 8;
1164 int packed = !src[1];
1165 int transparency = f->transparency;
1166 int packed_size = (3 + transparency)*2;
1167
1168 for (y = 0; y < h; y++) {
1169 int lastr=0, lastg=0, lastb=0;
1170 for (p = 0; p < 3; p++)
1171 sample[p] = sc->sample_buffer + p*w;
1172
1173 for (x = 0; x < w; x++) {
1174 int b, g, r;
1175 int ab, ag, ar;
1176 if (lbd) {
1177 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1178 b = v & 0xFF;
1179 g = (v >> 8) & 0xFF;
1180 r = (v >> 16) & 0xFF;
1181 } else if (packed) {
1182 const uint16_t *p = ((const uint16_t*)(src[0] + x*packed_size + stride[0]*y));
1183 r = p[0];
1184 g = p[1];
1185 b = p[2];
1186 } else if (f->use32bit || transparency) {
1187 g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
1188 b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
1189 r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
1190 } else {
1191 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1192 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1193 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1194 }
1195
1196 ar = r - lastr;
1197 ag = g - lastg;
1198 ab = b - lastb;
1199 if (x && y) {
1200 int bg = ag - sample[0][x];
1201 int bb = ab - sample[1][x];
1202 int br = ar - sample[2][x];
1203
1204 br -= bg;
1205 bb -= bg;
1206
1207 for (i = 0; i<NB_Y_COEFF; i++) {
1208 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1209 }
1210
1211 }
1212 sample[0][x] = ag;
1213 sample[1][x] = ab;
1214 sample[2][x] = ar;
1215
1216 lastr = r;
1217 lastg = g;
1218 lastb = b;
1219 }
1220 }
1221
1222 best = 0;
1223 for (i=1; i<NB_Y_COEFF; i++) {
1224 if (stat[i] < stat[best])
1225 best = i;
1226 }
1227
1228 sc->slice_rct_by_coef = rct_y_coeff[best][1];
1229 sc->slice_rct_ry_coef = rct_y_coeff[best][0];
1230}
1231
1232static void choose_rct_params_bayer(const FFV1Context *f, FFV1SliceContext *sc,
1233 const uint8_t *src[4], const int stride[4],
1234 int w, int h)
1235{
1236 static const int rct_y_coeff[NB_Y_COEFF][2] = {
1237 { 0, 0 }, { 1, 1 }, { 2, 2 }, { 0, 2 }, { 2, 0 }, { 4, 0 }, { 0, 4 }, { 0, 3 },
1238 { 3, 0 }, { 3, 1 }, { 1, 3 }, { 1, 2 }, { 2, 1 }, { 0, 1 }, { 1, 0 },
1239 };
1240 int stat[NB_Y_COEFF] = {0};
1241 int16_t *sample[3];
1242 int i, best;
1243
1244 /* Walk in 2x2 blocks, build per-block gm/b/r, evaluate prediction-error */
1245 w >>= 1;
1246 for (i = 0; i < 3; i++)
1247 sample[i] = sc->sample_buffer + i*w;
1248
1249 for (int y = 0; y < h; y += 2) {
1250 int last_gm = 0, last_b = 0, last_r = 0;
1251 for (int x = 0; x < w; x++) {
1252 const uint16_t *l1 = (const uint16_t *)(src[0] + stride[0]*(y + 0) + x*2*2);
1253 const uint16_t *l2 = (const uint16_t *)(src[0] + stride[0]*(y + 1) + x*2*2);
1254 int r = l1[0];
1255 int gr = l1[1];
1256 int gb = l2[0];
1257 int b = l2[1];
1258 int gd = gr - gb;
1259 int gm = gb + (gd >> 1);
1260
1261 int agm = gm - last_gm;
1262 int ab = b - last_b;
1263 int ar = r - last_r;
1264
1265 if (x && y) {
1266 int bgm = agm - sample[0][x];
1267 int bb = ab - sample[1][x];
1268 int br = ar - sample[2][x];
1269
1270 br -= bgm;
1271 bb -= bgm;
1272
1273 for (i = 0; i < NB_Y_COEFF; i++)
1274 stat[i] += FFABS(bgm + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1]) >> 2));
1275 }
1276 sample[0][x] = agm;
1277 sample[1][x] = ab;
1278 sample[2][x] = ar;
1279
1280 last_gm = gm;
1281 last_b = b;
1282 last_r = r;
1283 }
1284 }
1285
1286 best = 0;
1287 for (i = 1; i < NB_Y_COEFF; i++)
1288 if (stat[i] < stat[best])
1289 best = i;
1290
1291 sc->slice_rct_by_coef = rct_y_coeff[best][1];
1292 sc->slice_rct_ry_coef = rct_y_coeff[best][0];
1293}
1294
1295static void encode_histogram_remap(FFV1Context *f, FFV1SliceContext *sc)
1296{
1297 int len = 1 << f->bits_per_raw_sample;
1298 int flip = sc->remap == 2 ? 0x7FFF : 0;
1299
1300 for (int p= 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
1301 int j = 0;
1302 int lu = 0;
1303 uint8_t state[2][32];
1304 int run = 0;
1305
1306 memset(state, 128, sizeof(state));
1307 put_symbol(&sc->c, state[0], 0, 0);
1308 memset(state, 128, sizeof(state));
1309 for (int i= 0; i<len; i++) {
1310 int ri = i ^ ((i&0x8000) ? 0 : flip);
1311 int u = sc->fltmap[p][ri];
1312 sc->fltmap[p][ri] = j;
1313 j+= u;
1314
1315 if (lu == u) {
1316 run ++;
1317 } else {
1318 put_symbol_inline(&sc->c, state[lu], run, 0, NULL, NULL);
1319 if (run == 0)
1320 lu = u;
1321 run = 0;
1322 }
1323 }
1324 if (run)
1325 put_symbol(&sc->c, state[lu], run, 0);
1326 sc->remap_count[p] = j;
1327 }
1328}
1329
1330static void load_rgb_float32_frame(FFV1Context *f, FFV1SliceContext *sc,
1331 const uint8_t *src[4],
1332 int w, int h, const int stride[4])
1333{
1334 int x, y;
1335 int transparency = f->transparency;
1336 int i = 0;
1337
1338 for (y = 0; y < h; y++) {
1339 for (x = 0; x < w; x++) {
1340 int b, g, r, av_uninit(a);
1341
1342 g = *((const uint32_t *)(src[0] + x*4 + stride[0]*y));
1343 b = *((const uint32_t *)(src[1] + x*4 + stride[1]*y));
1344 r = *((const uint32_t *)(src[2] + x*4 + stride[2]*y));
1345 if (transparency)
1346 a = *((const uint32_t *)(src[3] + x*4 + stride[3]*y));
1347
1348 if (sc->remap == 2) {
1349#define FLIP(f) (((f)&0x80000000) ? (f) : (f)^0x7FFFFFFF);
1350 g = FLIP(g);
1351 b = FLIP(b);
1352 r = FLIP(r);
1353 }
1354 // We cannot build a histogram as we do for 16bit, we need a bit of magic here
1355 // Its possible to reduce the memory needed at the cost of more dereferencing
1356 sc->unit[0][i].val = g;
1357 sc->unit[0][i].ndx = x + y*w;
1358
1359 sc->unit[1][i].val = b;
1360 sc->unit[1][i].ndx = x + y*w;
1361
1362 sc->unit[2][i].val = r;
1363 sc->unit[2][i].ndx = x + y*w;
1364
1365 if (transparency) {
1366 sc->unit[3][i].val = a;
1367 sc->unit[3][i].ndx = x + y*w;
1368 }
1369 i++;
1370 }
1371 }
1372
1373 //TODO switch to radix sort
1374#define CMP(A,B) ((A)->val - (int64_t)(B)->val)
1375 AV_QSORT(sc->unit[0], i, struct Unit, CMP);
1376 AV_QSORT(sc->unit[1], i, struct Unit, CMP);
1377 AV_QSORT(sc->unit[2], i, struct Unit, CMP);
1378 if (transparency)
1379 AV_QSORT(sc->unit[3], i, struct Unit, CMP);
1380}
1381
1382static int encode_float32_remap_segment(FFV1SliceContext *sc,
1383 int p, int mul_count, int *mul_tab, int update, int final)
1384{
1385 const int pixel_num = sc->slice_width * sc->slice_height;
1386 uint8_t state[2][3][32];
1387 int mul[4096+1];
1388 RangeCoder rc = sc->c;
1389 int lu = 0;
1390 int run = 0;
1391 int64_t last_val = -1;
1392 int compact_index = -1;
1393 int i = 0;
1394 int current_mul_index = -1;
1395 int run1final = 0;
1396 int run1start_i;
1397 int run1start_last_val;
1398 int run1start_mul_index;
1399
1400 memcpy(mul, mul_tab, sizeof(*mul_tab)*(mul_count+1));
1401 memset(state, 128, sizeof(state));
1402 put_symbol(&rc, state[0][0], mul_count, 0);
1403 memset(state, 128, sizeof(state));
1404
1405 for (; i < pixel_num+1; i++) {
1406 int current_mul = current_mul_index < 0 ? 1 : FFABS(mul[current_mul_index]);
1407 int64_t val;
1408 if (i == pixel_num) {
1409 if (last_val == 0xFFFFFFFF && (!run || run1final)) {
1410 break;
1411 } else {
1412 val = last_val + ((1LL<<32) - last_val + current_mul - 1) / current_mul * current_mul;
1413 av_assert2(val >= (1LL<<32));
1414 val += lu * current_mul; //ensure a run1 ends
1415 }
1416 } else
1417 val = sc->unit[p][i].val;
1418
1419 if (last_val != val) {
1420 int64_t delta = val - last_val;
1421 int64_t step = FFMAX(1, (delta + current_mul/2) / current_mul);
1422 av_assert2(last_val < val);
1423 av_assert2(current_mul > 0);
1424
1425 delta -= step*current_mul;
1426 av_assert2(delta <= current_mul/2);
1427 av_assert2(delta > -current_mul);
1428
1429 av_assert2(step > 0);
1430 if (lu) {
1431 if (!run) {
1432 run1start_i = i - 1;
1433 run1start_last_val = last_val;
1434 run1start_mul_index= current_mul_index;
1435 }
1436 if (step == 1) {
1437 if (run1final) {
1438 if (current_mul>1)
1439 put_symbol_inline(&rc, state[lu][1], delta, 1, NULL, NULL);
1440 }
1441 run ++;
1442 av_assert2(last_val + current_mul + delta == val);
1443 } else {
1444 if (run1final) {
1445 if (run == 0)
1446 lu ^= 1;
1447 i--; // we did not encode val so we need to backstep
1448 last_val += current_mul;
1449 } else {
1450 put_symbol_inline(&rc, state[lu][0], run, 0, NULL, NULL);
1451 i = run1start_i;
1452 last_val = run1start_last_val; // we could compute this instead of storing
1453 current_mul_index = run1start_mul_index;
1454 }
1455 run1final ^= 1;
1456
1457 run = 0;
1458 continue;
1459 }
1460 } else {
1461 av_assert2(run == 0);
1462 av_assert2(run1final == 0);
1463 put_symbol_inline(&rc, state[lu][0], step - 1, 0, NULL, NULL);
1464
1465 if (current_mul > 1)
1466 put_symbol_inline(&rc, state[lu][1], delta, 1, NULL, NULL);
1467 if (step == 1)
1468 lu ^= 1;
1469
1470 av_assert2(last_val + step * current_mul + delta == val);
1471 }
1472 last_val = val;
1473 current_mul_index = ((last_val + 1) * mul_count) >> 32;
1474 if (!run || run1final) {
1475 av_assert2(mul[ current_mul_index ]);
1476 if (mul[ current_mul_index ] < 0) {
1477 av_assert2(i < pixel_num);
1478 mul[ current_mul_index ] *= -1;
1479 put_symbol_inline(&rc, state[0][2], mul[ current_mul_index ], 0, NULL, NULL);
1480 }
1481 if (i < pixel_num)
1482 compact_index ++;
1483 }
1484 }
1485 if (!run || run1final)
1486 if (final && i < pixel_num)
1487 sc->bitmap[p][sc->unit[p][i].ndx] = compact_index;
1488 }
1489
1490 if (update) {
1491 sc->c = rc;
1492 sc->remap_count[p] = compact_index + 1;
1493 }
1494 return get_rac_count(&rc);
1495}
1496
1497static void encode_float32_remap(FFV1Context *f, FFV1SliceContext *sc,
1498 const uint8_t *src[4])
1499{
1500 int pixel_num = sc->slice_width * sc->slice_height;
1501 const int max_log2_mul_count = ((int[]){ 1, 1, 1, 9, 9, 10})[f->remap_optimizer];
1502 const int log2_mul_count_step = ((int[]){ 1, 1, 1, 9, 9, 1})[f->remap_optimizer];
1503 const int max_log2_mul = ((int[]){ 1, 8, 8, 9, 22, 22})[f->remap_optimizer];
1504 const int log2_mul_step = ((int[]){ 1, 8, 1, 1, 1, 1})[f->remap_optimizer];
1505 const int bruteforce_count = ((int[]){ 0, 0, 0, 1, 1, 1})[f->remap_optimizer];
1506 const int stair_mode = ((int[]){ 0, 0, 0, 1, 0, 0})[f->remap_optimizer];
1507 const int magic_log2 = ((int[]){ 1, 1, 1, 1, 0, 0})[f->remap_optimizer];
1508
1509 for (int p= 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
1510 int best_log2_mul_count = 0;
1511 float score_sum[11] = {0};
1512 int mul_all[11][1025];
1513
1514 for (int log2_mul_count= 0; log2_mul_count <= max_log2_mul_count; log2_mul_count += log2_mul_count_step) {
1515 float score_tab_all[1025][23] = {0};
1516 int64_t last_val = -1;
1517 int *mul_tab = mul_all[log2_mul_count];
1518 int last_mul_index = -1;
1519 int mul_count = 1 << log2_mul_count;
1520
1521 score_sum[log2_mul_count] = 2 * log2_mul_count;
1522 if (magic_log2)
1523 score_sum[log2_mul_count] = av_float2int((float)mul_count * mul_count);
1524 for (int i= 0; i<pixel_num; i++) {
1525 int64_t val = sc->unit[p][i].val;
1526 int mul_index = (val + 1LL)*mul_count >> 32;
1527 if (val != last_val) {
1528 float *score_tab = score_tab_all[(last_val + 1LL)*mul_count >> 32];
1529 av_assert2(last_val < val);
1530 for(int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1531 int64_t delta = val - last_val;
1532 int mul;
1533 int64_t cost;
1534
1535 if (last_val < 0) {
1536 mul = 1;
1537 } else if (stair_mode && mul_count == 512 && si == max_log2_mul ) {
1538 if (mul_index >= 0x378/8 && mul_index <= 23 + 0x378/8) {
1539 mul = (0x800080 >> (mul_index - 0x378/8));
1540 } else
1541 mul = 1;
1542 } else {
1543 mul = (0x10001LL)<<si >> 16;
1544 }
1545
1546 cost = FFMAX((delta + mul/2) / mul, 1);
1547 float score = 1;
1548 if (mul > 1) {
1549 score *= (FFABS(delta - cost*mul)+1);
1550 if (mul_count > 1)
1551 score *= score;
1552 }
1553 score *= cost;
1554 score *= score;
1555 if (mul_index != last_mul_index)
1556 score *= mul;
1557 if (magic_log2) {
1558 score_tab[si] += av_float2int(score);
1559 } else
1560 score_tab[si] += log2f(score);
1561 }
1562 }
1563 last_val = val;
1564 last_mul_index = mul_index;
1565 }
1566 for(int i= 0; i<mul_count; i++) {
1567 int best_index = 0;
1568 float *score_tab = score_tab_all[i];
1569 for(int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1570 if (score_tab[si] < score_tab[ best_index ])
1571 best_index = si;
1572 }
1573 if (stair_mode && mul_count == 512 && best_index == max_log2_mul ) {
1574 if (i >= 0x378/8 && i <= 23 + 0x378/8) {
1575 mul_tab[i] = -(0x800080 >> (i - 0x378/8));
1576 } else
1577 mul_tab[i] = -1;
1578 } else
1579 mul_tab[i] = -((0x10001LL)<<best_index >> 16);
1580 score_sum[log2_mul_count] += score_tab[ best_index ];
1581 }
1582 mul_tab[mul_count] = 1;
1583
1584 if (bruteforce_count)
1585 score_sum[log2_mul_count] = encode_float32_remap_segment(sc, p, mul_count, mul_all[log2_mul_count], 0, 0);
1586
1587 if (score_sum[log2_mul_count] < score_sum[best_log2_mul_count])
1588 best_log2_mul_count = log2_mul_count;
1589 }
1590
1591 encode_float32_remap_segment(sc, p, 1<<best_log2_mul_count, mul_all[best_log2_mul_count], 1, 1);
1592 }
1593}
1594
1595static int encode_float32_rgb_frame(FFV1Context *f, FFV1SliceContext *sc,
1596 const uint8_t *src[4],
1597 int w, int h, const int stride[4], int ac)
1598{
1599 int x, y, p, i;
1600 const int ring_size = f->context_model ? 3 : 2;
1601 int32_t *sample[4][3];
1602 const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
1603 int bits[4], offset;
1604 int transparency = f->transparency;
1605
1606 ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, NULL, f->bits_per_raw_sample);
1607
1608 sc->run_index = 0;
1609
1610 for (int p = 0; p < MAX_PLANES; ++p)
1611 sample[p][2] = sc->sample_buffer32; // dummy to avoid UB pointer arithmetic
1612
1613 memset(RENAME(sc->sample_buffer), 0, ring_size * MAX_PLANES *
1614 (w + 6) * sizeof(*RENAME(sc->sample_buffer)));
1615
1616 for (y = 0; y < h; y++) {
1617 for (i = 0; i < ring_size; i++)
1618 for (p = 0; p < MAX_PLANES; p++)
1619 sample[p][i]= RENAME(sc->sample_buffer) + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
1620
1621 for (x = 0; x < w; x++) {
1622 int b, g, r, av_uninit(a);
1623 g = sc->bitmap[0][x + w*y];
1624 b = sc->bitmap[1][x + w*y];
1625 r = sc->bitmap[2][x + w*y];
1626 if (transparency)
1627 a = sc->bitmap[3][x + w*y];
1628
1629 if (sc->slice_coding_mode != 1) {
1630 b -= g;
1631 r -= g;
1632 g += (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2;
1633 b += offset;
1634 r += offset;
1635 }
1636
1637 sample[0][0][x] = g;
1638 sample[1][0][x] = b;
1639 sample[2][0][x] = r;
1640 sample[3][0][x] = a;
1641 }
1642 for (p = 0; p < 3 + transparency; p++) {
1643 int ret;
1644 sample[p][0][-1] = sample[p][1][0 ];
1645 sample[p][1][ w] = sample[p][1][w-1];
1646 ret = encode_line32(f, sc, f->avctx, w, sample[p], (p + 1) / 2,
1647 bits[p], ac, pass1);
1648 if (ret < 0)
1649 return ret;
1650 }
1651 }
1652 return 0;
1653}
1654
1655static int encode_bayer_frame(FFV1Context *f, FFV1SliceContext *sc,
1656 const uint8_t *src[4],
1657 int w, int h, const int stride[4], int ac)
1658{
1659 const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
1660 const int ring_size = f->context_model ? 3 : 2;
1661 TYPE *sample[4][3];
1662
1663 int bits[4], offset;
1664 ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, NULL, f->bits_per_raw_sample);
1665
1666 w >>= 1;
1667
1668 sc->run_index = 0;
1669
1670 for (int p = 0; p < MAX_PLANES; ++p)
1671 sample[p][2] = RENAME(sc->sample_buffer);
1672
1673 memset(RENAME(sc->sample_buffer), 0, ring_size * MAX_PLANES *
1674 (w + 6) * sizeof(*RENAME(sc->sample_buffer)));
1675
1676 for (int y = 0; y < h; y += 2) {
1677 for (int i = 0; i < ring_size; i++)
1678 for (int p = 0; p < MAX_PLANES; p++)
1679 sample[p][i] = RENAME(sc->sample_buffer) + p*ring_size*(w+6) +
1680 ((h+i-y/2) % ring_size)*(w+6) + 3;
1681
1682 for (int x = 0; x < w; x++) {
1683 const uint16_t *l1 = ((const uint16_t*)(src[0] + stride[0]*(y + 0) + x*2*2));
1684 const uint16_t *l2 = ((const uint16_t*)(src[0] + stride[0]*(y + 1) + x*2*2));
1685
1686 int r, gr, gb, b;
1687 r = l1[0];
1688 gr = l1[1];
1689 gb = l2[0];
1690 b = l2[1];
1691
1692 if (sc->slice_coding_mode != 1) {
1693 /**
1694 * Bayer 2x2 RCT, based on:
1695 * "Reversible color transform for Bayer color filter array images", S. Poomrittigul et al,
1696 * APSIPA Transactions on Signal and Information Processing (2013) 2 (1): 1-10,
1697 * doi:10.1017/ATSIP.2013.6 */
1698 int gd = gr - gb;
1699 int gm = gb + (gd >> 1);
1700
1701 b -= gm;
1702 r -= gm;
1703 gm += (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2;
1704 b += offset;
1705 r += offset;
1706 gd += offset;
1707
1708 gr = gm;
1709 gb = gd;
1710 }
1711
1712 sample[0][0][x] = gr;
1713 sample[1][0][x] = gb;
1714 sample[2][0][x] = b;
1715 sample[3][0][x] = r;
1716 }
1717
1718 for (int p = 0; p < 4; p++) {
1719 int ret;
1720 sample[p][0][-1] = sample[p][1][0 ];
1721 sample[p][1][ w] = sample[p][1][w-1];
1722 /* Plane contexts: gm=0 (luma), b-gm/r-gm=1 (chroma diff from
1723 * green), gd=2 (own context - green-green diff has different
1724 * statistics from both luma and chroma). */
1725 ret = RENAME(encode_line)(f, sc, f->avctx, w, sample[p],
1726 p == 1 ? 2 : (p > 1),
1727 bits[p], ac, pass1);
1728 if (ret < 0)
1729 return ret;
1730 }
1731 }
1732
1733 return 0;
1734}
1735
1736static int encode_slice(AVCodecContext *c, void *arg)
1737{
1738 FFV1SliceContext *sc = arg;
1739 FFV1Context *f = c->priv_data;
1740 int width = sc->slice_width;
1741 int height = sc->slice_height;
1742 int x = sc->slice_x;
1743 int y = sc->slice_y;
1744 const AVFrame *const p = f->cur_enc_frame;
1745 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1746 int ret;
1747 RangeCoder c_bak = sc->c;
1748 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1749 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1750 const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1751 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1752 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1753 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1754 int ac = f->ac;
1755
1756 sc->slice_coding_mode = 0;
1757 if (f->version > 3 && f->colorspace == 1) {
1758 choose_rct_params(f, sc, planes, p->linesize, width, height);
1759 } else if (f->bayer) {
1760 choose_rct_params_bayer(f, sc, planes, p->linesize, width, height);
1761 } else {
1762 sc->slice_rct_by_coef = 1;
1763 sc->slice_rct_ry_coef = 1;
1764 }
1765
1766retry:
1767 if (f->key_frame)
1768 ff_ffv1_clear_slice_state(f, sc);
1769 if (f->version > 2) {
1770 encode_slice_header(f, sc);
1771 }
1772
1773 if (sc->remap) {
1774 //Both the 16bit and 32bit remap do exactly the same thing but with 16bits we can
1775 //Implement this using a "histogram" while for 32bit that would be gb sized, thus a more
1776 //complex implementation sorting pairs is used.
1777 if (f->bits_per_raw_sample != 32) {
1778 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8 && c->pix_fmt != AV_PIX_FMT_YAF16) {
1779 const int cx = x >> f->chroma_h_shift;
1780 const int cy = y >> f->chroma_v_shift;
1781
1782 //TODO decide on the order for the encoded remaps and loads. with golomb rice it
1783 // easier to have all range coded ones together, otherwise it may be nicer to handle each plane as a whole?
1784
1785 load_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1786
1787 if (f->chroma_planes) {
1788 load_plane(f, sc, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1789 load_plane(f, sc, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 2, 1);
1790 }
1791 if (f->transparency)
1792 load_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 3, 1);
1793 } else if (c->pix_fmt == AV_PIX_FMT_YA8 || c->pix_fmt == AV_PIX_FMT_YAF16) {
1794 load_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1795 load_plane(f, sc, p->data[0] + (ps>>1) + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1796 } else if (f->use32bit) {
1797 load_rgb_frame32(f, sc, planes, width, height, p->linesize);
1798 } else
1799 load_rgb_frame (f, sc, planes, width, height, p->linesize);
1800
1801 encode_histogram_remap(f, sc);
1802 } else {
1803 load_rgb_float32_frame(f, sc, planes, width, height, p->linesize);
1804 encode_float32_remap(f, sc, planes);
1805 }
1806 }
1807
1808 if (ac == AC_GOLOMB_RICE) {
1809 sc->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&sc->c, f->version > 2) : 0;
1810 init_put_bits(&sc->pb,
1811 sc->c.bytestream_start + sc->ac_byte_count,
1812 sc->c.bytestream_end - sc->c.bytestream_start - sc->ac_byte_count);
1813 }
1814
1815 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8 && c->pix_fmt != AV_PIX_FMT_YAF16) {
1816 const int cx = x >> f->chroma_h_shift;
1817 const int cy = y >> f->chroma_v_shift;
1818
1819 ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 1, ac);
1820
1821 if (f->chroma_planes) {
1822 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);
1823 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);
1824 }
1825 if (f->transparency)
1826 ret |= encode_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 3, 1, ac);
1827 } else if (c->pix_fmt == AV_PIX_FMT_YA8 || c->pix_fmt == AV_PIX_FMT_YAF16) {
1828 ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 2, ac);
1829 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);
1830 } else if (f->bits_per_raw_sample == 32) {
1831 ret = encode_float32_rgb_frame(f, sc, planes, width, height, p->linesize, ac);
1832 } else if (f->bayer) {
1833 ret = encode_bayer_frame(f, sc, planes, width, height, p->linesize, ac);
1834 } else if (f->use32bit) {
1835 ret = encode_rgb_frame32(f, sc, planes, width, height, p->linesize, ac);
1836 } else {
1837 ret = encode_rgb_frame(f, sc, planes, width, height, p->linesize, ac);
1838 }
1839
1840 if (ac != AC_GOLOMB_RICE) {
1841 sc->ac_byte_count = ff_rac_terminate(&sc->c, 1);
1842 } else {
1843 flush_put_bits(&sc->pb); // FIXME: nicer padding
1844 sc->ac_byte_count += put_bytes_output(&sc->pb);
1845 }
1846
1847 if (ret < 0) {
1848 av_assert0(sc->slice_coding_mode == 0);
1849 if (f->version < 4) {
1850 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1851 return ret;
1852 }
1853 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1854 ac = 1;
1855 sc->slice_coding_mode = 1;
1856 sc->c = c_bak;
1857 goto retry;
1858 }
1859
1860 return 0;
1861}
1862
1863size_t ff_ffv1_encode_buffer_size(AVCodecContext *avctx)
1864{
1865 FFV1Context *f = avctx->priv_data;
1866
1867 int w = avctx->width + f->num_h_slices;
1868 int h = avctx->height + f->num_v_slices;
1869 size_t maxsize = w*h * (1 + f->transparency);
1870 if (f->chroma_planes)
1871 maxsize += AV_CEIL_RSHIFT(w, f->chroma_h_shift) * AV_CEIL_RSHIFT(h, f->chroma_v_shift) * 2;
1872 maxsize += f->slice_count * 800; //for slice header
1873 if (f->version > 3) {
1874 maxsize *= f->bits_per_raw_sample + 1;
1875 if (f->remap_mode)
1876 maxsize += f->slice_count * 70000 * (1 + 2*f->chroma_planes + f->bayer + f->transparency);
1877 } else {
1878 maxsize += f->slice_count * 2 * (avctx->width + avctx->height); //for bug with slices that code some pixels more than once
1879 maxsize *= 8*(2*f->bits_per_raw_sample + 5);
1880 }
1881 maxsize >>= 3;
1882 maxsize += FF_INPUT_BUFFER_MIN_SIZE;
1883
1884 return maxsize;
1885}
1886
1887static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1888 const AVFrame *pict, int *got_packet)
1889{
1890 FFV1Context *f = avctx->priv_data;
1891 RangeCoder *const c = &f->slices[0].c;
1892 uint8_t keystate = 128;
1893 uint8_t *buf_p;
1894 int i, ret;
1895 int64_t maxsize;
1896
1897 if(!pict) {
1898 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1899 int j, k, m;
1900 char *p = avctx->stats_out;
1901 char *end = p + STATS_OUT_SIZE;
1902
1903 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1904 for (i = 0; i < f->quant_table_count; i++)
1905 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1906
1907 av_assert0(f->slice_count == f->max_slice_count);
1908 for (j = 0; j < f->slice_count; j++) {
1909 const FFV1SliceContext *sc = &f->slices[j];
1910 for (i = 0; i < 256; i++) {
1911 f->rc_stat[i][0] += sc->rc_stat[i][0];
1912 f->rc_stat[i][1] += sc->rc_stat[i][1];
1913 }
1914 for (i = 0; i < f->quant_table_count; i++) {
1915 for (k = 0; k < f->context_count[i]; k++)
1916 for (m = 0; m < 32; m++) {
1917 f->rc_stat2[i][k][m][0] += sc->rc_stat2[i][k][m][0];
1918 f->rc_stat2[i][k][m][1] += sc->rc_stat2[i][k][m][1];
1919 }
1920 }
1921 }
1922
1923 for (j = 0; j < 256; j++) {
1924 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1925 f->rc_stat[j][0], f->rc_stat[j][1]);
1926 p += strlen(p);
1927 }
1928 snprintf(p, end - p, "\n");
1929
1930 for (i = 0; i < f->quant_table_count; i++) {
1931 for (j = 0; j < f->context_count[i]; j++)
1932 for (m = 0; m < 32; m++) {
1933 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1934 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1935 p += strlen(p);
1936 }
1937 }
1938 snprintf(p, end - p, "%d\n", f->gob_count);
1939 }
1940 return 0;
1941 }
1942
1943 /* Maximum packet size */
1944 maxsize = ff_ffv1_encode_buffer_size(avctx);
1945
1946 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1947 FFV1Context *f = avctx->priv_data;
1948 if (!f->maxsize_warned) {
1949 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1950 f->maxsize_warned++;
1951 }
1952 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1953 }
1954
1955 if ((ret = ff_alloc_packet(avctx, pkt, maxsize)) < 0)
1956 return ret;
1957
1958 ff_init_range_encoder(c, pkt->data, pkt->size);
1959 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1960
1961 f->cur_enc_frame = pict;
1962
1963 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1964 put_rac(c, &keystate, 1);
1965 f->key_frame = 1;
1966 f->gob_count++;
1967 write_header(f);
1968 } else {
1969 put_rac(c, &keystate, 0);
1970 f->key_frame = 0;
1971 }
1972
1973 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1974 int i;
1975 for (i = 1; i < 256; i++) {
1976 c->one_state[i] = f->state_transition[i];
1977 c->zero_state[256 - i] = 256 - c->one_state[i];
1978 }
1979 }
1980
1981 for (i = 0; i < f->slice_count; i++) {
1982 FFV1SliceContext *sc = &f->slices[i];
1983 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1984 int len = pkt->size / f->slice_count;
1985 if (i) {
1986 ff_init_range_encoder(&sc->c, start, len);
1987 } else {
1988 av_assert0(sc->c.bytestream_end >= sc->c.bytestream_start + len);
1989 av_assert0(sc->c.bytestream < sc->c.bytestream_start + len);
1990 sc->c.bytestream_end = sc->c.bytestream_start + len;
1991 }
1992 }
1993 avctx->execute(avctx, encode_slice, f->slices, NULL,
1994 f->slice_count, sizeof(*f->slices));
1995
1996 buf_p = pkt->data;
1997 for (i = 0; i < f->slice_count; i++) {
1998 FFV1SliceContext *sc = &f->slices[i];
1999 int bytes = sc->ac_byte_count;
2000 if (i > 0 || f->version > 2) {
2001 av_assert0(bytes < pkt->size / f->slice_count);
2002 memmove(buf_p, sc->c.bytestream_start, bytes);
2003 av_assert0(bytes < (1 << 24));
2004 AV_WB24(buf_p + bytes, bytes);
2005 bytes += 3;
2006 }
2007 if (f->ec) {
2008 unsigned v;
2009 buf_p[bytes++] = 0;
2010 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, buf_p, bytes) ^ (f->crcref ? 0x8CD88196 : 0);
2011 AV_WL32(buf_p + bytes, v);
2012 bytes += 4;
2013 }
2014 buf_p += bytes;
2015 }
2016
2017 if (avctx->flags & AV_CODEC_FLAG_PASS1)
2018 avctx->stats_out[0] = '\0';
2019
2020 f->picture_number++;
2021 pkt->size = buf_p - pkt->data;
2022 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
2023 *got_packet = 1;
2024
2025 return 0;
2026}
2027
2028static av_cold int encode_close(AVCodecContext *avctx)
2029{
2030 FFV1Context *const s = avctx->priv_data;
2031
2032 for (int j = 0; j < s->max_slice_count; j++) {
2033 FFV1SliceContext *sc = &s->slices[j];
2034
2035 for(int p = 0; p<4; p++) {
2036 av_freep(&sc->unit[p]);
2037 av_freep(&sc->bitmap[p]);
2038 }
2039 }
2040
2041 av_freep(&avctx->stats_out);
2042 ff_ffv1_close(s);
2043
2044 return 0;
2045}
2046
2047#define OFFSET(x) offsetof(FFV1Context, x)
2048#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
2049static const AVOption options[] = {
2050 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
2051 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
2052 { .i64 = 0 }, -2, 2, VE, .unit = "coder" },
2053 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
2054 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2055 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
2056 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2057 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
2058 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2059 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
2060 { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2061 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
2062 { .i64 = 0 }, 0, 1, VE },
2063 { "qtable", "Quantization table", OFFSET(qtable), AV_OPT_TYPE_INT,
2064 { .i64 = -1 }, -1, 2, VE , .unit = "qtable"},
2065 { "default", NULL, 0, AV_OPT_TYPE_CONST,
2066 { .i64 = QTABLE_DEFAULT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2067 { "8bit", NULL, 0, AV_OPT_TYPE_CONST,
2068 { .i64 = QTABLE_8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2069 { "greater8bit", NULL, 0, AV_OPT_TYPE_CONST,
2070 { .i64 = QTABLE_GT8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2071 { "remap_mode", "Remap Mode", OFFSET(remap_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE, .unit = "remap_mode" },
2072 { "auto", "Automatic", 0, AV_OPT_TYPE_CONST,
2073 { .i64 = -1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2074 { "off", "Disabled", 0, AV_OPT_TYPE_CONST,
2075 { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2076 { "dualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
2077 { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2078 { "flipdualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
2079 { .i64 = 2 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2080 { "remap_optimizer", "Remap Optimizer", OFFSET(remap_optimizer), AV_OPT_TYPE_INT, { .i64 = 3 }, 0, 5, VE, .unit = "remap_optimizer" },
2081
2082 { NULL }
2083};
2084
2085static const AVClass ffv1_class = {
2086 .class_name = "ffv1 encoder",
2087 .item_name = av_default_item_name,
2088 .option = options,
2089 .version = LIBAVUTIL_VERSION_INT,
2090};
2091
2092const FFCodec ff_ffv1_encoder = {
2093 .p.name = "ffv1",
2094 CODEC_LONG_NAME("FFmpeg video codec #1"),
2095 .p.type = AVMEDIA_TYPE_VIDEO,
2096 .p.id = AV_CODEC_ID_FFV1,
2097 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
2098 AV_CODEC_CAP_SLICE_THREADS |
2099 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
2100 .priv_data_size = sizeof(FFV1Context),
2101 .init = encode_init_internal,
2102 FF_CODEC_ENCODE_CB(encode_frame),
2103 .close = encode_close,
2104 CODEC_PIXFMTS(
2105 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
2106 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
2107 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
2108 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
2109 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
2110 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
2111 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
2112 AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA422P12,
2113 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
2114 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
2115 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
2116 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRAP14,
2117 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
2118 AV_PIX_FMT_YA8,
2119 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
2120 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
2121 AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
2122 AV_PIX_FMT_GRAY9,
2123 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
2124 AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
2125 AV_PIX_FMT_YAF16,
2126 AV_PIX_FMT_GRAYF16,
2127 AV_PIX_FMT_GBRPF16, AV_PIX_FMT_GBRPF32,
2128 AV_PIX_FMT_BAYER_RGGB16),
2129 .color_ranges = AVCOL_RANGE_MPEG,
2130 .p.priv_class = &ffv1_class,
2131 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
2132};
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:2092
VE
#define VE
Definition amfenc_av1.c:30
ring_size
static int ring_size(RingBuffer *ring)
Definition async.c:107
int32_t
int32_t
Definition audioconvert.c:56
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:411
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition codec_internal.h:386
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition codec_internal.h:359
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:694
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:1595
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:1736
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:1232
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:2028
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:1382
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:1655
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition ffv1enc.c:1887
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:1330
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:1295
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:1137
ffv1_class
static const AVClass ffv1_class
Definition ffv1enc.c:2085
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:1002
encode_slice_header
static void encode_slice_header(FFV1Context *f, FFV1SliceContext *sc)
Definition ffv1enc.c:1103
OFFSET
#define OFFSET(x)
Definition ffv1enc.c:2047
ff_ffv1_encode_buffer_size
size_t ff_ffv1_encode_buffer_size(AVCodecContext *avctx)
Definition ffv1enc.c:1863
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:807
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:1497
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:695
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:700
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
log2
#define log2(x)
Definition libm.h:406
log2f
#define log2f(x)
Definition libm.h:411
round
static av_always_inline av_const double round(double x)
Definition libm.h:446
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
snprintf
#define snprintf
Definition snprintf.h:34
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:1375
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:1646
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:1609
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition avcodec.h:1571
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:472
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 Mon Aug 17 2026 20:20:54 for FFmpeg by doxygen 1.13.2