FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 #if 0 // JPEG LS
256  if (k == 0 && 2 * state->drift <= -state->count)
257  code = v ^ (-1);
258  else
259  code = v;
260 #else
261  code = v ^ ((2 * state->drift + state->count) >> 31);
262 #endif
263 
264  ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
265  state->bias, state->error_sum, state->drift, state->count, k);
266  set_sr_golomb(pb, code, k, 12, bits);
267 
268  update_vlc_state(state, v);
269 }
270 
271 #define TYPE int16_t
272 #define RENAME(name) name
273 #include "ffv1enc_template.c"
274 #undef TYPE
275 #undef RENAME
276 
277 #define TYPE int32_t
278 #define RENAME(name) name ## 32
279 #include "ffv1enc_template.c"
280 
281 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
282  int stride, int plane_index, int pixel_stride)
283 {
284  int x, y, i, ret;
285  const int ring_size = s->context_model ? 3 : 2;
286  int16_t *sample[3];
287  s->run_index = 0;
288 
289  memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
290 
291  for (y = 0; y < h; y++) {
292  for (i = 0; i < ring_size; i++)
293  sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
294 
295  sample[0][-1]= sample[1][0 ];
296  sample[1][ w]= sample[1][w-1];
297 // { START_TIMER
298  if (s->bits_per_raw_sample <= 8) {
299  for (x = 0; x < w; x++)
300  sample[0][x] = src[x * pixel_stride + stride * y];
301  if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
302  return ret;
303  } else {
304  if (s->packed_at_lsb) {
305  for (x = 0; x < w; x++) {
306  sample[0][x] = ((uint16_t*)(src + stride*y))[x];
307  }
308  } else {
309  for (x = 0; x < w; x++) {
310  sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
311  }
312  }
313  if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
314  return ret;
315  }
316 // STOP_TIMER("encode line") }
317  }
318  return 0;
319 }
320 
321 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
322 {
323  int last = 0;
324  int i;
326  memset(state, 128, sizeof(state));
327 
328  for (i = 1; i < 128; i++)
329  if (quant_table[i] != quant_table[i - 1]) {
330  put_symbol(c, state, i - last - 1, 0);
331  last = i;
332  }
333  put_symbol(c, state, i - last - 1, 0);
334 }
335 
337  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
338 {
339  int i;
340  for (i = 0; i < 5; i++)
342 }
343 
344 static void write_header(FFV1Context *f)
345 {
347  int i, j;
348  RangeCoder *const c = &f->slice_context[0]->c;
349 
350  memset(state, 128, sizeof(state));
351 
352  if (f->version < 2) {
353  put_symbol(c, state, f->version, 0);
354  put_symbol(c, state, f->ac, 0);
355  if (f->ac == AC_RANGE_CUSTOM_TAB) {
356  for (i = 1; i < 256; i++)
357  put_symbol(c, state,
358  f->state_transition[i] - c->one_state[i], 1);
359  }
360  put_symbol(c, state, f->colorspace, 0); //YUV cs type
361  if (f->version > 0)
362  put_symbol(c, state, f->bits_per_raw_sample, 0);
363  put_rac(c, state, f->chroma_planes);
364  put_symbol(c, state, f->chroma_h_shift, 0);
365  put_symbol(c, state, f->chroma_v_shift, 0);
366  put_rac(c, state, f->transparency);
367 
369  } else if (f->version < 3) {
370  put_symbol(c, state, f->slice_count, 0);
371  for (i = 0; i < f->slice_count; i++) {
372  FFV1Context *fs = f->slice_context[i];
373  put_symbol(c, state,
374  (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
375  put_symbol(c, state,
376  (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
377  put_symbol(c, state,
378  (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
379  0);
380  put_symbol(c, state,
381  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
382  0);
383  for (j = 0; j < f->plane_count; j++) {
384  put_symbol(c, state, f->plane[j].quant_table_index, 0);
386  }
387  }
388  }
389 }
390 
392 {
393  RangeCoder *const c = &f->c;
395  int i, j, k;
396  uint8_t state2[32][CONTEXT_SIZE];
397  unsigned v;
398 
399  memset(state2, 128, sizeof(state2));
400  memset(state, 128, sizeof(state));
401 
402  f->avctx->extradata_size = 10000 + 4 +
403  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
405  if (!f->avctx->extradata)
406  return AVERROR(ENOMEM);
408  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
409 
410  put_symbol(c, state, f->version, 0);
411  if (f->version > 2) {
412  if (f->version == 3) {
413  f->micro_version = 4;
414  } else if (f->version == 4)
415  f->micro_version = 2;
416  put_symbol(c, state, f->micro_version, 0);
417  }
418 
419  put_symbol(c, state, f->ac, 0);
420  if (f->ac == AC_RANGE_CUSTOM_TAB)
421  for (i = 1; i < 256; i++)
422  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
423 
424  put_symbol(c, state, f->colorspace, 0); // YUV cs type
425  put_symbol(c, state, f->bits_per_raw_sample, 0);
426  put_rac(c, state, f->chroma_planes);
427  put_symbol(c, state, f->chroma_h_shift, 0);
428  put_symbol(c, state, f->chroma_v_shift, 0);
429  put_rac(c, state, f->transparency);
430  put_symbol(c, state, f->num_h_slices - 1, 0);
431  put_symbol(c, state, f->num_v_slices - 1, 0);
432 
433  put_symbol(c, state, f->quant_table_count, 0);
434  for (i = 0; i < f->quant_table_count; i++)
436 
437  for (i = 0; i < f->quant_table_count; i++) {
438  for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
439  if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
440  break;
441  if (j < f->context_count[i] * CONTEXT_SIZE) {
442  put_rac(c, state, 1);
443  for (j = 0; j < f->context_count[i]; j++)
444  for (k = 0; k < CONTEXT_SIZE; k++) {
445  int pred = j ? f->initial_states[i][j - 1][k] : 128;
446  put_symbol(c, state2[k],
447  (int8_t)(f->initial_states[i][j][k] - pred), 1);
448  }
449  } else {
450  put_rac(c, state, 0);
451  }
452  }
453 
454  if (f->version > 2) {
455  put_symbol(c, state, f->ec, 0);
456  put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
457  }
458 
462  f->avctx->extradata_size += 4;
463 
464  return 0;
465 }
466 
467 static int sort_stt(FFV1Context *s, uint8_t stt[256])
468 {
469  int i, i2, changed, print = 0;
470 
471  do {
472  changed = 0;
473  for (i = 12; i < 244; i++) {
474  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
475 
476 #define COST(old, new) \
477  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
478  s->rc_stat[old][1] * -log2((new) / 256.0)
479 
480 #define COST2(old, new) \
481  COST(old, new) + COST(256 - (old), 256 - (new))
482 
483  double size0 = COST2(i, i) + COST2(i2, i2);
484  double sizeX = COST2(i, i2) + COST2(i2, i);
485  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
486  int j;
487  FFSWAP(int, stt[i], stt[i2]);
488  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
489  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
490  if (i != 256 - i2) {
491  FFSWAP(int, stt[256 - i], stt[256 - i2]);
492  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
493  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
494  }
495  for (j = 1; j < 256; j++) {
496  if (stt[j] == i)
497  stt[j] = i2;
498  else if (stt[j] == i2)
499  stt[j] = i;
500  if (i != 256 - i2) {
501  if (stt[256 - j] == 256 - i)
502  stt[256 - j] = 256 - i2;
503  else if (stt[256 - j] == 256 - i2)
504  stt[256 - j] = 256 - i;
505  }
506  }
507  print = changed = 1;
508  }
509  }
510  }
511  } while (changed);
512  return print;
513 }
514 
516 {
517  FFV1Context *s = avctx->priv_data;
519  int i, j, k, m, ret;
520 
521  if ((ret = ff_ffv1_common_init(avctx)) < 0)
522  return ret;
523 
524  s->version = 0;
525 
526  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
527  avctx->slices > 1)
528  s->version = FFMAX(s->version, 2);
529 
530  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
531  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
532  s->version = FFMAX(s->version, 2);
533 
534  if (avctx->level <= 0 && s->version == 2) {
535  s->version = 3;
536  }
537  if (avctx->level >= 0 && avctx->level <= 4) {
538  if (avctx->level < s->version) {
539  av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
540  return AVERROR(EINVAL);
541  }
542  s->version = avctx->level;
543  }
544 
545  if (s->ec < 0) {
546  s->ec = (s->version >= 3);
547  }
548 
549  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
550  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
551  return AVERROR_INVALIDDATA;
552  }
553 
554 #if FF_API_CODER_TYPE
556  if (avctx->coder_type != -1)
557  s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
558  else
560 #endif
561  if (s->ac == 1) // Compatbility with common command line usage
562  s->ac = AC_RANGE_CUSTOM_TAB;
563  else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
565 
566  s->plane_count = 3;
567  switch(avctx->pix_fmt) {
568  case AV_PIX_FMT_YUV444P9:
569  case AV_PIX_FMT_YUV422P9:
570  case AV_PIX_FMT_YUV420P9:
574  if (!avctx->bits_per_raw_sample)
575  s->bits_per_raw_sample = 9;
576  case AV_PIX_FMT_GRAY10:
583  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
584  s->bits_per_raw_sample = 10;
585  case AV_PIX_FMT_GRAY12:
589  s->packed_at_lsb = 1;
590  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
591  s->bits_per_raw_sample = 12;
592  case AV_PIX_FMT_GRAY16:
599  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
600  s->bits_per_raw_sample = 16;
601  } else if (!s->bits_per_raw_sample) {
603  }
604  if (s->bits_per_raw_sample <= 8) {
605  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
606  return AVERROR_INVALIDDATA;
607  }
608  s->version = FFMAX(s->version, 1);
609  case AV_PIX_FMT_GRAY8:
610  case AV_PIX_FMT_YA8:
611  case AV_PIX_FMT_YUV444P:
612  case AV_PIX_FMT_YUV440P:
613  case AV_PIX_FMT_YUV422P:
614  case AV_PIX_FMT_YUV420P:
615  case AV_PIX_FMT_YUV411P:
616  case AV_PIX_FMT_YUV410P:
617  case AV_PIX_FMT_YUVA444P:
618  case AV_PIX_FMT_YUVA422P:
619  case AV_PIX_FMT_YUVA420P:
620  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
621  s->colorspace = 0;
622  s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
623  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
624  s->bits_per_raw_sample = 8;
625  else if (!s->bits_per_raw_sample)
626  s->bits_per_raw_sample = 8;
627  break;
628  case AV_PIX_FMT_RGB32:
629  s->colorspace = 1;
630  s->transparency = 1;
631  s->chroma_planes = 1;
632  s->bits_per_raw_sample = 8;
633  break;
634  case AV_PIX_FMT_RGB48:
635  s->colorspace = 1;
636  s->chroma_planes = 1;
637  s->bits_per_raw_sample = 16;
638  s->use32bit = 1;
639  s->version = FFMAX(s->version, 1);
641  av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
642  return AVERROR_INVALIDDATA;
643  }
644  break;
645  case AV_PIX_FMT_0RGB32:
646  s->colorspace = 1;
647  s->chroma_planes = 1;
648  s->bits_per_raw_sample = 8;
649  break;
650  case AV_PIX_FMT_GBRP9:
651  if (!avctx->bits_per_raw_sample)
652  s->bits_per_raw_sample = 9;
653  case AV_PIX_FMT_GBRP10:
654  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
655  s->bits_per_raw_sample = 10;
656  case AV_PIX_FMT_GBRP12:
657  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
658  s->bits_per_raw_sample = 12;
659  case AV_PIX_FMT_GBRP14:
660  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
661  s->bits_per_raw_sample = 14;
662  case AV_PIX_FMT_GBRP16:
663  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
664  s->bits_per_raw_sample = 16;
665  else if (!s->bits_per_raw_sample)
667  s->colorspace = 1;
668  s->chroma_planes = 1;
669  if (s->bits_per_raw_sample >= 16) {
670  s->use32bit = 1;
672  av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
673  return AVERROR_INVALIDDATA;
674  }
675  }
676  s->version = FFMAX(s->version, 1);
677  break;
678  default:
679  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
680  return AVERROR(ENOSYS);
681  }
683 
684  if (s->bits_per_raw_sample > 8) {
685  if (s->ac == AC_GOLOMB_RICE) {
686  av_log(avctx, AV_LOG_INFO,
687  "bits_per_raw_sample > 8, forcing range coder\n");
688  s->ac = AC_RANGE_CUSTOM_TAB;
689  }
690  }
691  if (s->transparency) {
692  av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
693  }
694 #if FF_API_PRIVATE_OPT
696  if (avctx->context_model)
697  s->context_model = avctx->context_model;
698  if (avctx->context_model > 1U) {
699  av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
700  return AVERROR(EINVAL);
701  }
703 #endif
704 
705  if (s->ac == AC_RANGE_CUSTOM_TAB) {
706  for (i = 1; i < 256; i++)
707  s->state_transition[i] = ver2_state[i];
708  } else {
709  RangeCoder c;
710  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
711  for (i = 1; i < 256; i++)
712  s->state_transition[i] = c.one_state[i];
713  }
714 
715  for (i = 0; i < 256; i++) {
716  s->quant_table_count = 2;
717  if (s->bits_per_raw_sample <= 8) {
718  s->quant_tables[0][0][i]= quant11[i];
719  s->quant_tables[0][1][i]= 11*quant11[i];
720  s->quant_tables[0][2][i]= 11*11*quant11[i];
721  s->quant_tables[1][0][i]= quant11[i];
722  s->quant_tables[1][1][i]= 11*quant11[i];
723  s->quant_tables[1][2][i]= 11*11*quant5 [i];
724  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
725  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
726  } else {
727  s->quant_tables[0][0][i]= quant9_10bit[i];
728  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
729  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
730  s->quant_tables[1][0][i]= quant9_10bit[i];
731  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
732  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
733  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
734  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
735  }
736  }
737  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
738  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
739  memcpy(s->quant_table, s->quant_tables[s->context_model],
740  sizeof(s->quant_table));
741 
742  for (i = 0; i < s->plane_count; i++) {
743  PlaneContext *const p = &s->plane[i];
744 
745  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
748  }
749 
750  if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
751  return ret;
752 
753 #if FF_API_CODED_FRAME
757 #endif
758 
759  if (!s->transparency)
760  s->plane_count = 2;
761  if (!s->chroma_planes && s->version > 3)
762  s->plane_count--;
763 
765  s->picture_number = 0;
766 
767  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
768  for (i = 0; i < s->quant_table_count; i++) {
769  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
770  sizeof(*s->rc_stat2[i]));
771  if (!s->rc_stat2[i])
772  return AVERROR(ENOMEM);
773  }
774  }
775  if (avctx->stats_in) {
776  char *p = avctx->stats_in;
777  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
778  int gob_count = 0;
779  char *next;
780  if (!best_state)
781  return AVERROR(ENOMEM);
782 
783  av_assert0(s->version >= 2);
784 
785  for (;;) {
786  for (j = 0; j < 256; j++)
787  for (i = 0; i < 2; i++) {
788  s->rc_stat[j][i] = strtol(p, &next, 0);
789  if (next == p) {
790  av_log(avctx, AV_LOG_ERROR,
791  "2Pass file invalid at %d %d [%s]\n", j, i, p);
792  av_freep(&best_state);
793  return AVERROR_INVALIDDATA;
794  }
795  p = next;
796  }
797  for (i = 0; i < s->quant_table_count; i++)
798  for (j = 0; j < s->context_count[i]; j++) {
799  for (k = 0; k < 32; k++)
800  for (m = 0; m < 2; m++) {
801  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
802  if (next == p) {
803  av_log(avctx, AV_LOG_ERROR,
804  "2Pass file invalid at %d %d %d %d [%s]\n",
805  i, j, k, m, p);
806  av_freep(&best_state);
807  return AVERROR_INVALIDDATA;
808  }
809  p = next;
810  }
811  }
812  gob_count = strtol(p, &next, 0);
813  if (next == p || gob_count <= 0) {
814  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
815  av_freep(&best_state);
816  return AVERROR_INVALIDDATA;
817  }
818  p = next;
819  while (*p == '\n' || *p == ' ')
820  p++;
821  if (p[0] == 0)
822  break;
823  }
824  if (s->ac == AC_RANGE_CUSTOM_TAB)
825  sort_stt(s, s->state_transition);
826 
827  find_best_state(best_state, s->state_transition);
828 
829  for (i = 0; i < s->quant_table_count; i++) {
830  for (k = 0; k < 32; k++) {
831  double a=0, b=0;
832  int jp = 0;
833  for (j = 0; j < s->context_count[i]; j++) {
834  double p = 128;
835  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
836  if (a+b)
837  p = 256.0 * b / (a + b);
838  s->initial_states[i][jp][k] =
839  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
840  for(jp++; jp<j; jp++)
841  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
842  a=b=0;
843  }
844  a += s->rc_stat2[i][j][k][0];
845  b += s->rc_stat2[i][j][k][1];
846  if (a+b) {
847  p = 256.0 * b / (a + b);
848  }
849  s->initial_states[i][j][k] =
850  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
851  }
852  }
853  }
854  av_freep(&best_state);
855  }
856 
857  if (s->version > 1) {
858  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
859  for (; s->num_v_slices < 9; s->num_v_slices++) {
860  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
861  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
862  goto slices_ok;
863  }
864  }
865  av_log(avctx, AV_LOG_ERROR,
866  "Unsupported number %d of slices requested, please specify a "
867  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
868  avctx->slices);
869  return AVERROR(ENOSYS);
870 slices_ok:
871  if ((ret = write_extradata(s)) < 0)
872  return ret;
873  }
874 
875  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
876  return ret;
878  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
879  return ret;
880 
881 #define STATS_OUT_SIZE 1024 * 1024 * 6
882  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
884  if (!avctx->stats_out)
885  return AVERROR(ENOMEM);
886  for (i = 0; i < s->quant_table_count; i++)
887  for (j = 0; j < s->max_slice_count; j++) {
888  FFV1Context *sf = s->slice_context[j];
889  av_assert0(!sf->rc_stat2[i]);
890  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
891  sizeof(*sf->rc_stat2[i]));
892  if (!sf->rc_stat2[i])
893  return AVERROR(ENOMEM);
894  }
895  }
896 
897  return 0;
898 }
899 
901 {
902  RangeCoder *c = &fs->c;
904  int j;
905  memset(state, 128, sizeof(state));
906 
907  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
908  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
909  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
910  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
911  for (j=0; j<f->plane_count; j++) {
912  put_symbol(c, state, f->plane[j].quant_table_index, 0);
914  }
915  if (!f->picture.f->interlaced_frame)
916  put_symbol(c, state, 3, 0);
917  else
918  put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
919  put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
920  put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
921  if (f->version > 3) {
922  put_rac(c, state, fs->slice_coding_mode == 1);
923  if (fs->slice_coding_mode == 1)
925  put_symbol(c, state, fs->slice_coding_mode, 0);
926  if (fs->slice_coding_mode != 1) {
927  put_symbol(c, state, fs->slice_rct_by_coef, 0);
928  put_symbol(c, state, fs->slice_rct_ry_coef, 0);
929  }
930  }
931 }
932 
933 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
934 {
935 #define NB_Y_COEFF 15
936  static const int rct_y_coeff[15][2] = {
937  {0, 0}, // 4G
938  {1, 1}, // R + 2G + B
939  {2, 2}, // 2R + 2B
940  {0, 2}, // 2G + 2B
941  {2, 0}, // 2R + 2G
942  {4, 0}, // 4R
943  {0, 4}, // 4B
944 
945  {0, 3}, // 1G + 3B
946  {3, 0}, // 3R + 1G
947  {3, 1}, // 3R + B
948  {1, 3}, // R + 3B
949  {1, 2}, // R + G + 2B
950  {2, 1}, // 2R + G + B
951  {0, 1}, // 3G + B
952  {1, 0}, // R + 3G
953  };
954 
955  int stat[NB_Y_COEFF] = {0};
956  int x, y, i, p, best;
957  int16_t *sample[3];
958  int lbd = fs->bits_per_raw_sample <= 8;
959 
960  for (y = 0; y < h; y++) {
961  int lastr=0, lastg=0, lastb=0;
962  for (p = 0; p < 3; p++)
963  sample[p] = fs->sample_buffer + p*w;
964 
965  for (x = 0; x < w; x++) {
966  int b, g, r;
967  int ab, ag, ar;
968  if (lbd) {
969  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
970  b = v & 0xFF;
971  g = (v >> 8) & 0xFF;
972  r = (v >> 16) & 0xFF;
973  } else {
974  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
975  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
976  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
977  }
978 
979  ar = r - lastr;
980  ag = g - lastg;
981  ab = b - lastb;
982  if (x && y) {
983  int bg = ag - sample[0][x];
984  int bb = ab - sample[1][x];
985  int br = ar - sample[2][x];
986 
987  br -= bg;
988  bb -= bg;
989 
990  for (i = 0; i<NB_Y_COEFF; i++) {
991  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
992  }
993 
994  }
995  sample[0][x] = ag;
996  sample[1][x] = ab;
997  sample[2][x] = ar;
998 
999  lastr = r;
1000  lastg = g;
1001  lastb = b;
1002  }
1003  }
1004 
1005  best = 0;
1006  for (i=1; i<NB_Y_COEFF; i++) {
1007  if (stat[i] < stat[best])
1008  best = i;
1009  }
1010 
1011  fs->slice_rct_by_coef = rct_y_coeff[best][1];
1012  fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1013 }
1014 
1015 static int encode_slice(AVCodecContext *c, void *arg)
1016 {
1017  FFV1Context *fs = *(void **)arg;
1018  FFV1Context *f = fs->avctx->priv_data;
1019  int width = fs->slice_width;
1020  int height = fs->slice_height;
1021  int x = fs->slice_x;
1022  int y = fs->slice_y;
1023  const AVFrame *const p = f->picture.f;
1024  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1025  int ret;
1026  RangeCoder c_bak = fs->c;
1027  const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1028  p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1029  p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL};
1030 
1031  fs->slice_coding_mode = 0;
1032  if (f->version > 3) {
1033  choose_rct_params(fs, planes, p->linesize, width, height);
1034  } else {
1035  fs->slice_rct_by_coef = 1;
1036  fs->slice_rct_ry_coef = 1;
1037  }
1038 
1039 retry:
1040  if (f->key_frame)
1042  if (f->version > 2) {
1043  encode_slice_header(f, fs);
1044  }
1045  if (fs->ac == AC_GOLOMB_RICE) {
1046  if (f->version > 2)
1047  put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1048  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1049  init_put_bits(&fs->pb,
1050  fs->c.bytestream_start + fs->ac_byte_count,
1051  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1052  }
1053 
1054  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1055  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1056  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1057  const int cx = x >> f->chroma_h_shift;
1058  const int cy = y >> f->chroma_v_shift;
1059 
1060  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1061 
1062  if (f->chroma_planes) {
1063  ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1064  ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1065  }
1066  if (fs->transparency)
1067  ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1068  } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1069  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1070  ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1071  } else if (f->use32bit) {
1072  ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1073  } else {
1074  ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1075  }
1076  emms_c();
1077 
1078  if (ret < 0) {
1079  av_assert0(fs->slice_coding_mode == 0);
1080  if (fs->version < 4 || !fs->ac) {
1081  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1082  return ret;
1083  }
1084  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1085  fs->slice_coding_mode = 1;
1086  fs->c = c_bak;
1087  goto retry;
1088  }
1089 
1090  return 0;
1091 }
1092 
1094  const AVFrame *pict, int *got_packet)
1095 {
1096  FFV1Context *f = avctx->priv_data;
1097  RangeCoder *const c = &f->slice_context[0]->c;
1098  AVFrame *const p = f->picture.f;
1099  int used_count = 0;
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 
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 ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1156  return ret;
1157 
1158  ff_init_range_encoder(c, pkt->data, pkt->size);
1159  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1160 
1161  av_frame_unref(p);
1162  if ((ret = av_frame_ref(p, pict)) < 0)
1163  return ret;
1164 #if FF_API_CODED_FRAME
1168 #endif
1169 
1170  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1171  put_rac(c, &keystate, 1);
1172  f->key_frame = 1;
1173  f->gob_count++;
1174  write_header(f);
1175  } else {
1176  put_rac(c, &keystate, 0);
1177  f->key_frame = 0;
1178  }
1179 
1180  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1181  int i;
1182  for (i = 1; i < 256; i++) {
1183  c->one_state[i] = f->state_transition[i];
1184  c->zero_state[256 - i] = 256 - c->one_state[i];
1185  }
1186  }
1187 
1188  for (i = 1; i < f->slice_count; i++) {
1189  FFV1Context *fs = f->slice_context[i];
1190  uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1191  int len = pkt->size / f->slice_count;
1192  ff_init_range_encoder(&fs->c, start, len);
1193  }
1194  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1195  f->slice_count, sizeof(void *));
1196 
1197  buf_p = pkt->data;
1198  for (i = 0; i < f->slice_count; i++) {
1199  FFV1Context *fs = f->slice_context[i];
1200  int bytes;
1201 
1202  if (fs->ac != AC_GOLOMB_RICE) {
1203  uint8_t state = 129;
1204  put_rac(&fs->c, &state, 0);
1205  bytes = ff_rac_terminate(&fs->c);
1206  } else {
1207  flush_put_bits(&fs->pb); // FIXME: nicer padding
1208  bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1209  }
1210  if (i > 0 || f->version > 2) {
1211  av_assert0(bytes < pkt->size / f->slice_count);
1212  memmove(buf_p, fs->c.bytestream_start, bytes);
1213  av_assert0(bytes < (1 << 24));
1214  AV_WB24(buf_p + bytes, bytes);
1215  bytes += 3;
1216  }
1217  if (f->ec) {
1218  unsigned v;
1219  buf_p[bytes++] = 0;
1220  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1221  AV_WL32(buf_p + bytes, v);
1222  bytes += 4;
1223  }
1224  buf_p += bytes;
1225  }
1226 
1227  if (avctx->flags & AV_CODEC_FLAG_PASS1)
1228  avctx->stats_out[0] = '\0';
1229 
1230 #if FF_API_CODED_FRAME
1232  avctx->coded_frame->key_frame = f->key_frame;
1234 #endif
1235 
1236  f->picture_number++;
1237  pkt->size = buf_p - pkt->data;
1238  pkt->pts =
1239  pkt->dts = pict->pts;
1240  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1241  *got_packet = 1;
1242 
1243  return 0;
1244 }
1245 
1247 {
1248  ff_ffv1_close(avctx);
1249  return 0;
1250 }
1251 
1252 #define OFFSET(x) offsetof(FFV1Context, x)
1253 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1254 static const AVOption options[] = {
1255  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1256  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1257  { .i64 = 0 }, -2, 2, VE, "coder" },
1258  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1259  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1260  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1261  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1262  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1263  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1264  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1265  { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1266  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1267  { .i64 = 0 }, 0, 1, VE },
1268 
1269  { NULL }
1270 };
1271 
1272 static const AVClass ffv1_class = {
1273  .class_name = "ffv1 encoder",
1274  .item_name = av_default_item_name,
1275  .option = options,
1276  .version = LIBAVUTIL_VERSION_INT,
1277 };
1278 
1279 #if FF_API_CODER_TYPE
1280 static const AVCodecDefault ffv1_defaults[] = {
1281  { "coder", "-1" },
1282  { NULL },
1283 };
1284 #endif
1285 
1287  .name = "ffv1",
1288  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1289  .type = AVMEDIA_TYPE_VIDEO,
1290  .id = AV_CODEC_ID_FFV1,
1291  .priv_data_size = sizeof(FFV1Context),
1292  .init = encode_init,
1293  .encode2 = encode_frame,
1294  .close = encode_close,
1296  .pix_fmts = (const enum AVPixelFormat[]) {
1312 
1313  },
1314 #if FF_API_CODER_TYPE
1315  .defaults = ffv1_defaults,
1316 #endif
1317  .priv_class = &ffv1_class,
1318 };
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:2900
#define NULL
Definition: coverity.c:32
static const AVCodecDefault ffv1_defaults[]
Definition: ffv1enc.c:1280
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:388
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:382
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2332
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
AVOption.
Definition: opt.h:246
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
Definition: ffv1enc.c:900
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:384
8 bits gray, 8 bits alpha
Definition: pixfmt.h:154
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:385
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:67
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:85
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:1602
const char * b
Definition: vf_curves.c:113
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:367
int av_log2(unsigned v)
Definition: intmath.c:26
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1904
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:355
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2853
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
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:252
static int ring_size(RingBuffer *ring)
Definition: async.c:105
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:3078
FF Video Codec 1 (a lossless codec)
#define src
Definition: vp8dsp.c:254
#define sample
int height
Definition: ffv1.h:89
AVCodec.
Definition: avcodec.h:3601
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:333
int plane_count
Definition: ffv1.h:100
int ff_rac_terminate(RangeCoder *c)
Definition: rangecoder.c:104
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1enc.c:336
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:334
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:984
ThreadFrame picture
Definition: ffv1.h:96
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:102
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:385
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:268
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:1791
static av_cold int encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:515
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:381
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:366
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:1601
attribute_deprecated int context_model
Definition: avcodec.h:2735
uint8_t count
Definition: ffv1.h:65
#define ff_dlog(a,...)
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:1015
static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
Definition: ffv1enc.c:933
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:364
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:322
ptrdiff_t size
Definition: opengl_enc.c:101
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:356
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2845
#define NB_Y_COEFF
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:387
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:741
#define av_log(a,...)
static int write_extradata(FFV1Context *f)
Definition: ffv1enc.c:391
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:1633
#define U(x)
Definition: vp56_arith.h:37
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:467
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:188
#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:176
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:389
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1771
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:337
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3608
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:354
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:167
#define FFMAX(a, b)
Definition: common.h:94
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1607
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:66
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:349
#define av_flatten
Definition: attributes.h:88
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: ffv1enc.c:1093
static av_cold int encode_close(AVCodecContext *avctx)
Definition: ffv1enc.c:1246
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:258
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:370
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:335
int key_frame
Definition: ffv1.h:95
#define FFMIN(a, b)
Definition: common.h:96
int num_h_slices
Definition: ffv1.h:132
#define width
int width
picture width / height.
Definition: avcodec.h:1863
int colorspace
Definition: ffv1.h:110
static float quant_table[96]
Definition: binkaudio.c:42
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:849
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:450
AVCodec ff_ffv1_encoder
Definition: ffv1enc.c:1286
int max_slice_count
Definition: ffv1.h:130
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:63
#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:3280
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:117
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:386
int ac_byte_count
number of bytes used for AC coding
Definition: ffv1.h:102
int16_t drift
Definition: ffv1.h:62
void avcodec_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: imgconvert.c:38
int packed_at_lsb
Definition: ffv1.h:123
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:350
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:369
attribute_deprecated int coder_type
Definition: avcodec.h:2729
#define VE
Definition: ffv1enc.c:1253
static const AVOption options[]
Definition: ffv1enc.c:1254
static const float pred[4]
Definition: siprdata.h:259
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:362
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1026
#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:215
#define STATS_OUT_SIZE
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:189
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:1676
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:326
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:263
static struct @246 state
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:1792
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:351
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:68
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition: ffv1enc.c:321
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:281
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:554
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:1272
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:348
#define snprintf
Definition: snprintf.h:34
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1722
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:368
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:495
#define CONTEXT_SIZE
Definition: ffv1.h:51
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:352
int gob_count
Definition: ffv1.h:125
int quant_table_index
Definition: ffv1.h:70
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:358
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
#define OFFSET(x)
Definition: ffv1enc.c:1252
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1889
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:343
#define COST2(old, new)
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
int context_model
Definition: ffv1.h:120
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:62
Y , 8bpp.
Definition: pixfmt.h:70
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:80
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
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:383
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:3099
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:69
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:734
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:853
int slices
Number of slices.
Definition: avcodec.h:2429
void * priv_data
Definition: avcodec.h:1718
int chroma_h_shift
Definition: ffv1.h:91
PlaneContext plane[MAX_PLANES]
Definition: ffv1.h:103
int transparency
Definition: ffv1.h:92
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:3148
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
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:327
int len
int chroma_planes
Definition: ffv1.h:90
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:253
static AVCodec * c
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:344
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:1600
#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:100
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
exp golomb vlc stuff
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1578
AVCodecContext * avctx
Definition: ffv1.h:81
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2895
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:363
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1594
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:426
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:330
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
int slice_rct_ry_coef
Definition: ffv1.h:140
bitstream writer API