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