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