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 "codec_internal.h"
38 #include "put_bits.h"
39 #include "put_golomb.h"
40 #include "rangecoder.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  uint32_t l2tab[256];
144 
145  for (i = 1; i < 256; i++)
146  l2tab[i] = -log2(i / 256.0) * ((1U << 31) / 8);
147 
148  for (i = 0; i < 256; i++) {
149  uint64_t best_len[256];
150 
151  for (j = 0; j < 256; j++)
152  best_len[j] = UINT64_MAX;
153 
154  for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
155  uint32_t occ[256] = { 0 };
156  uint64_t len = 0;
157  occ[j] = UINT32_MAX;
158 
159  if (!one_state[j])
160  continue;
161 
162  for (k = 0; k < 256; k++) {
163  uint32_t newocc[256] = { 0 };
164  for (m = 1; m < 256; m++)
165  if (occ[m]) {
166  len += (occ[m]*(( i *(uint64_t)l2tab[ m]
167  + (256-i)*(uint64_t)l2tab[256-m])>>8)) >> 8;
168  }
169  if (len < best_len[k]) {
170  best_len[k] = len;
171  best_state[i][k] = j;
172  }
173  for (m = 1; m < 256; m++)
174  if (occ[m]) {
175  newocc[ one_state[ m]] += occ[m] * (uint64_t) i >> 8;
176  newocc[256 - one_state[256 - m]] += occ[m] * (uint64_t)(256 - i) >> 8;
177  }
178  memcpy(occ, newocc, sizeof(occ));
179  }
180  }
181  }
182 }
183 
184  static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
185  uint8_t *state, int v,
186  int is_signed,
187  uint64_t rc_stat[256][2],
188  uint64_t rc_stat2[32][2])
189 {
190  int i;
191 
192 #define put_rac(C, S, B) \
193  do { \
194  if (rc_stat) { \
195  rc_stat[*(S)][B]++; \
196  rc_stat2[(S) - state][B]++; \
197  } \
198  put_rac(C, S, B); \
199  } while (0)
200 
201  if (v) {
202  const int a = FFABS(v);
203  const int e = av_log2(a);
204  put_rac(c, state + 0, 0);
205  if (e <= 9) {
206  for (i = 0; i < e; i++)
207  put_rac(c, state + 1 + i, 1); // 1..10
208  put_rac(c, state + 1 + i, 0);
209 
210  for (i = e - 1; i >= 0; i--)
211  put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
212 
213  if (is_signed)
214  put_rac(c, state + 11 + e, v < 0); // 11..21
215  } else {
216  for (i = 0; i < e; i++)
217  put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
218  put_rac(c, state + 1 + 9, 0);
219 
220  for (i = e - 1; i >= 0; i--)
221  put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
222 
223  if (is_signed)
224  put_rac(c, state + 11 + 10, v < 0); // 11..21
225  }
226  } else {
227  put_rac(c, state + 0, 1);
228  }
229 #undef put_rac
230 }
231 
232  static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
233  int v, int is_signed)
234 {
235  put_symbol_inline(c, state, v, is_signed, NULL, NULL);
236 }
237 
238 
239  static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
240  int v, int bits)
241 {
242  int i, k, code;
243  v = fold(v - state->bias, bits);
244 
245  i = state->count;
246  k = 0;
247  while (i < state->error_sum) { // FIXME: optimize
248  k++;
249  i += i;
250  }
251 
252  av_assert2(k <= 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 
260  update_vlc_state(state, v);
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, const uint8_t *src, int w, int h,
274  int stride, int plane_index, int pixel_stride)
275 {
276  int x, y, i, ret;
277  const int 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;
315  uint8_t state[CONTEXT_SIZE];
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 
326  static void write_quant_tables(RangeCoder *c,
327  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
328 {
329  int i;
330  for (i = 0; i < 5; i++)
331  write_quant_table(c, quant_table[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 
346  static void write_header(FFV1Context *f)
347 {
348  uint8_t state[CONTEXT_SIZE];
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 
393  static int write_extradata(FFV1Context *f)
394 {
395  RangeCoder *const c = &f->c;
396  uint8_t state[CONTEXT_SIZE];
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 
514  static av_cold int encode_init(AVCodecContext *avctx)
515 {
516  FFV1Context *s = avctx->priv_data;
517  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
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  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
530  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
531  s->version = FFMAX(s->version, 2);
532 
533  if (avctx->level <= 0 && s->version == 2) {
534  s->version = 3;
535  }
536  if (avctx->level >= 0 && avctx->level <= 4) {
537  if (avctx->level < s->version) {
538  av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
539  return AVERROR(EINVAL);
540  }
541  s->version = avctx->level;
542  }
543 
544  if (s->ec < 0) {
545  s->ec = (s->version >= 3);
546  }
547 
548  // CRC requires version 3+
549  if (s->ec)
550  s->version = FFMAX(s->version, 3);
551 
552  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
553  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
554  return AVERROR_INVALIDDATA;
555  }
556 
557  if (s->ac == 1) // Compatbility with common command line usage
558  s->ac = AC_RANGE_CUSTOM_TAB;
559  else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
560  s->ac = AC_RANGE_DEFAULT_TAB;
561 
562  s->plane_count = 3;
563  switch(avctx->pix_fmt) {
564  case AV_PIX_FMT_GRAY9:
565  case AV_PIX_FMT_YUV444P9:
566  case AV_PIX_FMT_YUV422P9:
567  case AV_PIX_FMT_YUV420P9:
568  case AV_PIX_FMT_YUVA444P9:
569  case AV_PIX_FMT_YUVA422P9:
570  case AV_PIX_FMT_YUVA420P9:
571  if (!avctx->bits_per_raw_sample)
572  s->bits_per_raw_sample = 9;
573  case AV_PIX_FMT_GRAY10:
574  case AV_PIX_FMT_YUV444P10:
575  case AV_PIX_FMT_YUV440P10:
576  case AV_PIX_FMT_YUV420P10:
577  case AV_PIX_FMT_YUV422P10:
578  case AV_PIX_FMT_YUVA444P10:
579  case AV_PIX_FMT_YUVA422P10:
580  case AV_PIX_FMT_YUVA420P10:
581  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
582  s->bits_per_raw_sample = 10;
583  case AV_PIX_FMT_GRAY12:
584  case AV_PIX_FMT_YUV444P12:
585  case AV_PIX_FMT_YUV440P12:
586  case AV_PIX_FMT_YUV420P12:
587  case AV_PIX_FMT_YUV422P12:
588  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
589  s->bits_per_raw_sample = 12;
590  case AV_PIX_FMT_YUV444P14:
591  case AV_PIX_FMT_YUV420P14:
592  case AV_PIX_FMT_YUV422P14:
593  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
594  s->bits_per_raw_sample = 14;
595  s->packed_at_lsb = 1;
596  case AV_PIX_FMT_GRAY16:
597  case AV_PIX_FMT_YUV444P16:
598  case AV_PIX_FMT_YUV422P16:
599  case AV_PIX_FMT_YUV420P16:
600  case AV_PIX_FMT_YUVA444P16:
601  case AV_PIX_FMT_YUVA422P16:
602  case AV_PIX_FMT_YUVA420P16:
603  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
604  s->bits_per_raw_sample = 16;
605  } else if (!s->bits_per_raw_sample) {
606  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
607  }
608  if (s->bits_per_raw_sample <= 8) {
609  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
610  return AVERROR_INVALIDDATA;
611  }
612  s->version = FFMAX(s->version, 1);
613  case AV_PIX_FMT_GRAY8:
614  case AV_PIX_FMT_YA8:
615  case AV_PIX_FMT_YUV444P:
616  case AV_PIX_FMT_YUV440P:
617  case AV_PIX_FMT_YUV422P:
618  case AV_PIX_FMT_YUV420P:
619  case AV_PIX_FMT_YUV411P:
620  case AV_PIX_FMT_YUV410P:
621  case AV_PIX_FMT_YUVA444P:
622  case AV_PIX_FMT_YUVA422P:
623  case AV_PIX_FMT_YUVA420P:
624  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
625  s->colorspace = 0;
626  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
627  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
628  s->bits_per_raw_sample = 8;
629  else if (!s->bits_per_raw_sample)
630  s->bits_per_raw_sample = 8;
631  break;
632  case AV_PIX_FMT_RGB32:
633  s->colorspace = 1;
634  s->transparency = 1;
635  s->chroma_planes = 1;
636  s->bits_per_raw_sample = 8;
637  break;
638  case AV_PIX_FMT_RGBA64:
639  s->colorspace = 1;
640  s->transparency = 1;
641  s->chroma_planes = 1;
642  s->bits_per_raw_sample = 16;
643  s->use32bit = 1;
644  s->version = FFMAX(s->version, 1);
645  break;
646  case AV_PIX_FMT_RGB48:
647  s->colorspace = 1;
648  s->chroma_planes = 1;
649  s->bits_per_raw_sample = 16;
650  s->use32bit = 1;
651  s->version = FFMAX(s->version, 1);
652  break;
653  case AV_PIX_FMT_0RGB32:
654  s->colorspace = 1;
655  s->chroma_planes = 1;
656  s->bits_per_raw_sample = 8;
657  break;
658  case AV_PIX_FMT_GBRP9:
659  if (!avctx->bits_per_raw_sample)
660  s->bits_per_raw_sample = 9;
661  case AV_PIX_FMT_GBRP10:
662  case AV_PIX_FMT_GBRAP10:
663  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
664  s->bits_per_raw_sample = 10;
665  case AV_PIX_FMT_GBRP12:
666  case AV_PIX_FMT_GBRAP12:
667  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
668  s->bits_per_raw_sample = 12;
669  case AV_PIX_FMT_GBRP14:
670  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
671  s->bits_per_raw_sample = 14;
672  case AV_PIX_FMT_GBRP16:
673  case AV_PIX_FMT_GBRAP16:
674  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
675  s->bits_per_raw_sample = 16;
676  else if (!s->bits_per_raw_sample)
677  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
678  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
679  s->colorspace = 1;
680  s->chroma_planes = 1;
681  if (s->bits_per_raw_sample >= 16) {
682  s->use32bit = 1;
683  }
684  s->version = FFMAX(s->version, 1);
685  break;
686  default:
687  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
688  return AVERROR(ENOSYS);
689  }
690  av_assert0(s->bits_per_raw_sample >= 8);
691 
692  if (s->bits_per_raw_sample > 8) {
693  if (s->ac == AC_GOLOMB_RICE) {
694  av_log(avctx, AV_LOG_INFO,
695  "bits_per_raw_sample > 8, forcing range coder\n");
696  s->ac = AC_RANGE_CUSTOM_TAB;
697  }
698  }
699 
700  if (s->ac == AC_RANGE_CUSTOM_TAB) {
701  for (i = 1; i < 256; i++)
702  s->state_transition[i] = ver2_state[i];
703  } else {
704  RangeCoder c;
705  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
706  for (i = 1; i < 256; i++)
707  s->state_transition[i] = c.one_state[i];
708  }
709 
710  for (i = 0; i < 256; i++) {
711  s->quant_table_count = 2;
712  if (s->bits_per_raw_sample <= 8) {
713  s->quant_tables[0][0][i]= quant11[i];
714  s->quant_tables[0][1][i]= 11*quant11[i];
715  s->quant_tables[0][2][i]= 11*11*quant11[i];
716  s->quant_tables[1][0][i]= quant11[i];
717  s->quant_tables[1][1][i]= 11*quant11[i];
718  s->quant_tables[1][2][i]= 11*11*quant5 [i];
719  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
720  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
721  } else {
722  s->quant_tables[0][0][i]= quant9_10bit[i];
723  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
724  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
725  s->quant_tables[1][0][i]= quant9_10bit[i];
726  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
727  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
728  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
729  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
730  }
731  }
732  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
733  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
734  memcpy(s->quant_table, s->quant_tables[s->context_model],
735  sizeof(s->quant_table));
736 
737  for (i = 0; i < s->plane_count; i++) {
738  PlaneContext *const p = &s->plane[i];
739 
740  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
741  p->quant_table_index = s->context_model;
742  p->context_count = s->context_count[p->quant_table_index];
743  }
744 
745  if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
746  return ret;
747 
748  if (!s->transparency)
749  s->plane_count = 2;
750  if (!s->chroma_planes && s->version > 3)
751  s->plane_count--;
752 
753  ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
754  if (ret)
755  return ret;
756 
757  s->picture_number = 0;
758 
759  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
760  for (i = 0; i < s->quant_table_count; i++) {
761  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
762  sizeof(*s->rc_stat2[i]));
763  if (!s->rc_stat2[i])
764  return AVERROR(ENOMEM);
765  }
766  }
767  if (avctx->stats_in) {
768  char *p = avctx->stats_in;
769  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
770  int gob_count = 0;
771  char *next;
772  if (!best_state)
773  return AVERROR(ENOMEM);
774 
775  av_assert0(s->version >= 2);
776 
777  for (;;) {
778  for (j = 0; j < 256; j++)
779  for (i = 0; i < 2; i++) {
780  s->rc_stat[j][i] = strtol(p, &next, 0);
781  if (next == p) {
782  av_log(avctx, AV_LOG_ERROR,
783  "2Pass file invalid at %d %d [%s]\n", j, i, p);
784  av_freep(&best_state);
785  return AVERROR_INVALIDDATA;
786  }
787  p = next;
788  }
789  for (i = 0; i < s->quant_table_count; i++)
790  for (j = 0; j < s->context_count[i]; j++) {
791  for (k = 0; k < 32; k++)
792  for (m = 0; m < 2; m++) {
793  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
794  if (next == p) {
795  av_log(avctx, AV_LOG_ERROR,
796  "2Pass file invalid at %d %d %d %d [%s]\n",
797  i, j, k, m, p);
798  av_freep(&best_state);
799  return AVERROR_INVALIDDATA;
800  }
801  p = next;
802  }
803  }
804  gob_count = strtol(p, &next, 0);
805  if (next == p || gob_count <= 0) {
806  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
807  av_freep(&best_state);
808  return AVERROR_INVALIDDATA;
809  }
810  p = next;
811  while (*p == '\n' || *p == ' ')
812  p++;
813  if (p[0] == 0)
814  break;
815  }
816  if (s->ac == AC_RANGE_CUSTOM_TAB)
817  sort_stt(s, s->state_transition);
818 
819  find_best_state(best_state, s->state_transition);
820 
821  for (i = 0; i < s->quant_table_count; i++) {
822  for (k = 0; k < 32; k++) {
823  double a=0, b=0;
824  int jp = 0;
825  for (j = 0; j < s->context_count[i]; j++) {
826  double p = 128;
827  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
828  if (a+b)
829  p = 256.0 * b / (a + b);
830  s->initial_states[i][jp][k] =
831  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
832  for(jp++; jp<j; jp++)
833  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
834  a=b=0;
835  }
836  a += s->rc_stat2[i][j][k][0];
837  b += s->rc_stat2[i][j][k][1];
838  if (a+b) {
839  p = 256.0 * b / (a + b);
840  }
841  s->initial_states[i][j][k] =
842  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
843  }
844  }
845  }
846  av_freep(&best_state);
847  }
848 
849  if (s->version > 1) {
850  int plane_count = 1 + 2*s->chroma_planes + s->transparency;
851  int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
852  int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
853  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
854 
855  s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
856 
857  for (; s->num_v_slices < 32; s->num_v_slices++) {
858  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
859  int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
860  int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
861  if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
862  continue;
863  if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
864  continue;
865  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
866  goto slices_ok;
867  }
868  }
869  av_log(avctx, AV_LOG_ERROR,
870  "Unsupported number %d of slices requested, please specify a "
871  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
872  avctx->slices);
873  return AVERROR(ENOSYS);
874 slices_ok:
875  if ((ret = write_extradata(s)) < 0)
876  return ret;
877  }
878 
879  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
880  return ret;
881  s->slice_count = s->max_slice_count;
882  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
883  return ret;
884 
885 #define STATS_OUT_SIZE 1024 * 1024 * 6
886  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
887  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
888  if (!avctx->stats_out)
889  return AVERROR(ENOMEM);
890  for (i = 0; i < s->quant_table_count; i++)
891  for (j = 0; j < s->max_slice_count; j++) {
892  FFV1Context *sf = s->slice_context[j];
893  av_assert0(!sf->rc_stat2[i]);
894  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
895  sizeof(*sf->rc_stat2[i]));
896  if (!sf->rc_stat2[i])
897  return AVERROR(ENOMEM);
898  }
899  }
900 
901  return 0;
902 }
903 
904  static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
905 {
906  RangeCoder *c = &fs->c;
907  uint8_t state[CONTEXT_SIZE];
908  int j;
909  memset(state, 128, sizeof(state));
910 
911  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
912  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
913  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
914  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
915  for (j=0; j<f->plane_count; j++) {
916  put_symbol(c, state, f->plane[j].quant_table_index, 0);
917  av_assert0(f->plane[j].quant_table_index == f->context_model);
918  }
919  if (!f->cur_enc_frame->interlaced_frame)
920  put_symbol(c, state, 3, 0);
921  else
922  put_symbol(c, state, 1 + !f->cur_enc_frame->top_field_first, 0);
923  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.num, 0);
924  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.den, 0);
925  if (f->version > 3) {
926  put_rac(c, state, fs->slice_coding_mode == 1);
927  if (fs->slice_coding_mode == 1)
928  ff_ffv1_clear_slice_state(f, fs);
929  put_symbol(c, state, fs->slice_coding_mode, 0);
930  if (fs->slice_coding_mode != 1) {
931  put_symbol(c, state, fs->slice_rct_by_coef, 0);
932  put_symbol(c, state, fs->slice_rct_ry_coef, 0);
933  }
934  }
935 }
936 
937  static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
938 {
939 #define NB_Y_COEFF 15
940  static const int rct_y_coeff[15][2] = {
941  {0, 0}, // 4G
942  {1, 1}, // R + 2G + B
943  {2, 2}, // 2R + 2B
944  {0, 2}, // 2G + 2B
945  {2, 0}, // 2R + 2G
946  {4, 0}, // 4R
947  {0, 4}, // 4B
948 
949  {0, 3}, // 1G + 3B
950  {3, 0}, // 3R + 1G
951  {3, 1}, // 3R + B
952  {1, 3}, // R + 3B
953  {1, 2}, // R + G + 2B
954  {2, 1}, // 2R + G + B
955  {0, 1}, // 3G + B
956  {1, 0}, // R + 3G
957  };
958 
959  int stat[NB_Y_COEFF] = {0};
960  int x, y, i, p, best;
961  int16_t *sample[3];
962  int lbd = fs->bits_per_raw_sample <= 8;
963 
964  for (y = 0; y < h; y++) {
965  int lastr=0, lastg=0, lastb=0;
966  for (p = 0; p < 3; p++)
967  sample[p] = fs->sample_buffer + p*w;
968 
969  for (x = 0; x < w; x++) {
970  int b, g, r;
971  int ab, ag, ar;
972  if (lbd) {
973  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
974  b = v & 0xFF;
975  g = (v >> 8) & 0xFF;
976  r = (v >> 16) & 0xFF;
977  } else {
978  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
979  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
980  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
981  }
982 
983  ar = r - lastr;
984  ag = g - lastg;
985  ab = b - lastb;
986  if (x && y) {
987  int bg = ag - sample[0][x];
988  int bb = ab - sample[1][x];
989  int br = ar - sample[2][x];
990 
991  br -= bg;
992  bb -= bg;
993 
994  for (i = 0; i<NB_Y_COEFF; i++) {
995  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
996  }
997 
998  }
999  sample[0][x] = ag;
1000  sample[1][x] = ab;
1001  sample[2][x] = ar;
1002 
1003  lastr = r;
1004  lastg = g;
1005  lastb = b;
1006  }
1007  }
1008 
1009  best = 0;
1010  for (i=1; i<NB_Y_COEFF; i++) {
1011  if (stat[i] < stat[best])
1012  best = i;
1013  }
1014 
1015  fs->slice_rct_by_coef = rct_y_coeff[best][1];
1016  fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1017 }
1018 
1019  static int encode_slice(AVCodecContext *c, void *arg)
1020 {
1021  FFV1Context *fs = *(void **)arg;
1022  FFV1Context *f = fs->avctx->priv_data;
1023  int width = fs->slice_width;
1024  int height = fs->slice_height;
1025  int x = fs->slice_x;
1026  int y = fs->slice_y;
1027  const AVFrame *const p = f->cur_enc_frame;
1028  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1029  int ret;
1030  RangeCoder c_bak = fs->c;
1031  const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1032  p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1033  p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1034  p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1035 
1036  fs->slice_coding_mode = 0;
1037  if (f->version > 3) {
1038  choose_rct_params(fs, planes, p->linesize, width, height);
1039  } else {
1040  fs->slice_rct_by_coef = 1;
1041  fs->slice_rct_ry_coef = 1;
1042  }
1043 
1044 retry:
1045  if (f->key_frame)
1046  ff_ffv1_clear_slice_state(f, fs);
1047  if (f->version > 2) {
1048  encode_slice_header(f, fs);
1049  }
1050  if (fs->ac == AC_GOLOMB_RICE) {
1051  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1052  init_put_bits(&fs->pb,
1053  fs->c.bytestream_start + fs->ac_byte_count,
1054  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1055  }
1056 
1057  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1058  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1059  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1060  const int cx = x >> f->chroma_h_shift;
1061  const int cy = y >> f->chroma_v_shift;
1062 
1063  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1064 
1065  if (f->chroma_planes) {
1066  ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1067  ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1068  }
1069  if (fs->transparency)
1070  ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1071  } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1072  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1073  ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1074  } else if (f->use32bit) {
1075  ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1076  } else {
1077  ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1078  }
1079 
1080  if (ret < 0) {
1081  av_assert0(fs->slice_coding_mode == 0);
1082  if (fs->version < 4 || !fs->ac) {
1083  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1084  return ret;
1085  }
1086  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1087  fs->slice_coding_mode = 1;
1088  fs->c = c_bak;
1089  goto retry;
1090  }
1091 
1092  return 0;
1093 }
1094 
1095  static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1096  const AVFrame *pict, int *got_packet)
1097 {
1098  FFV1Context *f = avctx->priv_data;
1099  RangeCoder *const c = &f->slice_context[0]->c;
1100  uint8_t keystate = 128;
1101  uint8_t *buf_p;
1102  int i, ret;
1103  int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1104  + avctx->width*avctx->height*37LL*4;
1105 
1106  if(!pict) {
1107  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1108  int j, k, m;
1109  char *p = avctx->stats_out;
1110  char *end = p + STATS_OUT_SIZE;
1111 
1112  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1113  for (i = 0; i < f->quant_table_count; i++)
1114  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1115 
1116  av_assert0(f->slice_count == f->max_slice_count);
1117  for (j = 0; j < f->slice_count; j++) {
1118  FFV1Context *fs = f->slice_context[j];
1119  for (i = 0; i < 256; i++) {
1120  f->rc_stat[i][0] += fs->rc_stat[i][0];
1121  f->rc_stat[i][1] += fs->rc_stat[i][1];
1122  }
1123  for (i = 0; i < f->quant_table_count; i++) {
1124  for (k = 0; k < f->context_count[i]; k++)
1125  for (m = 0; m < 32; m++) {
1126  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1127  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1128  }
1129  }
1130  }
1131 
1132  for (j = 0; j < 256; j++) {
1133  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1134  f->rc_stat[j][0], f->rc_stat[j][1]);
1135  p += strlen(p);
1136  }
1137  snprintf(p, end - p, "\n");
1138 
1139  for (i = 0; i < f->quant_table_count; i++) {
1140  for (j = 0; j < f->context_count[i]; j++)
1141  for (m = 0; m < 32; m++) {
1142  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1143  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1144  p += strlen(p);
1145  }
1146  }
1147  snprintf(p, end - p, "%d\n", f->gob_count);
1148  }
1149  return 0;
1150  }
1151 
1152  if (f->version > 3)
1153  maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1154 
1155  if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1156  av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1157  maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1158  }
1159 
1160  if ((ret = ff_alloc_packet(avctx, pkt, maxsize)) < 0)
1161  return ret;
1162 
1163  ff_init_range_encoder(c, pkt->data, pkt->size);
1164  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1165 
1166  f->cur_enc_frame = pict;
1167 
1168  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1169  put_rac(c, &keystate, 1);
1170  f->key_frame = 1;
1171  f->gob_count++;
1172  write_header(f);
1173  } else {
1174  put_rac(c, &keystate, 0);
1175  f->key_frame = 0;
1176  }
1177 
1178  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1179  int i;
1180  for (i = 1; i < 256; i++) {
1181  c->one_state[i] = f->state_transition[i];
1182  c->zero_state[256 - i] = 256 - c->one_state[i];
1183  }
1184  }
1185 
1186  for (i = 0; i < f->slice_count; i++) {
1187  FFV1Context *fs = f->slice_context[i];
1188  uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1189  int len = pkt->size / f->slice_count;
1190  if (i) {
1191  ff_init_range_encoder(&fs->c, start, len);
1192  } else {
1193  av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1194  av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1195  fs->c.bytestream_end = fs->c.bytestream_start + len;
1196  }
1197  }
1198  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1199  f->slice_count, sizeof(void *));
1200 
1201  buf_p = pkt->data;
1202  for (i = 0; i < f->slice_count; i++) {
1203  FFV1Context *fs = f->slice_context[i];
1204  int bytes;
1205 
1206  if (fs->ac != AC_GOLOMB_RICE) {
1207  bytes = ff_rac_terminate(&fs->c, 1);
1208  } else {
1209  flush_put_bits(&fs->pb); // FIXME: nicer padding
1210  bytes = fs->ac_byte_count + put_bytes_output(&fs->pb);
1211  }
1212  if (i > 0 || f->version > 2) {
1213  av_assert0(bytes < pkt->size / f->slice_count);
1214  memmove(buf_p, fs->c.bytestream_start, bytes);
1215  av_assert0(bytes < (1 << 24));
1216  AV_WB24(buf_p + bytes, bytes);
1217  bytes += 3;
1218  }
1219  if (f->ec) {
1220  unsigned v;
1221  buf_p[bytes++] = 0;
1222  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1223  AV_WL32(buf_p + bytes, v);
1224  bytes += 4;
1225  }
1226  buf_p += bytes;
1227  }
1228 
1229  if (avctx->flags & AV_CODEC_FLAG_PASS1)
1230  avctx->stats_out[0] = '0円';
1231 
1232  f->picture_number++;
1233  pkt->size = buf_p - pkt->data;
1234  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1235  *got_packet = 1;
1236 
1237  return 0;
1238 }
1239 
1240  #define OFFSET(x) offsetof(FFV1Context, x)
1241  #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1242  static const AVOption options[] = {
1243  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1244  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1245  { .i64 = 0 }, -2, 2, VE, "coder" },
1246  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1247  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1248  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1249  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1250  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1251  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1252  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1253  { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1254  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1255  { .i64 = 0 }, 0, 1, VE },
1256 
1257  { NULL }
1258 };
1259 
1260  static const AVClass ffv1_class = {
1261  .class_name = "ffv1 encoder",
1262  .item_name = av_default_item_name,
1263  .option = options,
1264  .version = LIBAVUTIL_VERSION_INT,
1265 };
1266 
1267  const FFCodec ff_ffv1_encoder = {
1268  .p.name = "ffv1",
1269  CODEC_LONG_NAME("FFmpeg video codec #1"),
1270  .p.type = AVMEDIA_TYPE_VIDEO,
1271  .p.id = AV_CODEC_ID_FFV1,
1272  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1273  AV_CODEC_CAP_SLICE_THREADS |
1274  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1275  .priv_data_size = sizeof(FFV1Context),
1276  .init = encode_init,
1277  FF_CODEC_ENCODE_CB(encode_frame),
1278  .close = ff_ffv1_close,
1279  .p.pix_fmts = (const enum AVPixelFormat[]) {
1280  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1281  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1282  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1283  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1284  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1285  AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1286  AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1287  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1288  AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1289  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1290  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1291  AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1292  AV_PIX_FMT_YA8,
1293  AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1294  AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1295  AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1296  AV_PIX_FMT_GRAY9,
1297  AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1298  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1299  AV_PIX_FMT_NONE
1300 
1301  },
1302  .p.priv_class = &ffv1_class,
1303  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
1304 };
encode_slice_header
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
Definition: ffv1enc.c:904
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:502
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:481
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
planes
static const struct @346 planes[]
av_clip
#define av_clip
Definition: common.h:95
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:157
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
r
const char * r
Definition: vf_curves.c:126
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
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2888
FFV1Context::ec
int ec
Definition: ffv1.h:111
FF_CODEC_CAP_EOF_FLUSH
#define FF_CODEC_CAP_EOF_FLUSH
The encoder has AV_CODEC_CAP_DELAY set, but does not actually have delay - it only wants to be flushe...
Definition: codec_internal.h:90
put_symbol_inline
static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2])
Definition: ffv1enc.c:184
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
encode_plane
static int encode_plane(FFV1Context *s, const uint8_t *src, int w, int h, int stride, int plane_index, int pixel_stride)
Definition: ffv1enc.c:273
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:494
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
pixdesc.h
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:36
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:501
w
uint8_t w
Definition: llviddspenc.c:38
AC_RANGE_DEFAULT_TAB_FORCE
#define AC_RANGE_DEFAULT_TAB_FORCE
Definition: ffv1.h:53
AVPacket::data
uint8_t * data
Definition: packet.h:374
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:496
AVOption
AVOption.
Definition: opt.h:251
encode.h
b
#define b
Definition: input.c:41
rangecoder.h
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:40
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:459
FFCodec
Definition: codec_internal.h:127
write_quant_tables
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1enc.c:326
contains_non_128
static int contains_non_128(uint8_t(*initial_state)[CONTEXT_SIZE], int nb_contexts)
Definition: ffv1enc.c:334
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
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:52
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:497
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:429
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:232
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:439
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:351
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
crc.h
ff_ffv1_init_slices_state
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:95
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:493
quant11
static const int8_t quant11[256]
Definition: ffv1enc.c:101
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:514
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:477
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:475
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:503
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:937
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:457
encode_slice
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:1019
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:506
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:2916
av_noinline
#define av_noinline
Definition: attributes.h:72
NB_Y_COEFF
#define NB_Y_COEFF
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:45
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:443
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:315
PlaneContext::context_count
int context_count
Definition: ffv1.h:65
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:163
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:462
avassert.h
put_golomb.h
exp golomb vlc writing stuff
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:471
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:479
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:256
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:1304
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:480
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:472
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
g
const char * g
Definition: vf_curves.c:127
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:156
bits
uint8_t bits
Definition: vp3data.h:128
AC_RANGE_DEFAULT_TAB
#define AC_RANGE_DEFAULT_TAB
Definition: ffv1.h:51
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
quant5
static const int8_t quant5[256]
Definition: ffv1enc.c:63
FFV1Context::rc_stat
uint64_t rc_stat[256][2]
Definition: ffv1.h:79
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1487
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:456
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:470
write_extradata
static int write_extradata(FFV1Context *f)
Definition: ffv1enc.c:393
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:146
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:191
FFV1Context::ac
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:96
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:95
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
sort_stt
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:466
ver2_state
static const uint8_t ver2_state[256]
Definition: ffv1enc.c:120
arg
const char * arg
Definition: jacosubdec.c:67
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:440
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:1095
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:478
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:449
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:50
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:258
ff_rac_terminate
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
Definition: rangecoder.c:109
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:461
mathops.h
PlaneContext
Definition: ffv1.h:62
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:460
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:474
AVCodecContext::level
int level
level
Definition: avcodec.h:1691
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
VlcState
Definition: ffv1.h:55
VE
#define VE
Definition: ffv1enc.c:1241
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
options
static const AVOption options[]
Definition: ffv1enc.c:1242
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1296
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:85
f
f
Definition: af_crystalizer.c:122
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:620
codec_internal.h
quant9_10bit
static const int8_t quant9_10bit[256]
Definition: ffv1enc.c:82
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
print
static void print(AVTreeNode *t, int depth)
Definition: tree.c:44
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:464
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:191
sample
#define sample
Definition: flacdsp_template.c:44
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:445
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:466
encode_line
static av_always_inline int RENAME() encode_line(FFV1Context *s, int w, TYPE *sample[3], int plane_index, int bits)
Definition: ffv1enc_template.c:25
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:293
height
#define height
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:432
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:111
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:498
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:380
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:64
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:239
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:120
ffv1_class
static const AVClass ffv1_class
Definition: ffv1enc.c:1260
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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
av_flatten
#define av_flatten
Definition: attributes.h:96
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:476
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ffv1.h
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:191
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:598
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:635
write_quant_table
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition: ffv1enc.c:311
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:458
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:48
log2
#define log2(x)
Definition: libm.h:404
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
FFV1Context::avctx
AVCodecContext * avctx
Definition: ffv1.h:75
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:436
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:1341
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:495
set_sr_golomb
static void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len)
write signed golomb rice code (ffv1).
Definition: put_golomb.h:143
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:463
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
put_rac
#define put_rac(C, S, B)
U
#define U(x)
Definition: vpx_arith.h:37
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:468
FFV1Context::rc_stat2
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:80
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:148
AVCodecContext
main external API structure.
Definition: avcodec.h:426
MAX_SLICES
#define MAX_SLICES
Definition: dxva2_hevc.c:31
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:1532
FFV1Context::context_model
int context_model
Definition: ffv1.h:115
FFV1Context::pb
PutBitContext pb
Definition: ffv1.h:78
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
OFFSET
#define OFFSET(x)
Definition: ffv1enc.c:1240
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
COST2
#define COST2(old, new)
av_clip_uint8
#define av_clip_uint8
Definition: common.h:101
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:83
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:143
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
FFV1Context
Definition: ffv1.h:73
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1025
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:453
encode_rgb_frame
static int RENAME() encode_rgb_frame(FFV1Context *s, const uint8_t *src[4], int w, int h, const int stride[4])
Definition: ffv1enc_template.c:127
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:598
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:106
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:375
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:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:465
h
h
Definition: vp9dsp_template.c:2038
RangeCoder
Definition: mss3.c:62
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:469
state
static struct @345 state
ff_ffv1_encoder
const FFCodec ff_ffv1_encoder
Definition: ffv1enc.c:1267
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:441
PlaneContext::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:63
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
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:35
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:467
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:289
Generated on Tue Feb 28 2023 21:33:15 for FFmpeg by   doxygen 1.8.17

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