FFmpeg
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 
45 static 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 
64 static 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 
83 static 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 
102 static 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 
121 static 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 
140 static 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 
185 static 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 
233 static 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 
240 static 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 
274 static 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 
325 static 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 
349 static 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 
364 static 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 
372 static 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 
384 static 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 
431 static 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 = 9;
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 
447 av_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  put_symbol(&c, state, f->num_h_slices - 1, 0);
484  put_symbol(&c, state, f->num_v_slices - 1, 0);
485 
486  put_symbol(&c, state, f->quant_table_count, 0);
487  for (i = 0; i < f->quant_table_count; i++)
488  write_quant_tables(&c, f->quant_tables[i]);
489 
490  for (i = 0; i < f->quant_table_count; i++) {
491  if (contains_non_128(f->initial_states[i], f->context_count[i])) {
492  put_rac(&c, state, 1);
493  for (j = 0; j < f->context_count[i]; j++)
494  for (k = 0; k < CONTEXT_SIZE; k++) {
495  int pred = j ? f->initial_states[i][j - 1][k] : 128;
496  put_symbol(&c, state2[k],
497  (int8_t)(f->initial_states[i][j][k] - pred), 1);
498  }
499  } else {
500  put_rac(&c, state, 0);
501  }
502  }
503 
504  if (f->version > 2) {
505  put_symbol(&c, state, f->ec, 0);
506  put_symbol(&c, state, f->intra = (f->avctx->gop_size < 2), 0);
507  }
508 
509  f->avctx->extradata_size = ff_rac_terminate(&c, 0);
510  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, f->avctx->extradata, f->avctx->extradata_size) ^ (f->crcref ? 0x8CD88196 : 0);
511  AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
512  f->avctx->extradata_size += 4;
513 
514  return 0;
515 }
516 
517 static int sort_stt(FFV1Context *s, uint8_t stt[256])
518 {
519  int i, i2, changed, print = 0;
520 
521  do {
522  changed = 0;
523  for (i = 12; i < 244; i++) {
524  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
525 
526 #define COST(old, new) \
527  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
528  s->rc_stat[old][1] * -log2((new) / 256.0)
529 
530 #define COST2(old, new) \
531  COST(old, new) + COST(256 - (old), 256 - (new))
532 
533  double size0 = COST2(i, i) + COST2(i2, i2);
534  double sizeX = COST2(i, i2) + COST2(i2, i);
535  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
536  int j;
537  FFSWAP(int, stt[i], stt[i2]);
538  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
539  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
540  if (i != 256 - i2) {
541  FFSWAP(int, stt[256 - i], stt[256 - i2]);
542  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
543  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
544  }
545  for (j = 1; j < 256; j++) {
546  if (stt[j] == i)
547  stt[j] = i2;
548  else if (stt[j] == i2)
549  stt[j] = i;
550  if (i != 256 - i2) {
551  if (stt[256 - j] == 256 - i)
552  stt[256 - j] = 256 - i2;
553  else if (stt[256 - j] == 256 - i2)
554  stt[256 - j] = 256 - i;
555  }
556  }
557  print = changed = 1;
558  }
559  }
560  }
561  } while (changed);
562  return print;
563 }
564 
565 
566 int ff_ffv1_encode_determine_slices(AVCodecContext *avctx)
567 {
568  FFV1Context *s = avctx->priv_data;
569  int plane_count = 1 + 2*s->chroma_planes + s->transparency;
570  int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
571  int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
572  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
573  s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
574  for (; s->num_v_slices <= 32; s->num_v_slices++) {
575  for (s->num_h_slices = s->num_v_slices; s->num_h_slices <= 2*s->num_v_slices; s->num_h_slices++) {
576  int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
577  int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
578  if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
579  continue;
580  if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
581  continue;
582  if (s->version < 4)
583  if ( ff_need_new_slices(avctx->width , s->num_h_slices, s->chroma_h_shift)
584  ||ff_need_new_slices(avctx->height, s->num_v_slices, s->chroma_v_shift))
585  continue;
586  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES)
587  return 0;
588  if (maxw*maxh > 360*288)
589  continue;
590  if (!avctx->slices)
591  return 0;
592  }
593  }
594  av_log(avctx, AV_LOG_ERROR,
595  "Unsupported number %d of slices requested, please specify a "
596  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
597  avctx->slices);
598  return AVERROR(ENOSYS);
599 }
600 
601 av_cold int ff_ffv1_encode_init(AVCodecContext *avctx)
602 {
603  FFV1Context *s = avctx->priv_data;
604  int i, j, k, m, ret;
605 
606  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
607  avctx->slices > 1)
608  s->version = FFMAX(s->version, 2);
609 
610  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) && s->ac == AC_GOLOMB_RICE) {
611  av_log(avctx, AV_LOG_ERROR, "2 Pass mode is not possible with golomb coding\n");
612  return AVERROR(EINVAL);
613  }
614 
615  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
616  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
617  s->version = FFMAX(s->version, 2);
618 
619  if (avctx->level <= 0 && s->version == 2) {
620  s->version = 3;
621  }
622  if (avctx->level >= 0 && avctx->level <= 4) {
623  if (avctx->level < s->version) {
624  av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
625  return AVERROR(EINVAL);
626  }
627  s->version = avctx->level;
628  } else if (s->version < 3)
629  s->version = 3;
630 
631  if (s->ec < 0) {
632  if (s->version >= 4) {
633  s->ec = 2;
634  } else if (s->version >= 3) {
635  s->ec = 1;
636  } else
637  s->ec = 0;
638  }
639 
640  // CRC requires version 3+
641  if (s->ec == 1)
642  s->version = FFMAX(s->version, 3);
643  if (s->ec == 2) {
644  s->version = FFMAX(s->version, 4);
645  s->crcref = 0x7a8c4079;
646  }
647 
648  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
649  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");
650  return AVERROR_INVALIDDATA;
651  }
652 
653  if (s->ac == AC_RANGE_CUSTOM_TAB) {
654  for (i = 1; i < 256; i++)
655  s->state_transition[i] = ver2_state[i];
656  } else {
657  RangeCoder c;
658  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
659  for (i = 1; i < 256; i++)
660  s->state_transition[i] = c.one_state[i];
661  }
662 
663  for (i = 0; i < 256; i++) {
664  s->quant_table_count = 2;
665  if ((s->qtable == -1 && s->bits_per_raw_sample <= 8) || s->qtable == 1) {
666  s->quant_tables[0][0][i]= quant11[i];
667  s->quant_tables[0][1][i]= 11*quant11[i];
668  s->quant_tables[0][2][i]= 11*11*quant11[i];
669  s->quant_tables[1][0][i]= quant11[i];
670  s->quant_tables[1][1][i]= 11*quant11[i];
671  s->quant_tables[1][2][i]= 11*11*quant5 [i];
672  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
673  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
674  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
675  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
676  } else {
677  s->quant_tables[0][0][i]= quant9_10bit[i];
678  s->quant_tables[0][1][i]= 9*quant9_10bit[i];
679  s->quant_tables[0][2][i]= 9*9*quant9_10bit[i];
680  s->quant_tables[1][0][i]= quant9_10bit[i];
681  s->quant_tables[1][1][i]= 9*quant9_10bit[i];
682  s->quant_tables[1][2][i]= 9*9*quant5_10bit[i];
683  s->quant_tables[1][3][i]= 5*9*9*quant5_10bit[i];
684  s->quant_tables[1][4][i]= 5*5*9*9*quant5_10bit[i];
685  s->context_count[0] = (9 * 9 * 9 + 1) / 2;
686  s->context_count[1] = (9 * 9 * 5 * 5 * 5 + 1) / 2;
687  }
688  }
689 
690  if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
691  return ret;
692 
693  if (!s->transparency)
694  s->plane_count = 2;
695  if (!s->chroma_planes && s->version > 3)
696  s->plane_count--;
697 
698  s->picture_number = 0;
699 
700  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
701  for (i = 0; i < s->quant_table_count; i++) {
702  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
703  sizeof(*s->rc_stat2[i]));
704  if (!s->rc_stat2[i])
705  return AVERROR(ENOMEM);
706  }
707  }
708  if (avctx->stats_in) {
709  char *p = avctx->stats_in;
710  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
711  int gob_count = 0;
712  char *next;
713  if (!best_state)
714  return AVERROR(ENOMEM);
715 
716  av_assert0(s->version >= 2);
717 
718  for (;;) {
719  for (j = 0; j < 256; j++)
720  for (i = 0; i < 2; i++) {
721  s->rc_stat[j][i] = strtol(p, &next, 0);
722  if (next == p) {
723  av_log(avctx, AV_LOG_ERROR,
724  "2Pass file invalid at %d %d [%s]\n", j, i, p);
725  av_freep(&best_state);
726  return AVERROR_INVALIDDATA;
727  }
728  p = next;
729  }
730  for (i = 0; i < s->quant_table_count; i++)
731  for (j = 0; j < s->context_count[i]; j++) {
732  for (k = 0; k < 32; k++)
733  for (m = 0; m < 2; m++) {
734  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
735  if (next == p) {
736  av_log(avctx, AV_LOG_ERROR,
737  "2Pass file invalid at %d %d %d %d [%s]\n",
738  i, j, k, m, p);
739  av_freep(&best_state);
740  return AVERROR_INVALIDDATA;
741  }
742  p = next;
743  }
744  }
745  gob_count = strtol(p, &next, 0);
746  if (next == p || gob_count <= 0) {
747  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
748  av_freep(&best_state);
749  return AVERROR_INVALIDDATA;
750  }
751  p = next;
752  while (*p == '\n' || *p == ' ')
753  p++;
754  if (p[0] == 0)
755  break;
756  }
757  if (s->ac == AC_RANGE_CUSTOM_TAB)
758  sort_stt(s, s->state_transition);
759 
760  find_best_state(best_state, s->state_transition);
761 
762  for (i = 0; i < s->quant_table_count; i++) {
763  for (k = 0; k < 32; k++) {
764  double a=0, b=0;
765  int jp = 0;
766  for (j = 0; j < s->context_count[i]; j++) {
767  double p = 128;
768  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
769  if (a+b)
770  p = 256.0 * b / (a + b);
771  s->initial_states[i][jp][k] =
772  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
773  for(jp++; jp<j; jp++)
774  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
775  a=b=0;
776  }
777  a += s->rc_stat2[i][j][k][0];
778  b += s->rc_stat2[i][j][k][1];
779  if (a+b) {
780  p = 256.0 * b / (a + b);
781  }
782  s->initial_states[i][j][k] =
783  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
784  }
785  }
786  }
787  av_freep(&best_state);
788  }
789 
790  if (s->version <= 1) {
791  /* Disable slices when the version doesn't support them */
792  s->num_h_slices = 1;
793  s->num_v_slices = 1;
794  }
795 
796  set_micro_version(s);
797 
798  return 0;
799 }
800 
801 av_cold int ff_ffv1_encode_setup_plane_info(AVCodecContext *avctx,
802  enum AVPixelFormat pix_fmt)
803 {
804  FFV1Context *s = avctx->priv_data;
805  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
806 
807  s->plane_count = 3;
808  switch(pix_fmt) {
809  case AV_PIX_FMT_GRAY9:
810  case AV_PIX_FMT_YUV444P9:
811  case AV_PIX_FMT_YUV422P9:
812  case AV_PIX_FMT_YUV420P9:
813  case AV_PIX_FMT_YUVA444P9:
814  case AV_PIX_FMT_YUVA422P9:
815  case AV_PIX_FMT_YUVA420P9:
816  if (!avctx->bits_per_raw_sample)
817  s->bits_per_raw_sample = 9;
818  av_fallthrough;
819  case AV_PIX_FMT_GRAY10:
820  case AV_PIX_FMT_YUV444P10:
821  case AV_PIX_FMT_YUV440P10:
822  case AV_PIX_FMT_YUV420P10:
823  case AV_PIX_FMT_YUV422P10:
824  case AV_PIX_FMT_YUVA444P10:
825  case AV_PIX_FMT_YUVA422P10:
826  case AV_PIX_FMT_YUVA420P10:
827  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
828  s->bits_per_raw_sample = 10;
829  av_fallthrough;
830  case AV_PIX_FMT_GRAY12:
831  case AV_PIX_FMT_YUV444P12:
832  case AV_PIX_FMT_YUV440P12:
833  case AV_PIX_FMT_YUV420P12:
834  case AV_PIX_FMT_YUV422P12:
835  case AV_PIX_FMT_YUVA444P12:
836  case AV_PIX_FMT_YUVA422P12:
837  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
838  s->bits_per_raw_sample = 12;
839  av_fallthrough;
840  case AV_PIX_FMT_GRAY14:
841  case AV_PIX_FMT_YUV444P14:
842  case AV_PIX_FMT_YUV420P14:
843  case AV_PIX_FMT_YUV422P14:
844  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
845  s->bits_per_raw_sample = 14;
846  s->packed_at_lsb = 1;
847  av_fallthrough;
848  case AV_PIX_FMT_GRAY16:
849  case AV_PIX_FMT_P016:
850  case AV_PIX_FMT_P216:
851  case AV_PIX_FMT_P416:
852  case AV_PIX_FMT_YUV444P16:
853  case AV_PIX_FMT_YUV422P16:
854  case AV_PIX_FMT_YUV420P16:
855  case AV_PIX_FMT_YUVA444P16:
856  case AV_PIX_FMT_YUVA422P16:
857  case AV_PIX_FMT_YUVA420P16:
858  case AV_PIX_FMT_GRAYF16:
859  case AV_PIX_FMT_YAF16:
860  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
861  s->bits_per_raw_sample = 16;
862  } else if (!s->bits_per_raw_sample) {
863  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
864  }
865  if (s->bits_per_raw_sample <= 8) {
866  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
867  return AVERROR_INVALIDDATA;
868  }
869  s->version = FFMAX(s->version, 1);
870  av_fallthrough;
871  case AV_PIX_FMT_GRAY8:
872  case AV_PIX_FMT_YA8:
873  case AV_PIX_FMT_NV12:
874  case AV_PIX_FMT_NV16:
875  case AV_PIX_FMT_NV24:
876  case AV_PIX_FMT_YUV444P:
877  case AV_PIX_FMT_YUV440P:
878  case AV_PIX_FMT_YUV422P:
879  case AV_PIX_FMT_YUV420P:
880  case AV_PIX_FMT_YUV411P:
881  case AV_PIX_FMT_YUV410P:
882  case AV_PIX_FMT_YUVA444P:
883  case AV_PIX_FMT_YUVA422P:
884  case AV_PIX_FMT_YUVA420P:
885  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
886  s->colorspace = 0;
887  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
888  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
889  s->bits_per_raw_sample = 8;
890  else if (!s->bits_per_raw_sample)
891  s->bits_per_raw_sample = 8;
892  break;
893  case AV_PIX_FMT_RGB32:
894  s->colorspace = 1;
895  s->transparency = 1;
896  s->chroma_planes = 1;
897  s->bits_per_raw_sample = 8;
898  break;
899  case AV_PIX_FMT_RGBA64:
900  s->colorspace = 1;
901  s->transparency = 1;
902  s->chroma_planes = 1;
903  s->bits_per_raw_sample = 16;
904  s->use32bit = 1;
905  s->version = FFMAX(s->version, 1);
906  break;
907  case AV_PIX_FMT_RGB48:
908  s->colorspace = 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_GBRP:
915  case AV_PIX_FMT_0RGB32:
916  s->colorspace = 1;
917  s->chroma_planes = 1;
918  s->bits_per_raw_sample = 8;
919  break;
920  case AV_PIX_FMT_GBRP9:
921  if (!avctx->bits_per_raw_sample)
922  s->bits_per_raw_sample = 9;
923  av_fallthrough;
924  case AV_PIX_FMT_X2BGR10:
925  case AV_PIX_FMT_X2RGB10:
926  case AV_PIX_FMT_GBRP10:
927  case AV_PIX_FMT_GBRAP10:
928  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
929  s->bits_per_raw_sample = 10;
930  av_fallthrough;
931  case AV_PIX_FMT_GBRP12:
932  case AV_PIX_FMT_GBRAP12:
933  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
934  s->bits_per_raw_sample = 12;
935  av_fallthrough;
936  case AV_PIX_FMT_GBRP14:
937  case AV_PIX_FMT_GBRAP14:
938  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
939  s->bits_per_raw_sample = 14;
940  av_fallthrough;
941  case AV_PIX_FMT_GBRP16:
942  case AV_PIX_FMT_GBRAP16:
943  case AV_PIX_FMT_GBRPF16:
944  case AV_PIX_FMT_GBRAPF16:
945  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
946  s->bits_per_raw_sample = 16;
947  av_fallthrough;
948  case AV_PIX_FMT_GBRPF32:
949  case AV_PIX_FMT_GBRAPF32:
950  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
951  s->bits_per_raw_sample = 32;
952  else if (!s->bits_per_raw_sample)
953  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
954  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
955  s->colorspace = 1;
956  s->chroma_planes = 1;
957  if (s->bits_per_raw_sample >= 16) {
958  s->use32bit = 1;
959  }
960  s->version = FFMAX(s->version, 1);
961  break;
962  default:
963  av_log(avctx, AV_LOG_ERROR, "format %s not supported\n",
964  av_get_pix_fmt_name(pix_fmt));
965  return AVERROR(ENOSYS);
966  }
967  s->flt = !!(desc->flags & AV_PIX_FMT_FLAG_FLOAT);
968  if (s->flt || s->remap_mode > 0)
969  s->version = FFMAX(s->version, 4);
970  av_assert0(s->bits_per_raw_sample >= 8);
971 
972  if (s->remap_mode < 0)
973  s->remap_mode = s->flt ? 2 : 0;
974  if (s->remap_mode == 0 && s->bits_per_raw_sample == 32) {
975  av_log(avctx, AV_LOG_ERROR, "32bit requires remap\n");
976  return AVERROR(EINVAL);
977  }
978  if (s->remap_mode == 2 &&
979  !((s->bits_per_raw_sample == 16 || s->bits_per_raw_sample == 32 || s->bits_per_raw_sample == 64) && s->flt)) {
980  av_log(avctx, AV_LOG_ERROR, "remap 2 is for float16/32/64 only\n");
981  return AVERROR(EINVAL);
982  }
983 
984  return av_pix_fmt_get_chroma_sub_sample(pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
985 }
986 
987 static av_cold int encode_init_internal(AVCodecContext *avctx)
988 {
989  int ret;
990  FFV1Context *s = avctx->priv_data;
991 
992  if ((ret = ff_ffv1_common_init(avctx, s)) < 0)
993  return ret;
994 
995  if (s->ac == 1) // Compatibility with common command line usage
996  s->ac = AC_RANGE_CUSTOM_TAB;
997  else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
998  s->ac = AC_RANGE_DEFAULT_TAB;
999 
1000  ret = ff_ffv1_encode_setup_plane_info(avctx, avctx->pix_fmt);
1001  if (ret < 0)
1002  return ret;
1003 
1004  if (s->bits_per_raw_sample > (s->version > 3 ? 16 : 8) && !s->remap_mode) {
1005  if (s->ac == AC_GOLOMB_RICE) {
1006  av_log(avctx, AV_LOG_INFO,
1007  "high bits_per_raw_sample, forcing range coder\n");
1008  s->ac = AC_RANGE_CUSTOM_TAB;
1009  }
1010  }
1011 
1012 
1013  ret = ff_ffv1_encode_init(avctx);
1014  if (ret < 0)
1015  return ret;
1016 
1017  if (s->version > 1) {
1018  if ((ret = ff_ffv1_encode_determine_slices(avctx)) < 0)
1019  return ret;
1020 
1021  if ((ret = ff_ffv1_write_extradata(avctx)) < 0)
1022  return ret;
1023  }
1024 
1025  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
1026  return ret;
1027  s->slice_count = s->max_slice_count;
1028 
1029  for (int j = 0; j < s->slice_count; j++) {
1030  FFV1SliceContext *sc = &s->slices[j];
1031 
1032  for (int i = 0; i < s->plane_count; i++) {
1033  PlaneContext *const p = &s->slices[j].plane[i];
1034 
1035  p->quant_table_index = s->context_model;
1036  p->context_count = s->context_count[p->quant_table_index];
1037  }
1038  av_assert0(s->remap_mode >= 0);
1039  if (s->remap_mode) {
1040  for (int p = 0; p < 1 + 2*s->chroma_planes + s->transparency ; p++) {
1041  if (s->bits_per_raw_sample == 32) {
1042  sc->unit[p] = av_malloc_array(sc->slice_width, sc->slice_height * sizeof(**sc->unit));
1043  if (!sc->unit[p])
1044  return AVERROR(ENOMEM);
1045  sc->bitmap[p] = av_malloc_array(sc->slice_width * sc->slice_height, sizeof(*sc->bitmap[p]));
1046  if (!sc->bitmap[p])
1047  return AVERROR(ENOMEM);
1048  } else {
1049  sc->fltmap[p] = av_malloc_array(65536, sizeof(*sc->fltmap[p]));
1050  if (!sc->fltmap[p])
1051  return AVERROR(ENOMEM);
1052  }
1053  }
1054  }
1055 
1056  ff_build_rac_states(&s->slices[j].c, 0.05 * (1LL << 32), 256 - 8);
1057 
1058  s->slices[j].remap = s->remap_mode;
1059  }
1060 
1061  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
1062  return ret;
1063 
1064 #define STATS_OUT_SIZE 1024 * 1024 * 6
1065  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1066  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
1067  if (!avctx->stats_out)
1068  return AVERROR(ENOMEM);
1069  for (int i = 0; i < s->quant_table_count; i++)
1070  for (int j = 0; j < s->max_slice_count; j++) {
1071  FFV1SliceContext *sc = &s->slices[j];
1072  av_assert0(!sc->rc_stat2[i]);
1073  sc->rc_stat2[i] = av_mallocz(s->context_count[i] *
1074  sizeof(*sc->rc_stat2[i]));
1075  if (!sc->rc_stat2[i])
1076  return AVERROR(ENOMEM);
1077  }
1078  }
1079 
1080  return 0;
1081 }
1082 
1083 static void encode_slice_header(FFV1Context *f, FFV1SliceContext *sc)
1084 {
1085  RangeCoder *c = &sc->c;
1086  uint8_t state[CONTEXT_SIZE];
1087  int j;
1088  memset(state, 128, sizeof(state));
1089 
1090  put_symbol(c, state, sc->sx, 0);
1091  put_symbol(c, state, sc->sy, 0);
1092  put_symbol(c, state, 0, 0);
1093  put_symbol(c, state, 0, 0);
1094  for (j=0; j<f->plane_count; j++) {
1095  put_symbol(c, state, sc->plane[j].quant_table_index, 0);
1096  av_assert0(sc->plane[j].quant_table_index == f->context_model);
1097  }
1098  if (!(f->cur_enc_frame->flags & AV_FRAME_FLAG_INTERLACED))
1099  put_symbol(c, state, 3, 0);
1100  else
1101  put_symbol(c, state, 1 + !(f->cur_enc_frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST), 0);
1102  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.num, 0);
1103  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.den, 0);
1104  if (f->version > 3) {
1105  put_rac(c, state, sc->slice_coding_mode == 1);
1106  if (sc->slice_coding_mode == 1)
1107  ff_ffv1_clear_slice_state(f, sc);
1108  put_symbol(c, state, sc->slice_coding_mode, 0);
1109  if (sc->slice_coding_mode != 1 && f->colorspace == 1) {
1110  put_symbol(c, state, sc->slice_rct_by_coef, 0);
1111  put_symbol(c, state, sc->slice_rct_ry_coef, 0);
1112  }
1113  put_symbol(c, state, sc->remap, 0);
1114  }
1115 }
1116 
1117 static void choose_rct_params(const FFV1Context *f, FFV1SliceContext *sc,
1118  const uint8_t *src[3], const int stride[3], int w, int h)
1119 {
1120 #define NB_Y_COEFF 15
1121  static const int rct_y_coeff[15][2] = {
1122  {0, 0}, // 4G
1123  {1, 1}, // R + 2G + B
1124  {2, 2}, // 2R + 2B
1125  {0, 2}, // 2G + 2B
1126  {2, 0}, // 2R + 2G
1127  {4, 0}, // 4R
1128  {0, 4}, // 4B
1129 
1130  {0, 3}, // 1G + 3B
1131  {3, 0}, // 3R + 1G
1132  {3, 1}, // 3R + B
1133  {1, 3}, // R + 3B
1134  {1, 2}, // R + G + 2B
1135  {2, 1}, // 2R + G + B
1136  {0, 1}, // 3G + B
1137  {1, 0}, // R + 3G
1138  };
1139 
1140  int stat[NB_Y_COEFF] = {0};
1141  int x, y, i, p, best;
1142  int16_t *sample[3];
1143  int lbd = f->bits_per_raw_sample <= 8;
1144  int packed = !src[1];
1145  int transparency = f->transparency;
1146  int packed_size = (3 + transparency)*2;
1147 
1148  for (y = 0; y < h; y++) {
1149  int lastr=0, lastg=0, lastb=0;
1150  for (p = 0; p < 3; p++)
1151  sample[p] = sc->sample_buffer + p*w;
1152 
1153  for (x = 0; x < w; x++) {
1154  int b, g, r;
1155  int ab, ag, ar;
1156  if (lbd) {
1157  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1158  b = v & 0xFF;
1159  g = (v >> 8) & 0xFF;
1160  r = (v >> 16) & 0xFF;
1161  } else if (packed) {
1162  const uint16_t *p = ((const uint16_t*)(src[0] + x*packed_size + stride[0]*y));
1163  r = p[0];
1164  g = p[1];
1165  b = p[2];
1166  } else if (f->use32bit || transparency) {
1167  g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
1168  b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
1169  r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
1170  } else {
1171  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1172  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1173  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1174  }
1175 
1176  ar = r - lastr;
1177  ag = g - lastg;
1178  ab = b - lastb;
1179  if (x && y) {
1180  int bg = ag - sample[0][x];
1181  int bb = ab - sample[1][x];
1182  int br = ar - sample[2][x];
1183 
1184  br -= bg;
1185  bb -= bg;
1186 
1187  for (i = 0; i<NB_Y_COEFF; i++) {
1188  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1189  }
1190 
1191  }
1192  sample[0][x] = ag;
1193  sample[1][x] = ab;
1194  sample[2][x] = ar;
1195 
1196  lastr = r;
1197  lastg = g;
1198  lastb = b;
1199  }
1200  }
1201 
1202  best = 0;
1203  for (i=1; i<NB_Y_COEFF; i++) {
1204  if (stat[i] < stat[best])
1205  best = i;
1206  }
1207 
1208  sc->slice_rct_by_coef = rct_y_coeff[best][1];
1209  sc->slice_rct_ry_coef = rct_y_coeff[best][0];
1210 }
1211 
1212 static void encode_histogram_remap(FFV1Context *f, FFV1SliceContext *sc)
1213 {
1214  int len = 1 << f->bits_per_raw_sample;
1215  int flip = sc->remap == 2 ? 0x7FFF : 0;
1216 
1217  for (int p= 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
1218  int j = 0;
1219  int lu = 0;
1220  uint8_t state[2][32];
1221  int run = 0;
1222 
1223  memset(state, 128, sizeof(state));
1224  put_symbol(&sc->c, state[0], 0, 0);
1225  memset(state, 128, sizeof(state));
1226  for (int i= 0; i<len; i++) {
1227  int ri = i ^ ((i&0x8000) ? 0 : flip);
1228  int u = sc->fltmap[p][ri];
1229  sc->fltmap[p][ri] = j;
1230  j+= u;
1231 
1232  if (lu == u) {
1233  run ++;
1234  } else {
1235  put_symbol_inline(&sc->c, state[lu], run, 0, NULL, NULL);
1236  if (run == 0)
1237  lu = u;
1238  run = 0;
1239  }
1240  }
1241  if (run)
1242  put_symbol(&sc->c, state[lu], run, 0);
1243  sc->remap_count[p] = j;
1244  }
1245 }
1246 
1247 static void load_rgb_float32_frame(FFV1Context *f, FFV1SliceContext *sc,
1248  const uint8_t *src[4],
1249  int w, int h, const int stride[4])
1250 {
1251  int x, y;
1252  int transparency = f->transparency;
1253  int i = 0;
1254 
1255  for (y = 0; y < h; y++) {
1256  for (x = 0; x < w; x++) {
1257  int b, g, r, av_uninit(a);
1258 
1259  g = *((const uint32_t *)(src[0] + x*4 + stride[0]*y));
1260  b = *((const uint32_t *)(src[1] + x*4 + stride[1]*y));
1261  r = *((const uint32_t *)(src[2] + x*4 + stride[2]*y));
1262  if (transparency)
1263  a = *((const uint32_t *)(src[3] + x*4 + stride[3]*y));
1264 
1265  if (sc->remap == 2) {
1266 #define FLIP(f) (((f)&0x80000000) ? (f) : (f)^0x7FFFFFFF);
1267  g = FLIP(g);
1268  b = FLIP(b);
1269  r = FLIP(r);
1270  }
1271  // We cannot build a histogram as we do for 16bit, we need a bit of magic here
1272  // Its possible to reduce the memory needed at the cost of more dereferencing
1273  sc->unit[0][i].val = g;
1274  sc->unit[0][i].ndx = x + y*w;
1275 
1276  sc->unit[1][i].val = b;
1277  sc->unit[1][i].ndx = x + y*w;
1278 
1279  sc->unit[2][i].val = r;
1280  sc->unit[2][i].ndx = x + y*w;
1281 
1282  if (transparency) {
1283  sc->unit[3][i].val = a;
1284  sc->unit[3][i].ndx = x + y*w;
1285  }
1286  i++;
1287  }
1288  }
1289 
1290  //TODO switch to radix sort
1291 #define CMP(A,B) ((A)->val - (int64_t)(B)->val)
1292  AV_QSORT(sc->unit[0], i, struct Unit, CMP);
1293  AV_QSORT(sc->unit[1], i, struct Unit, CMP);
1294  AV_QSORT(sc->unit[2], i, struct Unit, CMP);
1295  if (transparency)
1296  AV_QSORT(sc->unit[3], i, struct Unit, CMP);
1297 }
1298 
1299 static int encode_float32_remap_segment(FFV1SliceContext *sc,
1300  int p, int mul_count, int *mul_tab, int update, int final)
1301 {
1302  const int pixel_num = sc->slice_width * sc->slice_height;
1303  uint8_t state[2][3][32];
1304  int mul[4096+1];
1305  RangeCoder rc = sc->c;
1306  int lu = 0;
1307  int run = 0;
1308  int64_t last_val = -1;
1309  int compact_index = -1;
1310  int i = 0;
1311  int current_mul_index = -1;
1312  int run1final = 0;
1313  int run1start_i;
1314  int run1start_last_val;
1315  int run1start_mul_index;
1316 
1317  memcpy(mul, mul_tab, sizeof(*mul_tab)*(mul_count+1));
1318  memset(state, 128, sizeof(state));
1319  put_symbol(&rc, state[0][0], mul_count, 0);
1320  memset(state, 128, sizeof(state));
1321 
1322  for (; i < pixel_num+1; i++) {
1323  int current_mul = current_mul_index < 0 ? 1 : FFABS(mul[current_mul_index]);
1324  int64_t val;
1325  if (i == pixel_num) {
1326  if (last_val == 0xFFFFFFFF && (!run || run1final)) {
1327  break;
1328  } else {
1329  val = last_val + ((1LL<<32) - last_val + current_mul - 1) / current_mul * current_mul;
1330  av_assert2(val >= (1LL<<32));
1331  val += lu * current_mul; //ensure a run1 ends
1332  }
1333  } else
1334  val = sc->unit[p][i].val;
1335 
1336  if (last_val != val) {
1337  int64_t delta = val - last_val;
1338  int64_t step = FFMAX(1, (delta + current_mul/2) / current_mul);
1339  av_assert2(last_val < val);
1340  av_assert2(current_mul > 0);
1341 
1342  delta -= step*current_mul;
1343  av_assert2(delta <= current_mul/2);
1344  av_assert2(delta > -current_mul);
1345 
1346  av_assert2(step > 0);
1347  if (lu) {
1348  if (!run) {
1349  run1start_i = i - 1;
1350  run1start_last_val = last_val;
1351  run1start_mul_index= current_mul_index;
1352  }
1353  if (step == 1) {
1354  if (run1final) {
1355  if (current_mul>1)
1356  put_symbol_inline(&rc, state[lu][1], delta, 1, NULL, NULL);
1357  }
1358  run ++;
1359  av_assert2(last_val + current_mul + delta == val);
1360  } else {
1361  if (run1final) {
1362  if (run == 0)
1363  lu ^= 1;
1364  i--; // we did not encode val so we need to backstep
1365  last_val += current_mul;
1366  } else {
1367  put_symbol_inline(&rc, state[lu][0], run, 0, NULL, NULL);
1368  i = run1start_i;
1369  last_val = run1start_last_val; // we could compute this instead of storing
1370  current_mul_index = run1start_mul_index;
1371  }
1372  run1final ^= 1;
1373 
1374  run = 0;
1375  continue;
1376  }
1377  } else {
1378  av_assert2(run == 0);
1379  av_assert2(run1final == 0);
1380  put_symbol_inline(&rc, state[lu][0], step - 1, 0, NULL, NULL);
1381 
1382  if (current_mul > 1)
1383  put_symbol_inline(&rc, state[lu][1], delta, 1, NULL, NULL);
1384  if (step == 1)
1385  lu ^= 1;
1386 
1387  av_assert2(last_val + step * current_mul + delta == val);
1388  }
1389  last_val = val;
1390  current_mul_index = ((last_val + 1) * mul_count) >> 32;
1391  if (!run || run1final) {
1392  av_assert2(mul[ current_mul_index ]);
1393  if (mul[ current_mul_index ] < 0) {
1394  av_assert2(i < pixel_num);
1395  mul[ current_mul_index ] *= -1;
1396  put_symbol_inline(&rc, state[0][2], mul[ current_mul_index ], 0, NULL, NULL);
1397  }
1398  if (i < pixel_num)
1399  compact_index ++;
1400  }
1401  }
1402  if (!run || run1final)
1403  if (final && i < pixel_num)
1404  sc->bitmap[p][sc->unit[p][i].ndx] = compact_index;
1405  }
1406 
1407  if (update) {
1408  sc->c = rc;
1409  sc->remap_count[p] = compact_index + 1;
1410  }
1411  return get_rac_count(&rc);
1412 }
1413 
1414 static void encode_float32_remap(FFV1Context *f, FFV1SliceContext *sc,
1415  const uint8_t *src[4])
1416 {
1417  int pixel_num = sc->slice_width * sc->slice_height;
1418  const int max_log2_mul_count = ((int[]){ 1, 1, 1, 9, 9, 10})[f->remap_optimizer];
1419  const int log2_mul_count_step = ((int[]){ 1, 1, 1, 9, 9, 1})[f->remap_optimizer];
1420  const int max_log2_mul = ((int[]){ 1, 8, 8, 9, 22, 22})[f->remap_optimizer];
1421  const int log2_mul_step = ((int[]){ 1, 8, 1, 1, 1, 1})[f->remap_optimizer];
1422  const int bruteforce_count = ((int[]){ 0, 0, 0, 1, 1, 1})[f->remap_optimizer];
1423  const int stair_mode = ((int[]){ 0, 0, 0, 1, 0, 0})[f->remap_optimizer];
1424  const int magic_log2 = ((int[]){ 1, 1, 1, 1, 0, 0})[f->remap_optimizer];
1425 
1426  for (int p= 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
1427  int best_log2_mul_count = 0;
1428  float score_sum[11] = {0};
1429  int mul_all[11][1025];
1430 
1431  for (int log2_mul_count= 0; log2_mul_count <= max_log2_mul_count; log2_mul_count += log2_mul_count_step) {
1432  float score_tab_all[1025][23] = {0};
1433  int64_t last_val = -1;
1434  int *mul_tab = mul_all[log2_mul_count];
1435  int last_mul_index = -1;
1436  int mul_count = 1 << log2_mul_count;
1437 
1438  score_sum[log2_mul_count] = 2 * log2_mul_count;
1439  if (magic_log2)
1440  score_sum[log2_mul_count] = av_float2int((float)mul_count * mul_count);
1441  for (int i= 0; i<pixel_num; i++) {
1442  int64_t val = sc->unit[p][i].val;
1443  int mul_index = (val + 1LL)*mul_count >> 32;
1444  if (val != last_val) {
1445  float *score_tab = score_tab_all[(last_val + 1LL)*mul_count >> 32];
1446  av_assert2(last_val < val);
1447  for(int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1448  int64_t delta = val - last_val;
1449  int mul;
1450  int64_t cost;
1451 
1452  if (last_val < 0) {
1453  mul = 1;
1454  } else if (stair_mode && mul_count == 512 && si == max_log2_mul ) {
1455  if (mul_index >= 0x378/8 && mul_index <= 23 + 0x378/8) {
1456  mul = (0x800080 >> (mul_index - 0x378/8));
1457  } else
1458  mul = 1;
1459  } else {
1460  mul = (0x10001LL)<<si >> 16;
1461  }
1462 
1463  cost = FFMAX((delta + mul/2) / mul, 1);
1464  float score = 1;
1465  if (mul > 1) {
1466  score *= (FFABS(delta - cost*mul)+1);
1467  if (mul_count > 1)
1468  score *= score;
1469  }
1470  score *= cost;
1471  score *= score;
1472  if (mul_index != last_mul_index)
1473  score *= mul;
1474  if (magic_log2) {
1475  score_tab[si] += av_float2int(score);
1476  } else
1477  score_tab[si] += log2f(score);
1478  }
1479  }
1480  last_val = val;
1481  last_mul_index = mul_index;
1482  }
1483  for(int i= 0; i<mul_count; i++) {
1484  int best_index = 0;
1485  float *score_tab = score_tab_all[i];
1486  for(int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1487  if (score_tab[si] < score_tab[ best_index ])
1488  best_index = si;
1489  }
1490  if (stair_mode && mul_count == 512 && best_index == max_log2_mul ) {
1491  if (i >= 0x378/8 && i <= 23 + 0x378/8) {
1492  mul_tab[i] = -(0x800080 >> (i - 0x378/8));
1493  } else
1494  mul_tab[i] = -1;
1495  } else
1496  mul_tab[i] = -((0x10001LL)<<best_index >> 16);
1497  score_sum[log2_mul_count] += score_tab[ best_index ];
1498  }
1499  mul_tab[mul_count] = 1;
1500 
1501  if (bruteforce_count)
1502  score_sum[log2_mul_count] = encode_float32_remap_segment(sc, p, mul_count, mul_all[log2_mul_count], 0, 0);
1503 
1504  if (score_sum[log2_mul_count] < score_sum[best_log2_mul_count])
1505  best_log2_mul_count = log2_mul_count;
1506  }
1507 
1508  encode_float32_remap_segment(sc, p, 1<<best_log2_mul_count, mul_all[best_log2_mul_count], 1, 1);
1509  }
1510 }
1511 
1512 static int encode_float32_rgb_frame(FFV1Context *f, FFV1SliceContext *sc,
1513  const uint8_t *src[4],
1514  int w, int h, const int stride[4], int ac)
1515 {
1516  int x, y, p, i;
1517  const int ring_size = f->context_model ? 3 : 2;
1518  int32_t *sample[4][3];
1519  const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
1520  int bits[4], offset;
1521  int transparency = f->transparency;
1522 
1523  ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, NULL, f->bits_per_raw_sample);
1524 
1525  sc->run_index = 0;
1526 
1527  for (int p = 0; p < MAX_PLANES; ++p)
1528  sample[p][2] = sc->sample_buffer32; // dummy to avoid UB pointer arithmetic
1529 
1530  memset(RENAME(sc->sample_buffer), 0, ring_size * MAX_PLANES *
1531  (w + 6) * sizeof(*RENAME(sc->sample_buffer)));
1532 
1533  for (y = 0; y < h; y++) {
1534  for (i = 0; i < ring_size; i++)
1535  for (p = 0; p < MAX_PLANES; p++)
1536  sample[p][i]= RENAME(sc->sample_buffer) + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
1537 
1538  for (x = 0; x < w; x++) {
1539  int b, g, r, av_uninit(a);
1540  g = sc->bitmap[0][x + w*y];
1541  b = sc->bitmap[1][x + w*y];
1542  r = sc->bitmap[2][x + w*y];
1543  if (transparency)
1544  a = sc->bitmap[3][x + w*y];
1545 
1546  if (sc->slice_coding_mode != 1) {
1547  b -= g;
1548  r -= g;
1549  g += (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2;
1550  b += offset;
1551  r += offset;
1552  }
1553 
1554  sample[0][0][x] = g;
1555  sample[1][0][x] = b;
1556  sample[2][0][x] = r;
1557  sample[3][0][x] = a;
1558  }
1559  for (p = 0; p < 3 + transparency; p++) {
1560  int ret;
1561  sample[p][0][-1] = sample[p][1][0 ];
1562  sample[p][1][ w] = sample[p][1][w-1];
1563  ret = encode_line32(f, sc, f->avctx, w, sample[p], (p + 1) / 2,
1564  bits[p], ac, pass1);
1565  if (ret < 0)
1566  return ret;
1567  }
1568  }
1569  return 0;
1570 }
1571 
1572 
1573 static int encode_slice(AVCodecContext *c, void *arg)
1574 {
1575  FFV1SliceContext *sc = arg;
1576  FFV1Context *f = c->priv_data;
1577  int width = sc->slice_width;
1578  int height = sc->slice_height;
1579  int x = sc->slice_x;
1580  int y = sc->slice_y;
1581  const AVFrame *const p = f->cur_enc_frame;
1582  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1583  int ret;
1584  RangeCoder c_bak = sc->c;
1585  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1586  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1587  const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1588  p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1589  p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1590  p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1591  int ac = f->ac;
1592 
1593  sc->slice_coding_mode = 0;
1594  if (f->version > 3 && f->colorspace == 1) {
1595  choose_rct_params(f, sc, planes, p->linesize, width, height);
1596  } else {
1597  sc->slice_rct_by_coef = 1;
1598  sc->slice_rct_ry_coef = 1;
1599  }
1600 
1601 retry:
1602  if (f->key_frame)
1603  ff_ffv1_clear_slice_state(f, sc);
1604  if (f->version > 2) {
1605  encode_slice_header(f, sc);
1606  }
1607 
1608  if (sc->remap) {
1609  //Both the 16bit and 32bit remap do exactly the same thing but with 16bits we can
1610  //Implement this using a "histogram" while for 32bit that would be gb sized, thus a more
1611  //complex implementation sorting pairs is used.
1612  if (f->bits_per_raw_sample != 32) {
1613  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8 && c->pix_fmt != AV_PIX_FMT_YAF16) {
1614  const int cx = x >> f->chroma_h_shift;
1615  const int cy = y >> f->chroma_v_shift;
1616 
1617  //TODO decide on the order for the encoded remaps and loads. with golomb rice it
1618  // easier to have all range coded ones together, otherwise it may be nicer to handle each plane as a whole?
1619 
1620  load_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1621 
1622  if (f->chroma_planes) {
1623  load_plane(f, sc, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1624  load_plane(f, sc, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 2, 1);
1625  }
1626  if (f->transparency)
1627  load_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 3, 1);
1628  } else if (c->pix_fmt == AV_PIX_FMT_YA8 || c->pix_fmt == AV_PIX_FMT_YAF16) {
1629  load_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1630  load_plane(f, sc, p->data[0] + (ps>>1) + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1631  } else if (f->use32bit) {
1632  load_rgb_frame32(f, sc, planes, width, height, p->linesize);
1633  } else
1634  load_rgb_frame (f, sc, planes, width, height, p->linesize);
1635 
1636  encode_histogram_remap(f, sc);
1637  } else {
1638  load_rgb_float32_frame(f, sc, planes, width, height, p->linesize);
1639  encode_float32_remap(f, sc, planes);
1640  }
1641  }
1642 
1643  if (ac == AC_GOLOMB_RICE) {
1644  sc->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&sc->c, f->version > 2) : 0;
1645  init_put_bits(&sc->pb,
1646  sc->c.bytestream_start + sc->ac_byte_count,
1647  sc->c.bytestream_end - sc->c.bytestream_start - sc->ac_byte_count);
1648  }
1649 
1650  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8 && c->pix_fmt != AV_PIX_FMT_YAF16) {
1651  const int cx = x >> f->chroma_h_shift;
1652  const int cy = y >> f->chroma_v_shift;
1653 
1654  ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 1, ac);
1655 
1656  if (f->chroma_planes) {
1657  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);
1658  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);
1659  }
1660  if (f->transparency)
1661  ret |= encode_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 3, 1, ac);
1662  } else if (c->pix_fmt == AV_PIX_FMT_YA8 || c->pix_fmt == AV_PIX_FMT_YAF16) {
1663  ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 2, ac);
1664  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);
1665  } else if (f->bits_per_raw_sample == 32) {
1666  ret = encode_float32_rgb_frame(f, sc, planes, width, height, p->linesize, ac);
1667  } else if (f->use32bit) {
1668  ret = encode_rgb_frame32(f, sc, planes, width, height, p->linesize, ac);
1669  } else {
1670  ret = encode_rgb_frame(f, sc, planes, width, height, p->linesize, ac);
1671  }
1672 
1673  if (ac != AC_GOLOMB_RICE) {
1674  sc->ac_byte_count = ff_rac_terminate(&sc->c, 1);
1675  } else {
1676  flush_put_bits(&sc->pb); // FIXME: nicer padding
1677  sc->ac_byte_count += put_bytes_output(&sc->pb);
1678  }
1679 
1680  if (ret < 0) {
1681  av_assert0(sc->slice_coding_mode == 0);
1682  if (f->version < 4) {
1683  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1684  return ret;
1685  }
1686  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1687  ac = 1;
1688  sc->slice_coding_mode = 1;
1689  sc->c = c_bak;
1690  goto retry;
1691  }
1692 
1693  return 0;
1694 }
1695 
1696 size_t ff_ffv1_encode_buffer_size(AVCodecContext *avctx)
1697 {
1698  FFV1Context *f = avctx->priv_data;
1699 
1700  int w = avctx->width + f->num_h_slices;
1701  int h = avctx->height + f->num_v_slices;
1702  size_t maxsize = w*h * (1 + f->transparency);
1703  if (f->chroma_planes)
1704  maxsize += AV_CEIL_RSHIFT(w, f->chroma_h_shift) * AV_CEIL_RSHIFT(h, f->chroma_v_shift) * 2;
1705  maxsize += f->slice_count * 800; //for slice header
1706  if (f->version > 3) {
1707  maxsize *= f->bits_per_raw_sample + 1;
1708  if (f->remap_mode)
1709  maxsize += f->slice_count * 70000 * (1 + 2*f->chroma_planes + f->transparency);
1710  } else {
1711  maxsize += f->slice_count * 2 * (avctx->width + avctx->height); //for bug with slices that code some pixels more than once
1712  maxsize *= 8*(2*f->bits_per_raw_sample + 5);
1713  }
1714  maxsize >>= 3;
1715  maxsize += FF_INPUT_BUFFER_MIN_SIZE;
1716 
1717  return maxsize;
1718 }
1719 
1720 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1721  const AVFrame *pict, int *got_packet)
1722 {
1723  FFV1Context *f = avctx->priv_data;
1724  RangeCoder *const c = &f->slices[0].c;
1725  uint8_t keystate = 128;
1726  uint8_t *buf_p;
1727  int i, ret;
1728  int64_t maxsize;
1729 
1730  if(!pict) {
1731  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1732  int j, k, m;
1733  char *p = avctx->stats_out;
1734  char *end = p + STATS_OUT_SIZE;
1735 
1736  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1737  for (i = 0; i < f->quant_table_count; i++)
1738  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1739 
1740  av_assert0(f->slice_count == f->max_slice_count);
1741  for (j = 0; j < f->slice_count; j++) {
1742  const FFV1SliceContext *sc = &f->slices[j];
1743  for (i = 0; i < 256; i++) {
1744  f->rc_stat[i][0] += sc->rc_stat[i][0];
1745  f->rc_stat[i][1] += sc->rc_stat[i][1];
1746  }
1747  for (i = 0; i < f->quant_table_count; i++) {
1748  for (k = 0; k < f->context_count[i]; k++)
1749  for (m = 0; m < 32; m++) {
1750  f->rc_stat2[i][k][m][0] += sc->rc_stat2[i][k][m][0];
1751  f->rc_stat2[i][k][m][1] += sc->rc_stat2[i][k][m][1];
1752  }
1753  }
1754  }
1755 
1756  for (j = 0; j < 256; j++) {
1757  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1758  f->rc_stat[j][0], f->rc_stat[j][1]);
1759  p += strlen(p);
1760  }
1761  snprintf(p, end - p, "\n");
1762 
1763  for (i = 0; i < f->quant_table_count; i++) {
1764  for (j = 0; j < f->context_count[i]; j++)
1765  for (m = 0; m < 32; m++) {
1766  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1767  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1768  p += strlen(p);
1769  }
1770  }
1771  snprintf(p, end - p, "%d\n", f->gob_count);
1772  }
1773  return 0;
1774  }
1775 
1776  /* Maximum packet size */
1777  maxsize = ff_ffv1_encode_buffer_size(avctx);
1778 
1779  if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1780  FFV1Context *f = avctx->priv_data;
1781  if (!f->maxsize_warned) {
1782  av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1783  f->maxsize_warned++;
1784  }
1785  maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1786  }
1787 
1788  if ((ret = ff_alloc_packet(avctx, pkt, maxsize)) < 0)
1789  return ret;
1790 
1791  ff_init_range_encoder(c, pkt->data, pkt->size);
1792  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1793 
1794  f->cur_enc_frame = pict;
1795 
1796  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1797  put_rac(c, &keystate, 1);
1798  f->key_frame = 1;
1799  f->gob_count++;
1800  write_header(f);
1801  } else {
1802  put_rac(c, &keystate, 0);
1803  f->key_frame = 0;
1804  }
1805 
1806  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1807  int i;
1808  for (i = 1; i < 256; i++) {
1809  c->one_state[i] = f->state_transition[i];
1810  c->zero_state[256 - i] = 256 - c->one_state[i];
1811  }
1812  }
1813 
1814  for (i = 0; i < f->slice_count; i++) {
1815  FFV1SliceContext *sc = &f->slices[i];
1816  uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1817  int len = pkt->size / f->slice_count;
1818  if (i) {
1819  ff_init_range_encoder(&sc->c, start, len);
1820  } else {
1821  av_assert0(sc->c.bytestream_end >= sc->c.bytestream_start + len);
1822  av_assert0(sc->c.bytestream < sc->c.bytestream_start + len);
1823  sc->c.bytestream_end = sc->c.bytestream_start + len;
1824  }
1825  }
1826  avctx->execute(avctx, encode_slice, f->slices, NULL,
1827  f->slice_count, sizeof(*f->slices));
1828 
1829  buf_p = pkt->data;
1830  for (i = 0; i < f->slice_count; i++) {
1831  FFV1SliceContext *sc = &f->slices[i];
1832  int bytes = sc->ac_byte_count;
1833  if (i > 0 || f->version > 2) {
1834  av_assert0(bytes < pkt->size / f->slice_count);
1835  memmove(buf_p, sc->c.bytestream_start, bytes);
1836  av_assert0(bytes < (1 << 24));
1837  AV_WB24(buf_p + bytes, bytes);
1838  bytes += 3;
1839  }
1840  if (f->ec) {
1841  unsigned v;
1842  buf_p[bytes++] = 0;
1843  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, buf_p, bytes) ^ (f->crcref ? 0x8CD88196 : 0);
1844  AV_WL32(buf_p + bytes, v);
1845  bytes += 4;
1846  }
1847  buf_p += bytes;
1848  }
1849 
1850  if (avctx->flags & AV_CODEC_FLAG_PASS1)
1851  avctx->stats_out[0] = '\0';
1852 
1853  f->picture_number++;
1854  pkt->size = buf_p - pkt->data;
1855  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1856  *got_packet = 1;
1857 
1858  return 0;
1859 }
1860 
1861 static av_cold int encode_close(AVCodecContext *avctx)
1862 {
1863  FFV1Context *const s = avctx->priv_data;
1864 
1865  for (int j = 0; j < s->max_slice_count; j++) {
1866  FFV1SliceContext *sc = &s->slices[j];
1867 
1868  for(int p = 0; p<4; p++) {
1869  av_freep(&sc->unit[p]);
1870  av_freep(&sc->bitmap[p]);
1871  }
1872  }
1873 
1874  av_freep(&avctx->stats_out);
1875  ff_ffv1_close(s);
1876 
1877  return 0;
1878 }
1879 
1880 #define OFFSET(x) offsetof(FFV1Context, x)
1881 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1882 static const AVOption options[] = {
1883  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
1884  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1885  { .i64 = 0 }, -2, 2, VE, .unit = "coder" },
1886  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1887  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1888  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1889  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1890  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1891  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1892  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1893  { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1894  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1895  { .i64 = 0 }, 0, 1, VE },
1896  { "qtable", "Quantization table", OFFSET(qtable), AV_OPT_TYPE_INT,
1897  { .i64 = -1 }, -1, 2, VE , .unit = "qtable"},
1898  { "default", NULL, 0, AV_OPT_TYPE_CONST,
1899  { .i64 = QTABLE_DEFAULT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
1900  { "8bit", NULL, 0, AV_OPT_TYPE_CONST,
1901  { .i64 = QTABLE_8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
1902  { "greater8bit", NULL, 0, AV_OPT_TYPE_CONST,
1903  { .i64 = QTABLE_GT8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
1904  { "remap_mode", "Remap Mode", OFFSET(remap_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE, .unit = "remap_mode" },
1905  { "auto", "Automatic", 0, AV_OPT_TYPE_CONST,
1906  { .i64 = -1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
1907  { "off", "Disabled", 0, AV_OPT_TYPE_CONST,
1908  { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
1909  { "dualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
1910  { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
1911  { "flipdualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
1912  { .i64 = 2 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
1913  { "remap_optimizer", "Remap Optimizer", OFFSET(remap_optimizer), AV_OPT_TYPE_INT, { .i64 = 3 }, 0, 5, VE, .unit = "remap_optimizer" },
1914 
1915  { NULL }
1916 };
1917 
1918 static const AVClass ffv1_class = {
1919  .class_name = "ffv1 encoder",
1920  .item_name = av_default_item_name,
1921  .option = options,
1922  .version = LIBAVUTIL_VERSION_INT,
1923 };
1924 
1925 const FFCodec ff_ffv1_encoder = {
1926  .p.name = "ffv1",
1927  CODEC_LONG_NAME("FFmpeg video codec #1"),
1928  .p.type = AVMEDIA_TYPE_VIDEO,
1929  .p.id = AV_CODEC_ID_FFV1,
1930  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1931  AV_CODEC_CAP_SLICE_THREADS |
1932  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1933  .priv_data_size = sizeof(FFV1Context),
1934  .init = encode_init_internal,
1935  FF_CODEC_ENCODE_CB(encode_frame),
1936  .close = encode_close,
1937  CODEC_PIXFMTS(
1938  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1939  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1940  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1941  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1942  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1943  AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1944  AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1945  AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA422P12,
1946  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1947  AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1948  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1949  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRAP14,
1950  AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1951  AV_PIX_FMT_YA8,
1952  AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
1953  AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1954  AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1955  AV_PIX_FMT_GRAY9,
1956  AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1957  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1958  AV_PIX_FMT_YAF16,
1959  AV_PIX_FMT_GRAYF16,
1960  AV_PIX_FMT_GBRPF16, AV_PIX_FMT_GBRPF32),
1961  .color_ranges = AVCOL_RANGE_MPEG,
1962  .p.priv_class = &ffv1_class,
1963  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
1964 };
load_rgb_frame
static void RENAME() load_rgb_frame(FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src[4], int w, int h, const int stride[4])
Definition: ffv1enc_template.c:139
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:596
set_micro_version
static void set_micro_version(FFV1Context *f)
Definition: ffv1enc.c:431
CODEC_PIXFMTS
#define CODEC_PIXFMTS(...)
Definition: codec_internal.h:392
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:565
encode_init_internal
static av_cold int encode_init_internal(AVCodecContext *avctx)
Definition: ffv1enc.c:987
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
FFV1SliceContext::slice_height
int slice_height
Definition: ffv1.h:78
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
ff_ffv1_encode_determine_slices
int ff_ffv1_encode_determine_slices(AVCodecContext *avctx)
Definition: ffv1enc.c:566
av_clip
#define av_clip
Definition: common.h:100
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:225
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
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:99
encode_float32_remap
static void encode_float32_remap(FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src[4])
Definition: ffv1enc.c:1414
log2f
#define log2f(x)
Definition: libm.h:411
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
FFV1SliceContext::plane
PlaneContext * plane
Definition: ffv1.h:90
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
int64_t
long long int64_t
Definition: coverity.c:34
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
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
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_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:588
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:435
pixdesc.h
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:595
QTABLE_DEFAULT
@ QTABLE_DEFAULT
Definition: ffv1enc.h:29
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:68
AC_RANGE_DEFAULT_TAB_FORCE
#define AC_RANGE_DEFAULT_TAB_FORCE
Definition: ffv1.h:55
AVPacket::data
uint8_t * data
Definition: packet.h:595
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:590
AVOption
AVOption.
Definition: opt.h:429
encode.h
b
#define b
Definition: input.c:43
MAX_QUANT_TABLE_SIZE
#define MAX_QUANT_TABLE_SIZE
Definition: ffv1.h:48
rangecoder.h
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:40
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:539
ff_ffv1_write_extradata
av_cold int ff_ffv1_write_extradata(AVCodecContext *avctx)
Definition: ffv1enc.c:447
FFCodec
Definition: codec_internal.h:127
FFV1SliceContext::pb
PutBitContext pb
Definition: ffv1.h:91
RangeCoder::bytestream_end
uint8_t * bytestream_end
Definition: rangecoder.h:44
contains_non_128
static int contains_non_128(uint8_t(*initial_state)[CONTEXT_SIZE], int nb_contexts)
Definition: ffv1enc.c:372
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
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_float2int
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
Definition: intfloat.h:50
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:54
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:591
ring_size
static int ring_size(RingBuffer *ring)
Definition: async.c:105
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:650
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:33
FFV1SliceContext::slice_x
int slice_x
Definition: ffv1.h:79
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:233
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1SliceContext *sc)
Definition: ffv1.c:198
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:518
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:663
crc.h
ff_ffv1_init_slices_state
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:110
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:587
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
quant11
static const int8_t quant11[256]
Definition: ffv1enc.c:102
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
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:560
ff_init_range_encoder
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:42
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:558
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:597
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:537
encode_slice
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:1573
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:496
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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:3484
AV_PIX_FMT_GRAYF16
#define AV_PIX_FMT_GRAYF16
Definition: pixfmt.h:581
av_noinline
#define av_noinline
Definition: attributes.h:101
NB_Y_COEFF
#define NB_Y_COEFF
MAX_SLICES
#define MAX_SLICES
Definition: d3d12va_hevc.c:33
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:45
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:522
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:359
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:542
avassert.h
put_golomb.h
exp golomb vlc writing stuff
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:119
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:551
FFV1SliceContext::sample_buffer
int16_t * sample_buffer
Definition: ffv1.h:74
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:562
s
#define s(width, name)
Definition: cbs_vp9.c:198
MAX_PLANES
#define MAX_PLANES
Definition: ffv1.h:44
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:1332
AV_PIX_FMT_GBRAP14
#define AV_PIX_FMT_GBRAP14
Definition: pixfmt.h:564
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:563
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_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:552
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
g
const char * g
Definition: vf_curves.c:128
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
FLIP
#define FLIP(f)
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:144
bits
uint8_t bits
Definition: vp3data.h:128
AC_RANGE_DEFAULT_TAB
#define AC_RANGE_DEFAULT_TAB
Definition: ffv1.h:53
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
quant5
static const int8_t quant5[256]
Definition: ffv1enc.c:64
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:594
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1565
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:536
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:550
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
FFV1SliceContext::rc_stat2
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:106
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:1299
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:521
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:214
ff_ffv1_encode_setup_plane_info
av_cold int ff_ffv1_encode_setup_plane_info(AVCodecContext *avctx, enum AVPixelFormat pix_fmt)
Definition: ffv1enc.c:801
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_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
av_fallthrough
#define av_fallthrough
Definition: attributes.h:67
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:332
sort_stt
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:517
ver2_state
static const uint8_t ver2_state[256]
Definition: ffv1enc.c:121
arg
const char * arg
Definition: jacosubdec.c:65
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:519
if
if(ret)
Definition: filter_design.txt:179
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: ffv1enc.c:1720
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: ffv1enc.c:1861
quant_table
static const int16_t quant_table[64]
Definition: intrax8.c:511
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:561
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:529
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
FFV1SliceContext::sx
int sx
Definition: ffv1.h:81
ff_need_new_slices
int ff_need_new_slices(int width, int num_h_slices, int chroma_shift)
Definition: ffv1.c:120
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
NULL
#define NULL
Definition: coverity.c:32
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:52
CMP
#define CMP(A, B)
run
uint8_t run
Definition: svq3.c:207
FFV1SliceContext::unit
struct FFV1SliceContext::Unit * unit[4]
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:200
FFV1SliceContext::Unit::val
uint32_t val
Definition: ffv1.h:117
ff_rac_terminate
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
Definition: rangecoder.c:109
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:242
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:541
options
Definition: swscale.c:45
PlaneContext
Definition: ffv1.h:64
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:540
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:557
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1640
AV_PIX_FMT_GBRPF16
#define AV_PIX_FMT_GBRPF16
Definition: pixfmt.h:576
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
VlcState
Definition: ffv1.h:57
VE
#define VE
Definition: ffv1enc.c:1881
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
FFV1SliceContext::slice_width
int slice_width
Definition: ffv1.h:77
options
static const AVOption options[]
Definition: ffv1enc.c:1882
AV_PIX_FMT_X2BGR10
#define AV_PIX_FMT_X2BGR10
Definition: pixfmt.h:614
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1324
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:85
qsort.h
f
f
Definition: af_crystalizer.c:122
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:551
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:52
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:1117
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:131
AVPacket::size
int size
Definition: packet.h:596
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1017
height
#define height
Definition: dsp.h:89
FFV1SliceContext::bitmap
uint32_t * bitmap[4]
Definition: ffv1.h:111
codec_internal.h
quant9_10bit
static const int8_t quant9_10bit[256]
Definition: ffv1enc.c:83
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
print
static void print(AVTreeNode *t, int depth)
Definition: tree.c:45
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:578
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:544
sample
#define sample
Definition: flacdsp_template.c:44
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:525
size
int size
Definition: twinvq_data.h:10344
QTABLE_GT8BIT
@ QTABLE_GT8BIT
Definition: ffv1enc.h:31
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
STATS_OUT_SIZE
#define STATS_OUT_SIZE
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:546
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:446
QTABLE_8BIT
@ QTABLE_8BIT
Definition: ffv1enc.h:30
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
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
RangeCoder::bytestream
uint8_t * bytestream
Definition: rangecoder.h:43
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:294
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:511
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
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
FFV1SliceContext::slice_rct_by_coef
int slice_rct_by_coef
Definition: ffv1.h:85
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:389
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:99
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:592
planes
static const struct @585 planes[]
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
state
static struct @583 state
find_best_state
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256])
Definition: ffv1enc.c:140
attributes.h
FFV1SliceContext::rc_stat
uint64_t rc_stat[256][2]
Definition: ffv1.h:105
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:601
AV_PIX_FMT_P216
#define AV_PIX_FMT_P216
Definition: pixfmt.h:620
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:65
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
FFV1SliceContext::c
RangeCoder c
Definition: ffv1.h:92
put_vlc_symbol
static void put_vlc_symbol(PutBitContext *pb, VlcState *const state, int v, int bits)
Definition: ffv1enc.c:240
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
ffv1_class
static const AVClass ffv1_class
Definition: ffv1enc.c:1918
av_malloc
#define av_malloc(s)
Definition: ops_asmgen.c:44
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
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
round
static av_always_inline av_const double round(double x)
Definition: libm.h:446
FFV1SliceContext::slice_rct_ry_coef
int slice_rct_ry_coef
Definition: ffv1.h:86
av_flatten
#define av_flatten
Definition: attributes.h:125
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:559
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
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
FFV1SliceContext::remap_count
int remap_count[4]
Definition: ffv1.h:109
encode_rgb_frame
static int RENAME() encode_rgb_frame(FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src[4], int w, int h, const int stride[4], int ac)
Definition: ffv1enc_template.c:174
delta
float delta
Definition: vorbis_enc_data.h:430
av_always_inline
#define av_always_inline
Definition: attributes.h:76
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx, FFV1Context *s)
Definition: ffv1.c:36
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ffv1.h
FFV1SliceContext::sample_buffer32
int32_t * sample_buffer32
Definition: ffv1.h:75
AV_PIX_FMT_X2RGB10
#define AV_PIX_FMT_X2RGB10
Definition: pixfmt.h:613
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
FFV1SliceContext
Definition: ffv1.h:73
len
int len
Definition: vorbis_enc_data.h:426
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition: crc.h:52
AVCodecContext::height
int height
Definition: avcodec.h:600
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:639
write_quant_table
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition: ffv1enc.c:349
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:658
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:760
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:538
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:1247
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:50
log2
#define log2(x)
Definition: libm.h:406
AV_PIX_FMT_P016
#define AV_PIX_FMT_P016
Definition: pixfmt.h:604
avcodec.h
FFV1SliceContext::fltmap
uint16_t * fltmap[4]
Definition: ffv1.h:112
AV_PIX_FMT_YAF16
#define AV_PIX_FMT_YAF16
Definition: pixfmt.h:584
av_uninit
#define av_uninit(x)
Definition: attributes.h:187
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
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
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
ff_ffv1_encode_buffer_size
size_t ff_ffv1_encode_buffer_size(AVCodecContext *avctx)
Definition: ffv1enc.c:1696
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:515
quant5_10bit
static const int8_t quant5_10bit[256]
Definition: ffv1enc.c:45
FFV1SliceContext::slice_y
int slice_y
Definition: ffv1.h:80
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1369
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:589
FFV1SliceContext::Unit::ndx
uint32_t ndx
Definition: ffv1.h:118
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
ff_ffv1_close
av_cold void ff_ffv1_close(FFV1Context *s)
Definition: ffv1.c:264
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:543
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
put_rac
#define put_rac(C, S, B)
U
#define U(x)
Definition: vpx_arith.h:37
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:548
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:183
AVCodecContext
main external API structure.
Definition: avcodec.h:439
RangeCoder::bytestream_start
uint8_t * bytestream_start
Definition: rangecoder.h:42
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:1603
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_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:593
OFFSET
#define OFFSET(x)
Definition: ffv1enc.c:1880
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:579
FFV1SliceContext::remap
int remap
Definition: ffv1.h:87
AV_PIX_FMT_GBRAPF16
#define AV_PIX_FMT_GBRAPF16
Definition: pixfmt.h:577
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
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
get_rac_count
static int get_rac_count(RangeCoder *c)
Definition: rangecoder.h:79
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:76
FFV1SliceContext::sy
int sy
Definition: ffv1.h:81
ffv1enc.h
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
COST2
#define COST2(old, new)
av_clip_uint8
#define av_clip_uint8
Definition: common.h:106
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
ffv1enc_template.c
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
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
mem.h
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:153
ff_ffv1_encode_init
av_cold int ff_ffv1_encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:601
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
w
uint8_t w
Definition: llvidencdsp.c:39
FFV1Context
Definition: ffv1.h:122
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1033
AVPacket
This structure stores compressed data.
Definition: packet.h:572
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:466
AV_PIX_FMT_P416
#define AV_PIX_FMT_P416
Definition: pixfmt.h:621
FFV1SliceContext::run_index
int run_index
Definition: ffv1.h:83
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:600
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:140
encode_histogram_remap
static void encode_histogram_remap(FFV1Context *f, FFV1SliceContext *sc)
Definition: ffv1enc.c:1212
int32_t
int32_t
Definition: audioconvert.c:56
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_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:545
h
h
Definition: vp9dsp_template.c:2070
RangeCoder
Definition: mss3.c:63
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:549
stride
#define stride
Definition: h264pred_template.c:536
pkt
static AVPacket * pkt
Definition: demux_decode.c:55
ff_ffv1_encoder
const FFCodec ff_ffv1_encoder
Definition: ffv1enc.c:1925
width
#define width
Definition: dsp.h:89
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:384
RENAME
#define RENAME(name)
Definition: ffv1enc.c:271
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:520
FFV1SliceContext::ac_byte_count
int ac_byte_count
number of bytes used for AC coding
Definition: ffv1.h:94
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
snprintf
#define snprintf
Definition: snprintf.h:34
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
FFV1SliceContext::slice_coding_mode
int slice_coding_mode
Definition: ffv1.h:84
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:61
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:222
src
#define src
Definition: vp8dsp.c:248
encode_line
static av_always_inline int RENAME() encode_line(FFV1Context *f, FFV1SliceContext *sc, void *logctx, int w, TYPE *const sample[3], int plane_index, int bits, int ac, int pass1)
Definition: ffv1enc_template.c:26
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:1512
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_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:547
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:3376
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:290
encode_slice_header
static void encode_slice_header(FFV1Context *f, FFV1SliceContext *sc)
Definition: ffv1enc.c:1083
Generated on Fri May 1 2026 19:22:07 for FFmpeg by   doxygen 1.8.17