FFmpeg
ffv1dec.c
Go to the documentation of this file.
1 /*
2  * FFV1 decoder
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) decoder
26  */
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/crc.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/pixdesc.h"
33 #include "avcodec.h"
34 #include "internal.h"
35 #include "get_bits.h"
36 #include "rangecoder.h"
37 #include "golomb.h"
38 #include "mathops.h"
39 #include "ffv1.h"
40 
42  int is_signed)
43 {
44  if (get_rac(c, state + 0))
45  return 0;
46  else {
47  int i, e;
48  unsigned a;
49  e = 0;
50  while (get_rac(c, state + 1 + FFMIN(e, 9))) { // 1..10
51  e++;
52  if (e > 31)
53  return AVERROR_INVALIDDATA;
54  }
55 
56  a = 1;
57  for (i = e - 1; i >= 0; i--)
58  a += a + get_rac(c, state + 22 + FFMIN(i, 9)); // 22..31
59 
60  e = -(is_signed && get_rac(c, state + 11 + FFMIN(e, 10))); // 11..21
61  return (a ^ e) - e;
62  }
63 }
64 
65 static av_noinline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
66 {
67  return get_symbol_inline(c, state, is_signed);
68 }
69 
70 static inline int get_vlc_symbol(GetBitContext *gb, VlcState *const state,
71  int bits)
72 {
73  int k, i, v, ret;
74 
75  i = state->count;
76  k = 0;
77  while (i < state->error_sum) { // FIXME: optimize
78  k++;
79  i += i;
80  }
81 
82  v = get_sr_golomb(gb, k, 12, bits);
83  ff_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
84  v, state->bias, state->error_sum, state->drift, state->count, k);
85 
86  v ^= ((2 * state->drift + state->count) >> 31);
87 
88  ret = fold(v + state->bias, bits);
89 
91 
92  return ret;
93 }
94 
96 {
97  if (s->ac != AC_GOLOMB_RICE) {
98  RangeCoder *const c = &s->c;
99  if (c->overread > MAX_OVERREAD)
100  return AVERROR_INVALIDDATA;
101  } else {
102  if (get_bits_left(&s->gb) < 1)
103  return AVERROR_INVALIDDATA;
104  }
105  return 0;
106 }
107 
108 #define TYPE int16_t
109 #define RENAME(name) name
110 #include "ffv1dec_template.c"
111 #undef TYPE
112 #undef RENAME
113 
114 #define TYPE int32_t
115 #define RENAME(name) name ## 32
116 #include "ffv1dec_template.c"
117 
119  int w, int h, int stride, int plane_index,
120  int pixel_stride)
121 {
122  int x, y;
123  int16_t *sample[2];
124  sample[0] = s->sample_buffer + 3;
125  sample[1] = s->sample_buffer + w + 6 + 3;
126 
127  s->run_index = 0;
128 
129  memset(s->sample_buffer, 0, 2 * (w + 6) * sizeof(*s->sample_buffer));
130 
131  for (y = 0; y < h; y++) {
132  int16_t *temp = sample[0]; // FIXME: try a normal buffer
133 
134  sample[0] = sample[1];
135  sample[1] = temp;
136 
137  sample[1][-1] = sample[0][0];
138  sample[0][w] = sample[0][w - 1];
139 
140  if (s->avctx->bits_per_raw_sample <= 8) {
141  int ret = decode_line(s, w, sample, plane_index, 8);
142  if (ret < 0)
143  return ret;
144  for (x = 0; x < w; x++)
145  src[x*pixel_stride + stride * y] = sample[1][x];
146  } else {
147  int ret = decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
148  if (ret < 0)
149  return ret;
150  if (s->packed_at_lsb) {
151  for (x = 0; x < w; x++) {
152  ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x];
153  }
154  } else {
155  for (x = 0; x < w; x++) {
156  ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x] << (16 - s->avctx->bits_per_raw_sample) | ((uint16_t **)sample)[1][x] >> (2 * s->avctx->bits_per_raw_sample - 16);
157  }
158  }
159  }
160  }
161  return 0;
162 }
163 
165 {
166  RangeCoder *c = &fs->c;
168  unsigned ps, i, context_count;
169  memset(state, 128, sizeof(state));
170 
171  av_assert0(f->version > 2);
172 
173  fs->slice_x = get_symbol(c, state, 0) * f->width ;
174  fs->slice_y = get_symbol(c, state, 0) * f->height;
175  fs->slice_width = (get_symbol(c, state, 0) + 1) * f->width + fs->slice_x;
176  fs->slice_height = (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y;
177 
178  fs->slice_x /= f->num_h_slices;
179  fs->slice_y /= f->num_v_slices;
180  fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
181  fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
182  if ((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
183  return -1;
184  if ( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
185  || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
186  return -1;
187 
188  for (i = 0; i < f->plane_count; i++) {
189  PlaneContext * const p = &fs->plane[i];
190  int idx = get_symbol(c, state, 0);
191  if (idx >= (unsigned)f->quant_table_count) {
192  av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
193  return -1;
194  }
195  p->quant_table_index = idx;
196  memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
197  context_count = f->context_count[idx];
198 
199  if (p->context_count < context_count) {
200  av_freep(&p->state);
201  av_freep(&p->vlc_state);
202  }
204  }
205 
206  ps = get_symbol(c, state, 0);
207  if (ps == 1) {
208  f->cur->interlaced_frame = 1;
209  f->cur->top_field_first = 1;
210  } else if (ps == 2) {
211  f->cur->interlaced_frame = 1;
212  f->cur->top_field_first = 0;
213  } else if (ps == 3) {
214  f->cur->interlaced_frame = 0;
215  }
216  f->cur->sample_aspect_ratio.num = get_symbol(c, state, 0);
217  f->cur->sample_aspect_ratio.den = get_symbol(c, state, 0);
218 
219  if (av_image_check_sar(f->width, f->height,
220  f->cur->sample_aspect_ratio) < 0) {
221  av_log(f->avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
222  f->cur->sample_aspect_ratio.num,
223  f->cur->sample_aspect_ratio.den);
224  f->cur->sample_aspect_ratio = (AVRational){ 0, 1 };
225  }
226 
227  if (fs->version > 3) {
228  fs->slice_reset_contexts = get_rac(c, state);
229  fs->slice_coding_mode = get_symbol(c, state, 0);
230  if (fs->slice_coding_mode != 1) {
231  fs->slice_rct_by_coef = get_symbol(c, state, 0);
232  fs->slice_rct_ry_coef = get_symbol(c, state, 0);
233  if ((uint64_t)fs->slice_rct_by_coef + (uint64_t)fs->slice_rct_ry_coef > 4) {
234  av_log(f->avctx, AV_LOG_ERROR, "slice_rct_y_coef out of range\n");
235  return AVERROR_INVALIDDATA;
236  }
237  }
238  }
239 
240  return 0;
241 }
242 
243 static int decode_slice(AVCodecContext *c, void *arg)
244 {
245  FFV1Context *fs = *(void **)arg;
246  FFV1Context *f = fs->avctx->priv_data;
247  int width, height, x, y, ret;
248  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
249  AVFrame * const p = f->cur;
250  int i, si;
251 
252  for( si=0; fs != f->slice_context[si]; si ++)
253  ;
254 
255  if(f->fsrc && !p->key_frame)
256  ff_thread_await_progress(&f->last_picture, si, 0);
257 
258  if(f->fsrc && !p->key_frame) {
259  FFV1Context *fssrc = f->fsrc->slice_context[si];
260  FFV1Context *fsdst = f->slice_context[si];
261  av_assert1(fsdst->plane_count == fssrc->plane_count);
262  av_assert1(fsdst == fs);
263 
264  if (!p->key_frame)
265  fsdst->slice_damaged |= fssrc->slice_damaged;
266 
267  for (i = 0; i < f->plane_count; i++) {
268  PlaneContext *psrc = &fssrc->plane[i];
269  PlaneContext *pdst = &fsdst->plane[i];
270 
271  av_free(pdst->state);
272  av_free(pdst->vlc_state);
273  memcpy(pdst, psrc, sizeof(*pdst));
274  pdst->state = NULL;
275  pdst->vlc_state = NULL;
276 
277  if (fssrc->ac) {
279  memcpy(pdst->state, psrc->state, CONTEXT_SIZE * psrc->context_count);
280  } else {
281  pdst->vlc_state = av_malloc_array(sizeof(*pdst->vlc_state), psrc->context_count);
282  memcpy(pdst->vlc_state, psrc->vlc_state, sizeof(*pdst->vlc_state) * psrc->context_count);
283  }
284  }
285  }
286 
287  fs->slice_rct_by_coef = 1;
288  fs->slice_rct_ry_coef = 1;
289 
290  if (f->version > 2) {
291  if (ff_ffv1_init_slice_state(f, fs) < 0)
292  return AVERROR(ENOMEM);
293  if (decode_slice_header(f, fs) < 0) {
294  fs->slice_x = fs->slice_y = fs->slice_height = fs->slice_width = 0;
295  fs->slice_damaged = 1;
296  return AVERROR_INVALIDDATA;
297  }
298  }
299  if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0)
300  return ret;
301  if (f->cur->key_frame || fs->slice_reset_contexts)
303 
304  width = fs->slice_width;
305  height = fs->slice_height;
306  x = fs->slice_x;
307  y = fs->slice_y;
308 
309  if (fs->ac == AC_GOLOMB_RICE) {
310  if (f->version == 3 && f->micro_version > 1 || f->version > 3)
311  get_rac(&fs->c, (uint8_t[]) { 129 });
312  fs->ac_byte_count = f->version > 2 || (!x && !y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0;
313  init_get_bits(&fs->gb,
314  fs->c.bytestream_start + fs->ac_byte_count,
315  (fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count) * 8);
316  }
317 
318  av_assert1(width && height);
319  if (f->colorspace == 0 && (f->chroma_planes || !fs->transparency)) {
320  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
321  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
322  const int cx = x >> f->chroma_h_shift;
323  const int cy = y >> f->chroma_v_shift;
324  decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
325 
326  if (f->chroma_planes) {
327  decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
328  decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
329  }
330  if (fs->transparency)
331  decode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], (f->version >= 4 && !f->chroma_planes) ? 1 : 2, 1);
332  } else if (f->colorspace == 0) {
333  decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0] , width, height, p->linesize[0], 0, 2);
334  decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0] + 1, width, height, p->linesize[0], 1, 2);
335  } else if (f->use32bit) {
336  uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0],
337  p->data[1] + ps * x + y * p->linesize[1],
338  p->data[2] + ps * x + y * p->linesize[2],
339  p->data[3] + ps * x + y * p->linesize[3] };
340  decode_rgb_frame32(fs, planes, width, height, p->linesize);
341  } else {
342  uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0],
343  p->data[1] + ps * x + y * p->linesize[1],
344  p->data[2] + ps * x + y * p->linesize[2],
345  p->data[3] + ps * x + y * p->linesize[3] };
346  decode_rgb_frame(fs, planes, width, height, p->linesize);
347  }
348  if (fs->ac != AC_GOLOMB_RICE && f->version > 2) {
349  int v;
350  get_rac(&fs->c, (uint8_t[]) { 129 });
351  v = fs->c.bytestream_end - fs->c.bytestream - 2 - 5*f->ec;
352  if (v) {
353  av_log(f->avctx, AV_LOG_ERROR, "bytestream end mismatching by %d\n", v);
354  fs->slice_damaged = 1;
355  }
356  }
357 
358  emms_c();
359 
360  ff_thread_report_progress(&f->picture, si, 0);
361 
362  return 0;
363 }
364 
365 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
366 {
367  int v;
368  int i = 0;
370 
371  memset(state, 128, sizeof(state));
372 
373  for (v = 0; i < 128; v++) {
374  unsigned len = get_symbol(c, state, 0) + 1U;
375 
376  if (len > 128 - i || !len)
377  return AVERROR_INVALIDDATA;
378 
379  while (len--) {
380  quant_table[i] = scale * v;
381  i++;
382  }
383  }
384 
385  for (i = 1; i < 128; i++)
386  quant_table[256 - i] = -quant_table[i];
387  quant_table[128] = -quant_table[127];
388 
389  return 2 * v - 1;
390 }
391 
393  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
394 {
395  int i;
396  int context_count = 1;
397 
398  for (i = 0; i < 5; i++) {
400  if (ret < 0)
401  return ret;
402  context_count *= ret;
403  if (context_count > 32768U) {
404  return AVERROR_INVALIDDATA;
405  }
406  }
407  return (context_count + 1) / 2;
408 }
409 
411 {
412  RangeCoder *const c = &f->c;
414  int i, j, k, ret;
415  uint8_t state2[32][CONTEXT_SIZE];
416  unsigned crc = 0;
417 
418  memset(state2, 128, sizeof(state2));
419  memset(state, 128, sizeof(state));
420 
421  ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
422  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
423 
424  f->version = get_symbol(c, state, 0);
425  if (f->version < 2) {
426  av_log(f->avctx, AV_LOG_ERROR, "Invalid version in global header\n");
427  return AVERROR_INVALIDDATA;
428  }
429  if (f->version > 2) {
430  c->bytestream_end -= 4;
431  f->micro_version = get_symbol(c, state, 0);
432  if (f->micro_version < 0)
433  return AVERROR_INVALIDDATA;
434  }
435  f->ac = get_symbol(c, state, 0);
436 
437  if (f->ac == AC_RANGE_CUSTOM_TAB) {
438  for (i = 1; i < 256; i++)
439  f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i];
440  }
441 
442  f->colorspace = get_symbol(c, state, 0); //YUV cs type
443  f->avctx->bits_per_raw_sample = get_symbol(c, state, 0);
444  f->chroma_planes = get_rac(c, state);
445  f->chroma_h_shift = get_symbol(c, state, 0);
446  f->chroma_v_shift = get_symbol(c, state, 0);
447  f->transparency = get_rac(c, state);
448  f->plane_count = 1 + (f->chroma_planes || f->version<4) + f->transparency;
449  f->num_h_slices = 1 + get_symbol(c, state, 0);
450  f->num_v_slices = 1 + get_symbol(c, state, 0);
451 
452  if (f->chroma_h_shift > 4U || f->chroma_v_shift > 4U) {
453  av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
454  f->chroma_h_shift, f->chroma_v_shift);
455  return AVERROR_INVALIDDATA;
456  }
457 
458  if (f->num_h_slices > (unsigned)f->width || !f->num_h_slices ||
459  f->num_v_slices > (unsigned)f->height || !f->num_v_slices
460  ) {
461  av_log(f->avctx, AV_LOG_ERROR, "slice count invalid\n");
462  return AVERROR_INVALIDDATA;
463  }
464 
465  f->quant_table_count = get_symbol(c, state, 0);
466  if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES || !f->quant_table_count) {
467  av_log(f->avctx, AV_LOG_ERROR, "quant table count %d is invalid\n", f->quant_table_count);
468  f->quant_table_count = 0;
469  return AVERROR_INVALIDDATA;
470  }
471 
472  for (i = 0; i < f->quant_table_count; i++) {
473  f->context_count[i] = read_quant_tables(c, f->quant_tables[i]);
474  if (f->context_count[i] < 0) {
475  av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
476  return AVERROR_INVALIDDATA;
477  }
478  }
480  return ret;
481 
482  for (i = 0; i < f->quant_table_count; i++)
483  if (get_rac(c, state)) {
484  for (j = 0; j < f->context_count[i]; j++)
485  for (k = 0; k < CONTEXT_SIZE; k++) {
486  int pred = j ? f->initial_states[i][j - 1][k] : 128;
487  f->initial_states[i][j][k] =
488  (pred + get_symbol(c, state2[k], 1)) & 0xFF;
489  }
490  }
491 
492  if (f->version > 2) {
493  f->ec = get_symbol(c, state, 0);
494  if (f->micro_version > 2)
495  f->intra = get_symbol(c, state, 0);
496  }
497 
498  if (f->version > 2) {
499  unsigned v;
501  f->avctx->extradata, f->avctx->extradata_size);
502  if (v || f->avctx->extradata_size < 4) {
503  av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
504  return AVERROR_INVALIDDATA;
505  }
506  crc = AV_RB32(f->avctx->extradata + f->avctx->extradata_size - 4);
507  }
508 
509  if (f->avctx->debug & FF_DEBUG_PICT_INFO)
510  av_log(f->avctx, AV_LOG_DEBUG,
511  "global: ver:%d.%d, coder:%d, colorspace: %d bpr:%d chroma:%d(%d:%d), alpha:%d slices:%dx%d qtabs:%d ec:%d intra:%d CRC:0x%08X\n",
512  f->version, f->micro_version,
513  f->ac,
514  f->colorspace,
515  f->avctx->bits_per_raw_sample,
516  f->chroma_planes, f->chroma_h_shift, f->chroma_v_shift,
517  f->transparency,
518  f->num_h_slices, f->num_v_slices,
519  f->quant_table_count,
520  f->ec,
521  f->intra,
522  crc
523  );
524  return 0;
525 }
526 
528 {
530  int i, j, context_count = -1; //-1 to avoid warning
531  RangeCoder *const c = &f->slice_context[0]->c;
532 
533  memset(state, 128, sizeof(state));
534 
535  if (f->version < 2) {
537  unsigned v= get_symbol(c, state, 0);
538  if (v >= 2) {
539  av_log(f->avctx, AV_LOG_ERROR, "invalid version %d in ver01 header\n", v);
540  return AVERROR_INVALIDDATA;
541  }
542  f->version = v;
543  f->ac = get_symbol(c, state, 0);
544 
545  if (f->ac == AC_RANGE_CUSTOM_TAB) {
546  for (i = 1; i < 256; i++) {
547  int st = get_symbol(c, state, 1) + c->one_state[i];
548  if (st < 1 || st > 255) {
549  av_log(f->avctx, AV_LOG_ERROR, "invalid state transition %d\n", st);
550  return AVERROR_INVALIDDATA;
551  }
552  f->state_transition[i] = st;
553  }
554  }
555 
556  colorspace = get_symbol(c, state, 0); //YUV cs type
557  bits_per_raw_sample = f->version > 0 ? get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample;
562  if (colorspace == 0 && f->avctx->skip_alpha)
563  transparency = 0;
564 
565  if (f->plane_count) {
566  if (colorspace != f->colorspace ||
567  bits_per_raw_sample != f->avctx->bits_per_raw_sample ||
568  chroma_planes != f->chroma_planes ||
569  chroma_h_shift != f->chroma_h_shift ||
570  chroma_v_shift != f->chroma_v_shift ||
571  transparency != f->transparency) {
572  av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n");
573  return AVERROR_INVALIDDATA;
574  }
575  }
576 
577  if (chroma_h_shift > 4U || chroma_v_shift > 4U) {
578  av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
580  return AVERROR_INVALIDDATA;
581  }
582 
583  f->colorspace = colorspace;
584  f->avctx->bits_per_raw_sample = bits_per_raw_sample;
585  f->chroma_planes = chroma_planes;
586  f->chroma_h_shift = chroma_h_shift;
587  f->chroma_v_shift = chroma_v_shift;
588  f->transparency = transparency;
589 
590  f->plane_count = 2 + f->transparency;
591  }
592 
593  if (f->colorspace == 0) {
594  if (!f->transparency && !f->chroma_planes) {
595  if (f->avctx->bits_per_raw_sample <= 8)
596  f->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
597  else if (f->avctx->bits_per_raw_sample == 9) {
598  f->packed_at_lsb = 1;
599  f->avctx->pix_fmt = AV_PIX_FMT_GRAY9;
600  } else if (f->avctx->bits_per_raw_sample == 10) {
601  f->packed_at_lsb = 1;
602  f->avctx->pix_fmt = AV_PIX_FMT_GRAY10;
603  } else if (f->avctx->bits_per_raw_sample == 12) {
604  f->packed_at_lsb = 1;
605  f->avctx->pix_fmt = AV_PIX_FMT_GRAY12;
606  } else if (f->avctx->bits_per_raw_sample == 16) {
607  f->packed_at_lsb = 1;
608  f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
609  } else if (f->avctx->bits_per_raw_sample < 16) {
610  f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
611  } else
612  return AVERROR(ENOSYS);
613  } else if (f->transparency && !f->chroma_planes) {
614  if (f->avctx->bits_per_raw_sample <= 8)
615  f->avctx->pix_fmt = AV_PIX_FMT_YA8;
616  else
617  return AVERROR(ENOSYS);
618  } else if (f->avctx->bits_per_raw_sample<=8 && !f->transparency) {
619  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
620  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P; break;
621  case 0x01: f->avctx->pix_fmt = AV_PIX_FMT_YUV440P; break;
622  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P; break;
623  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P; break;
624  case 0x20: f->avctx->pix_fmt = AV_PIX_FMT_YUV411P; break;
625  case 0x22: f->avctx->pix_fmt = AV_PIX_FMT_YUV410P; break;
626  }
627  } else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency) {
628  switch(16*f->chroma_h_shift + f->chroma_v_shift) {
629  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P; break;
630  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P; break;
631  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P; break;
632  }
633  } else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency) {
634  f->packed_at_lsb = 1;
635  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
636  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P9; break;
637  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P9; break;
638  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P9; break;
639  }
640  } else if (f->avctx->bits_per_raw_sample == 9 && f->transparency) {
641  f->packed_at_lsb = 1;
642  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
643  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P9; break;
644  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P9; break;
645  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P9; break;
646  }
647  } else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency) {
648  f->packed_at_lsb = 1;
649  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
650  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P10; break;
651  case 0x01: f->avctx->pix_fmt = AV_PIX_FMT_YUV440P10; break;
652  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P10; break;
653  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P10; break;
654  }
655  } else if (f->avctx->bits_per_raw_sample == 10 && f->transparency) {
656  f->packed_at_lsb = 1;
657  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
658  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P10; break;
659  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P10; break;
660  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P10; break;
661  }
662  } else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency) {
663  f->packed_at_lsb = 1;
664  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
665  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P12; break;
666  case 0x01: f->avctx->pix_fmt = AV_PIX_FMT_YUV440P12; break;
667  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P12; break;
668  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P12; break;
669  }
670  } else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency) {
671  f->packed_at_lsb = 1;
672  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
673  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P14; break;
674  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P14; break;
675  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P14; break;
676  }
677  } else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency){
678  f->packed_at_lsb = 1;
679  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
680  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P16; break;
681  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P16; break;
682  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P16; break;
683  }
684  } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency){
685  f->packed_at_lsb = 1;
686  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
687  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P16; break;
688  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P16; break;
689  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16; break;
690  }
691  }
692  } else if (f->colorspace == 1) {
693  if (f->chroma_h_shift || f->chroma_v_shift) {
694  av_log(f->avctx, AV_LOG_ERROR,
695  "chroma subsampling not supported in this colorspace\n");
696  return AVERROR(ENOSYS);
697  }
698  if ( f->avctx->bits_per_raw_sample <= 8 && !f->transparency)
699  f->avctx->pix_fmt = AV_PIX_FMT_0RGB32;
700  else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency)
701  f->avctx->pix_fmt = AV_PIX_FMT_RGB32;
702  else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency)
703  f->avctx->pix_fmt = AV_PIX_FMT_GBRP9;
704  else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency)
705  f->avctx->pix_fmt = AV_PIX_FMT_GBRP10;
706  else if (f->avctx->bits_per_raw_sample == 10 && f->transparency)
707  f->avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
708  else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency)
709  f->avctx->pix_fmt = AV_PIX_FMT_GBRP12;
710  else if (f->avctx->bits_per_raw_sample == 12 && f->transparency)
711  f->avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
712  else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency)
713  f->avctx->pix_fmt = AV_PIX_FMT_GBRP14;
714  else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency) {
715  f->avctx->pix_fmt = AV_PIX_FMT_GBRP16;
716  f->use32bit = 1;
717  }
718  else if (f->avctx->bits_per_raw_sample == 16 && f->transparency) {
719  f->avctx->pix_fmt = AV_PIX_FMT_GBRAP16;
720  f->use32bit = 1;
721  }
722  } else {
723  av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
724  return AVERROR(ENOSYS);
725  }
726  if (f->avctx->pix_fmt == AV_PIX_FMT_NONE) {
727  av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
728  return AVERROR(ENOSYS);
729  }
730 
731  ff_dlog(f->avctx, "%d %d %d\n",
732  f->chroma_h_shift, f->chroma_v_shift, f->avctx->pix_fmt);
733  if (f->version < 2) {
734  context_count = read_quant_tables(c, f->quant_table);
735  if (context_count < 0) {
736  av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
737  return AVERROR_INVALIDDATA;
738  }
739  f->slice_count = f->max_slice_count;
740  } else if (f->version < 3) {
741  f->slice_count = get_symbol(c, state, 0);
742  } else {
743  const uint8_t *p = c->bytestream_end;
744  for (f->slice_count = 0;
745  f->slice_count < MAX_SLICES && 3 + 5*!!f->ec < p - c->bytestream_start;
746  f->slice_count++) {
747  int trailer = 3 + 5*!!f->ec;
748  int size = AV_RB24(p-trailer);
749  if (size + trailer > p - c->bytestream_start)
750  break;
751  p -= size + trailer;
752  }
753  }
754  if (f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0 || f->slice_count > f->max_slice_count) {
755  av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid (max=%d)\n", f->slice_count, f->max_slice_count);
756  return AVERROR_INVALIDDATA;
757  }
758 
759  for (j = 0; j < f->slice_count; j++) {
760  FFV1Context *fs = f->slice_context[j];
761  fs->ac = f->ac;
762  fs->packed_at_lsb = f->packed_at_lsb;
763 
764  fs->slice_damaged = 0;
765 
766  if (f->version == 2) {
767  fs->slice_x = get_symbol(c, state, 0) * f->width ;
768  fs->slice_y = get_symbol(c, state, 0) * f->height;
769  fs->slice_width = (get_symbol(c, state, 0) + 1) * f->width + fs->slice_x;
770  fs->slice_height = (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y;
771 
772  fs->slice_x /= f->num_h_slices;
773  fs->slice_y /= f->num_v_slices;
774  fs->slice_width = fs->slice_width / f->num_h_slices - fs->slice_x;
775  fs->slice_height = fs->slice_height / f->num_v_slices - fs->slice_y;
776  if ((unsigned)fs->slice_width > f->width ||
777  (unsigned)fs->slice_height > f->height)
778  return AVERROR_INVALIDDATA;
779  if ( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
780  || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
781  return AVERROR_INVALIDDATA;
782  }
783 
784  for (i = 0; i < f->plane_count; i++) {
785  PlaneContext *const p = &fs->plane[i];
786 
787  if (f->version == 2) {
788  int idx = get_symbol(c, state, 0);
789  if (idx >= (unsigned)f->quant_table_count) {
790  av_log(f->avctx, AV_LOG_ERROR,
791  "quant_table_index out of range\n");
792  return AVERROR_INVALIDDATA;
793  }
794  p->quant_table_index = idx;
795  memcpy(p->quant_table, f->quant_tables[idx],
796  sizeof(p->quant_table));
797  context_count = f->context_count[idx];
798  } else {
799  memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
800  }
801 
802  if (f->version <= 2) {
804  if (p->context_count < context_count) {
805  av_freep(&p->state);
806  av_freep(&p->vlc_state);
807  }
809  }
810  }
811  }
812  return 0;
813 }
814 
816 {
818  int ret;
819 
820  if ((ret = ff_ffv1_common_init(avctx)) < 0)
821  return ret;
822 
823  if (avctx->extradata_size > 0 && (ret = read_extra_header(f)) < 0)
824  return ret;
825 
826  if ((ret = ff_ffv1_init_slice_contexts(f)) < 0)
827  return ret;
828 
829  return 0;
830 }
831 
832 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
833 {
834  uint8_t *buf = avpkt->data;
835  int buf_size = avpkt->size;
837  RangeCoder *const c = &f->slice_context[0]->c;
838  int i, ret;
839  uint8_t keystate = 128;
840  uint8_t *buf_p;
841  AVFrame *p;
842 
843  if (f->last_picture.f)
844  ff_thread_release_buffer(avctx, &f->last_picture);
845  FFSWAP(ThreadFrame, f->picture, f->last_picture);
846 
847  f->cur = p = f->picture.f;
848 
849  if (f->version < 3 && avctx->field_order > AV_FIELD_PROGRESSIVE) {
850  /* we have interlaced material flagged in container */
851  p->interlaced_frame = 1;
853  p->top_field_first = 1;
854  }
855 
856  f->avctx = avctx;
857  ff_init_range_decoder(c, buf, buf_size);
858  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
859 
860  p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P
861  if (get_rac(c, &keystate)) {
862  p->key_frame = 1;
863  f->key_frame_ok = 0;
864  if ((ret = read_header(f)) < 0)
865  return ret;
866  f->key_frame_ok = 1;
867  } else {
868  if (!f->key_frame_ok) {
870  "Cannot decode non-keyframe without valid keyframe\n");
871  return AVERROR_INVALIDDATA;
872  }
873  p->key_frame = 0;
874  }
875 
876  if ((ret = ff_thread_get_buffer(avctx, &f->picture, AV_GET_BUFFER_FLAG_REF)) < 0)
877  return ret;
878 
880  av_log(avctx, AV_LOG_DEBUG, "ver:%d keyframe:%d coder:%d ec:%d slices:%d bps:%d\n",
881  f->version, p->key_frame, f->ac, f->ec, f->slice_count, f->avctx->bits_per_raw_sample);
882 
884 
885  buf_p = buf + buf_size;
886  for (i = f->slice_count - 1; i >= 0; i--) {
887  FFV1Context *fs = f->slice_context[i];
888  int trailer = 3 + 5*!!f->ec;
889  int v;
890 
891  if (i || f->version > 2) {
892  if (trailer > buf_p - buf) v = INT_MAX;
893  else v = AV_RB24(buf_p-trailer) + trailer;
894  } else v = buf_p - c->bytestream_start;
895  if (buf_p - c->bytestream_start < v) {
896  av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
897  ff_thread_report_progress(&f->picture, INT_MAX, 0);
898  return AVERROR_INVALIDDATA;
899  }
900  buf_p -= v;
901 
902  if (f->ec) {
903  unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, v);
904  if (crc) {
905  int64_t ts = avpkt->pts != AV_NOPTS_VALUE ? avpkt->pts : avpkt->dts;
906  av_log(f->avctx, AV_LOG_ERROR, "slice CRC mismatch %X!", crc);
907  if (ts != AV_NOPTS_VALUE && avctx->pkt_timebase.num) {
908  av_log(f->avctx, AV_LOG_ERROR, "at %f seconds\n", ts*av_q2d(avctx->pkt_timebase));
909  } else if (ts != AV_NOPTS_VALUE) {
910  av_log(f->avctx, AV_LOG_ERROR, "at %"PRId64"\n", ts);
911  } else {
912  av_log(f->avctx, AV_LOG_ERROR, "\n");
913  }
914  fs->slice_damaged = 1;
915  }
916  if (avctx->debug & FF_DEBUG_PICT_INFO) {
917  av_log(avctx, AV_LOG_DEBUG, "slice %d, CRC: 0x%08"PRIX32"\n", i, AV_RB32(buf_p + v - 4));
918  }
919  }
920 
921  if (i) {
922  ff_init_range_decoder(&fs->c, buf_p, v);
923  } else
924  fs->c.bytestream_end = buf_p + v;
925 
926  fs->avctx = avctx;
927  fs->cur = p;
928  }
929 
931  decode_slice,
932  &f->slice_context[0],
933  NULL,
934  f->slice_count,
935  sizeof(void*));
936 
937  for (i = f->slice_count - 1; i >= 0; i--) {
938  FFV1Context *fs = f->slice_context[i];
939  int j;
940  if (fs->slice_damaged && f->last_picture.f->data[0]) {
942  const uint8_t *src[4];
943  uint8_t *dst[4];
944  ff_thread_await_progress(&f->last_picture, INT_MAX, 0);
945  for (j = 0; j < desc->nb_components; j++) {
946  int pixshift = desc->comp[j].depth > 8;
947  int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
948  int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
949  dst[j] = p->data[j] + p->linesize[j] *
950  (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
951  src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] *
952  (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
953 
954  }
955  if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
956  desc->flags & FF_PSEUDOPAL) {
957  dst[1] = p->data[1];
958  src[1] = f->last_picture.f->data[1];
959  }
960  av_image_copy(dst, p->linesize, src,
961  f->last_picture.f->linesize,
962  avctx->pix_fmt,
963  fs->slice_width,
964  fs->slice_height);
965  }
966  }
967  ff_thread_report_progress(&f->picture, INT_MAX, 0);
968 
969  f->picture_number++;
970 
971  if (f->last_picture.f)
972  ff_thread_release_buffer(avctx, &f->last_picture);
973  f->cur = NULL;
974  if ((ret = av_frame_ref(data, f->picture.f)) < 0)
975  return ret;
976 
977  *got_frame = 1;
978 
979  return buf_size;
980 }
981 
982 static void copy_fields(FFV1Context *fsdst, FFV1Context *fssrc, FFV1Context *fsrc)
983 {
984  fsdst->version = fsrc->version;
985  fsdst->micro_version = fsrc->micro_version;
986  fsdst->chroma_planes = fsrc->chroma_planes;
989  fsdst->transparency = fsrc->transparency;
990  fsdst->plane_count = fsrc->plane_count;
991  fsdst->ac = fsrc->ac;
992  fsdst->colorspace = fsrc->colorspace;
993 
994  fsdst->ec = fsrc->ec;
995  fsdst->intra = fsrc->intra;
996  fsdst->slice_damaged = fssrc->slice_damaged;
997  fsdst->key_frame_ok = fsrc->key_frame_ok;
998 
1000  fsdst->packed_at_lsb = fsrc->packed_at_lsb;
1001  fsdst->slice_count = fsrc->slice_count;
1002  if (fsrc->version<3){
1003  fsdst->slice_x = fssrc->slice_x;
1004  fsdst->slice_y = fssrc->slice_y;
1005  fsdst->slice_width = fssrc->slice_width;
1006  fsdst->slice_height = fssrc->slice_height;
1007  }
1008 }
1009 
1010 #if HAVE_THREADS
1011 static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1012 {
1013  FFV1Context *fsrc = src->priv_data;
1014  FFV1Context *fdst = dst->priv_data;
1015  int i, ret;
1016 
1017  if (dst == src)
1018  return 0;
1019 
1020  {
1024  memcpy(initial_states, fdst->initial_states, sizeof(fdst->initial_states));
1025  memcpy(slice_context, fdst->slice_context , sizeof(fdst->slice_context));
1026 
1027  memcpy(fdst, fsrc, sizeof(*fdst));
1028  memcpy(fdst->initial_states, initial_states, sizeof(fdst->initial_states));
1029  memcpy(fdst->slice_context, slice_context , sizeof(fdst->slice_context));
1030  fdst->picture = picture;
1031  fdst->last_picture = last_picture;
1032  for (i = 0; i<fdst->num_h_slices * fdst->num_v_slices; i++) {
1033  FFV1Context *fssrc = fsrc->slice_context[i];
1034  FFV1Context *fsdst = fdst->slice_context[i];
1035  copy_fields(fsdst, fssrc, fsrc);
1036  }
1037  av_assert0(!fdst->plane[0].state);
1038  av_assert0(!fdst->sample_buffer);
1039  }
1040 
1042 
1043 
1044  ff_thread_release_buffer(dst, &fdst->picture);
1045  if (fsrc->picture.f->data[0]) {
1046  if ((ret = ff_thread_ref_frame(&fdst->picture, &fsrc->picture)) < 0)
1047  return ret;
1048  }
1049 
1050  fdst->fsrc = fsrc;
1051 
1052  return 0;
1053 }
1054 #endif
1055 
1057  .name = "ffv1",
1058  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1059  .type = AVMEDIA_TYPE_VIDEO,
1060  .id = AV_CODEC_ID_FFV1,
1061  .priv_data_size = sizeof(FFV1Context),
1062  .init = decode_init,
1063  .close = ff_ffv1_close,
1064  .decode = decode_frame,
1066  .capabilities = AV_CODEC_CAP_DR1 /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/ |
1069 };
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:440
read_extra_header
static int read_extra_header(FFV1Context *f)
Definition: ffv1dec.c:410
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:419
AVCodec
AVCodec.
Definition: codec.h:190
stride
int stride
Definition: mace.c:144
FFV1Context::chroma_v_shift
int chroma_v_shift
Definition: ffv1.h:90
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
FFV1Context::key_frame_ok
int key_frame_ok
Definition: ffv1.h:118
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:161
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
decode_slice
static int decode_slice(AVCodecContext *c, void *arg)
Definition: ffv1dec.c:243
opt.h
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:143
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
is_input_end
static int is_input_end(FFV1Context *s)
Definition: ffv1dec.c:95
FFV1Context::context_count
int context_count[MAX_QUANT_TABLES]
Definition: ffv1.h:105
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2549
MAX_OVERREAD
#define MAX_OVERREAD
Definition: lagarithrac.h:51
FFV1Context::ec
int ec
Definition: ffv1.h:115
FFV1Context::gb
GetBitContext gb
Definition: ffv1.h:82
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:432
get_sr_golomb
static int get_sr_golomb(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (ffv1).
Definition: golomb.h:529
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
pixdesc.h
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:41
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:439
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
FFV1Context::last_picture
ThreadFrame last_picture
Definition: ffv1.h:95
AVPacket::data
uint8_t * data
Definition: packet.h:355
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:434
AVCodecContext::field_order
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:1183
FFV1Context::slice_x
int slice_x
Definition: ffv1.h:134
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:452
last_picture
enum AVPictureType last_picture
Definition: movenc.c:68
data
const char data[16]
Definition: mxf.c:91
ff_ffv1_decoder
AVCodec ff_ffv1_decoder
Definition: ffv1dec.c:1056
rangecoder.h
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:41
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:397
PlaneContext::state
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:71
FFV1Context::num_h_slices
int num_h_slices
Definition: ffv1.h:131
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
FFV1Context::slice_context
struct FFV1Context * slice_context[MAX_SLICES]
Definition: ffv1.h:127
read_quant_table
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
Definition: ffv1dec.c:365
ff_ffv1_init_slice_state
av_cold int ff_ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:66
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:57
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:435
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
ff_thread_await_progress
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_thread_report_progress() has been called on them. This includes draw_edges(). Porting codecs to frame threading
ThreadFrame::f
AVFrame * f
Definition: thread.h:35
FFV1Context::chroma_h_shift
int chroma_h_shift
Definition: ffv1.h:90
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1612
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:377
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: ffv1dec.c:832
crc.h
golomb.h
exp golomb vlc stuff
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:431
AV_FIELD_TT
@ AV_FIELD_TT
Definition: codec_par.h:39
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:415
U
#define U(x)
Definition: vp56_arith.h:37
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:413
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:441
GetBitContext
Definition: get_bits.h:61
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:395
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:378
av_noinline
#define av_noinline
Definition: attributes.h:72
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:50
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:381
get_symbol_inline
static av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed)
Definition: ffv1dec.c:41
AV_FIELD_TB
@ AV_FIELD_TB
Definition: codec_par.h:41
FFV1Context::chroma_planes
int chroma_planes
Definition: ffv1.h:89
PlaneContext::context_count
int context_count
Definition: ffv1.h:70
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:409
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:568
FFV1Context::bits_per_raw_sample
int bits_per_raw_sample
Definition: ffv1.h:121
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:417
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:628
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:181
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:418
FFV1Context::slice_count
int slice_count
Definition: ffv1.h:128
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:410
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:509
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
FFV1Context::plane
PlaneContext plane[MAX_PLANES]
Definition: ffv1.h:102
FFV1Context::max_slice_count
int max_slice_count
Definition: ffv1.h:129
FFV1Context::slice_damaged
int slice_damaged
Definition: ffv1.h:117
bits
uint8_t bits
Definition: vp3data.h:202
FFV1Context::intra
int intra
Definition: ffv1.h:116
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
FFV1Context::fsrc
struct FFV1Context * fsrc
Definition: ffv1.h:96
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:394
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
read_quant_tables
static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1dec.c:392
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:408
get_bits.h
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:150
FFV1Context::ac
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:100
get_vlc_symbol
static int get_vlc_symbol(GetBitContext *gb, VlcState *const state, int bits)
Definition: ffv1dec.c:70
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
FFV1Context::plane_count
int plane_count
Definition: ffv1.h:99
f
#define f(width, name)
Definition: cbs_vp9.c:255
decode_slice_header
static int decode_slice_header(FFV1Context *f, FFV1Context *fs)
Definition: ffv1dec.c:164
arg
const char * arg
Definition: jacosubdec.c:66
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:378
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
FFV1Context::slice_height
int slice_height
Definition: ffv1.h:133
quant_table
static const int16_t quant_table[64]
Definition: intrax8.c:556
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:416
copy_fields
static void copy_fields(FFV1Context *fsdst, FFV1Context *fssrc, FFV1Context *fsrc)
Definition: ffv1dec.c:982
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
get_symbol
static av_noinline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
Definition: ffv1dec.c:65
NULL
#define NULL
Definition: coverity.c:32
PlaneContext::vlc_state
VlcState * vlc_state
Definition: ffv1.h:72
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:55
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
FFV1Context::num_v_slices
int num_v_slices
Definition: ffv1.h:130
FFV1Context::colorspace
int colorspace
Definition: ffv1.h:109
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
src
#define src
Definition: vp8dsp.c:254
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:399
mathops.h
PlaneContext
Definition: ffv1.h:67
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:227
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:398
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:412
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
VlcState
Definition: ffv1.h:60
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread_frame.c:1006
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
FFV1Context::slice_width
int slice_width
Definition: ffv1.h:132
ff_init_range_decoder
av_cold void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size)
Definition: rangecoder.c:53
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:82
desc
const char * desc
Definition: nvenc.c:79
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:383
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
AVPacket::size
int size
Definition: packet.h:356
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:188
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:444
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:402
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:209
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:2083
sample
#define sample
Definition: flacdsp_template.c:44
FFV1Context::picture
ThreadFrame picture
Definition: ffv1.h:95
size
int size
Definition: twinvq_data.h:11134
state
static struct @314 state
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:92
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:404
FFV1Context::sample_buffer
int16_t * sample_buffer
Definition: ffv1.h:110
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:354
height
#define height
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:370
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:110
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:436
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:69
FFV1Context::initial_states
uint8_t(*[MAX_QUANT_TABLES] initial_states)[32]
Definition: ffv1.h:107
planes
static const struct @315 planes[]
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:447
decode_plane
static int decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index, int pixel_stride)
Definition: ffv1dec.c:118
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
av_flatten
#define av_flatten
Definition: attributes.h:96
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:414
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
FFV1Context::slice_y
int slice_y
Definition: ffv1.h:135
ffv1.h
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
update_thread_context
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have update_thread_context() run it in the next thread. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. If there are inter-frame dependencies
len
int len
Definition: vorbis_enc_data.h:452
get_rac
static int get_rac(RangeCoder *c, uint8_t *const state)
Definition: rangecoder.h:136
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition: crc.h:53
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:396
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:53
FFV1Context::packed_at_lsb
int packed_at_lsb
Definition: ffv1.h:122
avcodec.h
FFV1Context::avctx
AVCodecContext * avctx
Definition: ffv1.h:80
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:374
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:433
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:401
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:406
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:166
AVCodecContext
main external API structure.
Definition: avcodec.h:526
MAX_SLICES
#define MAX_SLICES
Definition: dxva2_hevc.c:29
ThreadFrame
Definition: thread.h:34
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:1825
av_image_copy
void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
Definition: imgutils.c:387
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: ffv1dec.c:815
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
temp
else temp
Definition: vf_mcdeint.c:256
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1611
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:1885
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:75
MAX_QUANT_TABLES
#define MAX_QUANT_TABLES
Definition: ffv1.h:52
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:38
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
FFV1Context
Definition: ffv1.h:78
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FFV1Context::transparency
int transparency
Definition: ffv1.h:91
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
ffv1dec_template.c
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:116
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
FF_PSEUDOPAL
#define FF_PSEUDOPAL
Definition: internal.h:369
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
FFV1Context::micro_version
int micro_version
Definition: ffv1.h:87
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:403
h
h
Definition: vp9dsp_template.c:2038
RangeCoder
Definition: mss3.c:61
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:407
av_image_check_sar
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
Definition: imgutils.c:287
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:379
PlaneContext::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:68
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:93
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:132
FFV1Context::version
int version
Definition: ffv1.h:86
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:405