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