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->bayer && (avctx->width & 1 || avctx->height & 1)) {
1020  av_log(avctx, AV_LOG_ERROR, "bayer requires even dimensions\n");
1021  return AVERROR(EINVAL);
1022  }
1023 
1024  if (s->bits_per_raw_sample > (s->version > 3 ? 16 : 8) && !s->remap_mode) {
1025  if (s->ac == AC_GOLOMB_RICE) {
1026  av_log(avctx, AV_LOG_INFO,
1027  "high bits_per_raw_sample, forcing range coder\n");
1028  s->ac = AC_RANGE_CUSTOM_TAB;
1029  }
1030  }
1031 
1032 
1033  ret = ff_ffv1_encode_init(avctx);
1034  if (ret < 0)
1035  return ret;
1036 
1037  if (s->version > 1) {
1038  if ((ret = ff_ffv1_encode_determine_slices(avctx)) < 0)
1039  return ret;
1040 
1041  if ((ret = ff_ffv1_write_extradata(avctx)) < 0)
1042  return ret;
1043  }
1044 
1045  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
1046  return ret;
1047  s->slice_count = s->max_slice_count;
1048 
1049  for (int j = 0; j < s->slice_count; j++) {
1050  FFV1SliceContext *sc = &s->slices[j];
1051 
1052  for (int i = 0; i < s->plane_count; i++) {
1053  PlaneContext *const p = &s->slices[j].plane[i];
1054 
1055  p->quant_table_index = s->context_model;
1056  p->context_count = s->context_count[p->quant_table_index];
1057  }
1058  av_assert0(s->remap_mode >= 0);
1059  if (s->remap_mode) {
1060  for (int p = 0; p < 1 + 2*s->chroma_planes + s->transparency ; p++) {
1061  if (s->bits_per_raw_sample == 32) {
1062  sc->unit[p] = av_malloc_array(sc->slice_width, sc->slice_height * sizeof(**sc->unit));
1063  if (!sc->unit[p])
1064  return AVERROR(ENOMEM);
1065  sc->bitmap[p] = av_malloc_array(sc->slice_width * sc->slice_height, sizeof(*sc->bitmap[p]));
1066  if (!sc->bitmap[p])
1067  return AVERROR(ENOMEM);
1068  } else {
1069  sc->fltmap[p] = av_malloc_array(65536, sizeof(*sc->fltmap[p]));
1070  if (!sc->fltmap[p])
1071  return AVERROR(ENOMEM);
1072  }
1073  }
1074  }
1075 
1076  ff_build_rac_states(&s->slices[j].c, 0.05 * (1LL << 32), 256 - 8);
1077 
1078  s->slices[j].remap = s->remap_mode;
1079  }
1080 
1081  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
1082  return ret;
1083 
1084 #define STATS_OUT_SIZE 1024 * 1024 * 6
1085  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1086  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
1087  if (!avctx->stats_out)
1088  return AVERROR(ENOMEM);
1089  for (int i = 0; i < s->quant_table_count; i++)
1090  for (int j = 0; j < s->max_slice_count; j++) {
1091  FFV1SliceContext *sc = &s->slices[j];
1092  av_assert0(!sc->rc_stat2[i]);
1093  sc->rc_stat2[i] = av_mallocz(s->context_count[i] *
1094  sizeof(*sc->rc_stat2[i]));
1095  if (!sc->rc_stat2[i])
1096  return AVERROR(ENOMEM);
1097  }
1098  }
1099 
1100  return 0;
1101 }
1102 
1103 static void encode_slice_header(FFV1Context *f, FFV1SliceContext *sc)
1104 {
1105  RangeCoder *c = &sc->c;
1106  uint8_t state[CONTEXT_SIZE];
1107  int j;
1108  memset(state, 128, sizeof(state));
1109 
1110  put_symbol(c, state, sc->sx, 0);
1111  put_symbol(c, state, sc->sy, 0);
1112  put_symbol(c, state, 0, 0);
1113  put_symbol(c, state, 0, 0);
1114  for (j=0; j<f->plane_count; j++) {
1115  put_symbol(c, state, sc->plane[j].quant_table_index, 0);
1116  av_assert0(sc->plane[j].quant_table_index == f->context_model);
1117  }
1118  if (!(f->cur_enc_frame->flags & AV_FRAME_FLAG_INTERLACED))
1119  put_symbol(c, state, 3, 0);
1120  else
1121  put_symbol(c, state, 1 + !(f->cur_enc_frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST), 0);
1122  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.num, 0);
1123  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.den, 0);
1124  if (f->version > 3) {
1125  put_rac(c, state, sc->slice_coding_mode == 1);
1126  if (sc->slice_coding_mode == 1)
1127  ff_ffv1_clear_slice_state(f, sc);
1128  put_symbol(c, state, sc->slice_coding_mode, 0);
1129  if (sc->slice_coding_mode != 1 && f->colorspace != 0) {
1130  put_symbol(c, state, sc->slice_rct_by_coef, 0);
1131  put_symbol(c, state, sc->slice_rct_ry_coef, 0);
1132  }
1133  put_symbol(c, state, sc->remap, 0);
1134  }
1135 }
1136 
1137 static void choose_rct_params(const FFV1Context *f, FFV1SliceContext *sc,
1138  const uint8_t *src[3], const int stride[3], int w, int h)
1139 {
1140 #define NB_Y_COEFF 15
1141  static const int rct_y_coeff[15][2] = {
1142  {0, 0}, // 4G
1143  {1, 1}, // R + 2G + B
1144  {2, 2}, // 2R + 2B
1145  {0, 2}, // 2G + 2B
1146  {2, 0}, // 2R + 2G
1147  {4, 0}, // 4R
1148  {0, 4}, // 4B
1149 
1150  {0, 3}, // 1G + 3B
1151  {3, 0}, // 3R + 1G
1152  {3, 1}, // 3R + B
1153  {1, 3}, // R + 3B
1154  {1, 2}, // R + G + 2B
1155  {2, 1}, // 2R + G + B
1156  {0, 1}, // 3G + B
1157  {1, 0}, // R + 3G
1158  };
1159 
1160  int stat[NB_Y_COEFF] = {0};
1161  int x, y, i, p, best;
1162  int16_t *sample[3];
1163  int lbd = f->bits_per_raw_sample <= 8;
1164  int packed = !src[1];
1165  int transparency = f->transparency;
1166  int packed_size = (3 + transparency)*2;
1167 
1168  for (y = 0; y < h; y++) {
1169  int lastr=0, lastg=0, lastb=0;
1170  for (p = 0; p < 3; p++)
1171  sample[p] = sc->sample_buffer + p*w;
1172 
1173  for (x = 0; x < w; x++) {
1174  int b, g, r;
1175  int ab, ag, ar;
1176  if (lbd) {
1177  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1178  b = v & 0xFF;
1179  g = (v >> 8) & 0xFF;
1180  r = (v >> 16) & 0xFF;
1181  } else if (packed) {
1182  const uint16_t *p = ((const uint16_t*)(src[0] + x*packed_size + stride[0]*y));
1183  r = p[0];
1184  g = p[1];
1185  b = p[2];
1186  } else if (f->use32bit || transparency) {
1187  g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
1188  b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
1189  r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
1190  } else {
1191  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1192  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1193  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1194  }
1195 
1196  ar = r - lastr;
1197  ag = g - lastg;
1198  ab = b - lastb;
1199  if (x && y) {
1200  int bg = ag - sample[0][x];
1201  int bb = ab - sample[1][x];
1202  int br = ar - sample[2][x];
1203 
1204  br -= bg;
1205  bb -= bg;
1206 
1207  for (i = 0; i<NB_Y_COEFF; i++) {
1208  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1209  }
1210 
1211  }
1212  sample[0][x] = ag;
1213  sample[1][x] = ab;
1214  sample[2][x] = ar;
1215 
1216  lastr = r;
1217  lastg = g;
1218  lastb = b;
1219  }
1220  }
1221 
1222  best = 0;
1223  for (i=1; i<NB_Y_COEFF; i++) {
1224  if (stat[i] < stat[best])
1225  best = i;
1226  }
1227 
1228  sc->slice_rct_by_coef = rct_y_coeff[best][1];
1229  sc->slice_rct_ry_coef = rct_y_coeff[best][0];
1230 }
1231 
1232 static void choose_rct_params_bayer(const FFV1Context *f, FFV1SliceContext *sc,
1233  const uint8_t *src[4], const int stride[4],
1234  int w, int h)
1235 {
1236  static const int rct_y_coeff[NB_Y_COEFF][2] = {
1237  { 0, 0 }, { 1, 1 }, { 2, 2 }, { 0, 2 }, { 2, 0 }, { 4, 0 }, { 0, 4 }, { 0, 3 },
1238  { 3, 0 }, { 3, 1 }, { 1, 3 }, { 1, 2 }, { 2, 1 }, { 0, 1 }, { 1, 0 },
1239  };
1240  int stat[NB_Y_COEFF] = {0};
1241  int16_t *sample[3];
1242  int i, best;
1243 
1244  /* Walk in 2x2 blocks, build per-block gm/b/r, evaluate prediction-error */
1245  w >>= 1;
1246  for (i = 0; i < 3; i++)
1247  sample[i] = sc->sample_buffer + i*w;
1248 
1249  for (int y = 0; y < h; y += 2) {
1250  int last_gm = 0, last_b = 0, last_r = 0;
1251  for (int x = 0; x < w; x++) {
1252  const uint16_t *l1 = (const uint16_t *)(src[0] + stride[0]*(y + 0) + x*2*2);
1253  const uint16_t *l2 = (const uint16_t *)(src[0] + stride[0]*(y + 1) + x*2*2);
1254  int r = l1[0];
1255  int gr = l1[1];
1256  int gb = l2[0];
1257  int b = l2[1];
1258  int gd = gr - gb;
1259  int gm = gb + (gd >> 1);
1260 
1261  int agm = gm - last_gm;
1262  int ab = b - last_b;
1263  int ar = r - last_r;
1264 
1265  if (x && y) {
1266  int bgm = agm - sample[0][x];
1267  int bb = ab - sample[1][x];
1268  int br = ar - sample[2][x];
1269 
1270  br -= bgm;
1271  bb -= bgm;
1272 
1273  for (i = 0; i < NB_Y_COEFF; i++)
1274  stat[i] += FFABS(bgm + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1]) >> 2));
1275  }
1276  sample[0][x] = agm;
1277  sample[1][x] = ab;
1278  sample[2][x] = ar;
1279 
1280  last_gm = gm;
1281  last_b = b;
1282  last_r = r;
1283  }
1284  }
1285 
1286  best = 0;
1287  for (i = 1; i < NB_Y_COEFF; i++)
1288  if (stat[i] < stat[best])
1289  best = i;
1290 
1291  sc->slice_rct_by_coef = rct_y_coeff[best][1];
1292  sc->slice_rct_ry_coef = rct_y_coeff[best][0];
1293 }
1294 
1295 static void encode_histogram_remap(FFV1Context *f, FFV1SliceContext *sc)
1296 {
1297  int len = 1 << f->bits_per_raw_sample;
1298  int flip = sc->remap == 2 ? 0x7FFF : 0;
1299 
1300  for (int p= 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
1301  int j = 0;
1302  int lu = 0;
1303  uint8_t state[2][32];
1304  int run = 0;
1305 
1306  memset(state, 128, sizeof(state));
1307  put_symbol(&sc->c, state[0], 0, 0);
1308  memset(state, 128, sizeof(state));
1309  for (int i= 0; i<len; i++) {
1310  int ri = i ^ ((i&0x8000) ? 0 : flip);
1311  int u = sc->fltmap[p][ri];
1312  sc->fltmap[p][ri] = j;
1313  j+= u;
1314 
1315  if (lu == u) {
1316  run ++;
1317  } else {
1318  put_symbol_inline(&sc->c, state[lu], run, 0, NULL, NULL);
1319  if (run == 0)
1320  lu = u;
1321  run = 0;
1322  }
1323  }
1324  if (run)
1325  put_symbol(&sc->c, state[lu], run, 0);
1326  sc->remap_count[p] = j;
1327  }
1328 }
1329 
1330 static void load_rgb_float32_frame(FFV1Context *f, FFV1SliceContext *sc,
1331  const uint8_t *src[4],
1332  int w, int h, const int stride[4])
1333 {
1334  int x, y;
1335  int transparency = f->transparency;
1336  int i = 0;
1337 
1338  for (y = 0; y < h; y++) {
1339  for (x = 0; x < w; x++) {
1340  int b, g, r, av_uninit(a);
1341 
1342  g = *((const uint32_t *)(src[0] + x*4 + stride[0]*y));
1343  b = *((const uint32_t *)(src[1] + x*4 + stride[1]*y));
1344  r = *((const uint32_t *)(src[2] + x*4 + stride[2]*y));
1345  if (transparency)
1346  a = *((const uint32_t *)(src[3] + x*4 + stride[3]*y));
1347 
1348  if (sc->remap == 2) {
1349 #define FLIP(f) (((f)&0x80000000) ? (f) : (f)^0x7FFFFFFF);
1350  g = FLIP(g);
1351  b = FLIP(b);
1352  r = FLIP(r);
1353  }
1354  // We cannot build a histogram as we do for 16bit, we need a bit of magic here
1355  // Its possible to reduce the memory needed at the cost of more dereferencing
1356  sc->unit[0][i].val = g;
1357  sc->unit[0][i].ndx = x + y*w;
1358 
1359  sc->unit[1][i].val = b;
1360  sc->unit[1][i].ndx = x + y*w;
1361 
1362  sc->unit[2][i].val = r;
1363  sc->unit[2][i].ndx = x + y*w;
1364 
1365  if (transparency) {
1366  sc->unit[3][i].val = a;
1367  sc->unit[3][i].ndx = x + y*w;
1368  }
1369  i++;
1370  }
1371  }
1372 
1373  //TODO switch to radix sort
1374 #define CMP(A,B) ((A)->val - (int64_t)(B)->val)
1375  AV_QSORT(sc->unit[0], i, struct Unit, CMP);
1376  AV_QSORT(sc->unit[1], i, struct Unit, CMP);
1377  AV_QSORT(sc->unit[2], i, struct Unit, CMP);
1378  if (transparency)
1379  AV_QSORT(sc->unit[3], i, struct Unit, CMP);
1380 }
1381 
1382 static int encode_float32_remap_segment(FFV1SliceContext *sc,
1383  int p, int mul_count, int *mul_tab, int update, int final)
1384 {
1385  const int pixel_num = sc->slice_width * sc->slice_height;
1386  uint8_t state[2][3][32];
1387  int mul[4096+1];
1388  RangeCoder rc = sc->c;
1389  int lu = 0;
1390  int run = 0;
1391  int64_t last_val = -1;
1392  int compact_index = -1;
1393  int i = 0;
1394  int current_mul_index = -1;
1395  int run1final = 0;
1396  int run1start_i;
1397  int run1start_last_val;
1398  int run1start_mul_index;
1399 
1400  memcpy(mul, mul_tab, sizeof(*mul_tab)*(mul_count+1));
1401  memset(state, 128, sizeof(state));
1402  put_symbol(&rc, state[0][0], mul_count, 0);
1403  memset(state, 128, sizeof(state));
1404 
1405  for (; i < pixel_num+1; i++) {
1406  int current_mul = current_mul_index < 0 ? 1 : FFABS(mul[current_mul_index]);
1407  int64_t val;
1408  if (i == pixel_num) {
1409  if (last_val == 0xFFFFFFFF && (!run || run1final)) {
1410  break;
1411  } else {
1412  val = last_val + ((1LL<<32) - last_val + current_mul - 1) / current_mul * current_mul;
1413  av_assert2(val >= (1LL<<32));
1414  val += lu * current_mul; //ensure a run1 ends
1415  }
1416  } else
1417  val = sc->unit[p][i].val;
1418 
1419  if (last_val != val) {
1420  int64_t delta = val - last_val;
1421  int64_t step = FFMAX(1, (delta + current_mul/2) / current_mul);
1422  av_assert2(last_val < val);
1423  av_assert2(current_mul > 0);
1424 
1425  delta -= step*current_mul;
1426  av_assert2(delta <= current_mul/2);
1427  av_assert2(delta > -current_mul);
1428 
1429  av_assert2(step > 0);
1430  if (lu) {
1431  if (!run) {
1432  run1start_i = i - 1;
1433  run1start_last_val = last_val;
1434  run1start_mul_index= current_mul_index;
1435  }
1436  if (step == 1) {
1437  if (run1final) {
1438  if (current_mul>1)
1439  put_symbol_inline(&rc, state[lu][1], delta, 1, NULL, NULL);
1440  }
1441  run ++;
1442  av_assert2(last_val + current_mul + delta == val);
1443  } else {
1444  if (run1final) {
1445  if (run == 0)
1446  lu ^= 1;
1447  i--; // we did not encode val so we need to backstep
1448  last_val += current_mul;
1449  } else {
1450  put_symbol_inline(&rc, state[lu][0], run, 0, NULL, NULL);
1451  i = run1start_i;
1452  last_val = run1start_last_val; // we could compute this instead of storing
1453  current_mul_index = run1start_mul_index;
1454  }
1455  run1final ^= 1;
1456 
1457  run = 0;
1458  continue;
1459  }
1460  } else {
1461  av_assert2(run == 0);
1462  av_assert2(run1final == 0);
1463  put_symbol_inline(&rc, state[lu][0], step - 1, 0, NULL, NULL);
1464 
1465  if (current_mul > 1)
1466  put_symbol_inline(&rc, state[lu][1], delta, 1, NULL, NULL);
1467  if (step == 1)
1468  lu ^= 1;
1469 
1470  av_assert2(last_val + step * current_mul + delta == val);
1471  }
1472  last_val = val;
1473  current_mul_index = ((last_val + 1) * mul_count) >> 32;
1474  if (!run || run1final) {
1475  av_assert2(mul[ current_mul_index ]);
1476  if (mul[ current_mul_index ] < 0) {
1477  av_assert2(i < pixel_num);
1478  mul[ current_mul_index ] *= -1;
1479  put_symbol_inline(&rc, state[0][2], mul[ current_mul_index ], 0, NULL, NULL);
1480  }
1481  if (i < pixel_num)
1482  compact_index ++;
1483  }
1484  }
1485  if (!run || run1final)
1486  if (final && i < pixel_num)
1487  sc->bitmap[p][sc->unit[p][i].ndx] = compact_index;
1488  }
1489 
1490  if (update) {
1491  sc->c = rc;
1492  sc->remap_count[p] = compact_index + 1;
1493  }
1494  return get_rac_count(&rc);
1495 }
1496 
1497 static void encode_float32_remap(FFV1Context *f, FFV1SliceContext *sc,
1498  const uint8_t *src[4])
1499 {
1500  int pixel_num = sc->slice_width * sc->slice_height;
1501  const int max_log2_mul_count = ((int[]){ 1, 1, 1, 9, 9, 10})[f->remap_optimizer];
1502  const int log2_mul_count_step = ((int[]){ 1, 1, 1, 9, 9, 1})[f->remap_optimizer];
1503  const int max_log2_mul = ((int[]){ 1, 8, 8, 9, 22, 22})[f->remap_optimizer];
1504  const int log2_mul_step = ((int[]){ 1, 8, 1, 1, 1, 1})[f->remap_optimizer];
1505  const int bruteforce_count = ((int[]){ 0, 0, 0, 1, 1, 1})[f->remap_optimizer];
1506  const int stair_mode = ((int[]){ 0, 0, 0, 1, 0, 0})[f->remap_optimizer];
1507  const int magic_log2 = ((int[]){ 1, 1, 1, 1, 0, 0})[f->remap_optimizer];
1508 
1509  for (int p= 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
1510  int best_log2_mul_count = 0;
1511  float score_sum[11] = {0};
1512  int mul_all[11][1025];
1513 
1514  for (int log2_mul_count= 0; log2_mul_count <= max_log2_mul_count; log2_mul_count += log2_mul_count_step) {
1515  float score_tab_all[1025][23] = {0};
1516  int64_t last_val = -1;
1517  int *mul_tab = mul_all[log2_mul_count];
1518  int last_mul_index = -1;
1519  int mul_count = 1 << log2_mul_count;
1520 
1521  score_sum[log2_mul_count] = 2 * log2_mul_count;
1522  if (magic_log2)
1523  score_sum[log2_mul_count] = av_float2int((float)mul_count * mul_count);
1524  for (int i= 0; i<pixel_num; i++) {
1525  int64_t val = sc->unit[p][i].val;
1526  int mul_index = (val + 1LL)*mul_count >> 32;
1527  if (val != last_val) {
1528  float *score_tab = score_tab_all[(last_val + 1LL)*mul_count >> 32];
1529  av_assert2(last_val < val);
1530  for(int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1531  int64_t delta = val - last_val;
1532  int mul;
1533  int64_t cost;
1534 
1535  if (last_val < 0) {
1536  mul = 1;
1537  } else if (stair_mode && mul_count == 512 && si == max_log2_mul ) {
1538  if (mul_index >= 0x378/8 && mul_index <= 23 + 0x378/8) {
1539  mul = (0x800080 >> (mul_index - 0x378/8));
1540  } else
1541  mul = 1;
1542  } else {
1543  mul = (0x10001LL)<<si >> 16;
1544  }
1545 
1546  cost = FFMAX((delta + mul/2) / mul, 1);
1547  float score = 1;
1548  if (mul > 1) {
1549  score *= (FFABS(delta - cost*mul)+1);
1550  if (mul_count > 1)
1551  score *= score;
1552  }
1553  score *= cost;
1554  score *= score;
1555  if (mul_index != last_mul_index)
1556  score *= mul;
1557  if (magic_log2) {
1558  score_tab[si] += av_float2int(score);
1559  } else
1560  score_tab[si] += log2f(score);
1561  }
1562  }
1563  last_val = val;
1564  last_mul_index = mul_index;
1565  }
1566  for(int i= 0; i<mul_count; i++) {
1567  int best_index = 0;
1568  float *score_tab = score_tab_all[i];
1569  for(int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1570  if (score_tab[si] < score_tab[ best_index ])
1571  best_index = si;
1572  }
1573  if (stair_mode && mul_count == 512 && best_index == max_log2_mul ) {
1574  if (i >= 0x378/8 && i <= 23 + 0x378/8) {
1575  mul_tab[i] = -(0x800080 >> (i - 0x378/8));
1576  } else
1577  mul_tab[i] = -1;
1578  } else
1579  mul_tab[i] = -((0x10001LL)<<best_index >> 16);
1580  score_sum[log2_mul_count] += score_tab[ best_index ];
1581  }
1582  mul_tab[mul_count] = 1;
1583 
1584  if (bruteforce_count)
1585  score_sum[log2_mul_count] = encode_float32_remap_segment(sc, p, mul_count, mul_all[log2_mul_count], 0, 0);
1586 
1587  if (score_sum[log2_mul_count] < score_sum[best_log2_mul_count])
1588  best_log2_mul_count = log2_mul_count;
1589  }
1590 
1591  encode_float32_remap_segment(sc, p, 1<<best_log2_mul_count, mul_all[best_log2_mul_count], 1, 1);
1592  }
1593 }
1594 
1595 static int encode_float32_rgb_frame(FFV1Context *f, FFV1SliceContext *sc,
1596  const uint8_t *src[4],
1597  int w, int h, const int stride[4], int ac)
1598 {
1599  int x, y, p, i;
1600  const int ring_size = f->context_model ? 3 : 2;
1601  int32_t *sample[4][3];
1602  const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
1603  int bits[4], offset;
1604  int transparency = f->transparency;
1605 
1606  ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, NULL, f->bits_per_raw_sample);
1607 
1608  sc->run_index = 0;
1609 
1610  for (int p = 0; p < MAX_PLANES; ++p)
1611  sample[p][2] = sc->sample_buffer32; // dummy to avoid UB pointer arithmetic
1612 
1613  memset(RENAME(sc->sample_buffer), 0, ring_size * MAX_PLANES *
1614  (w + 6) * sizeof(*RENAME(sc->sample_buffer)));
1615 
1616  for (y = 0; y < h; y++) {
1617  for (i = 0; i < ring_size; i++)
1618  for (p = 0; p < MAX_PLANES; p++)
1619  sample[p][i]= RENAME(sc->sample_buffer) + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
1620 
1621  for (x = 0; x < w; x++) {
1622  int b, g, r, av_uninit(a);
1623  g = sc->bitmap[0][x + w*y];
1624  b = sc->bitmap[1][x + w*y];
1625  r = sc->bitmap[2][x + w*y];
1626  if (transparency)
1627  a = sc->bitmap[3][x + w*y];
1628 
1629  if (sc->slice_coding_mode != 1) {
1630  b -= g;
1631  r -= g;
1632  g += (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2;
1633  b += offset;
1634  r += offset;
1635  }
1636 
1637  sample[0][0][x] = g;
1638  sample[1][0][x] = b;
1639  sample[2][0][x] = r;
1640  sample[3][0][x] = a;
1641  }
1642  for (p = 0; p < 3 + transparency; p++) {
1643  int ret;
1644  sample[p][0][-1] = sample[p][1][0 ];
1645  sample[p][1][ w] = sample[p][1][w-1];
1646  ret = encode_line32(f, sc, f->avctx, w, sample[p], (p + 1) / 2,
1647  bits[p], ac, pass1);
1648  if (ret < 0)
1649  return ret;
1650  }
1651  }
1652  return 0;
1653 }
1654 
1655 static int encode_bayer_frame(FFV1Context *f, FFV1SliceContext *sc,
1656  const uint8_t *src[4],
1657  int w, int h, const int stride[4], int ac)
1658 {
1659  const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
1660  const int ring_size = f->context_model ? 3 : 2;
1661  TYPE *sample[4][3];
1662 
1663  int bits[4], offset;
1664  ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, NULL, f->bits_per_raw_sample);
1665 
1666  w >>= 1;
1667 
1668  sc->run_index = 0;
1669 
1670  for (int p = 0; p < MAX_PLANES; ++p)
1671  sample[p][2] = RENAME(sc->sample_buffer);
1672 
1673  memset(RENAME(sc->sample_buffer), 0, ring_size * MAX_PLANES *
1674  (w + 6) * sizeof(*RENAME(sc->sample_buffer)));
1675 
1676  for (int y = 0; y < h; y += 2) {
1677  for (int i = 0; i < ring_size; i++)
1678  for (int p = 0; p < MAX_PLANES; p++)
1679  sample[p][i] = RENAME(sc->sample_buffer) + p*ring_size*(w+6) +
1680  ((h+i-y/2) % ring_size)*(w+6) + 3;
1681 
1682  for (int x = 0; x < w; x++) {
1683  const uint16_t *l1 = ((const uint16_t*)(src[0] + stride[0]*(y + 0) + x*2*2));
1684  const uint16_t *l2 = ((const uint16_t*)(src[0] + stride[0]*(y + 1) + x*2*2));
1685 
1686  int r, gr, gb, b;
1687  r = l1[0];
1688  gr = l1[1];
1689  gb = l2[0];
1690  b = l2[1];
1691 
1692  if (sc->slice_coding_mode != 1) {
1693  /**
1694  * Bayer 2x2 RCT, based on:
1695  * "Reversible color transform for Bayer color filter array images", S. Poomrittigul et al,
1696  * APSIPA Transactions on Signal and Information Processing (2013) 2 (1): 1-10,
1697  * doi:10.1017/ATSIP.2013.6 */
1698  int gd = gr - gb;
1699  int gm = gb + (gd >> 1);
1700 
1701  b -= gm;
1702  r -= gm;
1703  gm += (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2;
1704  b += offset;
1705  r += offset;
1706  gd += offset;
1707 
1708  gr = gm;
1709  gb = gd;
1710  }
1711 
1712  sample[0][0][x] = gr;
1713  sample[1][0][x] = gb;
1714  sample[2][0][x] = b;
1715  sample[3][0][x] = r;
1716  }
1717 
1718  for (int p = 0; p < 4; p++) {
1719  int ret;
1720  sample[p][0][-1] = sample[p][1][0 ];
1721  sample[p][1][ w] = sample[p][1][w-1];
1722  /* Plane contexts: gm=0 (luma), b-gm/r-gm=1 (chroma diff from
1723  * green), gd=2 (own context - green-green diff has different
1724  * statistics from both luma and chroma). */
1725  ret = RENAME(encode_line)(f, sc, f->avctx, w, sample[p],
1726  p == 1 ? 2 : (p > 1),
1727  bits[p], ac, pass1);
1728  if (ret < 0)
1729  return ret;
1730  }
1731  }
1732 
1733  return 0;
1734 }
1735 
1736 static int encode_slice(AVCodecContext *c, void *arg)
1737 {
1738  FFV1SliceContext *sc = arg;
1739  FFV1Context *f = c->priv_data;
1740  int width = sc->slice_width;
1741  int height = sc->slice_height;
1742  int x = sc->slice_x;
1743  int y = sc->slice_y;
1744  const AVFrame *const p = f->cur_enc_frame;
1745  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1746  int ret;
1747  RangeCoder c_bak = sc->c;
1748  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1749  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1750  const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1751  p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1752  p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1753  p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1754  int ac = f->ac;
1755 
1756  sc->slice_coding_mode = 0;
1757  if (f->version > 3 && f->colorspace == 1) {
1758  choose_rct_params(f, sc, planes, p->linesize, width, height);
1759  } else if (f->bayer) {
1760  choose_rct_params_bayer(f, sc, planes, p->linesize, width, height);
1761  } else {
1762  sc->slice_rct_by_coef = 1;
1763  sc->slice_rct_ry_coef = 1;
1764  }
1765 
1766 retry:
1767  if (f->key_frame)
1768  ff_ffv1_clear_slice_state(f, sc);
1769  if (f->version > 2) {
1770  encode_slice_header(f, sc);
1771  }
1772 
1773  if (sc->remap) {
1774  //Both the 16bit and 32bit remap do exactly the same thing but with 16bits we can
1775  //Implement this using a "histogram" while for 32bit that would be gb sized, thus a more
1776  //complex implementation sorting pairs is used.
1777  if (f->bits_per_raw_sample != 32) {
1778  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8 && c->pix_fmt != AV_PIX_FMT_YAF16) {
1779  const int cx = x >> f->chroma_h_shift;
1780  const int cy = y >> f->chroma_v_shift;
1781 
1782  //TODO decide on the order for the encoded remaps and loads. with golomb rice it
1783  // easier to have all range coded ones together, otherwise it may be nicer to handle each plane as a whole?
1784 
1785  load_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1786 
1787  if (f->chroma_planes) {
1788  load_plane(f, sc, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1789  load_plane(f, sc, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 2, 1);
1790  }
1791  if (f->transparency)
1792  load_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 3, 1);
1793  } else if (c->pix_fmt == AV_PIX_FMT_YA8 || c->pix_fmt == AV_PIX_FMT_YAF16) {
1794  load_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1795  load_plane(f, sc, p->data[0] + (ps>>1) + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1796  } else if (f->use32bit) {
1797  load_rgb_frame32(f, sc, planes, width, height, p->linesize);
1798  } else
1799  load_rgb_frame (f, sc, planes, width, height, p->linesize);
1800 
1801  encode_histogram_remap(f, sc);
1802  } else {
1803  load_rgb_float32_frame(f, sc, planes, width, height, p->linesize);
1804  encode_float32_remap(f, sc, planes);
1805  }
1806  }
1807 
1808  if (ac == AC_GOLOMB_RICE) {
1809  sc->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&sc->c, f->version > 2) : 0;
1810  init_put_bits(&sc->pb,
1811  sc->c.bytestream_start + sc->ac_byte_count,
1812  sc->c.bytestream_end - sc->c.bytestream_start - sc->ac_byte_count);
1813  }
1814 
1815  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8 && c->pix_fmt != AV_PIX_FMT_YAF16) {
1816  const int cx = x >> f->chroma_h_shift;
1817  const int cy = y >> f->chroma_v_shift;
1818 
1819  ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 1, ac);
1820 
1821  if (f->chroma_planes) {
1822  ret |= encode_plane(f, sc, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1, 1, ac);
1823  ret |= encode_plane(f, sc, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 2, 1, ac);
1824  }
1825  if (f->transparency)
1826  ret |= encode_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 3, 1, ac);
1827  } else if (c->pix_fmt == AV_PIX_FMT_YA8 || c->pix_fmt == AV_PIX_FMT_YAF16) {
1828  ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 2, ac);
1829  ret |= encode_plane(f, sc, p->data[0] + (ps>>1) + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 1, 2, ac);
1830  } else if (f->bits_per_raw_sample == 32) {
1831  ret = encode_float32_rgb_frame(f, sc, planes, width, height, p->linesize, ac);
1832  } else if (f->bayer) {
1833  ret = encode_bayer_frame(f, sc, planes, width, height, p->linesize, ac);
1834  } else if (f->use32bit) {
1835  ret = encode_rgb_frame32(f, sc, planes, width, height, p->linesize, ac);
1836  } else {
1837  ret = encode_rgb_frame(f, sc, planes, width, height, p->linesize, ac);
1838  }
1839 
1840  if (ac != AC_GOLOMB_RICE) {
1841  sc->ac_byte_count = ff_rac_terminate(&sc->c, 1);
1842  } else {
1843  flush_put_bits(&sc->pb); // FIXME: nicer padding
1844  sc->ac_byte_count += put_bytes_output(&sc->pb);
1845  }
1846 
1847  if (ret < 0) {
1848  av_assert0(sc->slice_coding_mode == 0);
1849  if (f->version < 4) {
1850  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1851  return ret;
1852  }
1853  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1854  ac = 1;
1855  sc->slice_coding_mode = 1;
1856  sc->c = c_bak;
1857  goto retry;
1858  }
1859 
1860  return 0;
1861 }
1862 
1863 size_t ff_ffv1_encode_buffer_size(AVCodecContext *avctx)
1864 {
1865  FFV1Context *f = avctx->priv_data;
1866 
1867  int w = avctx->width + f->num_h_slices;
1868  int h = avctx->height + f->num_v_slices;
1869  size_t maxsize = w*h * (1 + f->transparency);
1870  if (f->chroma_planes)
1871  maxsize += AV_CEIL_RSHIFT(w, f->chroma_h_shift) * AV_CEIL_RSHIFT(h, f->chroma_v_shift) * 2;
1872  maxsize += f->slice_count * 800; //for slice header
1873  if (f->version > 3) {
1874  maxsize *= f->bits_per_raw_sample + 1;
1875  if (f->remap_mode)
1876  maxsize += f->slice_count * 70000 * (1 + 2*f->chroma_planes + f->bayer + f->transparency);
1877  } else {
1878  maxsize += f->slice_count * 2 * (avctx->width + avctx->height); //for bug with slices that code some pixels more than once
1879  maxsize *= 8*(2*f->bits_per_raw_sample + 5);
1880  }
1881  maxsize >>= 3;
1882  maxsize += FF_INPUT_BUFFER_MIN_SIZE;
1883 
1884  return maxsize;
1885 }
1886 
1887 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1888  const AVFrame *pict, int *got_packet)
1889 {
1890  FFV1Context *f = avctx->priv_data;
1891  RangeCoder *const c = &f->slices[0].c;
1892  uint8_t keystate = 128;
1893  uint8_t *buf_p;
1894  int i, ret;
1895  int64_t maxsize;
1896 
1897  if(!pict) {
1898  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1899  int j, k, m;
1900  char *p = avctx->stats_out;
1901  char *end = p + STATS_OUT_SIZE;
1902 
1903  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1904  for (i = 0; i < f->quant_table_count; i++)
1905  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1906 
1907  av_assert0(f->slice_count == f->max_slice_count);
1908  for (j = 0; j < f->slice_count; j++) {
1909  const FFV1SliceContext *sc = &f->slices[j];
1910  for (i = 0; i < 256; i++) {
1911  f->rc_stat[i][0] += sc->rc_stat[i][0];
1912  f->rc_stat[i][1] += sc->rc_stat[i][1];
1913  }
1914  for (i = 0; i < f->quant_table_count; i++) {
1915  for (k = 0; k < f->context_count[i]; k++)
1916  for (m = 0; m < 32; m++) {
1917  f->rc_stat2[i][k][m][0] += sc->rc_stat2[i][k][m][0];
1918  f->rc_stat2[i][k][m][1] += sc->rc_stat2[i][k][m][1];
1919  }
1920  }
1921  }
1922 
1923  for (j = 0; j < 256; j++) {
1924  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1925  f->rc_stat[j][0], f->rc_stat[j][1]);
1926  p += strlen(p);
1927  }
1928  snprintf(p, end - p, "\n");
1929 
1930  for (i = 0; i < f->quant_table_count; i++) {
1931  for (j = 0; j < f->context_count[i]; j++)
1932  for (m = 0; m < 32; m++) {
1933  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1934  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1935  p += strlen(p);
1936  }
1937  }
1938  snprintf(p, end - p, "%d\n", f->gob_count);
1939  }
1940  return 0;
1941  }
1942 
1943  /* Maximum packet size */
1944  maxsize = ff_ffv1_encode_buffer_size(avctx);
1945 
1946  if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1947  FFV1Context *f = avctx->priv_data;
1948  if (!f->maxsize_warned) {
1949  av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1950  f->maxsize_warned++;
1951  }
1952  maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1953  }
1954 
1955  if ((ret = ff_alloc_packet(avctx, pkt, maxsize)) < 0)
1956  return ret;
1957 
1958  ff_init_range_encoder(c, pkt->data, pkt->size);
1959  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1960 
1961  f->cur_enc_frame = pict;
1962 
1963  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1964  put_rac(c, &keystate, 1);
1965  f->key_frame = 1;
1966  f->gob_count++;
1967  write_header(f);
1968  } else {
1969  put_rac(c, &keystate, 0);
1970  f->key_frame = 0;
1971  }
1972 
1973  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1974  int i;
1975  for (i = 1; i < 256; i++) {
1976  c->one_state[i] = f->state_transition[i];
1977  c->zero_state[256 - i] = 256 - c->one_state[i];
1978  }
1979  }
1980 
1981  for (i = 0; i < f->slice_count; i++) {
1982  FFV1SliceContext *sc = &f->slices[i];
1983  uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1984  int len = pkt->size / f->slice_count;
1985  if (i) {
1986  ff_init_range_encoder(&sc->c, start, len);
1987  } else {
1988  av_assert0(sc->c.bytestream_end >= sc->c.bytestream_start + len);
1989  av_assert0(sc->c.bytestream < sc->c.bytestream_start + len);
1990  sc->c.bytestream_end = sc->c.bytestream_start + len;
1991  }
1992  }
1993  avctx->execute(avctx, encode_slice, f->slices, NULL,
1994  f->slice_count, sizeof(*f->slices));
1995 
1996  buf_p = pkt->data;
1997  for (i = 0; i < f->slice_count; i++) {
1998  FFV1SliceContext *sc = &f->slices[i];
1999  int bytes = sc->ac_byte_count;
2000  if (i > 0 || f->version > 2) {
2001  av_assert0(bytes < pkt->size / f->slice_count);
2002  memmove(buf_p, sc->c.bytestream_start, bytes);
2003  av_assert0(bytes < (1 << 24));
2004  AV_WB24(buf_p + bytes, bytes);
2005  bytes += 3;
2006  }
2007  if (f->ec) {
2008  unsigned v;
2009  buf_p[bytes++] = 0;
2010  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, buf_p, bytes) ^ (f->crcref ? 0x8CD88196 : 0);
2011  AV_WL32(buf_p + bytes, v);
2012  bytes += 4;
2013  }
2014  buf_p += bytes;
2015  }
2016 
2017  if (avctx->flags & AV_CODEC_FLAG_PASS1)
2018  avctx->stats_out[0] = '\0';
2019 
2020  f->picture_number++;
2021  pkt->size = buf_p - pkt->data;
2022  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
2023  *got_packet = 1;
2024 
2025  return 0;
2026 }
2027 
2028 static av_cold int encode_close(AVCodecContext *avctx)
2029 {
2030  FFV1Context *const s = avctx->priv_data;
2031 
2032  for (int j = 0; j < s->max_slice_count; j++) {
2033  FFV1SliceContext *sc = &s->slices[j];
2034 
2035  for(int p = 0; p<4; p++) {
2036  av_freep(&sc->unit[p]);
2037  av_freep(&sc->bitmap[p]);
2038  }
2039  }
2040 
2041  av_freep(&avctx->stats_out);
2042  ff_ffv1_close(s);
2043 
2044  return 0;
2045 }
2046 
2047 #define OFFSET(x) offsetof(FFV1Context, x)
2048 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
2049 static const AVOption options[] = {
2050  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
2051  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
2052  { .i64 = 0 }, -2, 2, VE, .unit = "coder" },
2053  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
2054  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2055  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
2056  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2057  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
2058  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2059  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
2060  { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2061  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
2062  { .i64 = 0 }, 0, 1, VE },
2063  { "qtable", "Quantization table", OFFSET(qtable), AV_OPT_TYPE_INT,
2064  { .i64 = -1 }, -1, 2, VE , .unit = "qtable"},
2065  { "default", NULL, 0, AV_OPT_TYPE_CONST,
2066  { .i64 = QTABLE_DEFAULT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2067  { "8bit", NULL, 0, AV_OPT_TYPE_CONST,
2068  { .i64 = QTABLE_8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2069  { "greater8bit", NULL, 0, AV_OPT_TYPE_CONST,
2070  { .i64 = QTABLE_GT8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2071  { "remap_mode", "Remap Mode", OFFSET(remap_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE, .unit = "remap_mode" },
2072  { "auto", "Automatic", 0, AV_OPT_TYPE_CONST,
2073  { .i64 = -1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2074  { "off", "Disabled", 0, AV_OPT_TYPE_CONST,
2075  { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2076  { "dualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
2077  { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2078  { "flipdualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
2079  { .i64 = 2 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2080  { "remap_optimizer", "Remap Optimizer", OFFSET(remap_optimizer), AV_OPT_TYPE_INT, { .i64 = 3 }, 0, 5, VE, .unit = "remap_optimizer" },
2081 
2082  { NULL }
2083 };
2084 
2085 static const AVClass ffv1_class = {
2086  .class_name = "ffv1 encoder",
2087  .item_name = av_default_item_name,
2088  .option = options,
2089  .version = LIBAVUTIL_VERSION_INT,
2090 };
2091 
2092 const FFCodec ff_ffv1_encoder = {
2093  .p.name = "ffv1",
2094  CODEC_LONG_NAME("FFmpeg video codec #1"),
2095  .p.type = AVMEDIA_TYPE_VIDEO,
2096  .p.id = AV_CODEC_ID_FFV1,
2097  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
2098  AV_CODEC_CAP_SLICE_THREADS |
2099  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
2100  .priv_data_size = sizeof(FFV1Context),
2101  .init = encode_init_internal,
2102  FF_CODEC_ENCODE_CB(encode_frame),
2103  .close = encode_close,
2104  CODEC_PIXFMTS(
2105  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
2106  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
2107  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
2108  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
2109  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
2110  AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
2111  AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
2112  AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA422P12,
2113  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
2114  AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
2115  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
2116  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRAP14,
2117  AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
2118  AV_PIX_FMT_YA8,
2119  AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
2120  AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
2121  AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
2122  AV_PIX_FMT_GRAY9,
2123  AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
2124  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
2125  AV_PIX_FMT_YAF16,
2126  AV_PIX_FMT_GRAYF16,
2127  AV_PIX_FMT_GBRPF16, AV_PIX_FMT_GBRPF32,
2128  AV_PIX_FMT_BAYER_RGGB16),
2129  .color_ranges = AVCOL_RANGE_MPEG,
2130  .p.priv_class = &ffv1_class,
2131  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
2132 };
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:401
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
QTABLE_DEFAULT
@ QTABLE_DEFAULT
Definition: ffv1enc.h:29
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:1497
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
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:428
encode.h
b
#define b
Definition: input.c:43
MAX_QUANT_TABLE_SIZE
#define MAX_QUANT_TABLE_SIZE
Definition: ffv1.h:48
rangecoder.h
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:40
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:539
ff_ffv1_write_extradata
av_cold int ff_ffv1_write_extradata(AVCodecContext *avctx)
Definition: ffv1enc.c:447
FFCodec
Definition: codec_internal.h:127
FFV1SliceContext::pb
PutBitContext pb
Definition: ffv1.h:91
RangeCoder::bytestream_end
uint8_t * bytestream_end
Definition: rangecoder.h:44
contains_non_128
static int contains_non_128(uint8_t(*initial_state)[CONTEXT_SIZE], int nb_contexts)
Definition: ffv1enc.c:372
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_float2int
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
Definition: intfloat.h:50
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:54
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:591
ring_size
static int ring_size(RingBuffer *ring)
Definition: async.c:107
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:650
FF_INPUT_BUFFER_MIN_SIZE
#define FF_INPUT_BUFFER_MIN_SIZE
Used by some encoders as upper bound for the length of headers.
Definition: encode.h:33
FFV1SliceContext::slice_x
int slice_x
Definition: ffv1.h:79
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:233
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1SliceContext *sc)
Definition: ffv1.c:200
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:518
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h: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:1736
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
QTABLE_GT8BIT
@ QTABLE_GT8BIT
Definition: ffv1enc.h:31
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:376
state
static struct @599 state
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
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
QTABLE_8BIT
@ QTABLE_8BIT
Definition: ffv1enc.h:30
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:141
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:1382
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:349
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:1887
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: ffv1enc.c:2028
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:2048
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:2049
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:83
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:49
choose_rct_params
static void choose_rct_params(const FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src[3], const int stride[3], int w, int h)
Definition: ffv1enc.c:1137
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
planes
static const struct @602 planes[]
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:96
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:2085
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
s
uint8_t s
Definition: llvidencdsp.c:39
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:176
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:1330
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:1863
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:1655
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:2047
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:258
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:73
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:1232
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:1295
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:2092
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
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:298
snprintf
#define snprintf
Definition: snprintf.h:34
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
FFV1SliceContext::slice_coding_mode
int slice_coding_mode
Definition: ffv1.h:84
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:61
ff_ffv1_compute_bits_per_plane
void ff_ffv1_compute_bits_per_plane(const FFV1Context *f, FFV1SliceContext *sc, int bits[4], int *offset, int mask[4], int bits_per_raw_sample)
Definition: ffv1.c: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:1595
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:1103
Generated on Tue Jul 7 2026 19:22:13 for FFmpeg by   doxygen 1.8.17