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/opt.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/pixdesc.h"
34 
35 #include "avcodec.h"
36 #include "internal.h"
37 #include "put_bits.h"
38 #include "rangecoder.h"
39 #include "golomb.h"
40 #include "mathops.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  double l2tab[256];
143 
144  for (i = 1; i < 256; i++)
145  l2tab[i] = log2(i / 256.0);
146 
147  for (i = 0; i < 256; i++) {
148  double best_len[256];
149  double p = i / 256.0;
150 
151  for (j = 0; j < 256; j++)
152  best_len[j] = 1 << 30;
153 
154  for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
155  double occ[256] = { 0 };
156  double len = 0;
157  occ[j] = 1.0;
158 
159  if (!one_state[j])
160  continue;
161 
162  for (k = 0; k < 256; k++) {
163  double newocc[256] = { 0 };
164  for (m = 1; m < 256; m++)
165  if (occ[m]) {
166  len -=occ[m]*( p *l2tab[ m]
167  + (1-p)*l2tab[256-m]);
168  }
169  if (len < best_len[k]) {
170  best_len[k] = len;
171  best_state[i][k] = j;
172  }
173  for (m = 1; m < 256; m++)
174  if (occ[m]) {
175  newocc[ one_state[ m]] += occ[m] * p;
176  newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
177  }
178  memcpy(occ, newocc, sizeof(occ));
179  }
180  }
181  }
182 }
183 
184 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
185  uint8_t *state, int v,
186  int is_signed,
187  uint64_t rc_stat[256][2],
188  uint64_t rc_stat2[32][2])
189 {
190  int i;
191 
192 #define put_rac(C, S, B) \
193  do { \
194  if (rc_stat) { \
195  rc_stat[*(S)][B]++; \
196  rc_stat2[(S) - state][B]++; \
197  } \
198  put_rac(C, S, B); \
199  } while (0)
200 
201  if (v) {
202  const int a = FFABS(v);
203  const int e = av_log2(a);
204  put_rac(c, state + 0, 0);
205  if (e <= 9) {
206  for (i = 0; i < e; i++)
207  put_rac(c, state + 1 + i, 1); // 1..10
208  put_rac(c, state + 1 + i, 0);
209 
210  for (i = e - 1; i >= 0; i--)
211  put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
212 
213  if (is_signed)
214  put_rac(c, state + 11 + e, v < 0); // 11..21
215  } else {
216  for (i = 0; i < e; i++)
217  put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
218  put_rac(c, state + 1 + 9, 0);
219 
220  for (i = e - 1; i >= 0; i--)
221  put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
222 
223  if (is_signed)
224  put_rac(c, state + 11 + 10, v < 0); // 11..21
225  }
226  } else {
227  put_rac(c, state + 0, 1);
228  }
229 #undef put_rac
230 }
231 
232 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
233  int v, int is_signed)
234 {
235  put_symbol_inline(c, state, v, is_signed, NULL, NULL);
236 }
237 
238 
239 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
240  int v, int bits)
241 {
242  int i, k, code;
243  v = fold(v - state->bias, bits);
244 
245  i = state->count;
246  k = 0;
247  while (i < state->error_sum) { // FIXME: optimize
248  k++;
249  i += i;
250  }
251 
252  av_assert2(k <= 13);
253 
254  code = v ^ ((2 * state->drift + state->count) >> 31);
255 
256  ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
257  state->bias, state->error_sum, state->drift, state->count, k);
258  set_sr_golomb(pb, code, k, 12, bits);
259 
260  update_vlc_state(state, v);
261 }
262 
263 #define TYPE int16_t
264 #define RENAME(name) name
265 #include "ffv1enc_template.c"
266 #undef TYPE
267 #undef RENAME
268 
269 #define TYPE int32_t
270 #define RENAME(name) name ## 32
271 #include "ffv1enc_template.c"
272 
273 static int encode_plane(FFV1Context *s, 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 ring_size = s->context_model ? 3 : 2;
278  int16_t *sample[3];
279  s->run_index = 0;
280 
281  memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
282 
283  for (y = 0; y < h; y++) {
284  for (i = 0; i < ring_size; i++)
285  sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
286 
287  sample[0][-1]= sample[1][0 ];
288  sample[1][ w]= sample[1][w-1];
289  if (s->bits_per_raw_sample <= 8) {
290  for (x = 0; x < w; x++)
291  sample[0][x] = src[x * pixel_stride + stride * y];
292  if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
293  return ret;
294  } else {
295  if (s->packed_at_lsb) {
296  for (x = 0; x < w; x++) {
297  sample[0][x] = ((uint16_t*)(src + stride*y))[x];
298  }
299  } else {
300  for (x = 0; x < w; x++) {
301  sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
302  }
303  }
304  if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
305  return ret;
306  }
307  }
308  return 0;
309 }
310 
311 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
312 {
313  int last = 0;
314  int i;
315  uint8_t state[CONTEXT_SIZE];
316  memset(state, 128, sizeof(state));
317 
318  for (i = 1; i < 128; i++)
319  if (quant_table[i] != quant_table[i - 1]) {
320  put_symbol(c, state, i - last - 1, 0);
321  last = i;
322  }
323  put_symbol(c, state, i - last - 1, 0);
324 }
325 
326 static void write_quant_tables(RangeCoder *c,
327  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
328 {
329  int i;
330  for (i = 0; i < 5; i++)
331  write_quant_table(c, quant_table[i]);
332 }
333 
334 static int contains_non_128(uint8_t (*initial_state)[CONTEXT_SIZE],
335  int nb_contexts)
336 {
337  if (!initial_state)
338  return 0;
339  for (int i = 0; i < nb_contexts; i++)
340  for (int j = 0; j < CONTEXT_SIZE; j++)
341  if (initial_state[i][j] != 128)
342  return 1;
343  return 0;
344 }
345 
346 static void write_header(FFV1Context *f)
347 {
348  uint8_t state[CONTEXT_SIZE];
349  int i, j;
350  RangeCoder *const c = &f->slice_context[0]->c;
351 
352  memset(state, 128, sizeof(state));
353 
354  if (f->version < 2) {
355  put_symbol(c, state, f->version, 0);
356  put_symbol(c, state, f->ac, 0);
357  if (f->ac == AC_RANGE_CUSTOM_TAB) {
358  for (i = 1; i < 256; i++)
359  put_symbol(c, state,
360  f->state_transition[i] - c->one_state[i], 1);
361  }
362  put_symbol(c, state, f->colorspace, 0); //YUV cs type
363  if (f->version > 0)
364  put_symbol(c, state, f->bits_per_raw_sample, 0);
365  put_rac(c, state, f->chroma_planes);
366  put_symbol(c, state, f->chroma_h_shift, 0);
367  put_symbol(c, state, f->chroma_v_shift, 0);
368  put_rac(c, state, f->transparency);
369 
370  write_quant_tables(c, f->quant_table);
371  } else if (f->version < 3) {
372  put_symbol(c, state, f->slice_count, 0);
373  for (i = 0; i < f->slice_count; i++) {
374  FFV1Context *fs = f->slice_context[i];
375  put_symbol(c, state,
376  (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
377  put_symbol(c, state,
378  (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
379  put_symbol(c, state,
380  (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
381  0);
382  put_symbol(c, state,
383  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
384  0);
385  for (j = 0; j < f->plane_count; j++) {
386  put_symbol(c, state, f->plane[j].quant_table_index, 0);
387  av_assert0(f->plane[j].quant_table_index == f->context_model);
388  }
389  }
390  }
391 }
392 
393 static int write_extradata(FFV1Context *f)
394 {
395  RangeCoder *const c = &f->c;
396  uint8_t state[CONTEXT_SIZE];
397  int i, j, k;
398  uint8_t state2[32][CONTEXT_SIZE];
399  unsigned v;
400 
401  memset(state2, 128, sizeof(state2));
402  memset(state, 128, sizeof(state));
403 
404  f->avctx->extradata_size = 10000 + 4 +
405  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
406  f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
407  if (!f->avctx->extradata)
408  return AVERROR(ENOMEM);
409  ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
410  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
411 
412  put_symbol(c, state, f->version, 0);
413  if (f->version > 2) {
414  if (f->version == 3) {
415  f->micro_version = 4;
416  } else if (f->version == 4)
417  f->micro_version = 2;
418  put_symbol(c, state, f->micro_version, 0);
419  }
420 
421  put_symbol(c, state, f->ac, 0);
422  if (f->ac == AC_RANGE_CUSTOM_TAB)
423  for (i = 1; i < 256; i++)
424  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
425 
426  put_symbol(c, state, f->colorspace, 0); // YUV cs type
427  put_symbol(c, state, f->bits_per_raw_sample, 0);
428  put_rac(c, state, f->chroma_planes);
429  put_symbol(c, state, f->chroma_h_shift, 0);
430  put_symbol(c, state, f->chroma_v_shift, 0);
431  put_rac(c, state, f->transparency);
432  put_symbol(c, state, f->num_h_slices - 1, 0);
433  put_symbol(c, state, f->num_v_slices - 1, 0);
434 
435  put_symbol(c, state, f->quant_table_count, 0);
436  for (i = 0; i < f->quant_table_count; i++)
437  write_quant_tables(c, f->quant_tables[i]);
438 
439  for (i = 0; i < f->quant_table_count; i++) {
440  if (contains_non_128(f->initial_states[i], f->context_count[i])) {
441  put_rac(c, state, 1);
442  for (j = 0; j < f->context_count[i]; j++)
443  for (k = 0; k < CONTEXT_SIZE; k++) {
444  int pred = j ? f->initial_states[i][j - 1][k] : 128;
445  put_symbol(c, state2[k],
446  (int8_t)(f->initial_states[i][j][k] - pred), 1);
447  }
448  } else {
449  put_rac(c, state, 0);
450  }
451  }
452 
453  if (f->version > 2) {
454  put_symbol(c, state, f->ec, 0);
455  put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
456  }
457 
458  f->avctx->extradata_size = ff_rac_terminate(c, 0);
459  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
460  AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
461  f->avctx->extradata_size += 4;
462 
463  return 0;
464 }
465 
466 static int sort_stt(FFV1Context *s, uint8_t stt[256])
467 {
468  int i, i2, changed, print = 0;
469 
470  do {
471  changed = 0;
472  for (i = 12; i < 244; i++) {
473  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
474 
475 #define COST(old, new) \
476  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
477  s->rc_stat[old][1] * -log2((new) / 256.0)
478 
479 #define COST2(old, new) \
480  COST(old, new) + COST(256 - (old), 256 - (new))
481 
482  double size0 = COST2(i, i) + COST2(i2, i2);
483  double sizeX = COST2(i, i2) + COST2(i2, i);
484  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
485  int j;
486  FFSWAP(int, stt[i], stt[i2]);
487  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
488  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
489  if (i != 256 - i2) {
490  FFSWAP(int, stt[256 - i], stt[256 - i2]);
491  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
492  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
493  }
494  for (j = 1; j < 256; j++) {
495  if (stt[j] == i)
496  stt[j] = i2;
497  else if (stt[j] == i2)
498  stt[j] = i;
499  if (i != 256 - i2) {
500  if (stt[256 - j] == 256 - i)
501  stt[256 - j] = 256 - i2;
502  else if (stt[256 - j] == 256 - i2)
503  stt[256 - j] = 256 - i;
504  }
505  }
506  print = changed = 1;
507  }
508  }
509  }
510  } while (changed);
511  return print;
512 }
513 
514 static av_cold int encode_init(AVCodecContext *avctx)
515 {
516  FFV1Context *s = avctx->priv_data;
517  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
518  int i, j, k, m, ret;
519 
520  if ((ret = ff_ffv1_common_init(avctx)) < 0)
521  return ret;
522 
523  s->version = 0;
524 
525  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
526  avctx->slices > 1)
527  s->version = FFMAX(s->version, 2);
528 
529  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
530  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
531  s->version = FFMAX(s->version, 2);
532 
533  if (avctx->level <= 0 && s->version == 2) {
534  s->version = 3;
535  }
536  if (avctx->level >= 0 && avctx->level <= 4) {
537  if (avctx->level < s->version) {
538  av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
539  return AVERROR(EINVAL);
540  }
541  s->version = avctx->level;
542  }
543 
544  if (s->ec < 0) {
545  s->ec = (s->version >= 3);
546  }
547 
548  // CRC requires version 3+
549  if (s->ec)
550  s->version = FFMAX(s->version, 3);
551 
552  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
553  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
554  return AVERROR_INVALIDDATA;
555  }
556 
557 #if FF_API_CODER_TYPE
558 FF_DISABLE_DEPRECATION_WARNINGS
559  if (avctx->coder_type != -1)
560  s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
561  else
562 FF_ENABLE_DEPRECATION_WARNINGS
563 #endif
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  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
596  s->bits_per_raw_sample = 12;
597  case AV_PIX_FMT_YUV444P14:
598  case AV_PIX_FMT_YUV420P14:
599  case AV_PIX_FMT_YUV422P14:
600  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
601  s->bits_per_raw_sample = 14;
602  s->packed_at_lsb = 1;
603  case AV_PIX_FMT_GRAY16:
604  case AV_PIX_FMT_YUV444P16:
605  case AV_PIX_FMT_YUV422P16:
606  case AV_PIX_FMT_YUV420P16:
607  case AV_PIX_FMT_YUVA444P16:
608  case AV_PIX_FMT_YUVA422P16:
609  case AV_PIX_FMT_YUVA420P16:
610  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
611  s->bits_per_raw_sample = 16;
612  } else if (!s->bits_per_raw_sample) {
613  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
614  }
615  if (s->bits_per_raw_sample <= 8) {
616  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
617  return AVERROR_INVALIDDATA;
618  }
619  s->version = FFMAX(s->version, 1);
620  case AV_PIX_FMT_GRAY8:
621  case AV_PIX_FMT_YA8:
622  case AV_PIX_FMT_YUV444P:
623  case AV_PIX_FMT_YUV440P:
624  case AV_PIX_FMT_YUV422P:
625  case AV_PIX_FMT_YUV420P:
626  case AV_PIX_FMT_YUV411P:
627  case AV_PIX_FMT_YUV410P:
628  case AV_PIX_FMT_YUVA444P:
629  case AV_PIX_FMT_YUVA422P:
630  case AV_PIX_FMT_YUVA420P:
631  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
632  s->colorspace = 0;
633  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
634  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
635  s->bits_per_raw_sample = 8;
636  else if (!s->bits_per_raw_sample)
637  s->bits_per_raw_sample = 8;
638  break;
639  case AV_PIX_FMT_RGB32:
640  s->colorspace = 1;
641  s->transparency = 1;
642  s->chroma_planes = 1;
643  s->bits_per_raw_sample = 8;
644  break;
645  case AV_PIX_FMT_RGBA64:
646  s->colorspace = 1;
647  s->transparency = 1;
648  s->chroma_planes = 1;
649  s->bits_per_raw_sample = 16;
650  s->use32bit = 1;
651  s->version = FFMAX(s->version, 1);
652  break;
653  case AV_PIX_FMT_RGB48:
654  s->colorspace = 1;
655  s->chroma_planes = 1;
656  s->bits_per_raw_sample = 16;
657  s->use32bit = 1;
658  s->version = FFMAX(s->version, 1);
659  break;
660  case AV_PIX_FMT_0RGB32:
661  s->colorspace = 1;
662  s->chroma_planes = 1;
663  s->bits_per_raw_sample = 8;
664  break;
665  case AV_PIX_FMT_GBRP9:
666  if (!avctx->bits_per_raw_sample)
667  s->bits_per_raw_sample = 9;
668  case AV_PIX_FMT_GBRP10:
669  case AV_PIX_FMT_GBRAP10:
670  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
671  s->bits_per_raw_sample = 10;
672  case AV_PIX_FMT_GBRP12:
673  case AV_PIX_FMT_GBRAP12:
674  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
675  s->bits_per_raw_sample = 12;
676  case AV_PIX_FMT_GBRP14:
677  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
678  s->bits_per_raw_sample = 14;
679  case AV_PIX_FMT_GBRP16:
680  case AV_PIX_FMT_GBRAP16:
681  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
682  s->bits_per_raw_sample = 16;
683  else if (!s->bits_per_raw_sample)
684  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
685  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
686  s->colorspace = 1;
687  s->chroma_planes = 1;
688  if (s->bits_per_raw_sample >= 16) {
689  s->use32bit = 1;
690  }
691  s->version = FFMAX(s->version, 1);
692  break;
693  default:
694  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
695  return AVERROR(ENOSYS);
696  }
697  av_assert0(s->bits_per_raw_sample >= 8);
698 
699  if (s->bits_per_raw_sample > 8) {
700  if (s->ac == AC_GOLOMB_RICE) {
701  av_log(avctx, AV_LOG_INFO,
702  "bits_per_raw_sample > 8, forcing range coder\n");
703  s->ac = AC_RANGE_CUSTOM_TAB;
704  }
705  }
706 #if FF_API_PRIVATE_OPT
707 FF_DISABLE_DEPRECATION_WARNINGS
708  if (avctx->context_model)
709  s->context_model = avctx->context_model;
710  if (avctx->context_model > 1U) {
711  av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
712  return AVERROR(EINVAL);
713  }
714 FF_ENABLE_DEPRECATION_WARNINGS
715 #endif
716 
717  if (s->ac == AC_RANGE_CUSTOM_TAB) {
718  for (i = 1; i < 256; i++)
719  s->state_transition[i] = ver2_state[i];
720  } else {
721  RangeCoder c;
722  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
723  for (i = 1; i < 256; i++)
724  s->state_transition[i] = c.one_state[i];
725  }
726 
727  for (i = 0; i < 256; i++) {
728  s->quant_table_count = 2;
729  if (s->bits_per_raw_sample <= 8) {
730  s->quant_tables[0][0][i]= quant11[i];
731  s->quant_tables[0][1][i]= 11*quant11[i];
732  s->quant_tables[0][2][i]= 11*11*quant11[i];
733  s->quant_tables[1][0][i]= quant11[i];
734  s->quant_tables[1][1][i]= 11*quant11[i];
735  s->quant_tables[1][2][i]= 11*11*quant5 [i];
736  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
737  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
738  } else {
739  s->quant_tables[0][0][i]= quant9_10bit[i];
740  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
741  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
742  s->quant_tables[1][0][i]= quant9_10bit[i];
743  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
744  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
745  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
746  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
747  }
748  }
749  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
750  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
751  memcpy(s->quant_table, s->quant_tables[s->context_model],
752  sizeof(s->quant_table));
753 
754  for (i = 0; i < s->plane_count; i++) {
755  PlaneContext *const p = &s->plane[i];
756 
757  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
758  p->quant_table_index = s->context_model;
759  p->context_count = s->context_count[p->quant_table_index];
760  }
761 
762  if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
763  return ret;
764 
765 #if FF_API_CODED_FRAME
766 FF_DISABLE_DEPRECATION_WARNINGS
767  avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
768 FF_ENABLE_DEPRECATION_WARNINGS
769 #endif
770 
771  if (!s->transparency)
772  s->plane_count = 2;
773  if (!s->chroma_planes && s->version > 3)
774  s->plane_count--;
775 
776  ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
777  if (ret)
778  return ret;
779 
780  s->picture_number = 0;
781 
782  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
783  for (i = 0; i < s->quant_table_count; i++) {
784  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
785  sizeof(*s->rc_stat2[i]));
786  if (!s->rc_stat2[i])
787  return AVERROR(ENOMEM);
788  }
789  }
790  if (avctx->stats_in) {
791  char *p = avctx->stats_in;
792  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
793  int gob_count = 0;
794  char *next;
795  if (!best_state)
796  return AVERROR(ENOMEM);
797 
798  av_assert0(s->version >= 2);
799 
800  for (;;) {
801  for (j = 0; j < 256; j++)
802  for (i = 0; i < 2; i++) {
803  s->rc_stat[j][i] = strtol(p, &next, 0);
804  if (next == p) {
805  av_log(avctx, AV_LOG_ERROR,
806  "2Pass file invalid at %d %d [%s]\n", j, i, p);
807  av_freep(&best_state);
808  return AVERROR_INVALIDDATA;
809  }
810  p = next;
811  }
812  for (i = 0; i < s->quant_table_count; i++)
813  for (j = 0; j < s->context_count[i]; j++) {
814  for (k = 0; k < 32; k++)
815  for (m = 0; m < 2; m++) {
816  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
817  if (next == p) {
818  av_log(avctx, AV_LOG_ERROR,
819  "2Pass file invalid at %d %d %d %d [%s]\n",
820  i, j, k, m, p);
821  av_freep(&best_state);
822  return AVERROR_INVALIDDATA;
823  }
824  p = next;
825  }
826  }
827  gob_count = strtol(p, &next, 0);
828  if (next == p || gob_count <= 0) {
829  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
830  av_freep(&best_state);
831  return AVERROR_INVALIDDATA;
832  }
833  p = next;
834  while (*p == '\n' || *p == ' ')
835  p++;
836  if (p[0] == 0)
837  break;
838  }
839  if (s->ac == AC_RANGE_CUSTOM_TAB)
840  sort_stt(s, s->state_transition);
841 
842  find_best_state(best_state, s->state_transition);
843 
844  for (i = 0; i < s->quant_table_count; i++) {
845  for (k = 0; k < 32; k++) {
846  double a=0, b=0;
847  int jp = 0;
848  for (j = 0; j < s->context_count[i]; j++) {
849  double p = 128;
850  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
851  if (a+b)
852  p = 256.0 * b / (a + b);
853  s->initial_states[i][jp][k] =
854  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
855  for(jp++; jp<j; jp++)
856  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
857  a=b=0;
858  }
859  a += s->rc_stat2[i][j][k][0];
860  b += s->rc_stat2[i][j][k][1];
861  if (a+b) {
862  p = 256.0 * b / (a + b);
863  }
864  s->initial_states[i][j][k] =
865  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
866  }
867  }
868  }
869  av_freep(&best_state);
870  }
871 
872  if (s->version > 1) {
873  int plane_count = 1 + 2*s->chroma_planes + s->transparency;
874  int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
875  int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
876  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
877 
878  s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
879 
880  for (; s->num_v_slices < 32; s->num_v_slices++) {
881  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
882  int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
883  int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
884  if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
885  continue;
886  if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
887  continue;
888  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
889  goto slices_ok;
890  }
891  }
892  av_log(avctx, AV_LOG_ERROR,
893  "Unsupported number %d of slices requested, please specify a "
894  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
895  avctx->slices);
896  return AVERROR(ENOSYS);
897 slices_ok:
898  if ((ret = write_extradata(s)) < 0)
899  return ret;
900  }
901 
902  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
903  return ret;
904  s->slice_count = s->max_slice_count;
905  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
906  return ret;
907 
908 #define STATS_OUT_SIZE 1024 * 1024 * 6
909  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
910  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
911  if (!avctx->stats_out)
912  return AVERROR(ENOMEM);
913  for (i = 0; i < s->quant_table_count; i++)
914  for (j = 0; j < s->max_slice_count; j++) {
915  FFV1Context *sf = s->slice_context[j];
916  av_assert0(!sf->rc_stat2[i]);
917  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
918  sizeof(*sf->rc_stat2[i]));
919  if (!sf->rc_stat2[i])
920  return AVERROR(ENOMEM);
921  }
922  }
923 
924  return 0;
925 }
926 
927 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
928 {
929  RangeCoder *c = &fs->c;
930  uint8_t state[CONTEXT_SIZE];
931  int j;
932  memset(state, 128, sizeof(state));
933 
934  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
935  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
936  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
937  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
938  for (j=0; j<f->plane_count; j++) {
939  put_symbol(c, state, f->plane[j].quant_table_index, 0);
940  av_assert0(f->plane[j].quant_table_index == f->context_model);
941  }
942  if (!f->picture.f->interlaced_frame)
943  put_symbol(c, state, 3, 0);
944  else
945  put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
946  put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
947  put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
948  if (f->version > 3) {
949  put_rac(c, state, fs->slice_coding_mode == 1);
950  if (fs->slice_coding_mode == 1)
951  ff_ffv1_clear_slice_state(f, fs);
952  put_symbol(c, state, fs->slice_coding_mode, 0);
953  if (fs->slice_coding_mode != 1) {
954  put_symbol(c, state, fs->slice_rct_by_coef, 0);
955  put_symbol(c, state, fs->slice_rct_ry_coef, 0);
956  }
957  }
958 }
959 
960 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
961 {
962 #define NB_Y_COEFF 15
963  static const int rct_y_coeff[15][2] = {
964  {0, 0}, // 4G
965  {1, 1}, // R + 2G + B
966  {2, 2}, // 2R + 2B
967  {0, 2}, // 2G + 2B
968  {2, 0}, // 2R + 2G
969  {4, 0}, // 4R
970  {0, 4}, // 4B
971 
972  {0, 3}, // 1G + 3B
973  {3, 0}, // 3R + 1G
974  {3, 1}, // 3R + B
975  {1, 3}, // R + 3B
976  {1, 2}, // R + G + 2B
977  {2, 1}, // 2R + G + B
978  {0, 1}, // 3G + B
979  {1, 0}, // R + 3G
980  };
981 
982  int stat[NB_Y_COEFF] = {0};
983  int x, y, i, p, best;
984  int16_t *sample[3];
985  int lbd = fs->bits_per_raw_sample <= 8;
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] = fs->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 {
1001  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1002  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1003  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1004  }
1005 
1006  ar = r - lastr;
1007  ag = g - lastg;
1008  ab = b - lastb;
1009  if (x && y) {
1010  int bg = ag - sample[0][x];
1011  int bb = ab - sample[1][x];
1012  int br = ar - sample[2][x];
1013 
1014  br -= bg;
1015  bb -= bg;
1016 
1017  for (i = 0; i<NB_Y_COEFF; i++) {
1018  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1019  }
1020 
1021  }
1022  sample[0][x] = ag;
1023  sample[1][x] = ab;
1024  sample[2][x] = ar;
1025 
1026  lastr = r;
1027  lastg = g;
1028  lastb = b;
1029  }
1030  }
1031 
1032  best = 0;
1033  for (i=1; i<NB_Y_COEFF; i++) {
1034  if (stat[i] < stat[best])
1035  best = i;
1036  }
1037 
1038  fs->slice_rct_by_coef = rct_y_coeff[best][1];
1039  fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1040 }
1041 
1042 static int encode_slice(AVCodecContext *c, void *arg)
1043 {
1044  FFV1Context *fs = *(void **)arg;
1045  FFV1Context *f = fs->avctx->priv_data;
1046  int width = fs->slice_width;
1047  int height = fs->slice_height;
1048  int x = fs->slice_x;
1049  int y = fs->slice_y;
1050  const AVFrame *const p = f->picture.f;
1051  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1052  int ret;
1053  RangeCoder c_bak = fs->c;
1054  const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1055  p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1056  p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1057  p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1058 
1059  fs->slice_coding_mode = 0;
1060  if (f->version > 3) {
1061  choose_rct_params(fs, planes, p->linesize, width, height);
1062  } else {
1063  fs->slice_rct_by_coef = 1;
1064  fs->slice_rct_ry_coef = 1;
1065  }
1066 
1067 retry:
1068  if (f->key_frame)
1069  ff_ffv1_clear_slice_state(f, fs);
1070  if (f->version > 2) {
1071  encode_slice_header(f, fs);
1072  }
1073  if (fs->ac == AC_GOLOMB_RICE) {
1074  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1075  init_put_bits(&fs->pb,
1076  fs->c.bytestream_start + fs->ac_byte_count,
1077  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1078  }
1079 
1080  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1081  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1082  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1083  const int cx = x >> f->chroma_h_shift;
1084  const int cy = y >> f->chroma_v_shift;
1085 
1086  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1087 
1088  if (f->chroma_planes) {
1089  ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1090  ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1091  }
1092  if (fs->transparency)
1093  ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1094  } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1095  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1096  ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1097  } else if (f->use32bit) {
1098  ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1099  } else {
1100  ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1101  }
1102  emms_c();
1103 
1104  if (ret < 0) {
1105  av_assert0(fs->slice_coding_mode == 0);
1106  if (fs->version < 4 || !fs->ac) {
1107  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1108  return ret;
1109  }
1110  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1111  fs->slice_coding_mode = 1;
1112  fs->c = c_bak;
1113  goto retry;
1114  }
1115 
1116  return 0;
1117 }
1118 
1119 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1120  const AVFrame *pict, int *got_packet)
1121 {
1122  FFV1Context *f = avctx->priv_data;
1123  RangeCoder *const c = &f->slice_context[0]->c;
1124  AVFrame *const p = f->picture.f;
1125  uint8_t keystate = 128;
1126  uint8_t *buf_p;
1127  int i, ret;
1128  int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1129  + avctx->width*avctx->height*37LL*4;
1130 
1131  if(!pict) {
1132  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1133  int j, k, m;
1134  char *p = avctx->stats_out;
1135  char *end = p + STATS_OUT_SIZE;
1136 
1137  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1138  for (i = 0; i < f->quant_table_count; i++)
1139  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1140 
1141  av_assert0(f->slice_count == f->max_slice_count);
1142  for (j = 0; j < f->slice_count; j++) {
1143  FFV1Context *fs = f->slice_context[j];
1144  for (i = 0; i < 256; i++) {
1145  f->rc_stat[i][0] += fs->rc_stat[i][0];
1146  f->rc_stat[i][1] += fs->rc_stat[i][1];
1147  }
1148  for (i = 0; i < f->quant_table_count; i++) {
1149  for (k = 0; k < f->context_count[i]; k++)
1150  for (m = 0; m < 32; m++) {
1151  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1152  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1153  }
1154  }
1155  }
1156 
1157  for (j = 0; j < 256; j++) {
1158  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1159  f->rc_stat[j][0], f->rc_stat[j][1]);
1160  p += strlen(p);
1161  }
1162  snprintf(p, end - p, "\n");
1163 
1164  for (i = 0; i < f->quant_table_count; i++) {
1165  for (j = 0; j < f->context_count[i]; j++)
1166  for (m = 0; m < 32; m++) {
1167  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1168  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1169  p += strlen(p);
1170  }
1171  }
1172  snprintf(p, end - p, "%d\n", f->gob_count);
1173  }
1174  return 0;
1175  }
1176 
1177  if (f->version > 3)
1178  maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1179 
1180  if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1181  av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1182  maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1183  }
1184 
1185  if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1186  return ret;
1187 
1188  ff_init_range_encoder(c, pkt->data, pkt->size);
1189  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1190 
1191  av_frame_unref(p);
1192  if ((ret = av_frame_ref(p, pict)) < 0)
1193  return ret;
1194 #if FF_API_CODED_FRAME
1195 FF_DISABLE_DEPRECATION_WARNINGS
1196  avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1197 FF_ENABLE_DEPRECATION_WARNINGS
1198 #endif
1199 
1200  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1201  put_rac(c, &keystate, 1);
1202  f->key_frame = 1;
1203  f->gob_count++;
1204  write_header(f);
1205  } else {
1206  put_rac(c, &keystate, 0);
1207  f->key_frame = 0;
1208  }
1209 
1210  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1211  int i;
1212  for (i = 1; i < 256; i++) {
1213  c->one_state[i] = f->state_transition[i];
1214  c->zero_state[256 - i] = 256 - c->one_state[i];
1215  }
1216  }
1217 
1218  for (i = 0; i < f->slice_count; i++) {
1219  FFV1Context *fs = f->slice_context[i];
1220  uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1221  int len = pkt->size / f->slice_count;
1222  if (i) {
1223  ff_init_range_encoder(&fs->c, start, len);
1224  } else {
1225  av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1226  av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1227  fs->c.bytestream_end = fs->c.bytestream_start + len;
1228  }
1229  }
1230  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1231  f->slice_count, sizeof(void *));
1232 
1233  buf_p = pkt->data;
1234  for (i = 0; i < f->slice_count; i++) {
1235  FFV1Context *fs = f->slice_context[i];
1236  int bytes;
1237 
1238  if (fs->ac != AC_GOLOMB_RICE) {
1239  bytes = ff_rac_terminate(&fs->c, 1);
1240  } else {
1241  flush_put_bits(&fs->pb); // FIXME: nicer padding
1242  bytes = fs->ac_byte_count + put_bytes_output(&fs->pb);
1243  }
1244  if (i > 0 || f->version > 2) {
1245  av_assert0(bytes < pkt->size / f->slice_count);
1246  memmove(buf_p, fs->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 #if FF_API_CODED_FRAME
1265 FF_DISABLE_DEPRECATION_WARNINGS
1266  avctx->coded_frame->key_frame = f->key_frame;
1267 FF_ENABLE_DEPRECATION_WARNINGS
1268 #endif
1269 
1270  f->picture_number++;
1271  pkt->size = buf_p - pkt->data;
1272  pkt->pts =
1273  pkt->dts = pict->pts;
1274  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1275  *got_packet = 1;
1276 
1277  return 0;
1278 }
1279 
1280 static av_cold int encode_close(AVCodecContext *avctx)
1281 {
1282  ff_ffv1_close(avctx);
1283  return 0;
1284 }
1285 
1286 #define OFFSET(x) offsetof(FFV1Context, x)
1287 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1288 static const AVOption options[] = {
1289  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1290  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1291  { .i64 = 0 }, -2, 2, VE, "coder" },
1292  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1293  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1294  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1295  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1296  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1297  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1298  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1299  { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1300  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1301  { .i64 = 0 }, 0, 1, VE },
1302 
1303  { NULL }
1304 };
1305 
1306 static const AVClass ffv1_class = {
1307  .class_name = "ffv1 encoder",
1308  .item_name = av_default_item_name,
1309  .option = options,
1310  .version = LIBAVUTIL_VERSION_INT,
1311 };
1312 
1313 #if FF_API_CODER_TYPE
1314 static const AVCodecDefault ffv1_defaults[] = {
1315  { "coder", "-1" },
1316  { NULL },
1317 };
1318 #endif
1319 
1320 AVCodec ff_ffv1_encoder = {
1321  .name = "ffv1",
1322  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1323  .type = AVMEDIA_TYPE_VIDEO,
1324  .id = AV_CODEC_ID_FFV1,
1325  .priv_data_size = sizeof(FFV1Context),
1326  .init = encode_init,
1327  .encode2 = encode_frame,
1328  .close = encode_close,
1329  .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1330  .pix_fmts = (const enum AVPixelFormat[]) {
1331  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1332  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1333  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1334  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1335  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1336  AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1337  AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1338  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1339  AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1340  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1341  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1342  AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1343  AV_PIX_FMT_YA8,
1344  AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1345  AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1346  AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1347  AV_PIX_FMT_GRAY9,
1348  AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1349  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1350  AV_PIX_FMT_NONE
1351 
1352  },
1353 #if FF_API_CODER_TYPE
1354  .defaults = ffv1_defaults,
1355 #endif
1356  .priv_class = &ffv1_class,
1357  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1358 };
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: internal.h:49
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:150
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1606
NULL
#define NULL
Definition: coverity.c:32
ffv1_defaults
static const AVCodecDefault ffv1_defaults[]
Definition: ffv1enc.c:1314
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:442
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:401
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:434
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
h
h
Definition: vp9dsp_template.c:2038
AVOption
AVOption.
Definition: opt.h:248
encode_slice_header
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
Definition: ffv1enc.c:927
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:436
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:409
AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:143
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:419
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:437
desc
const char * desc
Definition: libsvtav1.c:79
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
imgutils.h
misc image utilities
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
ThreadFrame::f
AVFrame * f
Definition: thread.h:35
PlaneContext::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:68
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
FFV1Context::quant_table_count
int quant_table_count
Definition: ffv1.h:125
g
const char * g
Definition: vf_curves.c:117
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AV_OPT_TYPE_INT
Definition: opt.h:225
FFV1Context::slice_height
int slice_height
Definition: ffv1.h:133
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:389
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:53
FFV1Context::sample_buffer
int16_t * sample_buffer
Definition: ffv1.h:110
FFV1Context::version
int version
Definition: ffv1.h:86
FFV1Context::micro_version
int micro_version
Definition: ffv1.h:87
RangeCoder::zero_state
uint8_t zero_state[256]
Definition: rangecoder.h:40
rangecoder.h
Range coder.
RangeCoder::bytestream_end
uint8_t * bytestream_end
Definition: rangecoder.h:44
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVPacket::size
int size
Definition: packet.h:370
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
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:36
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:379
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:403
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:1565
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:184
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:237
ring_size
static int ring_size(RingBuffer *ring)
Definition: async.c:105
FFV1Context::rc_stat2
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:85
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1747
ffv1.h
FF Video Codec 1 (a lossless codec)
pkt
AVPacket * pkt
Definition: movenc.c:59
sample
#define sample
Definition: flacdsp_template.c:44
FFV1Context::height
int height
Definition: ffv1.h:88
AVCodec
AVCodec.
Definition: codec.h:197
planes
static const struct @322 planes[]
RangeCoder::one_state
uint8_t one_state[256]
Definition: rangecoder.h:41
attributes.h
Macro definitions for various function/variable attributes.
FFV1Context::slice_rct_by_coef
int slice_rct_by_coef
Definition: ffv1.h:138
log2
#define log2(x)
Definition: libm.h:404
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:380
FFV1Context::plane_count
int plane_count
Definition: ffv1.h:99
contains_non_128
static int contains_non_128(uint8_t(*initial_state)[CONTEXT_SIZE], int nb_contexts)
Definition: ffv1enc.c:334
write_quant_tables
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1enc.c:326
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:381
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:72
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:77
FFV1Context::picture
ThreadFrame picture
Definition: ffv1.h:95
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ff_alloc_packet2
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
AV_OPT_TYPE_CONST
Definition: opt.h:234
FFV1Context::rc_stat
uint64_t rc_stat[256][2]
Definition: ffv1.h:84
FFV1Context::pb
PutBitContext pb
Definition: ffv1.h:83
AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:88
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:179
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:232
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
opt.h
AVOptions.
VlcState::bias
int8_t bias
Definition: ffv1.h:63
f
#define f(width, name)
Definition: cbs_vp9.c:255
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
FFV1Context::c
RangeCoder c
Definition: ffv1.h:81
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:444
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:41
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:514
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:433
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:414
quant11
static const int8_t quant11[256]
Definition: ffv1enc.c:100
FFV1Context::slice_y
int slice_y
Definition: ffv1.h:135
FFV1Context::initial_states
uint8_t(*[MAX_QUANT_TABLES] initial_states)[32]
Definition: ffv1.h:107
crc.h
Public header for CRC hash function implementation.
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:201
height
#define height
av_clip
#define av_clip
Definition: common.h:122
AVPacket::data
uint8_t * data
Definition: packet.h:369
AVCodecContext::context_model
attribute_deprecated int context_model
Definition: avcodec.h:1461
VlcState::count
uint8_t count
Definition: ffv1.h:64
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
encode_slice
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:1042
choose_rct_params
static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
Definition: ffv1enc.c:960
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:412
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:465
size
ptrdiff_t size
Definition: opengl_enc.c:100
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1557
NB_Y_COEFF
#define NB_Y_COEFF
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:441
state
static struct @321 state
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:222
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
write_extradata
static int write_extradata(FFV1Context *f)
Definition: ffv1enc.c:393
FFV1Context::bits_per_raw_sample
int bits_per_raw_sample
Definition: ffv1.h:121
FFV1Context::slice_width
int slice_width
Definition: ffv1.h:132
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
U
#define U(x)
Definition: vp56_arith.h:37
src
#define src
Definition: vp8dsp.c:255
sort_stt
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:466
ver2_state
static const uint8_t ver2_state[256]
Definition: ffv1enc.c:119
AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
ff_ffv1_init_slices_state
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:105
FFV1Context::quant_tables
int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:104
AV_CRC_32_IEEE
Definition: crc.h:53
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:2601
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
quant_table
static const int16_t quant_table[64]
Definition: intrax8.c:522
r
const char * r
Definition: vf_curves.c:116
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
PlaneContext::context_count
int context_count
Definition: ffv1.h:70
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:443
arg
const char * arg
Definition: jacosubdec.c:66
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:420
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:385
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
quant5
static const int8_t quant5[256]
Definition: ffv1enc.c:62
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
bits
uint8_t bits
Definition: vp3data.h:141
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:158
MAX_SLICES
#define MAX_SLICES
Definition: dxva2_hevc.c:29
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:421
RangeCoder::bytestream
uint8_t * bytestream
Definition: rangecoder.h:43
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
FFV1Context::ac
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:100
FFV1Context::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:103
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:57
FFV1Context::run_index
int run_index
Definition: ffv1.h:108
VlcState
Definition: ffv1.h:60
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:397
av_flatten
#define av_flatten
Definition: attributes.h:94
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: ffv1enc.c:1119
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: ffv1enc.c:1280
FFV1Context::state_transition
uint8_t state_transition[256]
Definition: ffv1.h:106
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
b
#define b
Definition: input.c:41
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:418
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:383
FFV1Context::key_frame
int key_frame
Definition: ffv1.h:94
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
FFV1Context::num_h_slices
int num_h_slices
Definition: ffv1.h:131
width
#define width
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:709
w
uint8_t w
Definition: llviddspenc.c:39
FFV1Context::colorspace
int colorspace
Definition: ffv1.h:109
AV_OPT_TYPE_BOOL
Definition: opt.h:242
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:161
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
FFV1Context::slice_count
int slice_count
Definition: ffv1.h:128
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
ff_ffv1_encoder
AVCodec ff_ffv1_encoder
Definition: ffv1enc.c:1320
FFV1Context::max_slice_count
int max_slice_count
Definition: ffv1.h:129
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVCodecContext::level
int level
level
Definition: avcodec.h:1984
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:116
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:438
FFV1Context::ac_byte_count
int ac_byte_count
number of bytes used for AC coding
Definition: ffv1.h:101
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:93
VlcState::drift
int16_t drift
Definition: ffv1.h:61
FFV1Context::packed_at_lsb
int packed_at_lsb
Definition: ffv1.h:122
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:417
AVCodecContext::coder_type
attribute_deprecated int coder_type
Definition: avcodec.h:1455
VE
#define VE
Definition: ffv1enc.c:1287
options
static const AVOption options[]
Definition: ffv1enc.c:1288
if
if(ret)
Definition: filter_design.txt:179
pred
static const float pred[4]
Definition: siprdata.h:259
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:410
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:112
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:407
FFV1Context::context_count
int context_count[MAX_QUANT_TABLES]
Definition: ffv1.h:105
quant9_10bit
static const int8_t quant9_10bit[256]
Definition: ffv1enc.c:81
avcodec.h
Libavcodec external API header.
AC_RANGE_DEFAULT_TAB_FORCE
#define AC_RANGE_DEFAULT_TAB_FORCE
Definition: ffv1.h:58
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
STATS_OUT_SIZE
#define STATS_OUT_SIZE
AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
AVCodecContext
main external API structure.
Definition: avcodec.h:536
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:372
FFV1Context::intra
int intra
Definition: ffv1.h:116
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:406
find_best_state
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256])
Definition: ffv1enc.c:138
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:638
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
write_quant_table
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition: ffv1enc.c:311
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
ff_init_range_encoder
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:42
FFV1Context::use32bit
int use32bit
Definition: ffv1.h:113
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:55
put_vlc_symbol
static void put_vlc_symbol(PutBitContext *pb, VlcState *const state, int v, int bits)
Definition: ffv1enc.c:239
encode_plane
static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index, int pixel_stride)
Definition: ffv1enc.c:273
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: golomb.h:724
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:405
FFV1Context::picture_number
int picture_number
Definition: ffv1.h:93
VlcState::error_sum
uint16_t error_sum
Definition: ffv1.h:62
AC_RANGE_DEFAULT_TAB
#define AC_RANGE_DEFAULT_TAB
Definition: ffv1.h:56
ffv1_class
static const AVClass ffv1_class
Definition: ffv1enc.c:1306
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:396
snprintf
#define snprintf
Definition: snprintf.h:34
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:408
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
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:172
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:50
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
FFV1Context::gob_count
int gob_count
Definition: ffv1.h:124
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:69
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
OFFSET
#define OFFSET(x)
Definition: ffv1enc.c:1286
ff_rac_terminate
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
Definition: rangecoder.c:109
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:731
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
COST2
#define COST2(old, new)
AV_CODEC_ID_FFV1
Definition: codec_id.h:82
stride
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
FFV1Context::context_model
int context_model
Definition: ffv1.h:119
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
internal.h
common internal api header.
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:147
quant5_10bit
static const int8_t quant5_10bit[256]
Definition: ffv1enc.c:43
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:173
put_rac
#define put_rac(C, S, B)
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:435
AVCodecContext::coded_frame
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1764
AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:66
AVRational::den
int den
Denominator.
Definition: rational.h:60
FFV1Context::slice_coding_mode
int slice_coding_mode
Definition: ffv1.h:137
RangeCoder::bytestream_start
uint8_t * bytestream_start
Definition: rangecoder.h:42
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:300
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1187
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
FFV1Context::chroma_h_shift
int chroma_h_shift
Definition: ffv1.h:90
FFV1Context::plane
PlaneContext plane[MAX_PLANES]
Definition: ffv1.h:102
FFV1Context::transparency
int transparency
Definition: ffv1.h:91
av_clip_uint8
#define av_clip_uint8
Definition: common.h:128
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
FFV1Context::chroma_v_shift
int chroma_v_shift
Definition: ffv1.h:90
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:470
len
int len
Definition: vorbis_enc_data.h:452
FFV1Context::chroma_planes
int chroma_planes
Definition: ffv1.h:89
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
FFV1Context::slice_context
struct FFV1Context * slice_context[MAX_SLICES]
Definition: ffv1.h:127
ffv1enc_template.c
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:368
av_noinline
#define av_noinline
Definition: attributes.h:68
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_always_inline
#define av_always_inline
Definition: attributes.h:45
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:108
FFV1Context::ec
int ec
Definition: ffv1.h:115
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
FFV1Context::num_v_slices
int num_v_slices
Definition: ffv1.h:130
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:1824
golomb.h
exp golomb vlc stuff
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVPacket
This structure stores compressed data.
Definition: packet.h:346
FFV1Context::avctx
AVCodecContext * avctx
Definition: ffv1.h:80
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1601
print
static void print(AVTreeNode *t, int depth)
Definition: tree.c:44
FFV1Context::slice_x
int slice_x
Definition: ffv1.h:134
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:411
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
i
int i
Definition: input.c:407
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:41
FFV1Context::width
int width
Definition: ffv1.h:88
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:376
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
FFV1Context::slice_rct_ry_coef
int slice_rct_ry_coef
Definition: ffv1.h:139
put_bits.h
bitstream writer API
Generated on Fri Apr 16 2021 19:21:56 for FFmpeg by   doxygen 1.8.11