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