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 
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 
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 
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 
330 {
331  int i;
332  for (i = 0; i < 5; 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 
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 
396 {
397  f->combined_version = f->version << 16;
398  if (f->version > 2) {
399  if (f->version == 3) {
400  f->micro_version = 4;
401  } else if (f->version == 4) {
402  f->micro_version = 5;
403  } else
404  av_assert0(0);
405 
406  f->combined_version += f->micro_version;
407  } else
408  av_assert0(f->micro_version == 0);
409 }
410 
412 {
413  FFV1Context *f = avctx->priv_data;
414 
415  RangeCoder c;
416  uint8_t state[CONTEXT_SIZE];
417  int i, j, k;
418  uint8_t state2[32][CONTEXT_SIZE];
419  unsigned v;
420 
421  memset(state2, 128, sizeof(state2));
422  memset(state, 128, sizeof(state));
423 
424  f->avctx->extradata_size = 10000 + 4 +
425  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
426  f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
427  if (!f->avctx->extradata)
428  return AVERROR(ENOMEM);
429  ff_init_range_encoder(&c, f->avctx->extradata, f->avctx->extradata_size);
430  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
431 
432  put_symbol(&c, state, f->version, 0);
433  if (f->version > 2)
434  put_symbol(&c, state, f->micro_version, 0);
435 
436  put_symbol(&c, state, f->ac, 0);
437  if (f->ac == AC_RANGE_CUSTOM_TAB)
438  for (i = 1; i < 256; i++)
439  put_symbol(&c, state, f->state_transition[i] - c.one_state[i], 1);
440 
441  put_symbol(&c, state, f->colorspace, 0); // YUV cs type
442  put_symbol(&c, state, f->bits_per_raw_sample, 0);
443  put_rac(&c, state, f->chroma_planes);
444  put_symbol(&c, state, f->chroma_h_shift, 0);
445  put_symbol(&c, state, f->chroma_v_shift, 0);
446  put_rac(&c, state, f->transparency);
447  put_symbol(&c, state, f->num_h_slices - 1, 0);
448  put_symbol(&c, state, f->num_v_slices - 1, 0);
449 
450  put_symbol(&c, state, f->quant_table_count, 0);
451  for (i = 0; i < f->quant_table_count; i++)
452  write_quant_tables(&c, f->quant_tables[i]);
453 
454  for (i = 0; i < f->quant_table_count; i++) {
455  if (contains_non_128(f->initial_states[i], f->context_count[i])) {
456  put_rac(&c, state, 1);
457  for (j = 0; j < f->context_count[i]; j++)
458  for (k = 0; k < CONTEXT_SIZE; k++) {
459  int pred = j ? f->initial_states[i][j - 1][k] : 128;
460  put_symbol(&c, state2[k],
461  (int8_t)(f->initial_states[i][j][k] - pred), 1);
462  }
463  } else {
464  put_rac(&c, state, 0);
465  }
466  }
467 
468  if (f->version > 2) {
469  put_symbol(&c, state, f->ec, 0);
470  put_symbol(&c, state, f->intra = (f->avctx->gop_size < 2), 0);
471  }
472 
473  f->avctx->extradata_size = ff_rac_terminate(&c, 0);
474  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, f->avctx->extradata, f->avctx->extradata_size) ^ (f->crcref ? 0x8CD88196 : 0);
475  AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
476  f->avctx->extradata_size += 4;
477 
478  return 0;
479 }
480 
481 static int sort_stt(FFV1Context *s, uint8_t stt[256])
482 {
483  int i, i2, changed, print = 0;
484 
485  do {
486  changed = 0;
487  for (i = 12; i < 244; i++) {
488  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
489 
490 #define COST(old, new) \
491  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
492  s->rc_stat[old][1] * -log2((new) / 256.0)
493 
494 #define COST2(old, new) \
495  COST(old, new) + COST(256 - (old), 256 - (new))
496 
497  double size0 = COST2(i, i) + COST2(i2, i2);
498  double sizeX = COST2(i, i2) + COST2(i2, i);
499  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
500  int j;
501  FFSWAP(int, stt[i], stt[i2]);
502  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
503  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
504  if (i != 256 - i2) {
505  FFSWAP(int, stt[256 - i], stt[256 - i2]);
506  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
507  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
508  }
509  for (j = 1; j < 256; j++) {
510  if (stt[j] == i)
511  stt[j] = i2;
512  else if (stt[j] == i2)
513  stt[j] = i;
514  if (i != 256 - i2) {
515  if (stt[256 - j] == 256 - i)
516  stt[256 - j] = 256 - i2;
517  else if (stt[256 - j] == 256 - i2)
518  stt[256 - j] = 256 - i;
519  }
520  }
521  print = changed = 1;
522  }
523  }
524  }
525  } while (changed);
526  return print;
527 }
528 
529 
531 {
532  FFV1Context *s = avctx->priv_data;
533  int plane_count = 1 + 2*s->chroma_planes + s->transparency;
534  int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
535  int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
536  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
537  s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
538  for (; s->num_v_slices < 32; s->num_v_slices++) {
539  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
540  int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
541  int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
542  if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
543  continue;
544  if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
545  continue;
546  if (s->version < 4)
547  if ( ff_need_new_slices(avctx->width , s->num_h_slices, s->chroma_h_shift)
548  ||ff_need_new_slices(avctx->height, s->num_v_slices, s->chroma_v_shift))
549  continue;
550  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
551  return 0;
552  }
553  }
554  av_log(avctx, AV_LOG_ERROR,
555  "Unsupported number %d of slices requested, please specify a "
556  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
557  avctx->slices);
558  return AVERROR(ENOSYS);
559 }
560 
562 {
563  FFV1Context *s = avctx->priv_data;
564  int i, j, k, m, ret;
565 
566  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
567  avctx->slices > 1)
568  s->version = FFMAX(s->version, 2);
569 
570  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) && s->ac == AC_GOLOMB_RICE) {
571  av_log(avctx, AV_LOG_ERROR, "2 Pass mode is not possible with golomb coding\n");
572  return AVERROR(EINVAL);
573  }
574 
575  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
576  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
577  s->version = FFMAX(s->version, 2);
578 
579  if (avctx->level <= 0 && s->version == 2) {
580  s->version = 3;
581  }
582  if (avctx->level >= 0 && avctx->level <= 4) {
583  if (avctx->level < s->version) {
584  av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
585  return AVERROR(EINVAL);
586  }
587  s->version = avctx->level;
588  }
589 
590  if (s->ec < 0) {
591  if (s->version >= 4) {
592  s->ec = 2;
593  s->crcref = 0x7a8c4079;
594  } else if (s->version >= 3) {
595  s->ec = 1;
596  } else
597  s->ec = 0;
598  }
599 
600  // CRC requires version 3+
601  if (s->ec == 1)
602  s->version = FFMAX(s->version, 3);
603  if (s->ec == 2)
604  s->version = FFMAX(s->version, 4);
605 
606  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
607  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");
608  return AVERROR_INVALIDDATA;
609  }
610 
611  if (s->ac == AC_RANGE_CUSTOM_TAB) {
612  for (i = 1; i < 256; i++)
613  s->state_transition[i] = ver2_state[i];
614  } else {
615  RangeCoder c;
616  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
617  for (i = 1; i < 256; i++)
618  s->state_transition[i] = c.one_state[i];
619  }
620 
621  for (i = 0; i < 256; i++) {
622  s->quant_table_count = 2;
623  if ((s->qtable == -1 && s->bits_per_raw_sample <= 8) || s->qtable == 1) {
624  s->quant_tables[0][0][i]= quant11[i];
625  s->quant_tables[0][1][i]= 11*quant11[i];
626  s->quant_tables[0][2][i]= 11*11*quant11[i];
627  s->quant_tables[1][0][i]= quant11[i];
628  s->quant_tables[1][1][i]= 11*quant11[i];
629  s->quant_tables[1][2][i]= 11*11*quant5 [i];
630  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
631  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
632  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
633  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
634  } else {
635  s->quant_tables[0][0][i]= quant9_10bit[i];
636  s->quant_tables[0][1][i]= 9*quant9_10bit[i];
637  s->quant_tables[0][2][i]= 9*9*quant9_10bit[i];
638  s->quant_tables[1][0][i]= quant9_10bit[i];
639  s->quant_tables[1][1][i]= 9*quant9_10bit[i];
640  s->quant_tables[1][2][i]= 9*9*quant5_10bit[i];
641  s->quant_tables[1][3][i]= 5*9*9*quant5_10bit[i];
642  s->quant_tables[1][4][i]= 5*5*9*9*quant5_10bit[i];
643  s->context_count[0] = (9 * 9 * 9 + 1) / 2;
644  s->context_count[1] = (9 * 9 * 5 * 5 * 5 + 1) / 2;
645  }
646  }
647 
649  return ret;
650 
651  if (!s->transparency)
652  s->plane_count = 2;
653  if (!s->chroma_planes && s->version > 3)
654  s->plane_count--;
655 
656  s->picture_number = 0;
657 
658  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
659  for (i = 0; i < s->quant_table_count; i++) {
660  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
661  sizeof(*s->rc_stat2[i]));
662  if (!s->rc_stat2[i])
663  return AVERROR(ENOMEM);
664  }
665  }
666  if (avctx->stats_in) {
667  char *p = avctx->stats_in;
668  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
669  int gob_count = 0;
670  char *next;
671  if (!best_state)
672  return AVERROR(ENOMEM);
673 
674  av_assert0(s->version >= 2);
675 
676  for (;;) {
677  for (j = 0; j < 256; j++)
678  for (i = 0; i < 2; i++) {
679  s->rc_stat[j][i] = strtol(p, &next, 0);
680  if (next == p) {
681  av_log(avctx, AV_LOG_ERROR,
682  "2Pass file invalid at %d %d [%s]\n", j, i, p);
683  av_freep(&best_state);
684  return AVERROR_INVALIDDATA;
685  }
686  p = next;
687  }
688  for (i = 0; i < s->quant_table_count; i++)
689  for (j = 0; j < s->context_count[i]; j++) {
690  for (k = 0; k < 32; k++)
691  for (m = 0; m < 2; m++) {
692  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
693  if (next == p) {
694  av_log(avctx, AV_LOG_ERROR,
695  "2Pass file invalid at %d %d %d %d [%s]\n",
696  i, j, k, m, p);
697  av_freep(&best_state);
698  return AVERROR_INVALIDDATA;
699  }
700  p = next;
701  }
702  }
703  gob_count = strtol(p, &next, 0);
704  if (next == p || gob_count <= 0) {
705  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
706  av_freep(&best_state);
707  return AVERROR_INVALIDDATA;
708  }
709  p = next;
710  while (*p == '\n' || *p == ' ')
711  p++;
712  if (p[0] == 0)
713  break;
714  }
715  if (s->ac == AC_RANGE_CUSTOM_TAB)
716  sort_stt(s, s->state_transition);
717 
718  find_best_state(best_state, s->state_transition);
719 
720  for (i = 0; i < s->quant_table_count; i++) {
721  for (k = 0; k < 32; k++) {
722  double a=0, b=0;
723  int jp = 0;
724  for (j = 0; j < s->context_count[i]; j++) {
725  double p = 128;
726  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
727  if (a+b)
728  p = 256.0 * b / (a + b);
729  s->initial_states[i][jp][k] =
730  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
731  for(jp++; jp<j; jp++)
732  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
733  a=b=0;
734  }
735  a += s->rc_stat2[i][j][k][0];
736  b += s->rc_stat2[i][j][k][1];
737  if (a+b) {
738  p = 256.0 * b / (a + b);
739  }
740  s->initial_states[i][j][k] =
741  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
742  }
743  }
744  }
745  av_freep(&best_state);
746  }
747 
748  if (s->version <= 1) {
749  /* Disable slices when the version doesn't support them */
750  s->num_h_slices = 1;
751  s->num_v_slices = 1;
752  }
753 
755 
756  return 0;
757 }
758 
760  enum AVPixelFormat pix_fmt)
761 {
762  FFV1Context *s = avctx->priv_data;
764 
765  s->plane_count = 3;
766  switch(pix_fmt) {
767  case AV_PIX_FMT_GRAY9:
768  case AV_PIX_FMT_YUV444P9:
769  case AV_PIX_FMT_YUV422P9:
770  case AV_PIX_FMT_YUV420P9:
774  if (!avctx->bits_per_raw_sample)
775  s->bits_per_raw_sample = 9;
776  case AV_PIX_FMT_GRAY10:
784  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
785  s->bits_per_raw_sample = 10;
786  case AV_PIX_FMT_GRAY12:
793  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
794  s->bits_per_raw_sample = 12;
795  case AV_PIX_FMT_GRAY14:
799  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
800  s->bits_per_raw_sample = 14;
801  s->packed_at_lsb = 1;
802  case AV_PIX_FMT_GRAY16:
809  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
810  s->bits_per_raw_sample = 16;
811  } else if (!s->bits_per_raw_sample) {
812  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
813  }
814  if (s->bits_per_raw_sample <= 8) {
815  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
816  return AVERROR_INVALIDDATA;
817  }
818  s->version = FFMAX(s->version, 1);
819  case AV_PIX_FMT_GRAY8:
820  case AV_PIX_FMT_YA8:
821  case AV_PIX_FMT_YUV444P:
822  case AV_PIX_FMT_YUV440P:
823  case AV_PIX_FMT_YUV422P:
824  case AV_PIX_FMT_YUV420P:
825  case AV_PIX_FMT_YUV411P:
826  case AV_PIX_FMT_YUV410P:
827  case AV_PIX_FMT_YUVA444P:
828  case AV_PIX_FMT_YUVA422P:
829  case AV_PIX_FMT_YUVA420P:
830  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
831  s->colorspace = 0;
832  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
833  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
834  s->bits_per_raw_sample = 8;
835  else if (!s->bits_per_raw_sample)
836  s->bits_per_raw_sample = 8;
837  break;
838  case AV_PIX_FMT_RGB32:
839  s->colorspace = 1;
840  s->transparency = 1;
841  s->chroma_planes = 1;
842  s->bits_per_raw_sample = 8;
843  break;
844  case AV_PIX_FMT_RGBA64:
845  s->colorspace = 1;
846  s->transparency = 1;
847  s->chroma_planes = 1;
848  s->bits_per_raw_sample = 16;
849  s->use32bit = 1;
850  s->version = FFMAX(s->version, 1);
851  break;
852  case AV_PIX_FMT_RGB48:
853  s->colorspace = 1;
854  s->chroma_planes = 1;
855  s->bits_per_raw_sample = 16;
856  s->use32bit = 1;
857  s->version = FFMAX(s->version, 1);
858  break;
859  case AV_PIX_FMT_0RGB32:
860  s->colorspace = 1;
861  s->chroma_planes = 1;
862  s->bits_per_raw_sample = 8;
863  break;
864  case AV_PIX_FMT_GBRP9:
865  if (!avctx->bits_per_raw_sample)
866  s->bits_per_raw_sample = 9;
867  case AV_PIX_FMT_GBRP10:
868  case AV_PIX_FMT_GBRAP10:
869  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
870  s->bits_per_raw_sample = 10;
871  case AV_PIX_FMT_GBRP12:
872  case AV_PIX_FMT_GBRAP12:
873  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
874  s->bits_per_raw_sample = 12;
875  case AV_PIX_FMT_GBRP14:
876  case AV_PIX_FMT_GBRAP14:
877  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
878  s->bits_per_raw_sample = 14;
879  case AV_PIX_FMT_GBRP16:
880  case AV_PIX_FMT_GBRAP16:
881  case AV_PIX_FMT_GBRPF16:
882  case AV_PIX_FMT_GBRAPF16:
883  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
884  s->bits_per_raw_sample = 16;
885  else if (!s->bits_per_raw_sample)
886  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
887  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
888  s->colorspace = 1;
889  s->chroma_planes = 1;
890  if (s->bits_per_raw_sample >= 16) {
891  s->use32bit = 1;
892  }
893  s->flt = !!(desc->flags & AV_PIX_FMT_FLAG_FLOAT);
894  s->version = FFMAX(s->version, 1);
895 
896  if (s->flt)
897  s->version = FFMAX(s->version, 4);
898  break;
899  default:
900  av_log(avctx, AV_LOG_ERROR, "format %s not supported\n",
902  return AVERROR(ENOSYS);
903  }
904  av_assert0(s->bits_per_raw_sample >= 8);
905 
906  if (s->remap_mode < 0)
907  s->remap_mode = s->flt ? 2 : 0;
908 
909  return av_pix_fmt_get_chroma_sub_sample(pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
910 }
911 
913 {
914  int ret;
915  FFV1Context *s = avctx->priv_data;
916 
917  if ((ret = ff_ffv1_common_init(avctx, s)) < 0)
918  return ret;
919 
920  if (s->ac == 1) // Compatbility with common command line usage
921  s->ac = AC_RANGE_CUSTOM_TAB;
922  else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
923  s->ac = AC_RANGE_DEFAULT_TAB;
924 
926  if (ret < 0)
927  return ret;
928 
929  if (s->bits_per_raw_sample > (s->version > 3 ? 16 : 8)) {
930  if (s->ac == AC_GOLOMB_RICE) {
931  av_log(avctx, AV_LOG_INFO,
932  "high bits_per_raw_sample, forcing range coder\n");
933  s->ac = AC_RANGE_CUSTOM_TAB;
934  }
935  }
936 
937 
938  ret = ff_ffv1_encode_init(avctx);
939  if (ret < 0)
940  return ret;
941 
942  if (s->version > 1) {
943  if ((ret = ff_ffv1_encode_determine_slices(avctx)) < 0)
944  return ret;
945 
946  if ((ret = ff_ffv1_write_extradata(avctx)) < 0)
947  return ret;
948  }
949 
950  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
951  return ret;
952  s->slice_count = s->max_slice_count;
953 
954  for (int j = 0; j < s->slice_count; j++) {
955  for (int i = 0; i < s->plane_count; i++) {
956  PlaneContext *const p = &s->slices[j].plane[i];
957 
958  p->quant_table_index = s->context_model;
959  p->context_count = s->context_count[p->quant_table_index];
960  }
961 
962  ff_build_rac_states(&s->slices[j].c, 0.05 * (1LL << 32), 256 - 8);
963 
964  s->slices[j].remap = s->remap_mode;
965  }
966 
967  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
968  return ret;
969 
970 #define STATS_OUT_SIZE 1024 * 1024 * 6
971  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
973  if (!avctx->stats_out)
974  return AVERROR(ENOMEM);
975  for (int i = 0; i < s->quant_table_count; i++)
976  for (int j = 0; j < s->max_slice_count; j++) {
977  FFV1SliceContext *sc = &s->slices[j];
978  av_assert0(!sc->rc_stat2[i]);
979  sc->rc_stat2[i] = av_mallocz(s->context_count[i] *
980  sizeof(*sc->rc_stat2[i]));
981  if (!sc->rc_stat2[i])
982  return AVERROR(ENOMEM);
983  }
984  }
985 
986  return 0;
987 }
988 
990 {
991  RangeCoder *c = &sc->c;
992  uint8_t state[CONTEXT_SIZE];
993  int j;
994  memset(state, 128, sizeof(state));
995 
996  put_symbol(c, state, sc->sx, 0);
997  put_symbol(c, state, sc->sy, 0);
998  put_symbol(c, state, 0, 0);
999  put_symbol(c, state, 0, 0);
1000  for (j=0; j<f->plane_count; j++) {
1001  put_symbol(c, state, sc->plane[j].quant_table_index, 0);
1002  av_assert0(sc->plane[j].quant_table_index == f->context_model);
1003  }
1004  if (!(f->cur_enc_frame->flags & AV_FRAME_FLAG_INTERLACED))
1005  put_symbol(c, state, 3, 0);
1006  else
1007  put_symbol(c, state, 1 + !(f->cur_enc_frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST), 0);
1008  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.num, 0);
1009  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.den, 0);
1010  if (f->version > 3) {
1011  put_rac(c, state, sc->slice_coding_mode == 1);
1012  if (sc->slice_coding_mode == 1)
1014  put_symbol(c, state, sc->slice_coding_mode, 0);
1015  if (sc->slice_coding_mode != 1 && f->colorspace == 1) {
1016  put_symbol(c, state, sc->slice_rct_by_coef, 0);
1017  put_symbol(c, state, sc->slice_rct_ry_coef, 0);
1018  }
1019  put_symbol(c, state, sc->remap, 0);
1020  }
1021 }
1022 
1024  const uint8_t *src[3], const int stride[3], int w, int h)
1025 {
1026 #define NB_Y_COEFF 15
1027  static const int rct_y_coeff[15][2] = {
1028  {0, 0}, // 4G
1029  {1, 1}, // R + 2G + B
1030  {2, 2}, // 2R + 2B
1031  {0, 2}, // 2G + 2B
1032  {2, 0}, // 2R + 2G
1033  {4, 0}, // 4R
1034  {0, 4}, // 4B
1035 
1036  {0, 3}, // 1G + 3B
1037  {3, 0}, // 3R + 1G
1038  {3, 1}, // 3R + B
1039  {1, 3}, // R + 3B
1040  {1, 2}, // R + G + 2B
1041  {2, 1}, // 2R + G + B
1042  {0, 1}, // 3G + B
1043  {1, 0}, // R + 3G
1044  };
1045 
1046  int stat[NB_Y_COEFF] = {0};
1047  int x, y, i, p, best;
1048  int16_t *sample[3];
1049  int lbd = f->bits_per_raw_sample <= 8;
1050  int packed = !src[1];
1051  int transparency = f->transparency;
1052  int packed_size = (3 + transparency)*2;
1053 
1054  for (y = 0; y < h; y++) {
1055  int lastr=0, lastg=0, lastb=0;
1056  for (p = 0; p < 3; p++)
1057  sample[p] = sc->sample_buffer + p*w;
1058 
1059  for (x = 0; x < w; x++) {
1060  int b, g, r;
1061  int ab, ag, ar;
1062  if (lbd) {
1063  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1064  b = v & 0xFF;
1065  g = (v >> 8) & 0xFF;
1066  r = (v >> 16) & 0xFF;
1067  } else if (packed) {
1068  const uint16_t *p = ((const uint16_t*)(src[0] + x*packed_size + stride[0]*y));
1069  r = p[0];
1070  g = p[1];
1071  b = p[2];
1072  } else if (f->use32bit || transparency) {
1073  g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
1074  b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
1075  r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
1076  } else {
1077  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1078  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1079  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1080  }
1081 
1082  ar = r - lastr;
1083  ag = g - lastg;
1084  ab = b - lastb;
1085  if (x && y) {
1086  int bg = ag - sample[0][x];
1087  int bb = ab - sample[1][x];
1088  int br = ar - sample[2][x];
1089 
1090  br -= bg;
1091  bb -= bg;
1092 
1093  for (i = 0; i<NB_Y_COEFF; i++) {
1094  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1095  }
1096 
1097  }
1098  sample[0][x] = ag;
1099  sample[1][x] = ab;
1100  sample[2][x] = ar;
1101 
1102  lastr = r;
1103  lastg = g;
1104  lastb = b;
1105  }
1106  }
1107 
1108  best = 0;
1109  for (i=1; i<NB_Y_COEFF; i++) {
1110  if (stat[i] < stat[best])
1111  best = i;
1112  }
1113 
1114  sc->slice_rct_by_coef = rct_y_coeff[best][1];
1115  sc->slice_rct_ry_coef = rct_y_coeff[best][0];
1116 }
1117 
1119 {
1120  int transparency = f->transparency;
1121  int flip = sc->remap == 2 ? 0x7FFF : 0;
1122 
1123  for (int p= 0; p<3 + transparency; p++) {
1124  int j = 0;
1125  int lu = 0;
1126  uint8_t state[2][32];
1127  int run = 0;
1128  memset(state, 128, sizeof(state));
1129  for (int i= 0; i<65536; i++) {
1130  int ri = i ^ ((i&0x8000) ? 0 : flip);
1131  int u = sc->fltmap[p][ri];
1132  sc->fltmap[p][ri] = j;
1133  j+= u;
1134 
1135  if (lu == u) {
1136  run ++;
1137  } else {
1138  put_symbol_inline(&sc->c, state[lu], run, 0, NULL, NULL);
1139  if (run == 0)
1140  lu = u;
1141  run = 0;
1142  }
1143  }
1144  if (run)
1145  put_symbol(&sc->c, state[lu], run, 0);
1146  }
1147 }
1148 
1149 static int encode_slice(AVCodecContext *c, void *arg)
1150 {
1151  FFV1SliceContext *sc = arg;
1152  FFV1Context *f = c->priv_data;
1153  int width = sc->slice_width;
1154  int height = sc->slice_height;
1155  int x = sc->slice_x;
1156  int y = sc->slice_y;
1157  const AVFrame *const p = f->cur_enc_frame;
1158  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1159  int ret;
1160  RangeCoder c_bak = sc->c;
1161  const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1162  p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1163  p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1164  p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1165  int ac = f->ac;
1166 
1167  sc->slice_coding_mode = 0;
1168  if (f->version > 3 && f->colorspace == 1) {
1170  } else {
1171  sc->slice_rct_by_coef = 1;
1172  sc->slice_rct_ry_coef = 1;
1173  }
1174 
1175 retry:
1176  if (f->key_frame)
1178  if (f->version > 2) {
1179  encode_slice_header(f, sc);
1180  }
1181 
1182  if (sc->remap) {
1183  if (f->colorspace == 0) {
1184  av_assert0(0);
1185  } else if (f->use32bit) {
1186  load_rgb_frame32(f, sc, planes, width, height, p->linesize);
1187  } else
1188  load_rgb_frame (f, sc, planes, width, height, p->linesize);
1189 
1190  encode_remap(f, sc);
1191  }
1192 
1193  if (ac == AC_GOLOMB_RICE) {
1194  sc->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&sc->c, f->version > 2) : 0;
1195  init_put_bits(&sc->pb,
1196  sc->c.bytestream_start + sc->ac_byte_count,
1197  sc->c.bytestream_end - sc->c.bytestream_start - sc->ac_byte_count);
1198  }
1199 
1200  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1201  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1202  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1203  const int cx = x >> f->chroma_h_shift;
1204  const int cy = y >> f->chroma_v_shift;
1205 
1206  ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1, ac);
1207 
1208  if (f->chroma_planes) {
1209  ret |= encode_plane(f, sc, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1, ac);
1210  ret |= encode_plane(f, sc, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1, ac);
1211  }
1212  if (f->transparency)
1213  ret |= encode_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1, ac);
1214  } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1215  ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2, ac);
1216  ret |= encode_plane(f, sc, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2, ac);
1217  } else if (f->use32bit) {
1218  ret = encode_rgb_frame32(f, sc, planes, width, height, p->linesize, ac);
1219  } else {
1220  ret = encode_rgb_frame(f, sc, planes, width, height, p->linesize, ac);
1221  }
1222 
1223  if (ac != AC_GOLOMB_RICE) {
1224  sc->ac_byte_count = ff_rac_terminate(&sc->c, 1);
1225  } else {
1226  flush_put_bits(&sc->pb); // FIXME: nicer padding
1227  sc->ac_byte_count += put_bytes_output(&sc->pb);
1228  }
1229 
1230  if (ret < 0) {
1231  av_assert0(sc->slice_coding_mode == 0);
1232  if (f->version < 4) {
1233  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1234  return ret;
1235  }
1236  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1237  ac = 1;
1238  sc->slice_coding_mode = 1;
1239  sc->c = c_bak;
1240  goto retry;
1241  }
1242 
1243  return 0;
1244 }
1245 
1247 {
1248  FFV1Context *f = avctx->priv_data;
1249 
1250  size_t maxsize = avctx->width*avctx->height * (1 + f->transparency);
1251  if (f->chroma_planes)
1252  maxsize += AV_CEIL_RSHIFT(avctx->width, f->chroma_h_shift) * AV_CEIL_RSHIFT(f->height, f->chroma_v_shift) * 2;
1253  maxsize += f->slice_count * 800; //for slice header
1254  if (f->version > 3) {
1255  maxsize *= f->bits_per_raw_sample + 1;
1256  if (f->remap_mode)
1257  maxsize += f->slice_count * 70000 * (1 + 2*f->chroma_planes + f->transparency);
1258  } else {
1259  maxsize += f->slice_count * 2 * (avctx->width + avctx->height); //for bug with slices that code some pixels more than once
1260  maxsize *= 8*(2*f->bits_per_raw_sample + 5);
1261  }
1262  maxsize >>= 3;
1263  maxsize += FF_INPUT_BUFFER_MIN_SIZE;
1264 
1265  return maxsize;
1266 }
1267 
1269  const AVFrame *pict, int *got_packet)
1270 {
1271  FFV1Context *f = avctx->priv_data;
1272  RangeCoder *const c = &f->slices[0].c;
1273  uint8_t keystate = 128;
1274  uint8_t *buf_p;
1275  int i, ret;
1276  int64_t maxsize;
1277 
1278  if(!pict) {
1279  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1280  int j, k, m;
1281  char *p = avctx->stats_out;
1282  char *end = p + STATS_OUT_SIZE;
1283 
1284  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1285  for (i = 0; i < f->quant_table_count; i++)
1286  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1287 
1288  av_assert0(f->slice_count == f->max_slice_count);
1289  for (j = 0; j < f->slice_count; j++) {
1290  const FFV1SliceContext *sc = &f->slices[j];
1291  for (i = 0; i < 256; i++) {
1292  f->rc_stat[i][0] += sc->rc_stat[i][0];
1293  f->rc_stat[i][1] += sc->rc_stat[i][1];
1294  }
1295  for (i = 0; i < f->quant_table_count; i++) {
1296  for (k = 0; k < f->context_count[i]; k++)
1297  for (m = 0; m < 32; m++) {
1298  f->rc_stat2[i][k][m][0] += sc->rc_stat2[i][k][m][0];
1299  f->rc_stat2[i][k][m][1] += sc->rc_stat2[i][k][m][1];
1300  }
1301  }
1302  }
1303 
1304  for (j = 0; j < 256; j++) {
1305  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1306  f->rc_stat[j][0], f->rc_stat[j][1]);
1307  p += strlen(p);
1308  }
1309  snprintf(p, end - p, "\n");
1310 
1311  for (i = 0; i < f->quant_table_count; i++) {
1312  for (j = 0; j < f->context_count[i]; j++)
1313  for (m = 0; m < 32; m++) {
1314  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1315  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1316  p += strlen(p);
1317  }
1318  }
1319  snprintf(p, end - p, "%d\n", f->gob_count);
1320  }
1321  return 0;
1322  }
1323 
1324  /* Maximum packet size */
1325  maxsize = ff_ffv1_encode_buffer_size(avctx);
1326 
1327  if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1328  av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1329  maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1330  }
1331 
1332  if ((ret = ff_alloc_packet(avctx, pkt, maxsize)) < 0)
1333  return ret;
1334 
1336  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1337 
1338  f->cur_enc_frame = pict;
1339 
1340  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1341  put_rac(c, &keystate, 1);
1342  f->key_frame = 1;
1343  f->gob_count++;
1344  write_header(f);
1345  } else {
1346  put_rac(c, &keystate, 0);
1347  f->key_frame = 0;
1348  }
1349 
1350  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1351  int i;
1352  for (i = 1; i < 256; i++) {
1353  c->one_state[i] = f->state_transition[i];
1354  c->zero_state[256 - i] = 256 - c->one_state[i];
1355  }
1356  }
1357 
1358  for (i = 0; i < f->slice_count; i++) {
1359  FFV1SliceContext *sc = &f->slices[i];
1360  uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1361  int len = pkt->size / f->slice_count;
1362  if (i) {
1363  ff_init_range_encoder(&sc->c, start, len);
1364  } else {
1367  sc->c.bytestream_end = sc->c.bytestream_start + len;
1368  }
1369  }
1370  avctx->execute(avctx, encode_slice, f->slices, NULL,
1371  f->slice_count, sizeof(*f->slices));
1372 
1373  buf_p = pkt->data;
1374  for (i = 0; i < f->slice_count; i++) {
1375  FFV1SliceContext *sc = &f->slices[i];
1376  int bytes = sc->ac_byte_count;
1377  if (i > 0 || f->version > 2) {
1378  av_assert0(bytes < pkt->size / f->slice_count);
1379  memmove(buf_p, sc->c.bytestream_start, bytes);
1380  av_assert0(bytes < (1 << 24));
1381  AV_WB24(buf_p + bytes, bytes);
1382  bytes += 3;
1383  }
1384  if (f->ec) {
1385  unsigned v;
1386  buf_p[bytes++] = 0;
1387  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, buf_p, bytes) ^ (f->crcref ? 0x8CD88196 : 0);
1388  AV_WL32(buf_p + bytes, v);
1389  bytes += 4;
1390  }
1391  buf_p += bytes;
1392  }
1393 
1394  if (avctx->flags & AV_CODEC_FLAG_PASS1)
1395  avctx->stats_out[0] = '\0';
1396 
1397  f->picture_number++;
1398  pkt->size = buf_p - pkt->data;
1399  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1400  *got_packet = 1;
1401 
1402  return 0;
1403 }
1404 
1406 {
1407  FFV1Context *const s = avctx->priv_data;
1408 
1409  av_freep(&avctx->stats_out);
1410  ff_ffv1_close(s);
1411 
1412  return 0;
1413 }
1414 
1415 #define OFFSET(x) offsetof(FFV1Context, x)
1416 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1417 static const AVOption options[] = {
1418  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
1419  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1420  { .i64 = 0 }, -2, 2, VE, .unit = "coder" },
1421  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1422  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1423  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1424  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1425  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1426  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1427  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1428  { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1429  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1430  { .i64 = 0 }, 0, 1, VE },
1431  { "qtable", "Quantization table", OFFSET(qtable), AV_OPT_TYPE_INT,
1432  { .i64 = -1 }, -1, 2, VE , .unit = "qtable"},
1433  { "default", NULL, 0, AV_OPT_TYPE_CONST,
1434  { .i64 = QTABLE_DEFAULT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
1435  { "8bit", NULL, 0, AV_OPT_TYPE_CONST,
1436  { .i64 = QTABLE_8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
1437  { "greater8bit", NULL, 0, AV_OPT_TYPE_CONST,
1438  { .i64 = QTABLE_GT8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
1439  { "remap_mode", "Remap Mode", OFFSET(remap_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE, .unit = "remap_mode" },
1440  { "auto", "Automatic", 0, AV_OPT_TYPE_CONST,
1441  { .i64 = -1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
1442  { "off", "Disabled", 0, AV_OPT_TYPE_CONST,
1443  { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
1444  { "dualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
1445  { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
1446  { "flipdualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
1447  { .i64 = 2 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
1448 
1449 
1450  { NULL }
1451 };
1452 
1453 static const AVClass ffv1_class = {
1454  .class_name = "ffv1 encoder",
1455  .item_name = av_default_item_name,
1456  .option = options,
1457  .version = LIBAVUTIL_VERSION_INT,
1458 };
1459 
1461  .p.name = "ffv1",
1462  CODEC_LONG_NAME("FFmpeg video codec #1"),
1463  .p.type = AVMEDIA_TYPE_VIDEO,
1464  .p.id = AV_CODEC_ID_FFV1,
1465  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1468  .priv_data_size = sizeof(FFV1Context),
1471  .close = encode_close,
1472  CODEC_PIXFMTS(
1494  .color_ranges = AVCOL_RANGE_MPEG,
1495  .p.priv_class = &ffv1_class,
1497 };
load_rgb_frame
static void RENAME() load_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_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:575
set_micro_version
static void set_micro_version(FFV1Context *f)
Definition: ffv1enc.c:395
CODEC_PIXFMTS
#define CODEC_PIXFMTS(...)
Definition: codec_internal.h:386
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:548
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:530
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:209
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:42
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
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:251
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3313
FFV1SliceContext::plane
PlaneContext * plane
Definition: ffv1.h:90
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:89
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_FLAG_FLOAT
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition: pixdesc.h:158
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:567
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:574
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:569
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:525
ff_ffv1_write_extradata
av_cold int ff_ffv1_write_extradata(AVCodecContext *avctx)
Definition: ffv1enc.c:411
FFCodec
Definition: codec_internal.h:127
FFV1SliceContext::pb
PutBitContext pb
Definition: ffv1.h:91
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:570
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:504
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:566
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:543
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:541
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:576
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:523
encode_slice
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:1149
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:3341
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:508
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:353
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:528
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:537
FFV1SliceContext::sample_buffer
int16_t * sample_buffer
Definition: ffv1.h:74
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:545
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:547
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:546
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:538
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:573
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:522
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:536
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:106
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:507
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:198
ff_ffv1_encode_setup_plane_info
av_cold int ff_ffv1_encode_setup_plane_info(AVCodecContext *avctx, enum AVPixelFormat pix_fmt)
Definition: ffv1enc.c:759
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:326
sort_stt
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:481
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:505
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:1268
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: ffv1enc.c:1405
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:544
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:515
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
run
uint8_t run
Definition: svq3.c:204
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:527
options
Definition: swscale.c:42
PlaneContext
Definition: ffv1.h:64
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:526
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:540
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1802
AV_PIX_FMT_GBRPF16
#define AV_PIX_FMT_GBRPF16
Definition: pixfmt.h:555
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:1416
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:1417
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:1023
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:131
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:530
sample
#define sample
Definition: flacdsp_template.c:44
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:511
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:532
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:497
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:571
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:105
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:92
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:1453
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:542
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
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], int ac)
Definition: ffv1enc_template.c:164
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:729
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:524
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:1246
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:501
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:568
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
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:529
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:534
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_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:572
OFFSET
#define OFFSET(x)
Definition: ffv1enc.c:1415
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
FFV1SliceContext::remap
int remap
Definition: ffv1.h:87
AV_PIX_FMT_GBRAPF16
#define AV_PIX_FMT_GBRAPF16
Definition: pixfmt.h:556
FFV1SliceContext::fltmap
uint16_t fltmap[4][65536]
Definition: ffv1.h:109
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:561
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
encode_remap
static void encode_remap(FFV1Context *f, FFV1SliceContext *sc)
Definition: ffv1enc.c:1118
FFV1Context
Definition: ffv1.h:112
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:531
h
h
Definition: vp9dsp_template.c:2070
RangeCoder
Definition: mss3.c:63
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:535
ff_ffv1_encoder
const FFCodec ff_ffv1_encoder
Definition: ffv1enc.c:1460
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:506
encode_init_internal
static int encode_init_internal(AVCodecContext *avctx)
Definition: ffv1enc.c:912
FFV1SliceContext::ac_byte_count
int ac_byte_count
number of bytes used for AC coding
Definition: ffv1.h:94
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:533
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:3233
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:989