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