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