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