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 
185 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
186  uint8_t *state, int v,
187  int is_signed,
188  uint64_t rc_stat[256][2],
189  uint64_t rc_stat2[32][2])
190 {
191  int i;
192 
193 #define put_rac(C, S, B) \
194  do { \
195  if (rc_stat) { \
196  rc_stat[*(S)][B]++; \
197  rc_stat2[(S) - state][B]++; \
198  } \
199  put_rac(C, S, B); \
200  } while (0)
201 
202  if (v) {
203  const int a = FFABS(v);
204  const int e = av_log2(a);
205  put_rac(c, state + 0, 0);
206  if (e <= 9) {
207  for (i = 0; i < e; i++)
208  put_rac(c, state + 1 + i, 1); // 1..10
209  put_rac(c, state + 1 + i, 0);
210 
211  for (i = e - 1; i >= 0; i--)
212  put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
213 
214  if (is_signed)
215  put_rac(c, state + 11 + e, v < 0); // 11..21
216  } else {
217  for (i = 0; i < e; i++)
218  put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
219  put_rac(c, state + 1 + 9, 0);
220 
221  for (i = e - 1; i >= 0; i--)
222  put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
223 
224  if (is_signed)
225  put_rac(c, state + 11 + 10, v < 0); // 11..21
226  }
227  } else {
228  put_rac(c, state + 0, 1);
229  }
230 #undef put_rac
231 }
232 
233 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
234  int v, int is_signed)
235 {
236  put_symbol_inline(c, state, v, is_signed, NULL, NULL);
237 }
238 
239 
240 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
241  int v, int bits)
242 {
243  int i, k, code;
244  v = fold(v - state->bias, bits);
245 
246  i = state->count;
247  k = 0;
248  while (i < state->error_sum) { // FIXME: optimize
249  k++;
250  i += i;
251  }
252 
253  av_assert2(k <= 13);
254 
255  code = v ^ ((2 * state->drift + state->count) >> 31);
256 
257  ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
258  state->bias, state->error_sum, state->drift, state->count, k);
259  set_sr_golomb(pb, code, k, 12, bits);
260 
261  update_vlc_state(state, v);
262 }
263 
264 #define TYPE int16_t
265 #define RENAME(name) name
266 #include "ffv1enc_template.c"
267 #undef TYPE
268 #undef RENAME
269 
270 #define TYPE int32_t
271 #define RENAME(name) name ## 32
272 #include "ffv1enc_template.c"
273 
274 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
275  int stride, int plane_index, int pixel_stride)
276 {
277  int x, y, i, ret;
278  const int ring_size = s->context_model ? 3 : 2;
279  int16_t *sample[3];
280  s->run_index = 0;
281 
282  memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
283 
284  for (y = 0; y < h; y++) {
285  for (i = 0; i < ring_size; i++)
286  sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
287 
288  sample[0][-1]= sample[1][0 ];
289  sample[1][ w]= sample[1][w-1];
290 // { 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;
318  uint8_t state[CONTEXT_SIZE];
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 
329 static void write_quant_tables(RangeCoder *c,
330  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
331 {
332  int i;
333  for (i = 0; i < 5; i++)
334  write_quant_table(c, quant_table[i]);
335 }
336 
337 static void write_header(FFV1Context *f)
338 {
339  uint8_t state[CONTEXT_SIZE];
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 
361  write_quant_tables(c, f->quant_table);
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);
378  av_assert0(f->plane[j].quant_table_index == f->context_model);
379  }
380  }
381  }
382 }
383 
384 static int write_extradata(FFV1Context *f)
385 {
386  RangeCoder *const c = &f->c;
387  uint8_t state[CONTEXT_SIZE];
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;
397  f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
398  if (!f->avctx->extradata)
399  return AVERROR(ENOMEM);
400  ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
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++)
428  write_quant_tables(c, f->quant_tables[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 
452  f->avctx->extradata_size = ff_rac_terminate(c);
453  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
454  AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
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 
508 static av_cold int encode_init(AVCodecContext *avctx)
509 {
510  FFV1Context *s = avctx->priv_data;
511  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
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  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
543  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
544  return AVERROR_INVALIDDATA;
545  }
546 
547 #if FF_API_CODER_TYPE
548 FF_DISABLE_DEPRECATION_WARNINGS
549  if (avctx->coder_type != -1)
550  s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
551  else
552 FF_ENABLE_DEPRECATION_WARNINGS
553 #endif
554  if (s->ac == 1) // Compatbility with common command line usage
555  s->ac = AC_RANGE_CUSTOM_TAB;
556  else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
557  s->ac = AC_RANGE_DEFAULT_TAB;
558 
559  s->plane_count = 3;
560  switch(avctx->pix_fmt) {
561  case AV_PIX_FMT_GRAY9:
562  case AV_PIX_FMT_YUV444P9:
563  case AV_PIX_FMT_YUV422P9:
564  case AV_PIX_FMT_YUV420P9:
565  case AV_PIX_FMT_YUVA444P9:
566  case AV_PIX_FMT_YUVA422P9:
567  case AV_PIX_FMT_YUVA420P9:
568  if (!avctx->bits_per_raw_sample)
569  s->bits_per_raw_sample = 9;
570  case AV_PIX_FMT_GRAY10:
571  case AV_PIX_FMT_YUV444P10:
572  case AV_PIX_FMT_YUV440P10:
573  case AV_PIX_FMT_YUV420P10:
574  case AV_PIX_FMT_YUV422P10:
575  case AV_PIX_FMT_YUVA444P10:
576  case AV_PIX_FMT_YUVA422P10:
577  case AV_PIX_FMT_YUVA420P10:
578  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
579  s->bits_per_raw_sample = 10;
580  case AV_PIX_FMT_GRAY12:
581  case AV_PIX_FMT_YUV444P12:
582  case AV_PIX_FMT_YUV440P12:
583  case AV_PIX_FMT_YUV420P12:
584  case AV_PIX_FMT_YUV422P12:
585  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
586  s->bits_per_raw_sample = 12;
587  case AV_PIX_FMT_YUV444P14:
588  case AV_PIX_FMT_YUV420P14:
589  case AV_PIX_FMT_YUV422P14:
590  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
591  s->bits_per_raw_sample = 14;
592  s->packed_at_lsb = 1;
593  case AV_PIX_FMT_GRAY16:
594  case AV_PIX_FMT_YUV444P16:
595  case AV_PIX_FMT_YUV422P16:
596  case AV_PIX_FMT_YUV420P16:
597  case AV_PIX_FMT_YUVA444P16:
598  case AV_PIX_FMT_YUVA422P16:
599  case AV_PIX_FMT_YUVA420P16:
600  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
601  s->bits_per_raw_sample = 16;
602  } else if (!s->bits_per_raw_sample) {
603  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
604  }
605  if (s->bits_per_raw_sample <= 8) {
606  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
607  return AVERROR_INVALIDDATA;
608  }
609  s->version = FFMAX(s->version, 1);
610  case AV_PIX_FMT_GRAY8:
611  case AV_PIX_FMT_YA8:
612  case AV_PIX_FMT_YUV444P:
613  case AV_PIX_FMT_YUV440P:
614  case AV_PIX_FMT_YUV422P:
615  case AV_PIX_FMT_YUV420P:
616  case AV_PIX_FMT_YUV411P:
617  case AV_PIX_FMT_YUV410P:
618  case AV_PIX_FMT_YUVA444P:
619  case AV_PIX_FMT_YUVA422P:
620  case AV_PIX_FMT_YUVA420P:
621  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
622  s->colorspace = 0;
623  s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
624  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
625  s->bits_per_raw_sample = 8;
626  else if (!s->bits_per_raw_sample)
627  s->bits_per_raw_sample = 8;
628  break;
629  case AV_PIX_FMT_RGB32:
630  s->colorspace = 1;
631  s->transparency = 1;
632  s->chroma_planes = 1;
633  s->bits_per_raw_sample = 8;
634  break;
635  case AV_PIX_FMT_RGBA64:
636  s->colorspace = 1;
637  s->transparency = 1;
638  s->chroma_planes = 1;
639  s->bits_per_raw_sample = 16;
640  s->use32bit = 1;
641  s->version = FFMAX(s->version, 1);
642  break;
643  case AV_PIX_FMT_RGB48:
644  s->colorspace = 1;
645  s->chroma_planes = 1;
646  s->bits_per_raw_sample = 16;
647  s->use32bit = 1;
648  s->version = FFMAX(s->version, 1);
649  break;
650  case AV_PIX_FMT_0RGB32:
651  s->colorspace = 1;
652  s->chroma_planes = 1;
653  s->bits_per_raw_sample = 8;
654  break;
655  case AV_PIX_FMT_GBRP9:
656  if (!avctx->bits_per_raw_sample)
657  s->bits_per_raw_sample = 9;
658  case AV_PIX_FMT_GBRP10:
659  case AV_PIX_FMT_GBRAP10:
660  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
661  s->bits_per_raw_sample = 10;
662  case AV_PIX_FMT_GBRP12:
663  case AV_PIX_FMT_GBRAP12:
664  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
665  s->bits_per_raw_sample = 12;
666  case AV_PIX_FMT_GBRP14:
667  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
668  s->bits_per_raw_sample = 14;
669  case AV_PIX_FMT_GBRP16:
670  case AV_PIX_FMT_GBRAP16:
671  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
672  s->bits_per_raw_sample = 16;
673  else if (!s->bits_per_raw_sample)
674  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
675  s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
676  s->colorspace = 1;
677  s->chroma_planes = 1;
678  if (s->bits_per_raw_sample >= 16) {
679  s->use32bit = 1;
680  }
681  s->version = FFMAX(s->version, 1);
682  break;
683  default:
684  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
685  return AVERROR(ENOSYS);
686  }
687  av_assert0(s->bits_per_raw_sample >= 8);
688 
689  if (s->bits_per_raw_sample > 8) {
690  if (s->ac == AC_GOLOMB_RICE) {
691  av_log(avctx, AV_LOG_INFO,
692  "bits_per_raw_sample > 8, forcing range coder\n");
693  s->ac = AC_RANGE_CUSTOM_TAB;
694  }
695  }
696 #if FF_API_PRIVATE_OPT
697 FF_DISABLE_DEPRECATION_WARNINGS
698  if (avctx->context_model)
699  s->context_model = avctx->context_model;
700  if (avctx->context_model > 1U) {
701  av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
702  return AVERROR(EINVAL);
703  }
704 FF_ENABLE_DEPRECATION_WARNINGS
705 #endif
706 
707  if (s->ac == AC_RANGE_CUSTOM_TAB) {
708  for (i = 1; i < 256; i++)
709  s->state_transition[i] = ver2_state[i];
710  } else {
711  RangeCoder c;
712  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
713  for (i = 1; i < 256; i++)
714  s->state_transition[i] = c.one_state[i];
715  }
716 
717  for (i = 0; i < 256; i++) {
718  s->quant_table_count = 2;
719  if (s->bits_per_raw_sample <= 8) {
720  s->quant_tables[0][0][i]= quant11[i];
721  s->quant_tables[0][1][i]= 11*quant11[i];
722  s->quant_tables[0][2][i]= 11*11*quant11[i];
723  s->quant_tables[1][0][i]= quant11[i];
724  s->quant_tables[1][1][i]= 11*quant11[i];
725  s->quant_tables[1][2][i]= 11*11*quant5 [i];
726  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
727  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
728  } else {
729  s->quant_tables[0][0][i]= quant9_10bit[i];
730  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
731  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
732  s->quant_tables[1][0][i]= quant9_10bit[i];
733  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
734  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
735  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
736  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
737  }
738  }
739  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
740  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
741  memcpy(s->quant_table, s->quant_tables[s->context_model],
742  sizeof(s->quant_table));
743 
744  for (i = 0; i < s->plane_count; i++) {
745  PlaneContext *const p = &s->plane[i];
746 
747  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
748  p->quant_table_index = s->context_model;
749  p->context_count = s->context_count[p->quant_table_index];
750  }
751 
752  if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
753  return ret;
754 
755 #if FF_API_CODED_FRAME
756 FF_DISABLE_DEPRECATION_WARNINGS
757  avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
758 FF_ENABLE_DEPRECATION_WARNINGS
759 #endif
760 
761  if (!s->transparency)
762  s->plane_count = 2;
763  if (!s->chroma_planes && s->version > 3)
764  s->plane_count--;
765 
766  ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
767  if (ret)
768  return ret;
769 
770  s->picture_number = 0;
771 
772  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
773  for (i = 0; i < s->quant_table_count; i++) {
774  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
775  sizeof(*s->rc_stat2[i]));
776  if (!s->rc_stat2[i])
777  return AVERROR(ENOMEM);
778  }
779  }
780  if (avctx->stats_in) {
781  char *p = avctx->stats_in;
782  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
783  int gob_count = 0;
784  char *next;
785  if (!best_state)
786  return AVERROR(ENOMEM);
787 
788  av_assert0(s->version >= 2);
789 
790  for (;;) {
791  for (j = 0; j < 256; j++)
792  for (i = 0; i < 2; i++) {
793  s->rc_stat[j][i] = strtol(p, &next, 0);
794  if (next == p) {
795  av_log(avctx, AV_LOG_ERROR,
796  "2Pass file invalid at %d %d [%s]\n", j, i, p);
797  av_freep(&best_state);
798  return AVERROR_INVALIDDATA;
799  }
800  p = next;
801  }
802  for (i = 0; i < s->quant_table_count; i++)
803  for (j = 0; j < s->context_count[i]; j++) {
804  for (k = 0; k < 32; k++)
805  for (m = 0; m < 2; m++) {
806  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
807  if (next == p) {
808  av_log(avctx, AV_LOG_ERROR,
809  "2Pass file invalid at %d %d %d %d [%s]\n",
810  i, j, k, m, p);
811  av_freep(&best_state);
812  return AVERROR_INVALIDDATA;
813  }
814  p = next;
815  }
816  }
817  gob_count = strtol(p, &next, 0);
818  if (next == p || gob_count <= 0) {
819  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
820  av_freep(&best_state);
821  return AVERROR_INVALIDDATA;
822  }
823  p = next;
824  while (*p == '\n' || *p == ' ')
825  p++;
826  if (p[0] == 0)
827  break;
828  }
829  if (s->ac == AC_RANGE_CUSTOM_TAB)
830  sort_stt(s, s->state_transition);
831 
832  find_best_state(best_state, s->state_transition);
833 
834  for (i = 0; i < s->quant_table_count; i++) {
835  for (k = 0; k < 32; k++) {
836  double a=0, b=0;
837  int jp = 0;
838  for (j = 0; j < s->context_count[i]; j++) {
839  double p = 128;
840  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
841  if (a+b)
842  p = 256.0 * b / (a + b);
843  s->initial_states[i][jp][k] =
844  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
845  for(jp++; jp<j; jp++)
846  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
847  a=b=0;
848  }
849  a += s->rc_stat2[i][j][k][0];
850  b += s->rc_stat2[i][j][k][1];
851  if (a+b) {
852  p = 256.0 * b / (a + b);
853  }
854  s->initial_states[i][j][k] =
855  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
856  }
857  }
858  }
859  av_freep(&best_state);
860  }
861 
862  if (s->version > 1) {
863  int plane_count = 1 + 2*s->chroma_planes + s->transparency;
864  int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
865  int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
866  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
867 
868  s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
869 
870  for (; s->num_v_slices < 32; s->num_v_slices++) {
871  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
872  int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
873  int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
874  if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
875  continue;
876  if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
877  continue;
878  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
879  goto slices_ok;
880  }
881  }
882  av_log(avctx, AV_LOG_ERROR,
883  "Unsupported number %d of slices requested, please specify a "
884  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
885  avctx->slices);
886  return AVERROR(ENOSYS);
887 slices_ok:
888  if ((ret = write_extradata(s)) < 0)
889  return ret;
890  }
891 
892  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
893  return ret;
894  s->slice_count = s->max_slice_count;
895  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
896  return ret;
897 
898 #define STATS_OUT_SIZE 1024 * 1024 * 6
899  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
900  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
901  if (!avctx->stats_out)
902  return AVERROR(ENOMEM);
903  for (i = 0; i < s->quant_table_count; i++)
904  for (j = 0; j < s->max_slice_count; j++) {
905  FFV1Context *sf = s->slice_context[j];
906  av_assert0(!sf->rc_stat2[i]);
907  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
908  sizeof(*sf->rc_stat2[i]));
909  if (!sf->rc_stat2[i])
910  return AVERROR(ENOMEM);
911  }
912  }
913 
914  return 0;
915 }
916 
917 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
918 {
919  RangeCoder *c = &fs->c;
920  uint8_t state[CONTEXT_SIZE];
921  int j;
922  memset(state, 128, sizeof(state));
923 
924  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
925  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
926  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
927  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
928  for (j=0; j<f->plane_count; j++) {
929  put_symbol(c, state, f->plane[j].quant_table_index, 0);
930  av_assert0(f->plane[j].quant_table_index == f->context_model);
931  }
932  if (!f->picture.f->interlaced_frame)
933  put_symbol(c, state, 3, 0);
934  else
935  put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
936  put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
937  put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
938  if (f->version > 3) {
939  put_rac(c, state, fs->slice_coding_mode == 1);
940  if (fs->slice_coding_mode == 1)
941  ff_ffv1_clear_slice_state(f, fs);
942  put_symbol(c, state, fs->slice_coding_mode, 0);
943  if (fs->slice_coding_mode != 1) {
944  put_symbol(c, state, fs->slice_rct_by_coef, 0);
945  put_symbol(c, state, fs->slice_rct_ry_coef, 0);
946  }
947  }
948 }
949 
950 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
951 {
952 #define NB_Y_COEFF 15
953  static const int rct_y_coeff[15][2] = {
954  {0, 0}, // 4G
955  {1, 1}, // R + 2G + B
956  {2, 2}, // 2R + 2B
957  {0, 2}, // 2G + 2B
958  {2, 0}, // 2R + 2G
959  {4, 0}, // 4R
960  {0, 4}, // 4B
961 
962  {0, 3}, // 1G + 3B
963  {3, 0}, // 3R + 1G
964  {3, 1}, // 3R + B
965  {1, 3}, // R + 3B
966  {1, 2}, // R + G + 2B
967  {2, 1}, // 2R + G + B
968  {0, 1}, // 3G + B
969  {1, 0}, // R + 3G
970  };
971 
972  int stat[NB_Y_COEFF] = {0};
973  int x, y, i, p, best;
974  int16_t *sample[3];
975  int lbd = fs->bits_per_raw_sample <= 8;
976 
977  for (y = 0; y < h; y++) {
978  int lastr=0, lastg=0, lastb=0;
979  for (p = 0; p < 3; p++)
980  sample[p] = fs->sample_buffer + p*w;
981 
982  for (x = 0; x < w; x++) {
983  int b, g, r;
984  int ab, ag, ar;
985  if (lbd) {
986  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
987  b = v & 0xFF;
988  g = (v >> 8) & 0xFF;
989  r = (v >> 16) & 0xFF;
990  } else {
991  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
992  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
993  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
994  }
995 
996  ar = r - lastr;
997  ag = g - lastg;
998  ab = b - lastb;
999  if (x && y) {
1000  int bg = ag - sample[0][x];
1001  int bb = ab - sample[1][x];
1002  int br = ar - sample[2][x];
1003 
1004  br -= bg;
1005  bb -= bg;
1006 
1007  for (i = 0; i<NB_Y_COEFF; i++) {
1008  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1009  }
1010 
1011  }
1012  sample[0][x] = ag;
1013  sample[1][x] = ab;
1014  sample[2][x] = ar;
1015 
1016  lastr = r;
1017  lastg = g;
1018  lastb = b;
1019  }
1020  }
1021 
1022  best = 0;
1023  for (i=1; i<NB_Y_COEFF; i++) {
1024  if (stat[i] < stat[best])
1025  best = i;
1026  }
1027 
1028  fs->slice_rct_by_coef = rct_y_coeff[best][1];
1029  fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1030 }
1031 
1032 static int encode_slice(AVCodecContext *c, void *arg)
1033 {
1034  FFV1Context *fs = *(void **)arg;
1035  FFV1Context *f = fs->avctx->priv_data;
1036  int width = fs->slice_width;
1037  int height = fs->slice_height;
1038  int x = fs->slice_x;
1039  int y = fs->slice_y;
1040  const AVFrame *const p = f->picture.f;
1041  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1042  int ret;
1043  RangeCoder c_bak = fs->c;
1044  const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1045  p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1046  p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1047  p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1048 
1049  fs->slice_coding_mode = 0;
1050  if (f->version > 3) {
1051  choose_rct_params(fs, planes, p->linesize, width, height);
1052  } else {
1053  fs->slice_rct_by_coef = 1;
1054  fs->slice_rct_ry_coef = 1;
1055  }
1056 
1057 retry:
1058  if (f->key_frame)
1059  ff_ffv1_clear_slice_state(f, fs);
1060  if (f->version > 2) {
1061  encode_slice_header(f, fs);
1062  }
1063  if (fs->ac == AC_GOLOMB_RICE) {
1064  if (f->version > 2)
1065  put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1066  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1067  init_put_bits(&fs->pb,
1068  fs->c.bytestream_start + fs->ac_byte_count,
1069  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1070  }
1071 
1072  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1073  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1074  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1075  const int cx = x >> f->chroma_h_shift;
1076  const int cy = y >> f->chroma_v_shift;
1077 
1078  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1079 
1080  if (f->chroma_planes) {
1081  ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1082  ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1083  }
1084  if (fs->transparency)
1085  ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1086  } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1087  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1088  ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1089  } else if (f->use32bit) {
1090  ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1091  } else {
1092  ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1093  }
1094  emms_c();
1095 
1096  if (ret < 0) {
1097  av_assert0(fs->slice_coding_mode == 0);
1098  if (fs->version < 4 || !fs->ac) {
1099  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1100  return ret;
1101  }
1102  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1103  fs->slice_coding_mode = 1;
1104  fs->c = c_bak;
1105  goto retry;
1106  }
1107 
1108  return 0;
1109 }
1110 
1111 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1112  const AVFrame *pict, int *got_packet)
1113 {
1114  FFV1Context *f = avctx->priv_data;
1115  RangeCoder *const c = &f->slice_context[0]->c;
1116  AVFrame *const p = f->picture.f;
1117  uint8_t keystate = 128;
1118  uint8_t *buf_p;
1119  int i, ret;
1120  int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1121  + avctx->width*avctx->height*37LL*4;
1122 
1123  if(!pict) {
1124  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1125  int j, k, m;
1126  char *p = avctx->stats_out;
1127  char *end = p + STATS_OUT_SIZE;
1128 
1129  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1130  for (i = 0; i < f->quant_table_count; i++)
1131  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1132 
1133  av_assert0(f->slice_count == f->max_slice_count);
1134  for (j = 0; j < f->slice_count; j++) {
1135  FFV1Context *fs = f->slice_context[j];
1136  for (i = 0; i < 256; i++) {
1137  f->rc_stat[i][0] += fs->rc_stat[i][0];
1138  f->rc_stat[i][1] += fs->rc_stat[i][1];
1139  }
1140  for (i = 0; i < f->quant_table_count; i++) {
1141  for (k = 0; k < f->context_count[i]; k++)
1142  for (m = 0; m < 32; m++) {
1143  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1144  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1145  }
1146  }
1147  }
1148 
1149  for (j = 0; j < 256; j++) {
1150  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1151  f->rc_stat[j][0], f->rc_stat[j][1]);
1152  p += strlen(p);
1153  }
1154  snprintf(p, end - p, "\n");
1155 
1156  for (i = 0; i < f->quant_table_count; i++) {
1157  for (j = 0; j < f->context_count[i]; j++)
1158  for (m = 0; m < 32; m++) {
1159  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1160  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1161  p += strlen(p);
1162  }
1163  }
1164  snprintf(p, end - p, "%d\n", f->gob_count);
1165  }
1166  return 0;
1167  }
1168 
1169  if (f->version > 3)
1170  maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1171 
1172  if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1173  av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1174  maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1175  }
1176 
1177  if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1178  return ret;
1179 
1180  ff_init_range_encoder(c, pkt->data, pkt->size);
1181  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1182 
1183  av_frame_unref(p);
1184  if ((ret = av_frame_ref(p, pict)) < 0)
1185  return ret;
1186 #if FF_API_CODED_FRAME
1187 FF_DISABLE_DEPRECATION_WARNINGS
1188  avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1189 FF_ENABLE_DEPRECATION_WARNINGS
1190 #endif
1191 
1192  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1193  put_rac(c, &keystate, 1);
1194  f->key_frame = 1;
1195  f->gob_count++;
1196  write_header(f);
1197  } else {
1198  put_rac(c, &keystate, 0);
1199  f->key_frame = 0;
1200  }
1201 
1202  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1203  int i;
1204  for (i = 1; i < 256; i++) {
1205  c->one_state[i] = f->state_transition[i];
1206  c->zero_state[256 - i] = 256 - c->one_state[i];
1207  }
1208  }
1209 
1210  for (i = 0; i < f->slice_count; i++) {
1211  FFV1Context *fs = f->slice_context[i];
1212  uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1213  int len = pkt->size / f->slice_count;
1214  if (i) {
1215  ff_init_range_encoder(&fs->c, start, len);
1216  } else {
1217  av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1218  av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1219  fs->c.bytestream_end = fs->c.bytestream_start + len;
1220  }
1221  }
1222  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1223  f->slice_count, sizeof(void *));
1224 
1225  buf_p = pkt->data;
1226  for (i = 0; i < f->slice_count; i++) {
1227  FFV1Context *fs = f->slice_context[i];
1228  int bytes;
1229 
1230  if (fs->ac != AC_GOLOMB_RICE) {
1231  uint8_t state = 129;
1232  put_rac(&fs->c, &state, 0);
1233  bytes = ff_rac_terminate(&fs->c);
1234  } else {
1235  flush_put_bits(&fs->pb); // FIXME: nicer padding
1236  bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1237  }
1238  if (i > 0 || f->version > 2) {
1239  av_assert0(bytes < pkt->size / f->slice_count);
1240  memmove(buf_p, fs->c.bytestream_start, bytes);
1241  av_assert0(bytes < (1 << 24));
1242  AV_WB24(buf_p + bytes, bytes);
1243  bytes += 3;
1244  }
1245  if (f->ec) {
1246  unsigned v;
1247  buf_p[bytes++] = 0;
1248  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1249  AV_WL32(buf_p + bytes, v);
1250  bytes += 4;
1251  }
1252  buf_p += bytes;
1253  }
1254 
1255  if (avctx->flags & AV_CODEC_FLAG_PASS1)
1256  avctx->stats_out[0] = '\0';
1257 
1258 #if FF_API_CODED_FRAME
1259 FF_DISABLE_DEPRECATION_WARNINGS
1260  avctx->coded_frame->key_frame = f->key_frame;
1261 FF_ENABLE_DEPRECATION_WARNINGS
1262 #endif
1263 
1264  f->picture_number++;
1265  pkt->size = buf_p - pkt->data;
1266  pkt->pts =
1267  pkt->dts = pict->pts;
1268  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1269  *got_packet = 1;
1270 
1271  return 0;
1272 }
1273 
1274 static av_cold int encode_close(AVCodecContext *avctx)
1275 {
1276  ff_ffv1_close(avctx);
1277  return 0;
1278 }
1279 
1280 #define OFFSET(x) offsetof(FFV1Context, x)
1281 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1282 static const AVOption options[] = {
1283  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1284  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1285  { .i64 = 0 }, -2, 2, VE, "coder" },
1286  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1287  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1288  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1289  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1290  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1291  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1292  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1293  { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1294  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1295  { .i64 = 0 }, 0, 1, VE },
1296 
1297  { NULL }
1298 };
1299 
1300 static const AVClass ffv1_class = {
1301  .class_name = "ffv1 encoder",
1302  .item_name = av_default_item_name,
1303  .option = options,
1304  .version = LIBAVUTIL_VERSION_INT,
1305 };
1306 
1307 #if FF_API_CODER_TYPE
1308 static const AVCodecDefault ffv1_defaults[] = {
1309  { "coder", "-1" },
1310  { NULL },
1311 };
1312 #endif
1313 
1314 AVCodec ff_ffv1_encoder = {
1315  .name = "ffv1",
1316  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1317  .type = AVMEDIA_TYPE_VIDEO,
1318  .id = AV_CODEC_ID_FFV1,
1319  .priv_data_size = sizeof(FFV1Context),
1320  .init = encode_init,
1321  .encode2 = encode_frame,
1322  .close = encode_close,
1323  .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1324  .pix_fmts = (const enum AVPixelFormat[]) {
1325  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1326  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1327  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1328  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1329  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1330  AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1331  AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1332  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1333  AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1334  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1335  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1336  AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1337  AV_PIX_FMT_YA8,
1338  AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1339  AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1340  AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1341  AV_PIX_FMT_GRAY9,
1342  AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1343  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1344  AV_PIX_FMT_NONE
1345 
1346  },
1347 #if FF_API_CODER_TYPE
1348  .defaults = ffv1_defaults,
1349 #endif
1350  .priv_class = &ffv1_class,
1351 };
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:151
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2581
NULL
#define NULL
Definition: coverity.c:32
ffv1_defaults
static const AVCodecDefault ffv1_defaults[]
Definition: ffv1enc.c:1308
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:407
s
const char * s
Definition: avisynth_c.h:768
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:370
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:401
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2363
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
h
h
Definition: vp9dsp_template.c:2038
AVOption
AVOption.
Definition: opt.h:246
encode_slice_header
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
Definition: ffv1enc.c:917
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:403
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:378
AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:139
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:388
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:404
AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:67
imgutils.h
misc image utilities
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
ThreadFrame::f
AVFrame * f
Definition: thread.h:35
PlaneContext::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:69
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
FFV1Context::quant_table_count
int quant_table_count
Definition: ffv1.h:126
g
const char * g
Definition: vf_curves.c:112
desc
const char * desc
Definition: nvenc.c:65
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AV_OPT_TYPE_INT
Definition: opt.h:223
FFV1Context::slice_height
int slice_height
Definition: ffv1.h:134
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:358
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:54
FFV1Context::sample_buffer
int16_t * sample_buffer
Definition: ffv1.h:111
FFV1Context::version
int version
Definition: ffv1.h:87
FFV1Context::micro_version
int micro_version
Definition: ffv1.h:88
RangeCoder::zero_state
uint8_t zero_state[256]
Definition: rangecoder.h:40
rangecoder.h
Range coder.
RangeCoder::bytestream_end
uint8_t * bytestream_end
Definition: rangecoder.h:44
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVPacket::size
int size
Definition: avcodec.h:1431
b
const char * b
Definition: vf_curves.c:113
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:384
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1727
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:349
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:372
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2540
put_symbol_inline
static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2])
Definition: ffv1enc.c:185
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
ring_size
static int ring_size(RingBuffer *ring)
Definition: async.c:105
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
FFV1Context::rc_stat2
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:86
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2741
ffv1.h
FF Video Codec 1 (a lossless codec)
src
#define src
Definition: vp8dsp.c:254
sample
#define sample
Definition: flacdsp_template.c:44
FFV1Context::height
int height
Definition: ffv1.h:89
AVCodec
AVCodec.
Definition: avcodec.h:3408
RangeCoder::one_state
uint8_t one_state[256]
Definition: rangecoder.h:41
attributes.h
Macro definitions for various function/variable attributes.
FFV1Context::slice_rct_by_coef
int slice_rct_by_coef
Definition: ffv1.h:139
log2
#define log2(x)
Definition: libm.h:404
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:350
FFV1Context::plane_count
int plane_count
Definition: ffv1.h:100
ff_rac_terminate
int ff_rac_terminate(RangeCoder *c)
Definition: rangecoder.c:109
write_quant_tables
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1enc.c:329
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:351
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:984
FFV1Context::picture
ThreadFrame picture
Definition: ffv1.h:96
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ff_alloc_packet2
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
AV_OPT_TYPE_CONST
Definition: opt.h:232
FFV1Context::rc_stat
uint64_t rc_stat[256][2]
Definition: ffv1.h:85
FFV1Context::pb
PutBitContext pb
Definition: ffv1.h:84
AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:97
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:82
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:233
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
opt.h
AVOptions.
VlcState::bias
int8_t bias
Definition: ffv1.h:64
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
FFV1Context::c
RangeCoder c
Definition: ffv1.h:82
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:441
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:311
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:42
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1618
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:508
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:400
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:383
quant11
static const int8_t quant11[256]
Definition: ffv1enc.c:101
FFV1Context::slice_y
int slice_y
Definition: ffv1.h:136
FFV1Context::initial_states
uint8_t(*[MAX_QUANT_TABLES] initial_states)[32]
Definition: ffv1.h:108
crc.h
Public header for CRC hash function implementation.
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:210
height
#define height
AVPacket::data
uint8_t * data
Definition: avcodec.h:1430
AVCodecContext::context_model
attribute_deprecated int context_model
Definition: avcodec.h:2436
VlcState::count
uint8_t count
Definition: ffv1.h:65
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
encode_slice
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:1032
choose_rct_params
static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
Definition: ffv1enc.c:950
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:381
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:365
size
ptrdiff_t size
Definition: opengl_enc.c:101
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:373
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2532
NB_Y_COEFF
#define NB_Y_COEFF
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:406
timer.h
high precision timer, useful to profile code
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:780
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
write_extradata
static int write_extradata(FFV1Context *f)
Definition: ffv1enc.c:384
FFV1Context::bits_per_raw_sample
int bits_per_raw_sample
Definition: ffv1.h:122
FFV1Context::slice_width
int slice_width
Definition: ffv1.h:133
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1462
U
#define U(x)
Definition: vp56_arith.h:37
sort_stt
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:460
ver2_state
static const uint8_t ver2_state[256]
Definition: ffv1enc.c:120
AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:172
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
ff_ffv1_init_slices_state
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:106
FFV1Context::quant_tables
int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:105
AVERROR
#define AVERROR(e)
Definition: error.h:43
AV_CRC_32_IEEE
Definition: crc.h:53
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2391
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
r
const char * r
Definition: vf_curves.c:111
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
PlaneContext::context_count
int context_count
Definition: ffv1.h:71
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:408
arg
const char * arg
Definition: jacosubdec.c:66
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1598
width
uint16_t width
Definition: gdv.c:47
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:389
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:354
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3415
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
quant5
static const int8_t quant5[256]
Definition: ffv1enc.c:63
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:371
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:167
MAX_SLICES
#define MAX_SLICES
Definition: dxva2_hevc.c:29
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:390
RangeCoder::bytestream
uint8_t * bytestream
Definition: rangecoder.h:43
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1436
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:66
FFV1Context::ac
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:101
FFV1Context::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:104
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:58
FFV1Context::run_index
int run_index
Definition: ffv1.h:109
VlcState
Definition: ffv1.h:61
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:366
av_flatten
#define av_flatten
Definition: attributes.h:88
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: ffv1enc.c:1111
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: ffv1enc.c:1274
FFV1Context::state_transition
uint8_t state_transition[256]
Definition: ffv1.h:107
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:301
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:387
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:352
FFV1Context::key_frame
int key_frame
Definition: ffv1.h:95
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
FFV1Context::num_h_slices
int num_h_slices
Definition: ffv1.h:132
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1690
w
uint8_t w
Definition: llviddspenc.c:38
FFV1Context::colorspace
int colorspace
Definition: ffv1.h:110
quant_table
static float quant_table[96]
Definition: binkaudio.c:43
AV_OPT_TYPE_BOOL
Definition: opt.h:240
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:849
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:164
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
FFV1Context::slice_count
int slice_count
Definition: ffv1.h:129
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
ff_ffv1_encoder
AVCodec ff_ffv1_encoder
Definition: ffv1enc.c:1314
FFV1Context::max_slice_count
int max_slice_count
Definition: ffv1.h:130
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
AVCodecContext::level
int level
level
Definition: avcodec.h:2953
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:117
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:405
FFV1Context::ac_byte_count
int ac_byte_count
number of bytes used for AC coding
Definition: ffv1.h:102
state
static struct @271 state
VlcState::drift
int16_t drift
Definition: ffv1.h:62
FFV1Context::packed_at_lsb
int packed_at_lsb
Definition: ffv1.h:123
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:367
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:386
AVCodecContext::coder_type
attribute_deprecated int coder_type
Definition: avcodec.h:2430
VE
#define VE
Definition: ffv1enc.c:1281
options
static const AVOption options[]
Definition: ffv1enc.c:1282
pred
static const float pred[4]
Definition: siprdata.h:259
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:379
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1019
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:376
FFV1Context::context_count
int context_count[MAX_QUANT_TABLES]
Definition: ffv1.h:106
quant9_10bit
static const int8_t quant9_10bit[256]
Definition: ffv1enc.c:82
avcodec.h
Libavcodec external API header.
AC_RANGE_DEFAULT_TAB_FORCE
#define AC_RANGE_DEFAULT_TAB_FORCE
Definition: ffv1.h:59
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:249
STATS_OUT_SIZE
#define STATS_OUT_SIZE
AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:173
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
AVCodecContext
main external API structure.
Definition: avcodec.h:1518
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:342
FFV1Context::intra
int intra
Definition: ffv1.h:117
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:306
find_best_state
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256])
Definition: ffv1enc.c:139
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:1619
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:368
AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:68
write_quant_table
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition: ffv1enc.c:314
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
ff_init_range_encoder
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:42
FFV1Context::use32bit
int use32bit
Definition: ffv1.h:114
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:56
put_vlc_symbol
static void put_vlc_symbol(PutBitContext *pb, VlcState *const state, int v, int bits)
Definition: ffv1enc.c:240
encode_plane
static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index, int pixel_stride)
Definition: ffv1enc.c:274
set_sr_golomb
static void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len)
write signed golomb rice code (ffv1).
Definition: golomb.h:565
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:374
FFV1Context::picture_number
int picture_number
Definition: ffv1.h:94
VlcState::error_sum
uint16_t error_sum
Definition: ffv1.h:63
AC_RANGE_DEFAULT_TAB
#define AC_RANGE_DEFAULT_TAB
Definition: ffv1.h:57
ffv1_class
static const AVClass ffv1_class
Definition: ffv1enc.c:1300
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:365
snprintf
#define snprintf
Definition: snprintf.h:34
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:377
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:385
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:551
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:51
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:369
FFV1Context::gob_count
int gob_count
Definition: ffv1.h:125
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:70
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:375
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:232
OFFSET
#define OFFSET(x)
Definition: ffv1enc.c:1280
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1712
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
COST2
#define COST2(old, new)
AV_CODEC_ID_FFV1
Definition: avcodec.h:251
stride
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
FFV1Context::context_model
int context_model
Definition: ffv1.h:120
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:62
AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:70
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
internal.h
common internal api header.
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
if
if(ret< 0)
Definition: vf_mcdeint.c:279
quant5_10bit
static const int8_t quant5_10bit[256]
Definition: ffv1enc.c:44
c
static double c[64]
Definition: vsrc_mptestsrc.c:87
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:182
put_rac
#define put_rac(C, S, B)
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:402
AVCodecContext::coded_frame
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2760
AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:69
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
AVRational::den
int den
Denominator.
Definition: rational.h:60
planes
static const struct @272 planes[]
FFV1Context::slice_coding_mode
int slice_coding_mode
Definition: ffv1.h:138
RangeCoder::bytestream_start
uint8_t * bytestream_start
Definition: rangecoder.h:42
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:773
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:853
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:2164
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1545
FFV1Context::chroma_h_shift
int chroma_h_shift
Definition: ffv1.h:91
FFV1Context::plane
PlaneContext plane[MAX_PLANES]
Definition: ffv1.h:103
FFV1Context::transparency
int transparency
Definition: ffv1.h:92
AVCodecContext::execute
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2809
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
FFV1Context::chroma_v_shift
int chroma_v_shift
Definition: ffv1.h:91
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:370
len
int len
Definition: vorbis_enc_data.h:452
FFV1Context::chroma_planes
int chroma_planes
Definition: ffv1.h:90
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:296
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:337
FFV1Context::slice_context
struct FFV1Context * slice_context[MAX_SLICES]
Definition: ffv1.h:128
ffv1enc_template.c
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1429
av_noinline
#define av_noinline
Definition: attributes.h:62
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:95
start
void INT64 start
Definition: avisynth_c.h:690
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_always_inline
#define av_always_inline
Definition: attributes.h:39
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
FFV1Context::ec
int ec
Definition: ffv1.h:116
FFV1Context::num_v_slices
int num_v_slices
Definition: ffv1.h:131
golomb.h
exp golomb vlc stuff
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1407
FFV1Context::avctx
AVCodecContext * avctx
Definition: ffv1.h:81
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2576
print
static void print(AVTreeNode *t, int depth)
Definition: tree.c:44
FFV1Context::slice_x
int slice_x
Definition: ffv1.h:135
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:380
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1423
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:41
FFV1Context::width
int width
Definition: ffv1.h:89
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:346
a
a
Definition: h264pred_template.c:468
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
FFV1Context::slice_rct_ry_coef
int slice_rct_ry_coef
Definition: ffv1.h:140
put_bits.h
bitstream writer API
Generated on Sun May 13 2018 02:03:46 for FFmpeg by   doxygen 1.8.6