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