FFmpeg
ffv1enc.c
Go to the documentation of this file.
1 /*
2  * FFV1 encoder
3  *
4  * Copyright (c) 2003-2013 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * FF Video Codec 1 (a lossless codec) encoder
26  */
27 
28 #include "libavutil/attributes.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/crc.h"
31 #include "libavutil/mem.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 
35 #include "avcodec.h"
36 #include "encode.h"
37 #include "codec_internal.h"
38 #include "put_bits.h"
39 #include "put_golomb.h"
40 #include "rangecoder.h"
41 #include "ffv1.h"
42 
43 static const int8_t quant5_10bit[256] = {
44  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
45  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
46  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
47  1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
48  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
49  2, 2, 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, -1,
57  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
58  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
59  -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
60 };
61 
62 static const int8_t quant5[256] = {
63  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
64  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
65  2, 2, 2, 2, 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, -1, -1, -1,
79 };
80 
81 static const int8_t quant9_10bit[256] = {
82  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
83  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
84  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
85  3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
86  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87  4, 4, 4, 4, 4, 4, 4, 4, 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, -3, -3, -3, -3, -3, -3, -3,
95  -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
96  -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
97  -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
98 };
99 
100 static const int8_t quant11[256] = {
101  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
102  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
103  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
104  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
105  5, 5, 5, 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, -4, -4,
115  -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
116  -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
117 };
118 
119 static const uint8_t ver2_state[256] = {
120  0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
121  59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
122  40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
123  53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
124  87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
125  85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
126  105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
127  115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
128  165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
129  147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
130  172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
131  175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
132  197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
133  209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
134  226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
135  241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
136 };
137 
138 static void find_best_state(uint8_t best_state[256][256],
139  const uint8_t one_state[256])
140 {
141  int i, j, k, m;
142  uint32_t l2tab[256];
143 
144  for (i = 1; i < 256; i++)
145  l2tab[i] = -log2(i / 256.0) * ((1U << 31) / 8);
146 
147  for (i = 0; i < 256; i++) {
148  uint64_t best_len[256];
149 
150  for (j = 0; j < 256; j++)
151  best_len[j] = UINT64_MAX;
152 
153  for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
154  uint32_t occ[256] = { 0 };
155  uint64_t len = 0;
156  occ[j] = UINT32_MAX;
157 
158  if (!one_state[j])
159  continue;
160 
161  for (k = 0; k < 256; k++) {
162  uint32_t newocc[256] = { 0 };
163  for (m = 1; m < 256; m++)
164  if (occ[m]) {
165  len += (occ[m]*(( i *(uint64_t)l2tab[ m]
166  + (256-i)*(uint64_t)l2tab[256-m])>>8)) >> 8;
167  }
168  if (len < best_len[k]) {
169  best_len[k] = len;
170  best_state[i][k] = j;
171  }
172  for (m = 1; m < 256; m++)
173  if (occ[m]) {
174  newocc[ one_state[ m]] += occ[m] * (uint64_t) i >> 8;
175  newocc[256 - one_state[256 - m]] += occ[m] * (uint64_t)(256 - i) >> 8;
176  }
177  memcpy(occ, newocc, sizeof(occ));
178  }
179  }
180  }
181 }
182 
183 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
184  uint8_t *state, int v,
185  int is_signed,
186  uint64_t rc_stat[256][2],
187  uint64_t rc_stat2[32][2])
188 {
189  int i;
190 
191 #define put_rac(C, S, B) \
192  do { \
193  if (rc_stat) { \
194  rc_stat[*(S)][B]++; \
195  rc_stat2[(S) - state][B]++; \
196  } \
197  put_rac(C, S, B); \
198  } while (0)
199 
200  if (v) {
201  const unsigned a = is_signed ? FFABS(v) : v;
202  const int e = av_log2(a);
203  put_rac(c, state + 0, 0);
204  if (e <= 9) {
205  for (i = 0; i < e; i++)
206  put_rac(c, state + 1 + i, 1); // 1..10
207  put_rac(c, state + 1 + i, 0);
208 
209  for (i = e - 1; i >= 0; i--)
210  put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
211 
212  if (is_signed)
213  put_rac(c, state + 11 + e, v < 0); // 11..21
214  } else {
215  for (i = 0; i < e; i++)
216  put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
217  put_rac(c, state + 1 + 9, 0);
218 
219  for (i = e - 1; i >= 0; i--)
220  put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
221 
222  if (is_signed)
223  put_rac(c, state + 11 + 10, v < 0); // 11..21
224  }
225  } else {
226  put_rac(c, state + 0, 1);
227  }
228 #undef put_rac
229 }
230 
231 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
232  int v, int is_signed)
233 {
234  put_symbol_inline(c, state, v, is_signed, NULL, NULL);
235 }
236 
237 
238 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
239  int v, int bits)
240 {
241  int i, k, code;
242  v = fold(v - state->bias, bits);
243 
244  i = state->count;
245  k = 0;
246  while (i < state->error_sum) { // FIXME: optimize
247  k++;
248  i += i;
249  }
250 
251  av_assert2(k <= 13);
252 
253  code = v ^ ((2 * state->drift + state->count) >> 31);
254 
255  ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
256  state->bias, state->error_sum, state->drift, state->count, k);
257  set_sr_golomb(pb, code, k, 12, bits);
258 
259  update_vlc_state(state, v);
260 }
261 
262 #define TYPE int16_t
263 #define RENAME(name) name
264 #include "ffv1enc_template.c"
265 #undef TYPE
266 #undef RENAME
267 
268 #define TYPE int32_t
269 #define RENAME(name) name ## 32
270 #include "ffv1enc_template.c"
271 
272 static int encode_plane(FFV1Context *f, FFV1SliceContext *sc,
273  const uint8_t *src, int w, int h,
274  int stride, int plane_index, int pixel_stride)
275 {
276  int x, y, i, ret;
277  const int ac = f->ac;
278  const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
279  const int ring_size = f->context_model ? 3 : 2;
280  int16_t *sample[3];
281  sc->run_index = 0;
282 
283  memset(sc->sample_buffer, 0, ring_size * (w + 6) * sizeof(*sc->sample_buffer));
284 
285  for (y = 0; y < h; y++) {
286  for (i = 0; i < ring_size; i++)
287  sample[i] = sc->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
288 
289  sample[0][-1]= sample[1][0 ];
290  sample[1][ w]= sample[1][w-1];
291  if (f->bits_per_raw_sample <= 8) {
292  for (x = 0; x < w; x++)
293  sample[0][x] = src[x * pixel_stride + stride * y];
294  if((ret = encode_line(f, sc, f->avctx, w, sample, plane_index, 8, ac, pass1)) < 0)
295  return ret;
296  } else {
297  if (f->packed_at_lsb) {
298  for (x = 0; x < w; x++) {
299  sample[0][x] = ((uint16_t*)(src + stride*y))[x];
300  }
301  } else {
302  for (x = 0; x < w; x++) {
303  sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - f->bits_per_raw_sample);
304  }
305  }
306  if((ret = encode_line(f, sc, f->avctx, w, sample, plane_index, f->bits_per_raw_sample, ac, pass1)) < 0)
307  return ret;
308  }
309  }
310  return 0;
311 }
312 
313 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
314 {
315  int last = 0;
316  int i;
317  uint8_t state[CONTEXT_SIZE];
318  memset(state, 128, sizeof(state));
319 
320  for (i = 1; i < MAX_QUANT_TABLE_SIZE/2; i++)
321  if (quant_table[i] != quant_table[i - 1]) {
322  put_symbol(c, state, i - last - 1, 0);
323  last = i;
324  }
325  put_symbol(c, state, i - last - 1, 0);
326 }
327 
328 static void write_quant_tables(RangeCoder *c,
329  int16_t quant_table[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE])
330 {
331  int i;
332  for (i = 0; i < 5; i++)
333  write_quant_table(c, quant_table[i]);
334 }
335 
336 static int contains_non_128(uint8_t (*initial_state)[CONTEXT_SIZE],
337  int nb_contexts)
338 {
339  if (!initial_state)
340  return 0;
341  for (int i = 0; i < nb_contexts; i++)
342  for (int j = 0; j < CONTEXT_SIZE; j++)
343  if (initial_state[i][j] != 128)
344  return 1;
345  return 0;
346 }
347 
348 static void write_header(FFV1Context *f)
349 {
350  uint8_t state[CONTEXT_SIZE];
351  int i, j;
352  RangeCoder *const c = &f->slices[0].c;
353 
354  memset(state, 128, sizeof(state));
355 
356  if (f->version < 2) {
357  put_symbol(c, state, f->version, 0);
358  put_symbol(c, state, f->ac, 0);
359  if (f->ac == AC_RANGE_CUSTOM_TAB) {
360  for (i = 1; i < 256; i++)
361  put_symbol(c, state,
362  f->state_transition[i] - c->one_state[i], 1);
363  }
364  put_symbol(c, state, f->colorspace, 0); //YUV cs type
365  if (f->version > 0)
366  put_symbol(c, state, f->bits_per_raw_sample, 0);
367  put_rac(c, state, f->chroma_planes);
368  put_symbol(c, state, f->chroma_h_shift, 0);
369  put_symbol(c, state, f->chroma_v_shift, 0);
370  put_rac(c, state, f->transparency);
371 
372  write_quant_tables(c, f->quant_tables[f->context_model]);
373  } else if (f->version < 3) {
374  put_symbol(c, state, f->slice_count, 0);
375  for (i = 0; i < f->slice_count; i++) {
376  FFV1SliceContext *fs = &f->slices[i];
377  put_symbol(c, state,
378  (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
379  put_symbol(c, state,
380  (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
381  put_symbol(c, state,
382  (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
383  0);
384  put_symbol(c, state,
385  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
386  0);
387  for (j = 0; j < f->plane_count; j++) {
388  put_symbol(c, state, fs->plane[j].quant_table_index, 0);
389  av_assert0(fs->plane[j].quant_table_index == f->context_model);
390  }
391  }
392  }
393 }
394 
395 static int write_extradata(FFV1Context *f)
396 {
397  RangeCoder c;
398  uint8_t state[CONTEXT_SIZE];
399  int i, j, k;
400  uint8_t state2[32][CONTEXT_SIZE];
401  unsigned v;
402 
403  memset(state2, 128, sizeof(state2));
404  memset(state, 128, sizeof(state));
405 
406  f->avctx->extradata_size = 10000 + 4 +
407  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
408  f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
409  if (!f->avctx->extradata)
410  return AVERROR(ENOMEM);
411  ff_init_range_encoder(&c, f->avctx->extradata, f->avctx->extradata_size);
412  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
413 
414  put_symbol(&c, state, f->version, 0);
415  if (f->version > 2) {
416  if (f->version == 3) {
417  f->micro_version = 4;
418  } else if (f->version == 4)
419  f->micro_version = 2;
420  put_symbol(&c, state, f->micro_version, 0);
421  }
422 
423  put_symbol(&c, state, f->ac, 0);
424  if (f->ac == AC_RANGE_CUSTOM_TAB)
425  for (i = 1; i < 256; i++)
426  put_symbol(&c, state, f->state_transition[i] - c.one_state[i], 1);
427 
428  put_symbol(&c, state, f->colorspace, 0); // YUV cs type
429  put_symbol(&c, state, f->bits_per_raw_sample, 0);
430  put_rac(&c, state, f->chroma_planes);
431  put_symbol(&c, state, f->chroma_h_shift, 0);
432  put_symbol(&c, state, f->chroma_v_shift, 0);
433  put_rac(&c, state, f->transparency);
434  put_symbol(&c, state, f->num_h_slices - 1, 0);
435  put_symbol(&c, state, f->num_v_slices - 1, 0);
436 
437  put_symbol(&c, state, f->quant_table_count, 0);
438  for (i = 0; i < f->quant_table_count; i++)
439  write_quant_tables(&c, f->quant_tables[i]);
440 
441  for (i = 0; i < f->quant_table_count; i++) {
442  if (contains_non_128(f->initial_states[i], f->context_count[i])) {
443  put_rac(&c, state, 1);
444  for (j = 0; j < f->context_count[i]; j++)
445  for (k = 0; k < CONTEXT_SIZE; k++) {
446  int pred = j ? f->initial_states[i][j - 1][k] : 128;
447  put_symbol(&c, state2[k],
448  (int8_t)(f->initial_states[i][j][k] - pred), 1);
449  }
450  } else {
451  put_rac(&c, state, 0);
452  }
453  }
454 
455  if (f->version > 2) {
456  put_symbol(&c, state, f->ec, 0);
457  put_symbol(&c, state, f->intra = (f->avctx->gop_size < 2), 0);
458  }
459 
460  f->avctx->extradata_size = ff_rac_terminate(&c, 0);
461  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
462  AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
463  f->avctx->extradata_size += 4;
464 
465  return 0;
466 }
467 
468 static int sort_stt(FFV1Context *s, uint8_t stt[256])
469 {
470  int i, i2, changed, print = 0;
471 
472  do {
473  changed = 0;
474  for (i = 12; i < 244; i++) {
475  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
476 
477 #define COST(old, new) \
478  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
479  s->rc_stat[old][1] * -log2((new) / 256.0)
480 
481 #define COST2(old, new) \
482  COST(old, new) + COST(256 - (old), 256 - (new))
483 
484  double size0 = COST2(i, i) + COST2(i2, i2);
485  double sizeX = COST2(i, i2) + COST2(i2, i);
486  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
487  int j;
488  FFSWAP(int, stt[i], stt[i2]);
489  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
490  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
491  if (i != 256 - i2) {
492  FFSWAP(int, stt[256 - i], stt[256 - i2]);
493  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
494  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
495  }
496  for (j = 1; j < 256; j++) {
497  if (stt[j] == i)
498  stt[j] = i2;
499  else if (stt[j] == i2)
500  stt[j] = i;
501  if (i != 256 - i2) {
502  if (stt[256 - j] == 256 - i)
503  stt[256 - j] = 256 - i2;
504  else if (stt[256 - j] == 256 - i2)
505  stt[256 - j] = 256 - i;
506  }
507  }
508  print = changed = 1;
509  }
510  }
511  }
512  } while (changed);
513  return print;
514 }
515 
516 static av_cold int encode_init(AVCodecContext *avctx)
517 {
518  FFV1Context *s = avctx->priv_data;
519  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
520  int i, j, k, m, ret;
521 
522  if ((ret = ff_ffv1_common_init(avctx)) < 0)
523  return ret;
524 
525  s->version = 0;
526 
527  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
528  avctx->slices > 1)
529  s->version = FFMAX(s->version, 2);
530 
531  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) && s->ac == AC_GOLOMB_RICE) {
532  av_log(avctx, AV_LOG_ERROR, "2 Pass mode is not possible with golomb coding\n");
533  return AVERROR(EINVAL);
534  }
535 
536  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
537  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
538  s->version = FFMAX(s->version, 2);
539 
540  if (avctx->level <= 0 && s->version == 2) {
541  s->version = 3;
542  }
543  if (avctx->level >= 0 && avctx->level <= 4) {
544  if (avctx->level < s->version) {
545  av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
546  return AVERROR(EINVAL);
547  }
548  s->version = avctx->level;
549  }
550 
551  if (s->ec < 0) {
552  s->ec = (s->version >= 3);
553  }
554 
555  // CRC requires version 3+
556  if (s->ec)
557  s->version = FFMAX(s->version, 3);
558 
559  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
560  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");
561  return AVERROR_INVALIDDATA;
562  }
563 
564  if (s->ac == 1) // Compatbility with common command line usage
565  s->ac = AC_RANGE_CUSTOM_TAB;
566  else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
567  s->ac = AC_RANGE_DEFAULT_TAB;
568 
569  s->plane_count = 3;
570  switch(avctx->pix_fmt) {
571  case AV_PIX_FMT_GRAY9:
572  case AV_PIX_FMT_YUV444P9:
573  case AV_PIX_FMT_YUV422P9:
574  case AV_PIX_FMT_YUV420P9:
575  case AV_PIX_FMT_YUVA444P9:
576  case AV_PIX_FMT_YUVA422P9:
577  case AV_PIX_FMT_YUVA420P9:
578  if (!avctx->bits_per_raw_sample)
579  s->bits_per_raw_sample = 9;
580  case AV_PIX_FMT_GRAY10:
581  case AV_PIX_FMT_YUV444P10:
582  case AV_PIX_FMT_YUV440P10:
583  case AV_PIX_FMT_YUV420P10:
584  case AV_PIX_FMT_YUV422P10:
585  case AV_PIX_FMT_YUVA444P10:
586  case AV_PIX_FMT_YUVA422P10:
587  case AV_PIX_FMT_YUVA420P10:
588  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
589  s->bits_per_raw_sample = 10;
590  case AV_PIX_FMT_GRAY12:
591  case AV_PIX_FMT_YUV444P12:
592  case AV_PIX_FMT_YUV440P12:
593  case AV_PIX_FMT_YUV420P12:
594  case AV_PIX_FMT_YUV422P12:
595  case AV_PIX_FMT_YUVA444P12:
596  case AV_PIX_FMT_YUVA422P12:
597  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
598  s->bits_per_raw_sample = 12;
599  case AV_PIX_FMT_GRAY14:
600  case AV_PIX_FMT_YUV444P14:
601  case AV_PIX_FMT_YUV420P14:
602  case AV_PIX_FMT_YUV422P14:
603  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
604  s->bits_per_raw_sample = 14;
605  s->packed_at_lsb = 1;
606  case AV_PIX_FMT_GRAY16:
607  case AV_PIX_FMT_YUV444P16:
608  case AV_PIX_FMT_YUV422P16:
609  case AV_PIX_FMT_YUV420P16:
610  case AV_PIX_FMT_YUVA444P16:
611  case AV_PIX_FMT_YUVA422P16:
612  case AV_PIX_FMT_YUVA420P16:
613  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
614  s->bits_per_raw_sample = 16;
615  } else if (!s->bits_per_raw_sample) {
616  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
617  }
618  if (s->bits_per_raw_sample <= 8) {
619  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
620  return AVERROR_INVALIDDATA;
621  }
622  s->version = FFMAX(s->version, 1);
623  case AV_PIX_FMT_GRAY8:
624  case AV_PIX_FMT_YA8:
625  case AV_PIX_FMT_YUV444P:
626  case AV_PIX_FMT_YUV440P:
627  case AV_PIX_FMT_YUV422P:
628  case AV_PIX_FMT_YUV420P:
629  case AV_PIX_FMT_YUV411P:
630  case AV_PIX_FMT_YUV410P:
631  case AV_PIX_FMT_YUVA444P:
632  case AV_PIX_FMT_YUVA422P:
633  case AV_PIX_FMT_YUVA420P:
634  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
635  s->colorspace = 0;
636  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
637  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
638  s->bits_per_raw_sample = 8;
639  else if (!s->bits_per_raw_sample)
640  s->bits_per_raw_sample = 8;
641  break;
642  case AV_PIX_FMT_RGB32:
643  s->colorspace = 1;
644  s->transparency = 1;
645  s->chroma_planes = 1;
646  s->bits_per_raw_sample = 8;
647  break;
648  case AV_PIX_FMT_RGBA64:
649  s->colorspace = 1;
650  s->transparency = 1;
651  s->chroma_planes = 1;
652  s->bits_per_raw_sample = 16;
653  s->use32bit = 1;
654  s->version = FFMAX(s->version, 1);
655  break;
656  case AV_PIX_FMT_RGB48:
657  s->colorspace = 1;
658  s->chroma_planes = 1;
659  s->bits_per_raw_sample = 16;
660  s->use32bit = 1;
661  s->version = FFMAX(s->version, 1);
662  break;
663  case AV_PIX_FMT_0RGB32:
664  s->colorspace = 1;
665  s->chroma_planes = 1;
666  s->bits_per_raw_sample = 8;
667  break;
668  case AV_PIX_FMT_GBRP9:
669  if (!avctx->bits_per_raw_sample)
670  s->bits_per_raw_sample = 9;
671  case AV_PIX_FMT_GBRP10:
672  case AV_PIX_FMT_GBRAP10:
673  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
674  s->bits_per_raw_sample = 10;
675  case AV_PIX_FMT_GBRP12:
676  case AV_PIX_FMT_GBRAP12:
677  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
678  s->bits_per_raw_sample = 12;
679  case AV_PIX_FMT_GBRP14:
680  case AV_PIX_FMT_GBRAP14:
681  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
682  s->bits_per_raw_sample = 14;
683  case AV_PIX_FMT_GBRP16:
684  case AV_PIX_FMT_GBRAP16:
685  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
686  s->bits_per_raw_sample = 16;
687  else if (!s->bits_per_raw_sample)
688  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
689  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
690  s->colorspace = 1;
691  s->chroma_planes = 1;
692  if (s->bits_per_raw_sample >= 16) {
693  s->use32bit = 1;
694  }
695  s->version = FFMAX(s->version, 1);
696  break;
697  default:
698  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
699  return AVERROR(ENOSYS);
700  }
701  av_assert0(s->bits_per_raw_sample >= 8);
702 
703  if (s->bits_per_raw_sample > 8) {
704  if (s->ac == AC_GOLOMB_RICE) {
705  av_log(avctx, AV_LOG_INFO,
706  "bits_per_raw_sample > 8, forcing range coder\n");
707  s->ac = AC_RANGE_CUSTOM_TAB;
708  }
709  }
710 
711  if (s->ac == AC_RANGE_CUSTOM_TAB) {
712  for (i = 1; i < 256; i++)
713  s->state_transition[i] = ver2_state[i];
714  } else {
715  RangeCoder c;
716  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
717  for (i = 1; i < 256; i++)
718  s->state_transition[i] = c.one_state[i];
719  }
720 
721  for (i = 0; i < MAX_QUANT_TABLE_SIZE; i++) {
722  s->quant_table_count = 2;
723  if (s->bits_per_raw_sample <= 8) {
724  s->quant_tables[0][0][i]= quant11[i];
725  s->quant_tables[0][1][i]= 11*quant11[i];
726  s->quant_tables[0][2][i]= 11*11*quant11[i];
727  s->quant_tables[1][0][i]= quant11[i];
728  s->quant_tables[1][1][i]= 11*quant11[i];
729  s->quant_tables[1][2][i]= 11*11*quant5 [i];
730  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
731  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
732  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
733  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
734  } else {
735  s->quant_tables[0][0][i]= quant9_10bit[i];
736  s->quant_tables[0][1][i]= 9*quant9_10bit[i];
737  s->quant_tables[0][2][i]= 9*9*quant9_10bit[i];
738  s->quant_tables[1][0][i]= quant9_10bit[i];
739  s->quant_tables[1][1][i]= 9*quant9_10bit[i];
740  s->quant_tables[1][2][i]= 9*9*quant5_10bit[i];
741  s->quant_tables[1][3][i]= 5*9*9*quant5_10bit[i];
742  s->quant_tables[1][4][i]= 5*5*9*9*quant5_10bit[i];
743  s->context_count[0] = (9 * 9 * 9 + 1) / 2;
744  s->context_count[1] = (9 * 9 * 5 * 5 * 5 + 1) / 2;
745  }
746  }
747 
748  if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
749  return ret;
750 
751  if (!s->transparency)
752  s->plane_count = 2;
753  if (!s->chroma_planes && s->version > 3)
754  s->plane_count--;
755 
756  ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
757  if (ret)
758  return ret;
759 
760  s->picture_number = 0;
761 
762  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
763  for (i = 0; i < s->quant_table_count; i++) {
764  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
765  sizeof(*s->rc_stat2[i]));
766  if (!s->rc_stat2[i])
767  return AVERROR(ENOMEM);
768  }
769  }
770  if (avctx->stats_in) {
771  char *p = avctx->stats_in;
772  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
773  int gob_count = 0;
774  char *next;
775  if (!best_state)
776  return AVERROR(ENOMEM);
777 
778  av_assert0(s->version >= 2);
779 
780  for (;;) {
781  for (j = 0; j < 256; j++)
782  for (i = 0; i < 2; i++) {
783  s->rc_stat[j][i] = strtol(p, &next, 0);
784  if (next == p) {
785  av_log(avctx, AV_LOG_ERROR,
786  "2Pass file invalid at %d %d [%s]\n", j, i, p);
787  av_freep(&best_state);
788  return AVERROR_INVALIDDATA;
789  }
790  p = next;
791  }
792  for (i = 0; i < s->quant_table_count; i++)
793  for (j = 0; j < s->context_count[i]; j++) {
794  for (k = 0; k < 32; k++)
795  for (m = 0; m < 2; m++) {
796  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
797  if (next == p) {
798  av_log(avctx, AV_LOG_ERROR,
799  "2Pass file invalid at %d %d %d %d [%s]\n",
800  i, j, k, m, p);
801  av_freep(&best_state);
802  return AVERROR_INVALIDDATA;
803  }
804  p = next;
805  }
806  }
807  gob_count = strtol(p, &next, 0);
808  if (next == p || gob_count <= 0) {
809  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
810  av_freep(&best_state);
811  return AVERROR_INVALIDDATA;
812  }
813  p = next;
814  while (*p == '\n' || *p == ' ')
815  p++;
816  if (p[0] == 0)
817  break;
818  }
819  if (s->ac == AC_RANGE_CUSTOM_TAB)
820  sort_stt(s, s->state_transition);
821 
822  find_best_state(best_state, s->state_transition);
823 
824  for (i = 0; i < s->quant_table_count; i++) {
825  for (k = 0; k < 32; k++) {
826  double a=0, b=0;
827  int jp = 0;
828  for (j = 0; j < s->context_count[i]; j++) {
829  double p = 128;
830  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
831  if (a+b)
832  p = 256.0 * b / (a + b);
833  s->initial_states[i][jp][k] =
834  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
835  for(jp++; jp<j; jp++)
836  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
837  a=b=0;
838  }
839  a += s->rc_stat2[i][j][k][0];
840  b += s->rc_stat2[i][j][k][1];
841  if (a+b) {
842  p = 256.0 * b / (a + b);
843  }
844  s->initial_states[i][j][k] =
845  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
846  }
847  }
848  }
849  av_freep(&best_state);
850  }
851 
852  if (s->version > 1) {
853  int plane_count = 1 + 2*s->chroma_planes + s->transparency;
854  int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
855  int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
856  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
857 
858  s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
859 
860  for (; s->num_v_slices < 32; s->num_v_slices++) {
861  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
862  int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
863  int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
864  if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
865  continue;
866  if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
867  continue;
868  if (s->version < 4)
869  if ( ff_need_new_slices(avctx->width , s->num_h_slices, s->chroma_h_shift)
870  ||ff_need_new_slices(avctx->height, s->num_v_slices, s->chroma_v_shift))
871  continue;
872  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
873  goto slices_ok;
874  }
875  }
876  av_log(avctx, AV_LOG_ERROR,
877  "Unsupported number %d of slices requested, please specify a "
878  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
879  avctx->slices);
880  return AVERROR(ENOSYS);
881 slices_ok:
882  if ((ret = write_extradata(s)) < 0)
883  return ret;
884  }
885 
886  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
887  return ret;
888  s->slice_count = s->max_slice_count;
889 
890  for (int j = 0; j < s->slice_count; j++) {
891  for (int i = 0; i < s->plane_count; i++) {
892  PlaneContext *const p = &s->slices[j].plane[i];
893 
894  p->quant_table_index = s->context_model;
895  p->context_count = s->context_count[p->quant_table_index];
896  }
897 
898  ff_build_rac_states(&s->slices[j].c, 0.05 * (1LL << 32), 256 - 8);
899  }
900 
901  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
902  return ret;
903 
904 #define STATS_OUT_SIZE 1024 * 1024 * 6
905  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
906  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
907  if (!avctx->stats_out)
908  return AVERROR(ENOMEM);
909  for (i = 0; i < s->quant_table_count; i++)
910  for (j = 0; j < s->max_slice_count; j++) {
911  FFV1SliceContext *sc = &s->slices[j];
912  av_assert0(!sc->rc_stat2[i]);
913  sc->rc_stat2[i] = av_mallocz(s->context_count[i] *
914  sizeof(*sc->rc_stat2[i]));
915  if (!sc->rc_stat2[i])
916  return AVERROR(ENOMEM);
917  }
918  }
919 
920  return 0;
921 }
922 
923 static void encode_slice_header(FFV1Context *f, FFV1SliceContext *sc)
924 {
925  RangeCoder *c = &sc->c;
926  uint8_t state[CONTEXT_SIZE];
927  int j;
928  memset(state, 128, sizeof(state));
929 
930  put_symbol(c, state, sc->sx, 0);
931  put_symbol(c, state, sc->sy, 0);
932  put_symbol(c, state, 0, 0);
933  put_symbol(c, state, 0, 0);
934  for (j=0; j<f->plane_count; j++) {
935  put_symbol(c, state, sc->plane[j].quant_table_index, 0);
936  av_assert0(sc->plane[j].quant_table_index == f->context_model);
937  }
938  if (!(f->cur_enc_frame->flags & AV_FRAME_FLAG_INTERLACED))
939  put_symbol(c, state, 3, 0);
940  else
941  put_symbol(c, state, 1 + !(f->cur_enc_frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST), 0);
942  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.num, 0);
943  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.den, 0);
944  if (f->version > 3) {
945  put_rac(c, state, sc->slice_coding_mode == 1);
946  if (sc->slice_coding_mode == 1)
947  ff_ffv1_clear_slice_state(f, sc);
948  put_symbol(c, state, sc->slice_coding_mode, 0);
949  if (sc->slice_coding_mode != 1 && f->colorspace == 1) {
950  put_symbol(c, state, sc->slice_rct_by_coef, 0);
951  put_symbol(c, state, sc->slice_rct_ry_coef, 0);
952  }
953  }
954 }
955 
956 static void choose_rct_params(const FFV1Context *f, FFV1SliceContext *sc,
957  const uint8_t *src[3], const int stride[3], int w, int h)
958 {
959 #define NB_Y_COEFF 15
960  static const int rct_y_coeff[15][2] = {
961  {0, 0}, // 4G
962  {1, 1}, // R + 2G + B
963  {2, 2}, // 2R + 2B
964  {0, 2}, // 2G + 2B
965  {2, 0}, // 2R + 2G
966  {4, 0}, // 4R
967  {0, 4}, // 4B
968 
969  {0, 3}, // 1G + 3B
970  {3, 0}, // 3R + 1G
971  {3, 1}, // 3R + B
972  {1, 3}, // R + 3B
973  {1, 2}, // R + G + 2B
974  {2, 1}, // 2R + G + B
975  {0, 1}, // 3G + B
976  {1, 0}, // R + 3G
977  };
978 
979  int stat[NB_Y_COEFF] = {0};
980  int x, y, i, p, best;
981  int16_t *sample[3];
982  int lbd = f->bits_per_raw_sample <= 8;
983  int packed = !src[1];
984  int transparency = f->transparency;
985  int packed_size = (3 + transparency)*2;
986 
987  for (y = 0; y < h; y++) {
988  int lastr=0, lastg=0, lastb=0;
989  for (p = 0; p < 3; p++)
990  sample[p] = sc->sample_buffer + p*w;
991 
992  for (x = 0; x < w; x++) {
993  int b, g, r;
994  int ab, ag, ar;
995  if (lbd) {
996  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
997  b = v & 0xFF;
998  g = (v >> 8) & 0xFF;
999  r = (v >> 16) & 0xFF;
1000  } else if (packed) {
1001  const uint16_t *p = ((const uint16_t*)(src[0] + x*packed_size + stride[0]*y));
1002  r = p[0];
1003  g = p[1];
1004  b = p[2];
1005  } else if (f->use32bit || transparency) {
1006  g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
1007  b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
1008  r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
1009  } else {
1010  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1011  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1012  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1013  }
1014 
1015  ar = r - lastr;
1016  ag = g - lastg;
1017  ab = b - lastb;
1018  if (x && y) {
1019  int bg = ag - sample[0][x];
1020  int bb = ab - sample[1][x];
1021  int br = ar - sample[2][x];
1022 
1023  br -= bg;
1024  bb -= bg;
1025 
1026  for (i = 0; i<NB_Y_COEFF; i++) {
1027  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1028  }
1029 
1030  }
1031  sample[0][x] = ag;
1032  sample[1][x] = ab;
1033  sample[2][x] = ar;
1034 
1035  lastr = r;
1036  lastg = g;
1037  lastb = b;
1038  }
1039  }
1040 
1041  best = 0;
1042  for (i=1; i<NB_Y_COEFF; i++) {
1043  if (stat[i] < stat[best])
1044  best = i;
1045  }
1046 
1047  sc->slice_rct_by_coef = rct_y_coeff[best][1];
1048  sc->slice_rct_ry_coef = rct_y_coeff[best][0];
1049 }
1050 
1051 static int encode_slice(AVCodecContext *c, void *arg)
1052 {
1053  FFV1SliceContext *sc = arg;
1054  FFV1Context *f = c->priv_data;
1055  int width = sc->slice_width;
1056  int height = sc->slice_height;
1057  int x = sc->slice_x;
1058  int y = sc->slice_y;
1059  const AVFrame *const p = f->cur_enc_frame;
1060  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1061  int ret;
1062  RangeCoder c_bak = sc->c;
1063  const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1064  p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1065  p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1066  p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1067 
1068  sc->slice_coding_mode = 0;
1069  if (f->version > 3 && f->colorspace == 1) {
1070  choose_rct_params(f, sc, planes, p->linesize, width, height);
1071  } else {
1072  sc->slice_rct_by_coef = 1;
1073  sc->slice_rct_ry_coef = 1;
1074  }
1075 
1076 retry:
1077  if (f->key_frame)
1078  ff_ffv1_clear_slice_state(f, sc);
1079  if (f->version > 2) {
1080  encode_slice_header(f, sc);
1081  }
1082  if (f->ac == AC_GOLOMB_RICE) {
1083  sc->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&sc->c, f->version > 2) : 0;
1084  init_put_bits(&sc->pb,
1085  sc->c.bytestream_start + sc->ac_byte_count,
1086  sc->c.bytestream_end - sc->c.bytestream_start - sc->ac_byte_count);
1087  }
1088 
1089  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1090  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1091  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1092  const int cx = x >> f->chroma_h_shift;
1093  const int cy = y >> f->chroma_v_shift;
1094 
1095  ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1096 
1097  if (f->chroma_planes) {
1098  ret |= encode_plane(f, sc, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1099  ret |= encode_plane(f, sc, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1100  }
1101  if (f->transparency)
1102  ret |= encode_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1103  } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1104  ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1105  ret |= encode_plane(f, sc, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1106  } else if (f->use32bit) {
1107  ret = encode_rgb_frame32(f, sc, planes, width, height, p->linesize);
1108  } else {
1109  ret = encode_rgb_frame(f, sc, planes, width, height, p->linesize);
1110  }
1111 
1112  if (f->ac != AC_GOLOMB_RICE) {
1113  sc->ac_byte_count = ff_rac_terminate(&sc->c, 1);
1114  } else {
1115  flush_put_bits(&sc->pb); // FIXME: nicer padding
1116  sc->ac_byte_count += put_bytes_output(&sc->pb);
1117  }
1118 
1119  if (ret < 0) {
1120  av_assert0(sc->slice_coding_mode == 0);
1121  if (f->version < 4 || !f->ac) {
1122  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1123  return ret;
1124  }
1125  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1126  sc->slice_coding_mode = 1;
1127  sc->c = c_bak;
1128  goto retry;
1129  }
1130 
1131  return 0;
1132 }
1133 
1134 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1135  const AVFrame *pict, int *got_packet)
1136 {
1137  FFV1Context *f = avctx->priv_data;
1138  RangeCoder *const c = &f->slices[0].c;
1139  uint8_t keystate = 128;
1140  uint8_t *buf_p;
1141  int i, ret;
1142  int64_t maxsize = FF_INPUT_BUFFER_MIN_SIZE
1143  + avctx->width*avctx->height*37LL*4;
1144 
1145  if(!pict) {
1146  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1147  int j, k, m;
1148  char *p = avctx->stats_out;
1149  char *end = p + STATS_OUT_SIZE;
1150 
1151  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1152  for (i = 0; i < f->quant_table_count; i++)
1153  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1154 
1155  av_assert0(f->slice_count == f->max_slice_count);
1156  for (j = 0; j < f->slice_count; j++) {
1157  const FFV1SliceContext *sc = &f->slices[j];
1158  for (i = 0; i < 256; i++) {
1159  f->rc_stat[i][0] += sc->rc_stat[i][0];
1160  f->rc_stat[i][1] += sc->rc_stat[i][1];
1161  }
1162  for (i = 0; i < f->quant_table_count; i++) {
1163  for (k = 0; k < f->context_count[i]; k++)
1164  for (m = 0; m < 32; m++) {
1165  f->rc_stat2[i][k][m][0] += sc->rc_stat2[i][k][m][0];
1166  f->rc_stat2[i][k][m][1] += sc->rc_stat2[i][k][m][1];
1167  }
1168  }
1169  }
1170 
1171  for (j = 0; j < 256; j++) {
1172  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1173  f->rc_stat[j][0], f->rc_stat[j][1]);
1174  p += strlen(p);
1175  }
1176  snprintf(p, end - p, "\n");
1177 
1178  for (i = 0; i < f->quant_table_count; i++) {
1179  for (j = 0; j < f->context_count[i]; j++)
1180  for (m = 0; m < 32; m++) {
1181  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1182  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1183  p += strlen(p);
1184  }
1185  }
1186  snprintf(p, end - p, "%d\n", f->gob_count);
1187  }
1188  return 0;
1189  }
1190 
1191  if (f->version > 3)
1192  maxsize = FF_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1193 
1194  if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1195  av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1196  maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1197  }
1198 
1199  if ((ret = ff_alloc_packet(avctx, pkt, maxsize)) < 0)
1200  return ret;
1201 
1202  ff_init_range_encoder(c, pkt->data, pkt->size);
1203  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1204 
1205  f->cur_enc_frame = pict;
1206 
1207  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1208  put_rac(c, &keystate, 1);
1209  f->key_frame = 1;
1210  f->gob_count++;
1211  write_header(f);
1212  } else {
1213  put_rac(c, &keystate, 0);
1214  f->key_frame = 0;
1215  }
1216 
1217  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1218  int i;
1219  for (i = 1; i < 256; i++) {
1220  c->one_state[i] = f->state_transition[i];
1221  c->zero_state[256 - i] = 256 - c->one_state[i];
1222  }
1223  }
1224 
1225  for (i = 0; i < f->slice_count; i++) {
1226  FFV1SliceContext *sc = &f->slices[i];
1227  uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1228  int len = pkt->size / f->slice_count;
1229  if (i) {
1230  ff_init_range_encoder(&sc->c, start, len);
1231  } else {
1232  av_assert0(sc->c.bytestream_end >= sc->c.bytestream_start + len);
1233  av_assert0(sc->c.bytestream < sc->c.bytestream_start + len);
1234  sc->c.bytestream_end = sc->c.bytestream_start + len;
1235  }
1236  }
1237  avctx->execute(avctx, encode_slice, f->slices, NULL,
1238  f->slice_count, sizeof(*f->slices));
1239 
1240  buf_p = pkt->data;
1241  for (i = 0; i < f->slice_count; i++) {
1242  FFV1SliceContext *sc = &f->slices[i];
1243  int bytes = sc->ac_byte_count;
1244  if (i > 0 || f->version > 2) {
1245  av_assert0(bytes < pkt->size / f->slice_count);
1246  memmove(buf_p, sc->c.bytestream_start, bytes);
1247  av_assert0(bytes < (1 << 24));
1248  AV_WB24(buf_p + bytes, bytes);
1249  bytes += 3;
1250  }
1251  if (f->ec) {
1252  unsigned v;
1253  buf_p[bytes++] = 0;
1254  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1255  AV_WL32(buf_p + bytes, v);
1256  bytes += 4;
1257  }
1258  buf_p += bytes;
1259  }
1260 
1261  if (avctx->flags & AV_CODEC_FLAG_PASS1)
1262  avctx->stats_out[0] = '\0';
1263 
1264  f->picture_number++;
1265  pkt->size = buf_p - pkt->data;
1266  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1267  *got_packet = 1;
1268 
1269  return 0;
1270 }
1271 
1272 #define OFFSET(x) offsetof(FFV1Context, x)
1273 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1274 static const AVOption options[] = {
1275  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1276  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1277  { .i64 = 0 }, -2, 2, VE, .unit = "coder" },
1278  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1279  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1280  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1281  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1282  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1283  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1284  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1285  { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1286  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1287  { .i64 = 0 }, 0, 1, VE },
1288 
1289  { NULL }
1290 };
1291 
1292 static const AVClass ffv1_class = {
1293  .class_name = "ffv1 encoder",
1294  .item_name = av_default_item_name,
1295  .option = options,
1296  .version = LIBAVUTIL_VERSION_INT,
1297 };
1298 
1299 const FFCodec ff_ffv1_encoder = {
1300  .p.name = "ffv1",
1301  CODEC_LONG_NAME("FFmpeg video codec #1"),
1302  .p.type = AVMEDIA_TYPE_VIDEO,
1303  .p.id = AV_CODEC_ID_FFV1,
1304  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1305  AV_CODEC_CAP_SLICE_THREADS |
1306  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1307  .priv_data_size = sizeof(FFV1Context),
1308  .init = encode_init,
1309  FF_CODEC_ENCODE_CB(encode_frame),
1310  .close = ff_ffv1_close,
1311  .p.pix_fmts = (const enum AVPixelFormat[]) {
1312  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1313  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1314  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1315  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1316  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1317  AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1318  AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1319  AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA422P12,
1320  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1321  AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1322  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1323  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRAP14,
1324  AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1325  AV_PIX_FMT_YA8,
1326  AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
1327  AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1328  AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1329  AV_PIX_FMT_GRAY9,
1330  AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1331  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1332  AV_PIX_FMT_NONE
1333 
1334  },
1335  .color_ranges = AVCOL_RANGE_MPEG,
1336  .p.priv_class = &ffv1_class,
1337  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
1338 };
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:522
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:501
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FFV1SliceContext::slice_height
int slice_height
Definition: ffv1.h:77
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
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:189
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
FFV1SliceContext::plane
PlaneContext * plane
Definition: ffv1.h:88
FF_CODEC_CAP_EOF_FLUSH
#define FF_CODEC_CAP_EOF_FLUSH
The encoder has AV_CODEC_CAP_DELAY set, but does not actually have delay - it only wants to be flushe...
Definition: codec_internal.h:90
int64_t
long long int64_t
Definition: coverity.c:34
put_symbol_inline
static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2])
Definition: ffv1enc.c:183
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_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:514
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
pixdesc.h
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:36
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:521
w
uint8_t w
Definition: llviddspenc.c:38
AC_RANGE_DEFAULT_TAB_FORCE
#define AC_RANGE_DEFAULT_TAB_FORCE
Definition: ffv1.h:54
AVPacket::data
uint8_t * data
Definition: packet.h:539
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:516
AVOption
AVOption.
Definition: opt.h:429
encode.h
b
#define b
Definition: input.c:41
MAX_QUANT_TABLE_SIZE
#define MAX_QUANT_TABLE_SIZE
Definition: ffv1.h:47
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:478
FFCodec
Definition: codec_internal.h:127
FFV1SliceContext::pb
PutBitContext pb
Definition: ffv1.h:89
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:336
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
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:53
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:517
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:594
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:78
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:231
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1SliceContext *sc)
Definition: ffv1.c:187
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:458
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
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:653
crc.h
ff_ffv1_init_slices_state
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:112
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:513
write_quant_tables
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE])
Definition: ffv1enc.c:328
quant11
static const int8_t quant11[256]
Definition: ffv1enc.c:100
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:516
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:496
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:494
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:523
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:476
encode_slice
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:1051
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
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:2993
av_noinline
#define av_noinline
Definition: attributes.h:72
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:44
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:462
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:320
PlaneContext::context_count
int context_count
Definition: ffv1.h:65
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
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:180
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:490
FFV1SliceContext::sample_buffer
int16_t * sample_buffer
Definition: ffv1.h:73
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:498
s
#define s(width, name)
Definition: cbs_vp9.c:198
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:1352
AV_PIX_FMT_GBRAP14
#define AV_PIX_FMT_GBRAP14
Definition: pixfmt.h:500
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:499
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:491
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
g
const char * g
Definition: vf_curves.c:128
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:159
bits
uint8_t bits
Definition: vp3data.h:128
AC_RANGE_DEFAULT_TAB
#define AC_RANGE_DEFAULT_TAB
Definition: ffv1.h:52
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
quant5
static const int8_t quant5[256]
Definition: ffv1enc.c:62
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:520
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1585
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:475
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:489
write_extradata
static int write_extradata(FFV1Context *f)
Definition: ffv1enc.c:395
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:104
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:461
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:178
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:296
sort_stt
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:468
ver2_state
static const uint8_t ver2_state[256]
Definition: ffv1enc.c:119
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:459
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:1134
quant_table
static const int16_t quant_table[64]
Definition: intrax8.c:517
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:497
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:468
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
FFV1SliceContext::sx
int sx
Definition: ffv1.h:80
ff_need_new_slices
int ff_need_new_slices(int width, int num_h_slices, int chroma_shift)
Definition: ffv1.c:122
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:51
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:200
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:237
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:480
PlaneContext
Definition: ffv1.h:63
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
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:493
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1794
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:56
VE
#define VE
Definition: ffv1enc.c:1273
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
FFV1SliceContext::slice_width
int slice_width
Definition: ffv1.h:76
options
static const AVOption options[]
Definition: ffv1enc.c:1274
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1344
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:85
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:956
AVPacket::size
int size
Definition: packet.h:540
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1037
height
#define height
Definition: dsp.h:85
codec_internal.h
quant9_10bit
static const int8_t quant9_10bit[256]
Definition: ffv1enc.c:81
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
print
static void print(AVTreeNode *t, int depth)
Definition: tree.c:45
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:483
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:212
sample
#define sample
Definition: flacdsp_template.c:44
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:464
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:485
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:446
RangeCoder::bytestream
uint8_t * bytestream
Definition: rangecoder.h:43
encode_plane
static int encode_plane(FFV1Context *f, FFV1SliceContext *sc, const uint8_t *src, int w, int h, int stride, int plane_index, int pixel_stride)
Definition: ffv1enc.c:272
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:314
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:451
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:84
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:114
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:518
find_best_state
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256])
Definition: ffv1enc.c:138
attributes.h
FFV1SliceContext::rc_stat
uint64_t rc_stat[256][2]
Definition: ffv1.h:103
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:64
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
FFV1SliceContext::c
RangeCoder c
Definition: ffv1.h:90
put_vlc_symbol
static void put_vlc_symbol(PutBitContext *pb, VlcState *const state, int v, int bits)
Definition: ffv1enc.c:238
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
ffv1_class
static const AVClass ffv1_class
Definition: ffv1enc.c:1292
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
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
FFV1SliceContext::slice_rct_ry_coef
int slice_rct_ry_coef
Definition: ffv1.h:85
av_flatten
#define av_flatten
Definition: attributes.h:96
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:495
av_always_inline
#define av_always_inline
Definition: attributes.h:49
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:194
FFV1SliceContext
Definition: ffv1.h:72
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:624
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
write_quant_table
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition: ffv1enc.c:313
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:648
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:669
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:477
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:49
log2
#define log2(x)
Definition: libm.h:404
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
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:71
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:455
quant5_10bit
static const int8_t quant5_10bit[256]
Definition: ffv1enc.c:43
FFV1SliceContext::slice_y
int slice_y
Definition: ffv1.h:79
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1389
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:515
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
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])
Definition: ffv1enc_template.c:130
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:482
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:487
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:172
AVCodecContext
main external API structure.
Definition: avcodec.h:451
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:1623
planes
static const struct @455 planes[]
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_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:519
OFFSET
#define OFFSET(x)
Definition: ffv1enc.c:1272
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
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:80
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:201
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:143
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:109
state
static struct @454 state
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1053
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
FFV1SliceContext::run_index
int run_index
Definition: ffv1.h:82
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:624
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:129
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:434
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:484
h
h
Definition: vp9dsp_template.c:2070
RangeCoder
Definition: mss3.c:63
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:488
ff_ffv1_encoder
const FFCodec ff_ffv1_encoder
Definition: ffv1enc.c:1299
width
#define width
Definition: dsp.h:85
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:348
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:460
FFV1SliceContext::ac_byte_count
int ac_byte_count
number of bytes used for AC coding
Definition: ffv1.h:92
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:83
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:62
src
#define src
Definition: vp8dsp.c:248
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:486
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:310
encode_slice_header
static void encode_slice_header(FFV1Context *f, FFV1SliceContext *sc)
Definition: ffv1enc.c:923
Generated on Fri Aug 22 2025 13:58:20 for FFmpeg by   doxygen 1.8.17