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