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