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 #include "avcodec.h"
36 #include "internal.h"
37 #include "put_bits.h"
38 #include "rangecoder.h"
39 #include "golomb.h"
40 #include "mathops.h"
41 #include "ffv1.h"
42 
43 static const int8_t quant5_10bit[256] = {
44  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
45  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
48  2, 2, 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, -1,
57  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -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, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
60 };
61 
62 static const int8_t quant5[256] = {
63  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
64  2, 2, 2, 2, 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, -1, -1, -1,
79 };
80 
81 static const int8_t quant9_10bit[256] = {
82  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
83  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
84  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
85  3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
86  4, 4, 4, 4, 4, 4, 4, 4, 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, -3, -3, -3, -3, -3, -3, -3,
95  -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
96  -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
97  -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
98 };
99 
100 static const int8_t quant11[256] = {
101  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
102  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
103  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
104  5, 5, 5, 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, -4, -4,
115  -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
116  -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
117 };
118 
119 static const uint8_t ver2_state[256] = {
120  0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
121  59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
122  40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
123  53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
124  87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
125  85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
126  105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
127  115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
128  165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
129  147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
130  172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
131  175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
132  197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
133  209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
134  226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
135  241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
136 };
137 
138 static void find_best_state(uint8_t best_state[256][256],
139  const uint8_t one_state[256])
140 {
141  int i, j, k, m;
142  double l2tab[256];
143 
144  for (i = 1; i < 256; i++)
145  l2tab[i] = log2(i / 256.0);
146 
147  for (i = 0; i < 256; i++) {
148  double best_len[256];
149  double p = i / 256.0;
150 
151  for (j = 0; j < 256; j++)
152  best_len[j] = 1 << 30;
153 
154  for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
155  double occ[256] = { 0 };
156  double len = 0;
157  occ[j] = 1.0;
158 
159  if (!one_state[j])
160  continue;
161 
162  for (k = 0; k < 256; k++) {
163  double newocc[256] = { 0 };
164  for (m = 1; m < 256; m++)
165  if (occ[m]) {
166  len -=occ[m]*( p *l2tab[ m]
167  + (1-p)*l2tab[256-m]);
168  }
169  if (len < best_len[k]) {
170  best_len[k] = len;
171  best_state[i][k] = j;
172  }
173  for (m = 1; m < 256; m++)
174  if (occ[m]) {
175  newocc[ one_state[ m]] += occ[m] * p;
176  newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
177  }
178  memcpy(occ, newocc, sizeof(occ));
179  }
180  }
181  }
182 }
183 
184 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
185  uint8_t *state, int v,
186  int is_signed,
187  uint64_t rc_stat[256][2],
188  uint64_t rc_stat2[32][2])
189 {
190  int i;
191 
192 #define put_rac(C, S, B) \
193  do { \
194  if (rc_stat) { \
195  rc_stat[*(S)][B]++; \
196  rc_stat2[(S) - state][B]++; \
197  } \
198  put_rac(C, S, B); \
199  } while (0)
200 
201  if (v) {
202  const int a = FFABS(v);
203  const int e = av_log2(a);
204  put_rac(c, state + 0, 0);
205  if (e <= 9) {
206  for (i = 0; i < e; i++)
207  put_rac(c, state + 1 + i, 1); // 1..10
208  put_rac(c, state + 1 + i, 0);
209 
210  for (i = e - 1; i >= 0; i--)
211  put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
212 
213  if (is_signed)
214  put_rac(c, state + 11 + e, v < 0); // 11..21
215  } else {
216  for (i = 0; i < e; i++)
217  put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
218  put_rac(c, state + 1 + 9, 0);
219 
220  for (i = e - 1; i >= 0; i--)
221  put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
222 
223  if (is_signed)
224  put_rac(c, state + 11 + 10, v < 0); // 11..21
225  }
226  } else {
227  put_rac(c, state + 0, 1);
228  }
229 #undef put_rac
230 }
231 
232 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
233  int v, int is_signed)
234 {
235  put_symbol_inline(c, state, v, is_signed, NULL, NULL);
236 }
237 
238 
239 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
240  int v, int bits)
241 {
242  int i, k, code;
243  v = fold(v - state->bias, bits);
244 
245  i = state->count;
246  k = 0;
247  while (i < state->error_sum) { // FIXME: optimize
248  k++;
249  i += i;
250  }
251 
252  av_assert2(k <= 13);
253 
254 #if 0 // JPEG LS
255  if (k == 0 && 2 * state->drift <= -state->count)
256  code = v ^ (-1);
257  else
258  code = v;
259 #else
260  code = v ^ ((2 * state->drift + state->count) >> 31);
261 #endif
262 
263  ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
264  state->bias, state->error_sum, state->drift, state->count, k);
265  set_sr_golomb(pb, code, k, 12, bits);
266 
267  update_vlc_state(state, v);
268 }
269 
270 static av_always_inline int encode_line(FFV1Context *s, int w,
271  int16_t *sample[3],
272  int plane_index, int bits)
273 {
274  PlaneContext *const p = &s->plane[plane_index];
275  RangeCoder *const c = &s->c;
276  int x;
277  int run_index = s->run_index;
278  int run_count = 0;
279  int run_mode = 0;
280 
281  if (s->ac != AC_GOLOMB_RICE) {
282  if (c->bytestream_end - c->bytestream < w * 35) {
283  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
284  return AVERROR_INVALIDDATA;
285  }
286  } else {
287  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
288  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
289  return AVERROR_INVALIDDATA;
290  }
291  }
292 
293  if (s->slice_coding_mode == 1) {
294  for (x = 0; x < w; x++) {
295  int i;
296  int v = sample[0][x];
297  for (i = bits-1; i>=0; i--) {
298  uint8_t state = 128;
299  put_rac(c, &state, (v>>i) & 1);
300  }
301  }
302  return 0;
303  }
304 
305  for (x = 0; x < w; x++) {
306  int diff, context;
307 
308  context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
309  diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
310 
311  if (context < 0) {
312  context = -context;
313  diff = -diff;
314  }
315 
316  diff = fold(diff, bits);
317 
318  if (s->ac != AC_GOLOMB_RICE) {
319  if (s->flags & AV_CODEC_FLAG_PASS1) {
320  put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
321  s->rc_stat2[p->quant_table_index][context]);
322  } else {
323  put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
324  }
325  } else {
326  if (context == 0)
327  run_mode = 1;
328 
329  if (run_mode) {
330  if (diff) {
331  while (run_count >= 1 << ff_log2_run[run_index]) {
332  run_count -= 1 << ff_log2_run[run_index];
333  run_index++;
334  put_bits(&s->pb, 1, 1);
335  }
336 
337  put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
338  if (run_index)
339  run_index--;
340  run_count = 0;
341  run_mode = 0;
342  if (diff > 0)
343  diff--;
344  } else {
345  run_count++;
346  }
347  }
348 
349  ff_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
350  run_count, run_index, run_mode, x,
351  (int)put_bits_count(&s->pb));
352 
353  if (run_mode == 0)
354  put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
355  }
356  }
357  if (run_mode) {
358  while (run_count >= 1 << ff_log2_run[run_index]) {
359  run_count -= 1 << ff_log2_run[run_index];
360  run_index++;
361  put_bits(&s->pb, 1, 1);
362  }
363 
364  if (run_count)
365  put_bits(&s->pb, 1, 1);
366  }
367  s->run_index = run_index;
368 
369  return 0;
370 }
371 
372 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
373  int stride, int plane_index, int pixel_stride)
374 {
375  int x, y, i, ret;
376  const int ring_size = s->context_model ? 3 : 2;
377  int16_t *sample[3];
378  s->run_index = 0;
379 
380  memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
381 
382  for (y = 0; y < h; y++) {
383  for (i = 0; i < ring_size; i++)
384  sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
385 
386  sample[0][-1]= sample[1][0 ];
387  sample[1][ w]= sample[1][w-1];
388 // { START_TIMER
389  if (s->bits_per_raw_sample <= 8) {
390  for (x = 0; x < w; x++)
391  sample[0][x] = src[x * pixel_stride + stride * y];
392  if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
393  return ret;
394  } else {
395  if (s->packed_at_lsb) {
396  for (x = 0; x < w; x++) {
397  sample[0][x] = ((uint16_t*)(src + stride*y))[x];
398  }
399  } else {
400  for (x = 0; x < w; x++) {
401  sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
402  }
403  }
404  if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
405  return ret;
406  }
407 // STOP_TIMER("encode line") }
408  }
409  return 0;
410 }
411 
412 static int encode_rgb_frame(FFV1Context *s, const uint8_t *src[3],
413  int w, int h, const int stride[3])
414 {
415  int x, y, p, i;
416  const int ring_size = s->context_model ? 3 : 2;
417  int16_t *sample[4][3];
418  int lbd = s->bits_per_raw_sample <= 8;
419  int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
420  int offset = 1 << bits;
421 
422  s->run_index = 0;
423 
424  memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
425  (w + 6) * sizeof(*s->sample_buffer));
426 
427  for (y = 0; y < h; y++) {
428  for (i = 0; i < ring_size; i++)
429  for (p = 0; p < MAX_PLANES; p++)
430  sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
431 
432  for (x = 0; x < w; x++) {
433  int b, g, r, av_uninit(a);
434  if (lbd) {
435  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
436  b = v & 0xFF;
437  g = (v >> 8) & 0xFF;
438  r = (v >> 16) & 0xFF;
439  a = v >> 24;
440  } else {
441  b = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
442  g = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
443  r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
444  }
445 
446  if (s->slice_coding_mode != 1) {
447  b -= g;
448  r -= g;
449  g += (b * s->slice_rct_by_coef + r * s->slice_rct_ry_coef) >> 2;
450  b += offset;
451  r += offset;
452  }
453 
454  sample[0][0][x] = g;
455  sample[1][0][x] = b;
456  sample[2][0][x] = r;
457  sample[3][0][x] = a;
458  }
459  for (p = 0; p < 3 + s->transparency; p++) {
460  int ret;
461  sample[p][0][-1] = sample[p][1][0 ];
462  sample[p][1][ w] = sample[p][1][w-1];
463  if (lbd && s->slice_coding_mode == 0)
464  ret = encode_line(s, w, sample[p], (p + 1) / 2, 9);
465  else
466  ret = encode_line(s, w, sample[p], (p + 1) / 2, bits + (s->slice_coding_mode != 1));
467  if (ret < 0)
468  return ret;
469  }
470  }
471  return 0;
472 }
473 
474 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
475 {
476  int last = 0;
477  int i;
478  uint8_t state[CONTEXT_SIZE];
479  memset(state, 128, sizeof(state));
480 
481  for (i = 1; i < 128; i++)
482  if (quant_table[i] != quant_table[i - 1]) {
483  put_symbol(c, state, i - last - 1, 0);
484  last = i;
485  }
486  put_symbol(c, state, i - last - 1, 0);
487 }
488 
489 static void write_quant_tables(RangeCoder *c,
490  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
491 {
492  int i;
493  for (i = 0; i < 5; i++)
494  write_quant_table(c, quant_table[i]);
495 }
496 
497 static void write_header(FFV1Context *f)
498 {
499  uint8_t state[CONTEXT_SIZE];
500  int i, j;
501  RangeCoder *const c = &f->slice_context[0]->c;
502 
503  memset(state, 128, sizeof(state));
504 
505  if (f->version < 2) {
506  put_symbol(c, state, f->version, 0);
507  put_symbol(c, state, f->ac, 0);
508  if (f->ac == AC_RANGE_CUSTOM_TAB) {
509  for (i = 1; i < 256; i++)
510  put_symbol(c, state,
511  f->state_transition[i] - c->one_state[i], 1);
512  }
513  put_symbol(c, state, f->colorspace, 0); //YUV cs type
514  if (f->version > 0)
515  put_symbol(c, state, f->bits_per_raw_sample, 0);
516  put_rac(c, state, f->chroma_planes);
517  put_symbol(c, state, f->chroma_h_shift, 0);
518  put_symbol(c, state, f->chroma_v_shift, 0);
519  put_rac(c, state, f->transparency);
520 
521  write_quant_tables(c, f->quant_table);
522  } else if (f->version < 3) {
523  put_symbol(c, state, f->slice_count, 0);
524  for (i = 0; i < f->slice_count; i++) {
525  FFV1Context *fs = f->slice_context[i];
526  put_symbol(c, state,
527  (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
528  put_symbol(c, state,
529  (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
530  put_symbol(c, state,
531  (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
532  0);
533  put_symbol(c, state,
534  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
535  0);
536  for (j = 0; j < f->plane_count; j++) {
537  put_symbol(c, state, f->plane[j].quant_table_index, 0);
538  av_assert0(f->plane[j].quant_table_index == f->context_model);
539  }
540  }
541  }
542 }
543 
544 static int write_extradata(FFV1Context *f)
545 {
546  RangeCoder *const c = &f->c;
547  uint8_t state[CONTEXT_SIZE];
548  int i, j, k;
549  uint8_t state2[32][CONTEXT_SIZE];
550  unsigned v;
551 
552  memset(state2, 128, sizeof(state2));
553  memset(state, 128, sizeof(state));
554 
555  f->avctx->extradata_size = 10000 + 4 +
556  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
557  f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
558  if (!f->avctx->extradata)
559  return AVERROR(ENOMEM);
560  ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
561  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
562 
563  put_symbol(c, state, f->version, 0);
564  if (f->version > 2) {
565  if (f->version == 3) {
566  f->micro_version = 4;
567  } else if (f->version == 4)
568  f->micro_version = 2;
569  put_symbol(c, state, f->micro_version, 0);
570  }
571 
572  put_symbol(c, state, f->ac, 0);
573  if (f->ac == AC_RANGE_CUSTOM_TAB)
574  for (i = 1; i < 256; i++)
575  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
576 
577  put_symbol(c, state, f->colorspace, 0); // YUV cs type
578  put_symbol(c, state, f->bits_per_raw_sample, 0);
579  put_rac(c, state, f->chroma_planes);
580  put_symbol(c, state, f->chroma_h_shift, 0);
581  put_symbol(c, state, f->chroma_v_shift, 0);
582  put_rac(c, state, f->transparency);
583  put_symbol(c, state, f->num_h_slices - 1, 0);
584  put_symbol(c, state, f->num_v_slices - 1, 0);
585 
586  put_symbol(c, state, f->quant_table_count, 0);
587  for (i = 0; i < f->quant_table_count; i++)
588  write_quant_tables(c, f->quant_tables[i]);
589 
590  for (i = 0; i < f->quant_table_count; i++) {
591  for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
592  if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
593  break;
594  if (j < f->context_count[i] * CONTEXT_SIZE) {
595  put_rac(c, state, 1);
596  for (j = 0; j < f->context_count[i]; j++)
597  for (k = 0; k < CONTEXT_SIZE; k++) {
598  int pred = j ? f->initial_states[i][j - 1][k] : 128;
599  put_symbol(c, state2[k],
600  (int8_t)(f->initial_states[i][j][k] - pred), 1);
601  }
602  } else {
603  put_rac(c, state, 0);
604  }
605  }
606 
607  if (f->version > 2) {
608  put_symbol(c, state, f->ec, 0);
609  put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
610  }
611 
612  f->avctx->extradata_size = ff_rac_terminate(c);
613  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
614  AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
615  f->avctx->extradata_size += 4;
616 
617  return 0;
618 }
619 
620 static int sort_stt(FFV1Context *s, uint8_t stt[256])
621 {
622  int i, i2, changed, print = 0;
623 
624  do {
625  changed = 0;
626  for (i = 12; i < 244; i++) {
627  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
628 
629 #define COST(old, new) \
630  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
631  s->rc_stat[old][1] * -log2((new) / 256.0)
632 
633 #define COST2(old, new) \
634  COST(old, new) + COST(256 - (old), 256 - (new))
635 
636  double size0 = COST2(i, i) + COST2(i2, i2);
637  double sizeX = COST2(i, i2) + COST2(i2, i);
638  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
639  int j;
640  FFSWAP(int, stt[i], stt[i2]);
641  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
642  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
643  if (i != 256 - i2) {
644  FFSWAP(int, stt[256 - i], stt[256 - i2]);
645  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
646  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
647  }
648  for (j = 1; j < 256; j++) {
649  if (stt[j] == i)
650  stt[j] = i2;
651  else if (stt[j] == i2)
652  stt[j] = i;
653  if (i != 256 - i2) {
654  if (stt[256 - j] == 256 - i)
655  stt[256 - j] = 256 - i2;
656  else if (stt[256 - j] == 256 - i2)
657  stt[256 - j] = 256 - i;
658  }
659  }
660  print = changed = 1;
661  }
662  }
663  }
664  } while (changed);
665  return print;
666 }
667 
668 static av_cold int encode_init(AVCodecContext *avctx)
669 {
670  FFV1Context *s = avctx->priv_data;
671  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
672  int i, j, k, m, ret;
673 
674  if ((ret = ff_ffv1_common_init(avctx)) < 0)
675  return ret;
676 
677  s->version = 0;
678 
679  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
680  avctx->slices > 1)
681  s->version = FFMAX(s->version, 2);
682 
683  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
684  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
685  s->version = FFMAX(s->version, 2);
686 
687  if (avctx->level <= 0 && s->version == 2) {
688  s->version = 3;
689  }
690  if (avctx->level >= 0 && avctx->level <= 4) {
691  if (avctx->level < s->version) {
692  av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
693  return AVERROR(EINVAL);
694  }
695  s->version = avctx->level;
696  }
697 
698  if (s->ec < 0) {
699  s->ec = (s->version >= 3);
700  }
701 
702  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
703  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
704  return AVERROR_INVALIDDATA;
705  }
706 
707 #if FF_API_CODER_TYPE
708 FF_DISABLE_DEPRECATION_WARNINGS
709  if (avctx->coder_type != -1)
710  s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
711  else
712 FF_ENABLE_DEPRECATION_WARNINGS
713 #endif
714  if (s->ac == 1) // Compatbility with common command line usage
715  s->ac = AC_RANGE_CUSTOM_TAB;
716  else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
717  s->ac = AC_RANGE_DEFAULT_TAB;
718 
719  s->plane_count = 3;
720  switch(avctx->pix_fmt) {
721  case AV_PIX_FMT_YUV444P9:
722  case AV_PIX_FMT_YUV422P9:
723  case AV_PIX_FMT_YUV420P9:
724  case AV_PIX_FMT_YUVA444P9:
725  case AV_PIX_FMT_YUVA422P9:
726  case AV_PIX_FMT_YUVA420P9:
727  if (!avctx->bits_per_raw_sample)
728  s->bits_per_raw_sample = 9;
729  case AV_PIX_FMT_YUV444P10:
730  case AV_PIX_FMT_YUV420P10:
731  case AV_PIX_FMT_YUV422P10:
732  case AV_PIX_FMT_YUVA444P10:
733  case AV_PIX_FMT_YUVA422P10:
734  case AV_PIX_FMT_YUVA420P10:
735  s->packed_at_lsb = 1;
736  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
737  s->bits_per_raw_sample = 10;
738  case AV_PIX_FMT_GRAY16:
739  case AV_PIX_FMT_YUV444P16:
740  case AV_PIX_FMT_YUV422P16:
741  case AV_PIX_FMT_YUV420P16:
742  case AV_PIX_FMT_YUVA444P16:
743  case AV_PIX_FMT_YUVA422P16:
744  case AV_PIX_FMT_YUVA420P16:
745  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
746  s->bits_per_raw_sample = 16;
747  } else if (!s->bits_per_raw_sample) {
748  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
749  }
750  if (s->bits_per_raw_sample <= 8) {
751  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
752  return AVERROR_INVALIDDATA;
753  }
754  if (s->ac == AC_GOLOMB_RICE) {
755  av_log(avctx, AV_LOG_INFO,
756  "bits_per_raw_sample > 8, forcing range coder\n");
757  s->ac = AC_RANGE_CUSTOM_TAB;
758  }
759  s->version = FFMAX(s->version, 1);
760  case AV_PIX_FMT_GRAY8:
761  case AV_PIX_FMT_YA8:
762  case AV_PIX_FMT_YUV444P:
763  case AV_PIX_FMT_YUV440P:
764  case AV_PIX_FMT_YUV422P:
765  case AV_PIX_FMT_YUV420P:
766  case AV_PIX_FMT_YUV411P:
767  case AV_PIX_FMT_YUV410P:
768  case AV_PIX_FMT_YUVA444P:
769  case AV_PIX_FMT_YUVA422P:
770  case AV_PIX_FMT_YUVA420P:
771  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
772  s->colorspace = 0;
773  s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
774  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
775  s->bits_per_raw_sample = 8;
776  else if (!s->bits_per_raw_sample)
777  s->bits_per_raw_sample = 8;
778  break;
779  case AV_PIX_FMT_RGB32:
780  s->colorspace = 1;
781  s->transparency = 1;
782  s->chroma_planes = 1;
783  if (!avctx->bits_per_raw_sample)
784  s->bits_per_raw_sample = 8;
785  break;
786  case AV_PIX_FMT_0RGB32:
787  s->colorspace = 1;
788  s->chroma_planes = 1;
789  if (!avctx->bits_per_raw_sample)
790  s->bits_per_raw_sample = 8;
791  break;
792  case AV_PIX_FMT_GBRP9:
793  if (!avctx->bits_per_raw_sample)
794  s->bits_per_raw_sample = 9;
795  case AV_PIX_FMT_GBRP10:
796  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
797  s->bits_per_raw_sample = 10;
798  case AV_PIX_FMT_GBRP12:
799  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
800  s->bits_per_raw_sample = 12;
801  case AV_PIX_FMT_GBRP14:
802  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
803  s->bits_per_raw_sample = 14;
804  else if (!s->bits_per_raw_sample)
805  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
806  s->colorspace = 1;
807  s->chroma_planes = 1;
808  s->version = FFMAX(s->version, 1);
809  if (s->ac == AC_GOLOMB_RICE) {
810  av_log(avctx, AV_LOG_INFO,
811  "bits_per_raw_sample > 8, forcing coder 1\n");
812  s->ac = AC_RANGE_CUSTOM_TAB;
813  }
814  break;
815  default:
816  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
817  return AVERROR(ENOSYS);
818  }
819  av_assert0(s->bits_per_raw_sample >= 8);
820 
821  if (s->transparency) {
822  av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
823  }
824 #if FF_API_PRIVATE_OPT
825 FF_DISABLE_DEPRECATION_WARNINGS
826  if (avctx->context_model)
827  s->context_model = avctx->context_model;
828  if (avctx->context_model > 1U) {
829  av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
830  return AVERROR(EINVAL);
831  }
832 FF_ENABLE_DEPRECATION_WARNINGS
833 #endif
834 
835  if (s->ac == AC_RANGE_CUSTOM_TAB) {
836  for (i = 1; i < 256; i++)
837  s->state_transition[i] = ver2_state[i];
838  } else {
839  RangeCoder c;
840  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
841  for (i = 1; i < 256; i++)
842  s->state_transition[i] = c.one_state[i];
843  }
844 
845  for (i = 0; i < 256; i++) {
846  s->quant_table_count = 2;
847  if (s->bits_per_raw_sample <= 8) {
848  s->quant_tables[0][0][i]= quant11[i];
849  s->quant_tables[0][1][i]= 11*quant11[i];
850  s->quant_tables[0][2][i]= 11*11*quant11[i];
851  s->quant_tables[1][0][i]= quant11[i];
852  s->quant_tables[1][1][i]= 11*quant11[i];
853  s->quant_tables[1][2][i]= 11*11*quant5 [i];
854  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
855  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
856  } else {
857  s->quant_tables[0][0][i]= quant9_10bit[i];
858  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
859  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
860  s->quant_tables[1][0][i]= quant9_10bit[i];
861  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
862  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
863  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
864  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
865  }
866  }
867  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
868  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
869  memcpy(s->quant_table, s->quant_tables[s->context_model],
870  sizeof(s->quant_table));
871 
872  for (i = 0; i < s->plane_count; i++) {
873  PlaneContext *const p = &s->plane[i];
874 
875  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
876  p->quant_table_index = s->context_model;
877  p->context_count = s->context_count[p->quant_table_index];
878  }
879 
880  if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
881  return ret;
882 
883 #if FF_API_CODED_FRAME
884 FF_DISABLE_DEPRECATION_WARNINGS
885  avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
886 FF_ENABLE_DEPRECATION_WARNINGS
887 #endif
888 
889  if (!s->transparency)
890  s->plane_count = 2;
891  if (!s->chroma_planes && s->version > 3)
892  s->plane_count--;
893 
894  avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
895  s->picture_number = 0;
896 
897  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
898  for (i = 0; i < s->quant_table_count; i++) {
899  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
900  sizeof(*s->rc_stat2[i]));
901  if (!s->rc_stat2[i])
902  return AVERROR(ENOMEM);
903  }
904  }
905  if (avctx->stats_in) {
906  char *p = avctx->stats_in;
907  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
908  int gob_count = 0;
909  char *next;
910  if (!best_state)
911  return AVERROR(ENOMEM);
912 
913  av_assert0(s->version >= 2);
914 
915  for (;;) {
916  for (j = 0; j < 256; j++)
917  for (i = 0; i < 2; i++) {
918  s->rc_stat[j][i] = strtol(p, &next, 0);
919  if (next == p) {
920  av_log(avctx, AV_LOG_ERROR,
921  "2Pass file invalid at %d %d [%s]\n", j, i, p);
922  av_freep(&best_state);
923  return AVERROR_INVALIDDATA;
924  }
925  p = next;
926  }
927  for (i = 0; i < s->quant_table_count; i++)
928  for (j = 0; j < s->context_count[i]; j++) {
929  for (k = 0; k < 32; k++)
930  for (m = 0; m < 2; m++) {
931  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
932  if (next == p) {
933  av_log(avctx, AV_LOG_ERROR,
934  "2Pass file invalid at %d %d %d %d [%s]\n",
935  i, j, k, m, p);
936  av_freep(&best_state);
937  return AVERROR_INVALIDDATA;
938  }
939  p = next;
940  }
941  }
942  gob_count = strtol(p, &next, 0);
943  if (next == p || gob_count <= 0) {
944  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
945  av_freep(&best_state);
946  return AVERROR_INVALIDDATA;
947  }
948  p = next;
949  while (*p == '\n' || *p == ' ')
950  p++;
951  if (p[0] == 0)
952  break;
953  }
954  if (s->ac == AC_RANGE_CUSTOM_TAB)
955  sort_stt(s, s->state_transition);
956 
957  find_best_state(best_state, s->state_transition);
958 
959  for (i = 0; i < s->quant_table_count; i++) {
960  for (k = 0; k < 32; k++) {
961  double a=0, b=0;
962  int jp = 0;
963  for (j = 0; j < s->context_count[i]; j++) {
964  double p = 128;
965  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
966  if (a+b)
967  p = 256.0 * b / (a + b);
968  s->initial_states[i][jp][k] =
969  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
970  for(jp++; jp<j; jp++)
971  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
972  a=b=0;
973  }
974  a += s->rc_stat2[i][j][k][0];
975  b += s->rc_stat2[i][j][k][1];
976  if (a+b) {
977  p = 256.0 * b / (a + b);
978  }
979  s->initial_states[i][j][k] =
980  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
981  }
982  }
983  }
984  av_freep(&best_state);
985  }
986 
987  if (s->version > 1) {
988  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
989  for (; s->num_v_slices < 9; s->num_v_slices++) {
990  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
991  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
992  goto slices_ok;
993  }
994  }
995  av_log(avctx, AV_LOG_ERROR,
996  "Unsupported number %d of slices requested, please specify a "
997  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
998  avctx->slices);
999  return AVERROR(ENOSYS);
1000 slices_ok:
1001  if ((ret = write_extradata(s)) < 0)
1002  return ret;
1003  }
1004 
1005  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
1006  return ret;
1007  s->slice_count = s->max_slice_count;
1008  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
1009  return ret;
1010 
1011 #define STATS_OUT_SIZE 1024 * 1024 * 6
1012  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1013  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
1014  if (!avctx->stats_out)
1015  return AVERROR(ENOMEM);
1016  for (i = 0; i < s->quant_table_count; i++)
1017  for (j = 0; j < s->max_slice_count; j++) {
1018  FFV1Context *sf = s->slice_context[j];
1019  av_assert0(!sf->rc_stat2[i]);
1020  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
1021  sizeof(*sf->rc_stat2[i]));
1022  if (!sf->rc_stat2[i])
1023  return AVERROR(ENOMEM);
1024  }
1025  }
1026 
1027  return 0;
1028 }
1029 
1030 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
1031 {
1032  RangeCoder *c = &fs->c;
1033  uint8_t state[CONTEXT_SIZE];
1034  int j;
1035  memset(state, 128, sizeof(state));
1036 
1037  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
1038  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
1039  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
1040  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
1041  for (j=0; j<f->plane_count; j++) {
1042  put_symbol(c, state, f->plane[j].quant_table_index, 0);
1043  av_assert0(f->plane[j].quant_table_index == f->context_model);
1044  }
1045  if (!f->picture.f->interlaced_frame)
1046  put_symbol(c, state, 3, 0);
1047  else
1048  put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
1049  put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
1050  put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
1051  if (f->version > 3) {
1052  put_rac(c, state, fs->slice_coding_mode == 1);
1053  if (fs->slice_coding_mode == 1)
1054  ff_ffv1_clear_slice_state(f, fs);
1055  put_symbol(c, state, fs->slice_coding_mode, 0);
1056  if (fs->slice_coding_mode != 1) {
1057  put_symbol(c, state, fs->slice_rct_by_coef, 0);
1058  put_symbol(c, state, fs->slice_rct_ry_coef, 0);
1059  }
1060  }
1061 }
1062 
1063 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
1064 {
1065 #define NB_Y_COEFF 15
1066  static const int rct_y_coeff[15][2] = {
1067  {0, 0}, // 4G
1068  {1, 1}, // R + 2G + B
1069  {2, 2}, // 2R + 2B
1070  {0, 2}, // 2G + 2B
1071  {2, 0}, // 2R + 2G
1072  {4, 0}, // 4R
1073  {0, 4}, // 4B
1074 
1075  {0, 3}, // 1G + 3B
1076  {3, 0}, // 3R + 1G
1077  {3, 1}, // 3R + B
1078  {1, 3}, // R + 3B
1079  {1, 2}, // R + G + 2B
1080  {2, 1}, // 2R + G + B
1081  {0, 1}, // 3G + B
1082  {1, 0}, // R + 3G
1083  };
1084 
1085  int stat[NB_Y_COEFF] = {0};
1086  int x, y, i, p, best;
1087  int16_t *sample[3];
1088  int lbd = fs->bits_per_raw_sample <= 8;
1089 
1090  for (y = 0; y < h; y++) {
1091  int lastr=0, lastg=0, lastb=0;
1092  for (p = 0; p < 3; p++)
1093  sample[p] = fs->sample_buffer + p*w;
1094 
1095  for (x = 0; x < w; x++) {
1096  int b, g, r;
1097  int ab, ag, ar;
1098  if (lbd) {
1099  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1100  b = v & 0xFF;
1101  g = (v >> 8) & 0xFF;
1102  r = (v >> 16) & 0xFF;
1103  } else {
1104  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1105  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1106  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1107  }
1108 
1109  ar = r - lastr;
1110  ag = g - lastg;
1111  ab = b - lastb;
1112  if (x && y) {
1113  int bg = ag - sample[0][x];
1114  int bb = ab - sample[1][x];
1115  int br = ar - sample[2][x];
1116 
1117  br -= bg;
1118  bb -= bg;
1119 
1120  for (i = 0; i<NB_Y_COEFF; i++) {
1121  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1122  }
1123 
1124  }
1125  sample[0][x] = ag;
1126  sample[1][x] = ab;
1127  sample[2][x] = ar;
1128 
1129  lastr = r;
1130  lastg = g;
1131  lastb = b;
1132  }
1133  }
1134 
1135  best = 0;
1136  for (i=1; i<NB_Y_COEFF; i++) {
1137  if (stat[i] < stat[best])
1138  best = i;
1139  }
1140 
1141  fs->slice_rct_by_coef = rct_y_coeff[best][1];
1142  fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1143 }
1144 
1145 static int encode_slice(AVCodecContext *c, void *arg)
1146 {
1147  FFV1Context *fs = *(void **)arg;
1148  FFV1Context *f = fs->avctx->priv_data;
1149  int width = fs->slice_width;
1150  int height = fs->slice_height;
1151  int x = fs->slice_x;
1152  int y = fs->slice_y;
1153  const AVFrame *const p = f->picture.f;
1154  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1155  int ret;
1156  RangeCoder c_bak = fs->c;
1157  const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1158  p->data[1] + ps*x + y*p->linesize[1],
1159  p->data[2] + ps*x + y*p->linesize[2]};
1160 
1161  fs->slice_coding_mode = 0;
1162  if (f->version > 3) {
1163  choose_rct_params(fs, planes, p->linesize, width, height);
1164  } else {
1165  fs->slice_rct_by_coef = 1;
1166  fs->slice_rct_ry_coef = 1;
1167  }
1168 
1169 retry:
1170  if (f->key_frame)
1171  ff_ffv1_clear_slice_state(f, fs);
1172  if (f->version > 2) {
1173  encode_slice_header(f, fs);
1174  }
1175  if (fs->ac == AC_GOLOMB_RICE) {
1176  if (f->version > 2)
1177  put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1178  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1179  init_put_bits(&fs->pb,
1180  fs->c.bytestream_start + fs->ac_byte_count,
1181  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1182  }
1183 
1184  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1185  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1186  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1187  const int cx = x >> f->chroma_h_shift;
1188  const int cy = y >> f->chroma_v_shift;
1189 
1190  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1191 
1192  if (f->chroma_planes) {
1193  ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1194  ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1195  }
1196  if (fs->transparency)
1197  ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1198  } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1199  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1200  ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1201  } else {
1202  ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1203  }
1204  emms_c();
1205 
1206  if (ret < 0) {
1207  av_assert0(fs->slice_coding_mode == 0);
1208  if (fs->version < 4 || !fs->ac) {
1209  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1210  return ret;
1211  }
1212  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1213  fs->slice_coding_mode = 1;
1214  fs->c = c_bak;
1215  goto retry;
1216  }
1217 
1218  return 0;
1219 }
1220 
1221 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1222  const AVFrame *pict, int *got_packet)
1223 {
1224  FFV1Context *f = avctx->priv_data;
1225  RangeCoder *const c = &f->slice_context[0]->c;
1226  AVFrame *const p = f->picture.f;
1227  int used_count = 0;
1228  uint8_t keystate = 128;
1229  uint8_t *buf_p;
1230  int i, ret;
1231  int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1232  + avctx->width*avctx->height*35LL*4;
1233 
1234  if(!pict) {
1235  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1236  int j, k, m;
1237  char *p = avctx->stats_out;
1238  char *end = p + STATS_OUT_SIZE;
1239 
1240  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1241  for (i = 0; i < f->quant_table_count; i++)
1242  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1243 
1244  av_assert0(f->slice_count == f->max_slice_count);
1245  for (j = 0; j < f->slice_count; j++) {
1246  FFV1Context *fs = f->slice_context[j];
1247  for (i = 0; i < 256; i++) {
1248  f->rc_stat[i][0] += fs->rc_stat[i][0];
1249  f->rc_stat[i][1] += fs->rc_stat[i][1];
1250  }
1251  for (i = 0; i < f->quant_table_count; i++) {
1252  for (k = 0; k < f->context_count[i]; k++)
1253  for (m = 0; m < 32; m++) {
1254  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1255  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1256  }
1257  }
1258  }
1259 
1260  for (j = 0; j < 256; j++) {
1261  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1262  f->rc_stat[j][0], f->rc_stat[j][1]);
1263  p += strlen(p);
1264  }
1265  snprintf(p, end - p, "\n");
1266 
1267  for (i = 0; i < f->quant_table_count; i++) {
1268  for (j = 0; j < f->context_count[i]; j++)
1269  for (m = 0; m < 32; m++) {
1270  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1271  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1272  p += strlen(p);
1273  }
1274  }
1275  snprintf(p, end - p, "%d\n", f->gob_count);
1276  }
1277  return 0;
1278  }
1279 
1280  if (f->version > 3)
1281  maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1282 
1283  if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1284  return ret;
1285 
1286  ff_init_range_encoder(c, pkt->data, pkt->size);
1287  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1288 
1289  av_frame_unref(p);
1290  if ((ret = av_frame_ref(p, pict)) < 0)
1291  return ret;
1292  avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1293 
1294  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1295  put_rac(c, &keystate, 1);
1296  f->key_frame = 1;
1297  f->gob_count++;
1298  write_header(f);
1299  } else {
1300  put_rac(c, &keystate, 0);
1301  f->key_frame = 0;
1302  }
1303 
1304  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1305  int i;
1306  for (i = 1; i < 256; i++) {
1307  c->one_state[i] = f->state_transition[i];
1308  c->zero_state[256 - i] = 256 - c->one_state[i];
1309  }
1310  }
1311 
1312  for (i = 1; i < f->slice_count; i++) {
1313  FFV1Context *fs = f->slice_context[i];
1314  uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1315  int len = pkt->size / f->slice_count;
1316  ff_init_range_encoder(&fs->c, start, len);
1317  }
1318  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1319  f->slice_count, sizeof(void *));
1320 
1321  buf_p = pkt->data;
1322  for (i = 0; i < f->slice_count; i++) {
1323  FFV1Context *fs = f->slice_context[i];
1324  int bytes;
1325 
1326  if (fs->ac != AC_GOLOMB_RICE) {
1327  uint8_t state = 129;
1328  put_rac(&fs->c, &state, 0);
1329  bytes = ff_rac_terminate(&fs->c);
1330  } else {
1331  flush_put_bits(&fs->pb); // FIXME: nicer padding
1332  bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1333  }
1334  if (i > 0 || f->version > 2) {
1335  av_assert0(bytes < pkt->size / f->slice_count);
1336  memmove(buf_p, fs->c.bytestream_start, bytes);
1337  av_assert0(bytes < (1 << 24));
1338  AV_WB24(buf_p + bytes, bytes);
1339  bytes += 3;
1340  }
1341  if (f->ec) {
1342  unsigned v;
1343  buf_p[bytes++] = 0;
1344  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1345  AV_WL32(buf_p + bytes, v);
1346  bytes += 4;
1347  }
1348  buf_p += bytes;
1349  }
1350 
1351  if (avctx->flags & AV_CODEC_FLAG_PASS1)
1352  avctx->stats_out[0] = '\0';
1353 
1354 #if FF_API_CODED_FRAME
1355 FF_DISABLE_DEPRECATION_WARNINGS
1356  avctx->coded_frame->key_frame = f->key_frame;
1357 FF_ENABLE_DEPRECATION_WARNINGS
1358 #endif
1359 
1360  f->picture_number++;
1361  pkt->size = buf_p - pkt->data;
1362  pkt->pts =
1363  pkt->dts = pict->pts;
1364  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1365  *got_packet = 1;
1366 
1367  return 0;
1368 }
1369 
1370 static av_cold int encode_close(AVCodecContext *avctx)
1371 {
1372  ff_ffv1_close(avctx);
1373  return 0;
1374 }
1375 
1376 #define OFFSET(x) offsetof(FFV1Context, x)
1377 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1378 static const AVOption options[] = {
1379  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1380  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1381  { .i64 = 0 }, -2, 2, VE, "coder" },
1382  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1383  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1384  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1385  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1386  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1387  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1388  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1389  { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1390  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1391  { .i64 = 0 }, 0, 1, VE },
1392 
1393  { NULL }
1394 };
1395 
1396 static const AVClass ffv1_class = {
1397  .class_name = "ffv1 encoder",
1398  .item_name = av_default_item_name,
1399  .option = options,
1400  .version = LIBAVUTIL_VERSION_INT,
1401 };
1402 
1403 #if FF_API_CODER_TYPE
1404 static const AVCodecDefault ffv1_defaults[] = {
1405  { "coder", "-1" },
1406  { NULL },
1407 };
1408 #endif
1409 
1410 AVCodec ff_ffv1_encoder = {
1411  .name = "ffv1",
1412  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1413  .type = AVMEDIA_TYPE_VIDEO,
1414  .id = AV_CODEC_ID_FFV1,
1415  .priv_data_size = sizeof(FFV1Context),
1416  .init = encode_init,
1417  .encode2 = encode_frame,
1418  .close = encode_close,
1419  .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1420  .pix_fmts = (const enum AVPixelFormat[]) {
1421  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1422  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1423  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1424  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1425  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1426  AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1427  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1428  AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1429  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1430  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1431  AV_PIX_FMT_YA8,
1432  AV_PIX_FMT_NONE
1433 
1434  },
1435 #if FF_API_CODER_TYPE
1436  .defaults = ffv1_defaults,
1437 #endif
1438  .priv_class = &ffv1_class,
1439 };
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:148
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2746
NULL
#define NULL
Definition: coverity.c:32
ff_log2_run
const uint8_t ff_log2_run[41]
Definition: bitstream.c:40
ffv1_defaults
static const AVCodecDefault ffv1_defaults[]
Definition: ffv1enc.c:1404
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:365
s
const char * s
Definition: avisynth_c.h:631
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:359
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2157
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:181
h
h
Definition: vp9dsp_template.c:2093
AVOption
AVOption.
Definition: opt.h:245
encode_slice_header
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
Definition: ffv1enc.c:1030
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:361
AV_PIX_FMT_YA8
8bit gray, 8bit alpha
Definition: pixfmt.h:155
FFV1Context::flags
int flags
Definition: ffv1.h:93
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:362
AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:68
imgutils.h
misc image utilities
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:168
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
ThreadFrame::f
AVFrame * f
Definition: thread.h:36
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:70
FFV1Context::quant_table_count
int quant_table_count
Definition: ffv1.h:123
g
const char * g
Definition: vf_curves.c:108
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:131
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:44
AVPacket::size
int size
Definition: avcodec.h:1468
b
const char * b
Definition: vf_curves.c:109
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:346
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:1752
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:2700
put_symbol_inline
static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2])
Definition: ffv1enc.c:184
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:2924
ffv1.h
FF Video Codec 1 (a lossless codec)
predict
static av_always_inline void predict(PredictorState *ps, float *coef, int output_enable)
Definition: aacdec.c:174
sample
#define sample
Definition: flacdsp_template.c:44
FFV1Context::height
int height
Definition: ffv1.h:89
AVCodec
AVCodec.
Definition: avcodec.h:3392
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:136
log2
#define log2(x)
Definition: libm.h:404
FFV1Context::plane_count
int plane_count
Definition: ffv1.h:100
ff_rac_terminate
int ff_rac_terminate(RangeCoder *c)
Definition: rangecoder.c:105
write_quant_tables
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1enc.c:489
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:881
FFV1Context::picture
ThreadFrame picture
Definition: ffv1.h:96
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_OPT_TYPE_CONST
Definition: opt.h:231
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:103
bits
uint8_t bits
Definition: crc.c:295
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:232
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
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:375
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:262
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:1647
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:668
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:358
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:345
quant11
static const int8_t quant11[256]
Definition: ffv1enc.c:100
FFV1Context::slice_y
int slice_y
Definition: ffv1.h:133
FFV1Context::initial_states
uint8_t(*[MAX_QUANT_TABLES] initial_states)[32]
Definition: ffv1.h:108
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:205
AVPacket::data
uint8_t * data
Definition: avcodec.h:1467
AVCodecContext::context_model
attribute_deprecated int context_model
Definition: avcodec.h:2582
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:1145
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:1063
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:343
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:312
PlaneContext::vlc_state
VlcState * vlc_state
Definition: ffv1.h:73
size
ptrdiff_t size
Definition: opengl_enc.c:101
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2692
NB_Y_COEFF
#define NB_Y_COEFF
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:364
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:642
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
write_extradata
static int write_extradata(FFV1Context *f)
Definition: ffv1enc.c:544
m
unsigned m
Definition: audioconvert.c:187
FFV1Context::bits_per_raw_sample
int bits_per_raw_sample
Definition: ffv1.h:119
FFV1Context::slice_width
int slice_width
Definition: ffv1.h:130
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1499
U
#define U(x)
Definition: vp56_arith.h:37
sort_stt
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:620
ver2_state
static const uint8_t ver2_state[256]
Definition: ffv1enc.c:119
AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:188
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
av_default_item_name
av_default_item_name
Definition: libopenh264enc.c:68
AVERROR
#define AVERROR(e)
Definition: error.h:43
AV_CRC_32_IEEE
Definition: crc.h:41
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:176
r
const char * r
Definition: vf_curves.c:107
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:366
arg
const char * arg
Definition: jacosubdec.c:66
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1627
PutBitContext::buf
uint8_t * buf
Definition: put_bits.h:38
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:3399
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:62
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:333
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:162
offset
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
RangeCoder::bytestream
uint8_t * bytestream
Definition: rangecoder.h:43
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1473
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:67
encode_line
static av_always_inline int encode_line(FFV1Context *s, int w, int16_t *sample[3], int plane_index, int bits)
Definition: ffv1enc.c:270
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:328
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:1221
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: ffv1enc.c:1370
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:266
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:252
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:314
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:129
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1711
FFV1Context::colorspace
int colorspace
Definition: ffv1.h:110
quant_table
static float quant_table[96]
Definition: binkaudio.c:41
get_context
static int get_context(PlaneContext *p, int16_t *src, int16_t *last, int16_t *last2)
Definition: ffv1.h:170
AV_OPT_TYPE_BOOL
Definition: opt.h:239
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:750
MAX_PLANES
#define MAX_PLANES
Definition: ffv1.h:50
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:192
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:356
FFV1Context::slice_count
int slice_count
Definition: ffv1.h:126
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
ff_ffv1_encoder
AVCodec ff_ffv1_encoder
Definition: ffv1enc.c:1410
FFV1Context::max_slice_count
int max_slice_count
Definition: ffv1.h:127
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:64
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
encode_rgb_frame
static int encode_rgb_frame(FFV1Context *s, const uint8_t *src[3], int w, int h, const int stride[3])
Definition: ffv1enc.c:412
AVCodecContext::level
int level
level
Definition: avcodec.h:3117
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:363
FFV1Context::ac_byte_count
int ac_byte_count
number of bytes used for AC coding
Definition: ffv1.h:102
VlcState::drift
int16_t drift
Definition: ffv1.h:62
src
#define src
Definition: vp9dsp.c:530
avcodec_get_chroma_sub_sample
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
FFV1Context::packed_at_lsb
int packed_at_lsb
Definition: ffv1.h:120
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:329
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:348
AVCodecContext::coder_type
attribute_deprecated int coder_type
Definition: avcodec.h:2576
VE
#define VE
Definition: ffv1enc.c:1377
options
static const AVOption options[]
Definition: ffv1enc.c:1378
pred
static const float pred[4]
Definition: siprdata.h:259
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:341
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:923
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
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:81
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:209
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:189
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:1532
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:307
FFV1Context::intra
int intra
Definition: ffv1.h:114
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:257
PutBitContext::buf_end
uint8_t * buf_end
Definition: put_bits.h:38
find_best_state
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256])
Definition: ffv1enc.c:138
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:1648
height
BYTE int const BYTE int int int height
Definition: avisynth_c.h:676
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:330
AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:69
write_quant_table
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition: ffv1enc.c:474
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:43
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:239
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:372
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:560
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:1396
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:327
snprintf
#define snprintf
Definition: snprintf.h:34
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: utils.c:1621
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:347
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:474
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:51
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:331
FFV1Context::gob_count
int gob_count
Definition: ffv1.h:122
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:70
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:192
OFFSET
#define OFFSET(x)
Definition: ffv1enc.c:1376
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1737
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:342
COST2
#define COST2(old, new)
AV_CODEC_ID_FFV1
Definition: avcodec.h:140
stride
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
FFV1Context::context_model
int context_model
Definition: ffv1.h:117
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:71
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:80
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
quant5_10bit
static const int8_t quant5_10bit[256]
Definition: ffv1enc.c:43
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:177
put_rac
#define put_rac(C, S, B)
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:360
AVCodecContext::coded_frame
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2945
PlaneContext::state
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:72
AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:70
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:45
FFV1Context::slice_coding_mode
int slice_coding_mode
Definition: ffv1.h:135
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:635
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:754
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:2278
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1574
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
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
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:2994
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
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:317
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:247
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:497
FFV1Context::slice_context
struct FFV1Context * slice_context[MAX_SLICES]
Definition: ffv1.h:125
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1466
av_uninit
#define av_uninit(x)
Definition: attributes.h:149
av_noinline
#define av_noinline
Definition: attributes.h:62
state
static struct @205 state
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:101
start
void INT64 start
Definition: avisynth_c.h:553
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:193
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:113
FFV1Context::num_v_slices
int num_v_slices
Definition: ffv1.h:128
golomb.h
exp golomb vlc stuff
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:61
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1444
FFV1Context::avctx
AVCodecContext * avctx
Definition: ffv1.h:81
av_mallocz
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
Definition: avcodec.h:2741
FFV1Context::slice_x
int slice_x
Definition: ffv1.h:132
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:342
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1460
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:311
a
a
Definition: h264pred_template.c:468
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
width
static int width
Definition: demuxing_decoding.c:39
FFV1Context::slice_rct_ry_coef
int slice_rct_ry_coef
Definition: ffv1.h:137
put_bits.h
bitstream writer API
Generated on Mon Feb 15 2016 15:20:38 for FFmpeg by   doxygen 1.8.6