FFmpeg: libavcodec/ffv1enc.c Source File

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 
35 #include "avcodec.h"
36 #include "encode.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  if (s->bits_per_raw_sample <= 8) {
291  for (x = 0; x < w; x++)
292  sample[0][x] = src[x * pixel_stride + stride * y];
293  if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
294  return ret;
295  } else {
296  if (s->packed_at_lsb) {
297  for (x = 0; x < w; x++) {
298  sample[0][x] = ((uint16_t*)(src + stride*y))[x];
299  }
300  } else {
301  for (x = 0; x < w; x++) {
302  sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
303  }
304  }
305  if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
306  return ret;
307  }
308  }
309  return 0;
310 }
311 
312  static void write_quant_table(RangeCoder *c, int16_t *quant_table)
313 {
314  int last = 0;
315  int i;
316  uint8_t state[CONTEXT_SIZE];
317  memset(state, 128, sizeof(state));
318 
319  for (i = 1; i < 128; i++)
320  if (quant_table[i] != quant_table[i - 1]) {
321  put_symbol(c, state, i - last - 1, 0);
322  last = i;
323  }
324  put_symbol(c, state, i - last - 1, 0);
325 }
326 
327  static void write_quant_tables(RangeCoder *c,
328  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
329 {
330  int i;
331  for (i = 0; i < 5; i++)
332  write_quant_table(c, quant_table[i]);
333 }
334 
335  static int contains_non_128(uint8_t (*initial_state)[CONTEXT_SIZE],
336  int nb_contexts)
337 {
338  if (!initial_state)
339  return 0;
340  for (int i = 0; i < nb_contexts; i++)
341  for (int j = 0; j < CONTEXT_SIZE; j++)
342  if (initial_state[i][j] != 128)
343  return 1;
344  return 0;
345 }
346 
347  static void write_header(FFV1Context *f)
348 {
349  uint8_t state[CONTEXT_SIZE];
350  int i, j;
351  RangeCoder *const c = &f->slice_context[0]->c;
352 
353  memset(state, 128, sizeof(state));
354 
355  if (f->version < 2) {
356  put_symbol(c, state, f->version, 0);
357  put_symbol(c, state, f->ac, 0);
358  if (f->ac == AC_RANGE_CUSTOM_TAB) {
359  for (i = 1; i < 256; i++)
360  put_symbol(c, state,
361  f->state_transition[i] - c->one_state[i], 1);
362  }
363  put_symbol(c, state, f->colorspace, 0); //YUV cs type
364  if (f->version > 0)
365  put_symbol(c, state, f->bits_per_raw_sample, 0);
366  put_rac(c, state, f->chroma_planes);
367  put_symbol(c, state, f->chroma_h_shift, 0);
368  put_symbol(c, state, f->chroma_v_shift, 0);
369  put_rac(c, state, f->transparency);
370 
371  write_quant_tables(c, f->quant_table);
372  } else if (f->version < 3) {
373  put_symbol(c, state, f->slice_count, 0);
374  for (i = 0; i < f->slice_count; i++) {
375  FFV1Context *fs = f->slice_context[i];
376  put_symbol(c, state,
377  (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
378  put_symbol(c, state,
379  (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
380  put_symbol(c, state,
381  (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
382  0);
383  put_symbol(c, state,
384  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
385  0);
386  for (j = 0; j < f->plane_count; j++) {
387  put_symbol(c, state, f->plane[j].quant_table_index, 0);
388  av_assert0(f->plane[j].quant_table_index == f->context_model);
389  }
390  }
391  }
392 }
393 
394  static int write_extradata(FFV1Context *f)
395 {
396  RangeCoder *const c = &f->c;
397  uint8_t state[CONTEXT_SIZE];
398  int i, j, k;
399  uint8_t state2[32][CONTEXT_SIZE];
400  unsigned v;
401 
402  memset(state2, 128, sizeof(state2));
403  memset(state, 128, sizeof(state));
404 
405  f->avctx->extradata_size = 10000 + 4 +
406  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
407  f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
408  if (!f->avctx->extradata)
409  return AVERROR(ENOMEM);
410  ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
411  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
412 
413  put_symbol(c, state, f->version, 0);
414  if (f->version > 2) {
415  if (f->version == 3) {
416  f->micro_version = 4;
417  } else if (f->version == 4)
418  f->micro_version = 2;
419  put_symbol(c, state, f->micro_version, 0);
420  }
421 
422  put_symbol(c, state, f->ac, 0);
423  if (f->ac == AC_RANGE_CUSTOM_TAB)
424  for (i = 1; i < 256; i++)
425  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
426 
427  put_symbol(c, state, f->colorspace, 0); // YUV cs type
428  put_symbol(c, state, f->bits_per_raw_sample, 0);
429  put_rac(c, state, f->chroma_planes);
430  put_symbol(c, state, f->chroma_h_shift, 0);
431  put_symbol(c, state, f->chroma_v_shift, 0);
432  put_rac(c, state, f->transparency);
433  put_symbol(c, state, f->num_h_slices - 1, 0);
434  put_symbol(c, state, f->num_v_slices - 1, 0);
435 
436  put_symbol(c, state, f->quant_table_count, 0);
437  for (i = 0; i < f->quant_table_count; i++)
438  write_quant_tables(c, f->quant_tables[i]);
439 
440  for (i = 0; i < f->quant_table_count; i++) {
441  if (contains_non_128(f->initial_states[i], f->context_count[i])) {
442  put_rac(c, state, 1);
443  for (j = 0; j < f->context_count[i]; j++)
444  for (k = 0; k < CONTEXT_SIZE; k++) {
445  int pred = j ? f->initial_states[i][j - 1][k] : 128;
446  put_symbol(c, state2[k],
447  (int8_t)(f->initial_states[i][j][k] - pred), 1);
448  }
449  } else {
450  put_rac(c, state, 0);
451  }
452  }
453 
454  if (f->version > 2) {
455  put_symbol(c, state, f->ec, 0);
456  put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
457  }
458 
459  f->avctx->extradata_size = ff_rac_terminate(c, 0);
460  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
461  AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
462  f->avctx->extradata_size += 4;
463 
464  return 0;
465 }
466 
467  static int sort_stt(FFV1Context *s, uint8_t stt[256])
468 {
469  int i, i2, changed, print = 0;
470 
471  do {
472  changed = 0;
473  for (i = 12; i < 244; i++) {
474  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
475 
476 #define COST(old, new) \
477  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
478  s->rc_stat[old][1] * -log2((new) / 256.0)
479 
480 #define COST2(old, new) \
481  COST(old, new) + COST(256 - (old), 256 - (new))
482 
483  double size0 = COST2(i, i) + COST2(i2, i2);
484  double sizeX = COST2(i, i2) + COST2(i2, i);
485  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
486  int j;
487  FFSWAP(int, stt[i], stt[i2]);
488  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
489  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
490  if (i != 256 - i2) {
491  FFSWAP(int, stt[256 - i], stt[256 - i2]);
492  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
493  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
494  }
495  for (j = 1; j < 256; j++) {
496  if (stt[j] == i)
497  stt[j] = i2;
498  else if (stt[j] == i2)
499  stt[j] = i;
500  if (i != 256 - i2) {
501  if (stt[256 - j] == 256 - i)
502  stt[256 - j] = 256 - i2;
503  else if (stt[256 - j] == 256 - i2)
504  stt[256 - j] = 256 - i;
505  }
506  }
507  print = changed = 1;
508  }
509  }
510  }
511  } while (changed);
512  return print;
513 }
514 
515  static av_cold int encode_init(AVCodecContext *avctx)
516 {
517  FFV1Context *s = avctx->priv_data;
518  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
519  int i, j, k, m, ret;
520 
521  if ((ret = ff_ffv1_common_init(avctx)) < 0)
522  return ret;
523 
524  s->version = 0;
525 
526  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
527  avctx->slices > 1)
528  s->version = FFMAX(s->version, 2);
529 
530  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
531  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
532  s->version = FFMAX(s->version, 2);
533 
534  if (avctx->level <= 0 && s->version == 2) {
535  s->version = 3;
536  }
537  if (avctx->level >= 0 && avctx->level <= 4) {
538  if (avctx->level < s->version) {
539  av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
540  return AVERROR(EINVAL);
541  }
542  s->version = avctx->level;
543  }
544 
545  if (s->ec < 0) {
546  s->ec = (s->version >= 3);
547  }
548 
549  // CRC requires version 3+
550  if (s->ec)
551  s->version = FFMAX(s->version, 3);
552 
553  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
554  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
555  return AVERROR_INVALIDDATA;
556  }
557 
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 
701  if (s->ac == AC_RANGE_CUSTOM_TAB) {
702  for (i = 1; i < 256; i++)
703  s->state_transition[i] = ver2_state[i];
704  } else {
705  RangeCoder c;
706  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
707  for (i = 1; i < 256; i++)
708  s->state_transition[i] = c.one_state[i];
709  }
710 
711  for (i = 0; i < 256; i++) {
712  s->quant_table_count = 2;
713  if (s->bits_per_raw_sample <= 8) {
714  s->quant_tables[0][0][i]= quant11[i];
715  s->quant_tables[0][1][i]= 11*quant11[i];
716  s->quant_tables[0][2][i]= 11*11*quant11[i];
717  s->quant_tables[1][0][i]= quant11[i];
718  s->quant_tables[1][1][i]= 11*quant11[i];
719  s->quant_tables[1][2][i]= 11*11*quant5 [i];
720  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
721  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
722  } else {
723  s->quant_tables[0][0][i]= quant9_10bit[i];
724  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
725  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
726  s->quant_tables[1][0][i]= quant9_10bit[i];
727  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
728  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
729  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
730  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
731  }
732  }
733  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
734  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
735  memcpy(s->quant_table, s->quant_tables[s->context_model],
736  sizeof(s->quant_table));
737 
738  for (i = 0; i < s->plane_count; i++) {
739  PlaneContext *const p = &s->plane[i];
740 
741  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
742  p->quant_table_index = s->context_model;
743  p->context_count = s->context_count[p->quant_table_index];
744  }
745 
746  if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
747  return ret;
748 
749  if (!s->transparency)
750  s->plane_count = 2;
751  if (!s->chroma_planes && s->version > 3)
752  s->plane_count--;
753 
754  ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
755  if (ret)
756  return ret;
757 
758  s->picture_number = 0;
759 
760  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
761  for (i = 0; i < s->quant_table_count; i++) {
762  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
763  sizeof(*s->rc_stat2[i]));
764  if (!s->rc_stat2[i])
765  return AVERROR(ENOMEM);
766  }
767  }
768  if (avctx->stats_in) {
769  char *p = avctx->stats_in;
770  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
771  int gob_count = 0;
772  char *next;
773  if (!best_state)
774  return AVERROR(ENOMEM);
775 
776  av_assert0(s->version >= 2);
777 
778  for (;;) {
779  for (j = 0; j < 256; j++)
780  for (i = 0; i < 2; i++) {
781  s->rc_stat[j][i] = strtol(p, &next, 0);
782  if (next == p) {
783  av_log(avctx, AV_LOG_ERROR,
784  "2Pass file invalid at %d %d [%s]\n", j, i, p);
785  av_freep(&best_state);
786  return AVERROR_INVALIDDATA;
787  }
788  p = next;
789  }
790  for (i = 0; i < s->quant_table_count; i++)
791  for (j = 0; j < s->context_count[i]; j++) {
792  for (k = 0; k < 32; k++)
793  for (m = 0; m < 2; m++) {
794  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
795  if (next == p) {
796  av_log(avctx, AV_LOG_ERROR,
797  "2Pass file invalid at %d %d %d %d [%s]\n",
798  i, j, k, m, p);
799  av_freep(&best_state);
800  return AVERROR_INVALIDDATA;
801  }
802  p = next;
803  }
804  }
805  gob_count = strtol(p, &next, 0);
806  if (next == p || gob_count <= 0) {
807  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
808  av_freep(&best_state);
809  return AVERROR_INVALIDDATA;
810  }
811  p = next;
812  while (*p == '\n' || *p == ' ')
813  p++;
814  if (p[0] == 0)
815  break;
816  }
817  if (s->ac == AC_RANGE_CUSTOM_TAB)
818  sort_stt(s, s->state_transition);
819 
820  find_best_state(best_state, s->state_transition);
821 
822  for (i = 0; i < s->quant_table_count; i++) {
823  for (k = 0; k < 32; k++) {
824  double a=0, b=0;
825  int jp = 0;
826  for (j = 0; j < s->context_count[i]; j++) {
827  double p = 128;
828  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
829  if (a+b)
830  p = 256.0 * b / (a + b);
831  s->initial_states[i][jp][k] =
832  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
833  for(jp++; jp<j; jp++)
834  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
835  a=b=0;
836  }
837  a += s->rc_stat2[i][j][k][0];
838  b += s->rc_stat2[i][j][k][1];
839  if (a+b) {
840  p = 256.0 * b / (a + b);
841  }
842  s->initial_states[i][j][k] =
843  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
844  }
845  }
846  }
847  av_freep(&best_state);
848  }
849 
850  if (s->version > 1) {
851  int plane_count = 1 + 2*s->chroma_planes + s->transparency;
852  int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
853  int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
854  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
855 
856  s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
857 
858  for (; s->num_v_slices < 32; s->num_v_slices++) {
859  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
860  int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
861  int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
862  if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
863  continue;
864  if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
865  continue;
866  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
867  goto slices_ok;
868  }
869  }
870  av_log(avctx, AV_LOG_ERROR,
871  "Unsupported number %d of slices requested, please specify a "
872  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
873  avctx->slices);
874  return AVERROR(ENOSYS);
875 slices_ok:
876  if ((ret = write_extradata(s)) < 0)
877  return ret;
878  }
879 
880  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
881  return ret;
882  s->slice_count = s->max_slice_count;
883  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
884  return ret;
885 
886 #define STATS_OUT_SIZE 1024 * 1024 * 6
887  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
888  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
889  if (!avctx->stats_out)
890  return AVERROR(ENOMEM);
891  for (i = 0; i < s->quant_table_count; i++)
892  for (j = 0; j < s->max_slice_count; j++) {
893  FFV1Context *sf = s->slice_context[j];
894  av_assert0(!sf->rc_stat2[i]);
895  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
896  sizeof(*sf->rc_stat2[i]));
897  if (!sf->rc_stat2[i])
898  return AVERROR(ENOMEM);
899  }
900  }
901 
902  return 0;
903 }
904 
905  static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
906 {
907  RangeCoder *c = &fs->c;
908  uint8_t state[CONTEXT_SIZE];
909  int j;
910  memset(state, 128, sizeof(state));
911 
912  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
913  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
914  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
915  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
916  for (j=0; j<f->plane_count; j++) {
917  put_symbol(c, state, f->plane[j].quant_table_index, 0);
918  av_assert0(f->plane[j].quant_table_index == f->context_model);
919  }
920  if (!f->picture.f->interlaced_frame)
921  put_symbol(c, state, 3, 0);
922  else
923  put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
924  put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
925  put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
926  if (f->version > 3) {
927  put_rac(c, state, fs->slice_coding_mode == 1);
928  if (fs->slice_coding_mode == 1)
929  ff_ffv1_clear_slice_state(f, fs);
930  put_symbol(c, state, fs->slice_coding_mode, 0);
931  if (fs->slice_coding_mode != 1) {
932  put_symbol(c, state, fs->slice_rct_by_coef, 0);
933  put_symbol(c, state, fs->slice_rct_ry_coef, 0);
934  }
935  }
936 }
937 
938  static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
939 {
940 #define NB_Y_COEFF 15
941  static const int rct_y_coeff[15][2] = {
942  {0, 0}, // 4G
943  {1, 1}, // R + 2G + B
944  {2, 2}, // 2R + 2B
945  {0, 2}, // 2G + 2B
946  {2, 0}, // 2R + 2G
947  {4, 0}, // 4R
948  {0, 4}, // 4B
949 
950  {0, 3}, // 1G + 3B
951  {3, 0}, // 3R + 1G
952  {3, 1}, // 3R + B
953  {1, 3}, // R + 3B
954  {1, 2}, // R + G + 2B
955  {2, 1}, // 2R + G + B
956  {0, 1}, // 3G + B
957  {1, 0}, // R + 3G
958  };
959 
960  int stat[NB_Y_COEFF] = {0};
961  int x, y, i, p, best;
962  int16_t *sample[3];
963  int lbd = fs->bits_per_raw_sample <= 8;
964 
965  for (y = 0; y < h; y++) {
966  int lastr=0, lastg=0, lastb=0;
967  for (p = 0; p < 3; p++)
968  sample[p] = fs->sample_buffer + p*w;
969 
970  for (x = 0; x < w; x++) {
971  int b, g, r;
972  int ab, ag, ar;
973  if (lbd) {
974  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
975  b = v & 0xFF;
976  g = (v >> 8) & 0xFF;
977  r = (v >> 16) & 0xFF;
978  } else {
979  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
980  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
981  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
982  }
983 
984  ar = r - lastr;
985  ag = g - lastg;
986  ab = b - lastb;
987  if (x && y) {
988  int bg = ag - sample[0][x];
989  int bb = ab - sample[1][x];
990  int br = ar - sample[2][x];
991 
992  br -= bg;
993  bb -= bg;
994 
995  for (i = 0; i<NB_Y_COEFF; i++) {
996  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
997  }
998 
999  }
1000  sample[0][x] = ag;
1001  sample[1][x] = ab;
1002  sample[2][x] = ar;
1003 
1004  lastr = r;
1005  lastg = g;
1006  lastb = b;
1007  }
1008  }
1009 
1010  best = 0;
1011  for (i=1; i<NB_Y_COEFF; i++) {
1012  if (stat[i] < stat[best])
1013  best = i;
1014  }
1015 
1016  fs->slice_rct_by_coef = rct_y_coeff[best][1];
1017  fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1018 }
1019 
1020  static int encode_slice(AVCodecContext *c, void *arg)
1021 {
1022  FFV1Context *fs = *(void **)arg;
1023  FFV1Context *f = fs->avctx->priv_data;
1024  int width = fs->slice_width;
1025  int height = fs->slice_height;
1026  int x = fs->slice_x;
1027  int y = fs->slice_y;
1028  const AVFrame *const p = f->picture.f;
1029  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1030  int ret;
1031  RangeCoder c_bak = fs->c;
1032  const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1033  p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1034  p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1035  p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1036 
1037  fs->slice_coding_mode = 0;
1038  if (f->version > 3) {
1039  choose_rct_params(fs, planes, p->linesize, width, height);
1040  } else {
1041  fs->slice_rct_by_coef = 1;
1042  fs->slice_rct_ry_coef = 1;
1043  }
1044 
1045 retry:
1046  if (f->key_frame)
1047  ff_ffv1_clear_slice_state(f, fs);
1048  if (f->version > 2) {
1049  encode_slice_header(f, fs);
1050  }
1051  if (fs->ac == AC_GOLOMB_RICE) {
1052  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1053  init_put_bits(&fs->pb,
1054  fs->c.bytestream_start + fs->ac_byte_count,
1055  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1056  }
1057 
1058  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1059  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1060  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1061  const int cx = x >> f->chroma_h_shift;
1062  const int cy = y >> f->chroma_v_shift;
1063 
1064  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1065 
1066  if (f->chroma_planes) {
1067  ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1068  ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1069  }
1070  if (fs->transparency)
1071  ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1072  } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1073  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1074  ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1075  } else if (f->use32bit) {
1076  ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1077  } else {
1078  ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1079  }
1080  emms_c();
1081 
1082  if (ret < 0) {
1083  av_assert0(fs->slice_coding_mode == 0);
1084  if (fs->version < 4 || !fs->ac) {
1085  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1086  return ret;
1087  }
1088  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1089  fs->slice_coding_mode = 1;
1090  fs->c = c_bak;
1091  goto retry;
1092  }
1093 
1094  return 0;
1095 }
1096 
1097  static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1098  const AVFrame *pict, int *got_packet)
1099 {
1100  FFV1Context *f = avctx->priv_data;
1101  RangeCoder *const c = &f->slice_context[0]->c;
1102  AVFrame *const p = f->picture.f;
1103  uint8_t keystate = 128;
1104  uint8_t *buf_p;
1105  int i, ret;
1106  int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1107  + avctx->width*avctx->height*37LL*4;
1108 
1109  if(!pict) {
1110  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1111  int j, k, m;
1112  char *p = avctx->stats_out;
1113  char *end = p + STATS_OUT_SIZE;
1114 
1115  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1116  for (i = 0; i < f->quant_table_count; i++)
1117  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1118 
1119  av_assert0(f->slice_count == f->max_slice_count);
1120  for (j = 0; j < f->slice_count; j++) {
1121  FFV1Context *fs = f->slice_context[j];
1122  for (i = 0; i < 256; i++) {
1123  f->rc_stat[i][0] += fs->rc_stat[i][0];
1124  f->rc_stat[i][1] += fs->rc_stat[i][1];
1125  }
1126  for (i = 0; i < f->quant_table_count; i++) {
1127  for (k = 0; k < f->context_count[i]; k++)
1128  for (m = 0; m < 32; m++) {
1129  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1130  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1131  }
1132  }
1133  }
1134 
1135  for (j = 0; j < 256; j++) {
1136  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1137  f->rc_stat[j][0], f->rc_stat[j][1]);
1138  p += strlen(p);
1139  }
1140  snprintf(p, end - p, "\n");
1141 
1142  for (i = 0; i < f->quant_table_count; i++) {
1143  for (j = 0; j < f->context_count[i]; j++)
1144  for (m = 0; m < 32; m++) {
1145  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1146  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1147  p += strlen(p);
1148  }
1149  }
1150  snprintf(p, end - p, "%d\n", f->gob_count);
1151  }
1152  return 0;
1153  }
1154 
1155  if (f->version > 3)
1156  maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1157 
1158  if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1159  av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1160  maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1161  }
1162 
1163  if ((ret = ff_alloc_packet(avctx, pkt, maxsize)) < 0)
1164  return ret;
1165 
1166  ff_init_range_encoder(c, pkt->data, pkt->size);
1167  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1168 
1169  av_frame_unref(p);
1170  if ((ret = av_frame_ref(p, pict)) < 0)
1171  return ret;
1172 
1173  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1174  put_rac(c, &keystate, 1);
1175  f->key_frame = 1;
1176  f->gob_count++;
1177  write_header(f);
1178  } else {
1179  put_rac(c, &keystate, 0);
1180  f->key_frame = 0;
1181  }
1182 
1183  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1184  int i;
1185  for (i = 1; i < 256; i++) {
1186  c->one_state[i] = f->state_transition[i];
1187  c->zero_state[256 - i] = 256 - c->one_state[i];
1188  }
1189  }
1190 
1191  for (i = 0; i < f->slice_count; i++) {
1192  FFV1Context *fs = f->slice_context[i];
1193  uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1194  int len = pkt->size / f->slice_count;
1195  if (i) {
1196  ff_init_range_encoder(&fs->c, start, len);
1197  } else {
1198  av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1199  av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1200  fs->c.bytestream_end = fs->c.bytestream_start + len;
1201  }
1202  }
1203  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1204  f->slice_count, sizeof(void *));
1205 
1206  buf_p = pkt->data;
1207  for (i = 0; i < f->slice_count; i++) {
1208  FFV1Context *fs = f->slice_context[i];
1209  int bytes;
1210 
1211  if (fs->ac != AC_GOLOMB_RICE) {
1212  bytes = ff_rac_terminate(&fs->c, 1);
1213  } else {
1214  flush_put_bits(&fs->pb); // FIXME: nicer padding
1215  bytes = fs->ac_byte_count + put_bytes_output(&fs->pb);
1216  }
1217  if (i > 0 || f->version > 2) {
1218  av_assert0(bytes < pkt->size / f->slice_count);
1219  memmove(buf_p, fs->c.bytestream_start, bytes);
1220  av_assert0(bytes < (1 << 24));
1221  AV_WB24(buf_p + bytes, bytes);
1222  bytes += 3;
1223  }
1224  if (f->ec) {
1225  unsigned v;
1226  buf_p[bytes++] = 0;
1227  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1228  AV_WL32(buf_p + bytes, v);
1229  bytes += 4;
1230  }
1231  buf_p += bytes;
1232  }
1233 
1234  if (avctx->flags & AV_CODEC_FLAG_PASS1)
1235  avctx->stats_out[0] = '0円';
1236 
1237  f->picture_number++;
1238  pkt->size = buf_p - pkt->data;
1239  pkt->pts =
1240  pkt->dts = pict->pts;
1241  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1242  *got_packet = 1;
1243 
1244  return 0;
1245 }
1246 
1247  static av_cold int encode_close(AVCodecContext *avctx)
1248 {
1249  ff_ffv1_close(avctx);
1250  return 0;
1251 }
1252 
1253  #define OFFSET(x) offsetof(FFV1Context, x)
1254  #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1255  static const AVOption options[] = {
1256  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1257  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1258  { .i64 = 0 }, -2, 2, VE, "coder" },
1259  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1260  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1261  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1262  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1263  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1264  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1265  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1266  { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1267  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1268  { .i64 = 0 }, 0, 1, VE },
1269 
1270  { NULL }
1271 };
1272 
1273  static const AVClass ffv1_class = {
1274  .class_name = "ffv1 encoder",
1275  .item_name = av_default_item_name,
1276  .option = options,
1277  .version = LIBAVUTIL_VERSION_INT,
1278 };
1279 
1280  const AVCodec ff_ffv1_encoder = {
1281  .name = "ffv1",
1282  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1283  .type = AVMEDIA_TYPE_VIDEO,
1284  .id = AV_CODEC_ID_FFV1,
1285  .priv_data_size = sizeof(FFV1Context),
1286  .init = encode_init,
1287  .encode2 = encode_frame,
1288  .close = encode_close,
1289  .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1290  .pix_fmts = (const enum AVPixelFormat[]) {
1291  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1292  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1293  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1294  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1295  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1296  AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1297  AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1298  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1299  AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1300  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1301  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1302  AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1303  AV_PIX_FMT_YA8,
1304  AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1305  AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1306  AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1307  AV_PIX_FMT_GRAY9,
1308  AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1309  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1310  AV_PIX_FMT_NONE
1311 
1312  },
1313  .priv_class = &ffv1_class,
1314  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
1315 };
encode_slice_header
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
Definition: ffv1enc.c:905
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:447
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:426
AVCodec
AVCodec.
Definition: codec.h:202
stride
int stride
Definition: mace.c:144
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
av_clip
#define av_clip
Definition: common.h:96
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:160
r
const char * r
Definition: vf_curves.c:116
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:133
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:1285
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:88
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2660
FFV1Context::ec
int ec
Definition: ffv1.h:114
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:61
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:439
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:424
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:41
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:446
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
AC_RANGE_DEFAULT_TAB_FORCE
#define AC_RANGE_DEFAULT_TAB_FORCE
Definition: ffv1.h:57
AVPacket::data
uint8_t * data
Definition: packet.h:373
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:441
AVOption
AVOption.
Definition: opt.h:247
encode.h
b
#define b
Definition: input.c:40
rangecoder.h
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:40
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:404
write_quant_tables
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1enc.c:327
contains_non_128
static int contains_non_128(uint8_t(*initial_state)[CONTEXT_SIZE], int nb_contexts)
Definition: ffv1enc.c:335
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
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:56
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:442
ring_size
static int ring_size(RingBuffer *ring)
Definition: async.c:105
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:428
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:384
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:338
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
init
static int init
Definition: av_tx.c:47
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:105
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:438
quant11
static const int8_t quant11[256]
Definition: ffv1enc.c:101
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:515
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:422
ff_init_range_encoder
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:42
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:420
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:448
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:938
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:402
encode_slice
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:1020
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
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:2688
av_noinline
#define av_noinline
Definition: attributes.h:72
NB_Y_COEFF
#define NB_Y_COEFF
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:49
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:388
PlaneContext::context_count
int context_count
Definition: ffv1.h:69
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:173
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:407
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:416
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:424
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:1244
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:425
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:417
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
g
const char * g
Definition: vf_curves.c:117
bits
uint8_t bits
Definition: vp3data.h:141
AC_RANGE_DEFAULT_TAB
#define AC_RANGE_DEFAULT_TAB
Definition: ffv1.h:55
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:296
quant5
static const int8_t quant5[256]
Definition: ffv1enc.c:63
FFV1Context::rc_stat
uint64_t rc_stat[256][2]
Definition: ffv1.h:83
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1425
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:401
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:415
write_extradata
static int write_extradata(FFV1Context *f)
Definition: ffv1enc.c:394
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:149
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:185
FFV1Context::ac
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:99
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:98
f
#define f(width, name)
Definition: cbs_vp9.c:255
PutBitContext
Definition: put_bits.h:49
sort_stt
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:467
ver2_state
static const uint8_t ver2_state[256]
Definition: ffv1enc.c:120
arg
const char * arg
Definition: jacosubdec.c:67
planes
static const struct @321 planes[]
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:385
if
if(ret)
Definition: filter_design.txt:179
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: ffv1enc.c:1097
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: ffv1enc.c:1247
quant_table
static const int16_t quant_table[64]
Definition: intrax8.c:522
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:423
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:394
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:54
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:235
src
#define src
Definition: vp8dsp.c:255
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:406
mathops.h
PlaneContext
Definition: ffv1.h:66
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:405
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:419
AVCodecContext::level
int level
level
Definition: avcodec.h:1651
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:59
VE
#define VE
Definition: ffv1enc.c:1254
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
options
static const AVOption options[]
Definition: ffv1enc.c:1255
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:724
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1236
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:83
state
static struct @320 state
AVPacket::size
int size
Definition: packet.h:374
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:117
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:578
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:325
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
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:409
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:201
sample
#define sample
Definition: flacdsp_template.c:44
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:390
size
int size
Definition: twinvq_data.h:10344
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
STATS_OUT_SIZE
#define STATS_OUT_SIZE
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:411
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: packet.h:372
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:235
height
#define height
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:377
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:167
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:443
find_best_state
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256])
Definition: ffv1enc.c:139
attributes.h
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:68
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
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:123
ffv1_class
static const AVClass ffv1_class
Definition: ffv1enc.c:1273
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:50
av_flatten
#define av_flatten
Definition: attributes.h:96
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:421
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ffv1.h
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:435
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:263
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
len
int len
Definition: vorbis_enc_data.h:426
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition: crc.h:52
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
write_quant_table
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition: ffv1enc.c:312
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:403
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:52
log2
#define log2(x)
Definition: libm.h:404
avcodec.h
FFV1Context::avctx
AVCodecContext * avctx
Definition: ffv1.h:79
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
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:381
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:1280
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:440
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:408
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
put_rac
#define put_rac(C, S, B)
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:413
FFV1Context::rc_stat2
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:84
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:158
AVCodecContext
main external API structure.
Definition: avcodec.h:383
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:1491
FFV1Context::context_model
int context_model
Definition: ffv1.h:118
FFV1Context::pb
PutBitContext pb
Definition: ffv1.h:82
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
ff_ffv1_encoder
const AVCodec ff_ffv1_encoder
Definition: ffv1enc.c:1280
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
OFFSET
#define OFFSET(x)
Definition: ffv1enc.c:1253
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:82
COST2
#define COST2(old, new)
av_clip_uint8
#define av_clip_uint8
Definition: common.h:102
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
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
FFV1Context
Definition: ffv1.h:77
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:983
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
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:556
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:116
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:362
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:61
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:410
h
h
Definition: vp9dsp_template.c:2038
RangeCoder
Definition: mss3.c:61
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:414
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:347
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:386
PlaneContext::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:67
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
snprintf
#define snprintf
Definition: snprintf.h:34
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:34
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:166
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:412
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:231
Generated on Wed Aug 24 2022 21:37:33 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /