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 
41 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state,
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 
90  update_vlc_state(state, v);
91 
92  return ret;
93 }
94 
95 static int is_input_end(FFV1Context *s)
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 
118 static int decode_plane(FFV1Context *s, uint8_t *src,
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 
164 static int decode_slice_header(const FFV1Context *f, FFV1Context *fs)
165 {
166  RangeCoder *c = &fs->c;
167  uint8_t state[CONTEXT_SIZE];
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  }
203  p->context_count = context_count;
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) {
278  pdst->state = av_malloc_array(CONTEXT_SIZE, psrc->context_count);
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)
302  ff_ffv1_clear_slice_state(f, fs);
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;
369  uint8_t state[CONTEXT_SIZE];
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 
392 static int read_quant_tables(RangeCoder *c,
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++) {
399  int ret = read_quant_table(c, quant_table[i], context_count);
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 
410 static int read_extra_header(FFV1Context *f)
411 {
412  RangeCoder *const c = &f->c;
413  uint8_t state[CONTEXT_SIZE];
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  }
479  if ((ret = ff_ffv1_allocate_initial_states(f)) < 0)
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;
500  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0,
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 
527 static int read_header(FFV1Context *f)
528 {
529  uint8_t state[CONTEXT_SIZE];
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) {
536  int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sample;
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;
558  chroma_planes = get_rac(c, state);
559  chroma_h_shift = get_symbol(c, state, 0);
560  chroma_v_shift = get_symbol(c, state, 0);
561  transparency = get_rac(c, state);
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",
579  chroma_h_shift, chroma_v_shift);
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) {
803  av_assert0(context_count >= 0);
804  if (p->context_count < context_count) {
805  av_freep(&p->state);
806  av_freep(&p->vlc_state);
807  }
808  p->context_count = context_count;
809  }
810  }
811  }
812  return 0;
813 }
814 
815 static av_cold int decode_init(AVCodecContext *avctx)
816 {
817  FFV1Context *f = avctx->priv_data;
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;
836  FFV1Context *f = avctx->priv_data;
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;
852  if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
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) {
869  av_log(avctx, AV_LOG_ERROR,
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 
879  if (avctx->debug & FF_DEBUG_PICT_INFO)
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 
883  ff_thread_finish_setup(avctx);
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  }
928 
929  avctx->execute(avctx,
930  decode_slice,
931  &f->slice_context[0],
932  NULL,
933  f->slice_count,
934  sizeof(void*));
935 
936  for (i = f->slice_count - 1; i >= 0; i--) {
937  FFV1Context *fs = f->slice_context[i];
938  int j;
939  if (fs->slice_damaged && f->last_picture.f->data[0]) {
940  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
941  const uint8_t *src[4];
942  uint8_t *dst[4];
943  ff_thread_await_progress(&f->last_picture, INT_MAX, 0);
944  for (j = 0; j < desc->nb_components; j++) {
945  int pixshift = desc->comp[j].depth > 8;
946  int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
947  int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
948  dst[j] = p->data[j] + p->linesize[j] *
949  (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
950  src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] *
951  (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
952 
953  }
954  if (desc->flags & AV_PIX_FMT_FLAG_PAL) {
955  dst[1] = p->data[1];
956  src[1] = f->last_picture.f->data[1];
957  }
958  av_image_copy(dst, p->linesize, src,
959  f->last_picture.f->linesize,
960  avctx->pix_fmt,
961  fs->slice_width,
962  fs->slice_height);
963  }
964  }
965  ff_thread_report_progress(&f->picture, INT_MAX, 0);
966 
967  if (f->last_picture.f)
968  ff_thread_release_buffer(avctx, &f->last_picture);
969  if ((ret = av_frame_ref(data, f->picture.f)) < 0)
970  return ret;
971 
972  *got_frame = 1;
973 
974  return buf_size;
975 }
976 
977 static void copy_fields(FFV1Context *fsdst, const FFV1Context *fssrc,
978  const FFV1Context *fsrc)
979 {
980  fsdst->version = fsrc->version;
981  fsdst->micro_version = fsrc->micro_version;
982  fsdst->chroma_planes = fsrc->chroma_planes;
983  fsdst->chroma_h_shift = fsrc->chroma_h_shift;
984  fsdst->chroma_v_shift = fsrc->chroma_v_shift;
985  fsdst->transparency = fsrc->transparency;
986  fsdst->plane_count = fsrc->plane_count;
987  fsdst->ac = fsrc->ac;
988  fsdst->colorspace = fsrc->colorspace;
989 
990  fsdst->ec = fsrc->ec;
991  fsdst->intra = fsrc->intra;
992  fsdst->slice_damaged = fssrc->slice_damaged;
993  fsdst->key_frame_ok = fsrc->key_frame_ok;
994 
995  fsdst->packed_at_lsb = fsrc->packed_at_lsb;
996  fsdst->slice_count = fsrc->slice_count;
997  if (fsrc->version<3){
998  fsdst->slice_x = fssrc->slice_x;
999  fsdst->slice_y = fssrc->slice_y;
1000  fsdst->slice_width = fssrc->slice_width;
1001  fsdst->slice_height = fssrc->slice_height;
1002  }
1003 }
1004 
1005 #if HAVE_THREADS
1006 static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1007 {
1008  FFV1Context *fsrc = src->priv_data;
1009  FFV1Context *fdst = dst->priv_data;
1010  int i, ret;
1011 
1012  if (dst == src)
1013  return 0;
1014 
1015  {
1016  ThreadFrame picture = fdst->picture, last_picture = fdst->last_picture;
1017  uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
1018  struct FFV1Context *slice_context[MAX_SLICES];
1019  memcpy(initial_states, fdst->initial_states, sizeof(fdst->initial_states));
1020  memcpy(slice_context, fdst->slice_context , sizeof(fdst->slice_context));
1021 
1022  memcpy(fdst, fsrc, sizeof(*fdst));
1023  memcpy(fdst->initial_states, initial_states, sizeof(fdst->initial_states));
1024  memcpy(fdst->slice_context, slice_context , sizeof(fdst->slice_context));
1025  fdst->picture = picture;
1026  fdst->last_picture = last_picture;
1027  for (i = 0; i<fdst->num_h_slices * fdst->num_v_slices; i++) {
1028  FFV1Context *fssrc = fsrc->slice_context[i];
1029  FFV1Context *fsdst = fdst->slice_context[i];
1030  copy_fields(fsdst, fssrc, fsrc);
1031  }
1032  av_assert0(!fdst->plane[0].state);
1033  av_assert0(!fdst->sample_buffer);
1034  }
1035 
1036  av_assert1(fdst->max_slice_count == fsrc->max_slice_count);
1037 
1038 
1039  ff_thread_release_buffer(dst, &fdst->picture);
1040  if (fsrc->picture.f->data[0]) {
1041  if ((ret = ff_thread_ref_frame(&fdst->picture, &fsrc->picture)) < 0)
1042  return ret;
1043  }
1044 
1045  fdst->fsrc = fsrc;
1046 
1047  return 0;
1048 }
1049 #endif
1050 
1051 const AVCodec ff_ffv1_decoder = {
1052  .name = "ffv1",
1053  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1054  .type = AVMEDIA_TYPE_VIDEO,
1055  .id = AV_CODEC_ID_FFV1,
1056  .priv_data_size = sizeof(FFV1Context),
1057  .init = decode_init,
1058  .close = ff_ffv1_close,
1059  .decode = decode_frame,
1060  .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
1061  .capabilities = AV_CODEC_CAP_DR1 /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/ |
1062  AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
1063  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
1064  FF_CODEC_CAP_ALLOCATE_PROGRESS,
1065 };
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:447
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:426
AVCodec
AVCodec.
Definition: codec.h:202
stride
int stride
Definition: mace.c:144
FFV1Context::chroma_v_shift
int chroma_v_shift
Definition: ffv1.h:89
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
FFV1Context::key_frame_ok
int key_frame_ok
Definition: ffv1.h:117
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:160
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
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:133
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:866
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:104
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2660
MAX_OVERREAD
#define MAX_OVERREAD
Definition: lagarithrac.h:51
FFV1Context::ec
int ec
Definition: ffv1.h:114
FFV1Context::gb
GetBitContext gb
Definition: ffv1.h:81
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:439
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:531
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
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:446
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
FFV1Context::last_picture
ThreadFrame last_picture
Definition: ffv1.h:94
AVPacket::data
uint8_t * data
Definition: packet.h:373
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:441
AVCodecContext::field_order
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:989
FFV1Context::slice_x
int slice_x
Definition: ffv1.h:133
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:474
last_picture
enum AVPictureType last_picture
Definition: movenc.c:69
data
const char data[16]
Definition: mxf.c:143
rangecoder.h
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:40
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:404
PlaneContext::state
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:70
FFV1Context::num_h_slices
int num_h_slices
Definition: ffv1.h:130
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:126
read_quant_table
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
Definition: ffv1dec.c:365
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:56
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:442
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
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:89
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1303
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:384
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:338
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: ffv1dec.c:832
init
static int init
Definition: av_tx.c:47
crc.h
golomb.h
exp golomb vlc stuff
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:438
AV_FIELD_TT
@ AV_FIELD_TT
Definition: codec_par.h:39
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:422
U
#define U(x)
Definition: vp56_arith.h:37
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:420
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:448
GetBitContext
Definition: get_bits.h:62
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:402
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:409
av_noinline
#define av_noinline
Definition: attributes.h:72
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:49
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1388
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:388
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:88
PlaneContext::context_count
int context_count
Definition: ffv1.h:69
AVRational::num
int num
Numerator.
Definition: rational.h:59
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:173
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:407
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:416
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:588
FFV1Context::bits_per_raw_sample
int bits_per_raw_sample
Definition: ffv1.h:120
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:424
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:485
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:425
FFV1Context::slice_count
int slice_count
Definition: ffv1.h:127
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:417
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
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:361
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:101
FFV1Context::max_slice_count
int max_slice_count
Definition: ffv1.h:128
FFV1Context::slice_damaged
int slice_damaged
Definition: ffv1.h:116
bits
uint8_t bits
Definition: vp3data.h:141
FFV1Context::intra
int intra
Definition: ffv1.h:115
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
FFV1Context::fsrc
struct FFV1Context * fsrc
Definition: ffv1.h:95
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:401
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
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:415
get_bits.h
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:149
FFV1Context::ac
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:99
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:98
f
#define f(width, name)
Definition: cbs_vp9.c:255
arg
const char * arg
Definition: jacosubdec.c:67
planes
static const struct @321 planes[]
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:385
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:113
FFV1Context::slice_height
int slice_height
Definition: ffv1.h:132
quant_table
static const int16_t quant_table[64]
Definition: intrax8.c:522
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:423
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:71
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:54
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
FFV1Context::num_v_slices
int num_v_slices
Definition: ffv1.h:129
FFV1Context::colorspace
int colorspace
Definition: ffv1.h:108
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:255
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:406
mathops.h
PlaneContext
Definition: ffv1.h:66
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:156
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:405
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:419
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:59
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:1056
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
FFV1Context::slice_width
int slice_width
Definition: ffv1.h:131
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:83
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:414
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
state
static struct @320 state
AVPacket::size
int size
Definition: packet.h:374
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:117
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:325
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:409
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:201
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:1724
sample
#define sample
Definition: flacdsp_template.c:44
FFV1Context::picture
ThreadFrame picture
Definition: ffv1.h:94
size
int size
Definition: twinvq_data.h:10344
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:96
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:411
FFV1Context::sample_buffer
int16_t * sample_buffer
Definition: ffv1.h:109
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
height
#define height
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:377
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:167
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:117
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:443
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:68
FFV1Context::initial_states
uint8_t(*[MAX_QUANT_TABLES] initial_states)[32]
Definition: ffv1.h:106
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:469
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
copy_fields
static void copy_fields(FFV1Context *fsdst, const FFV1Context *fssrc, const FFV1Context *fsrc)
Definition: ffv1dec.c:977
ff_ffv1_init_slice_state
av_cold int ff_ffv1_init_slice_state(const FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:66
ff_ffv1_decoder
const AVCodec ff_ffv1_decoder
Definition: ffv1dec.c:1051
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
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:50
av_flatten
#define av_flatten
Definition: attributes.h:96
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:421
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
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FFV1Context::slice_y
int slice_y
Definition: ffv1.h:134
ffv1.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
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:426
get_rac
static int get_rac(RangeCoder *c, uint8_t *const state)
Definition: rangecoder.h:127
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition: crc.h:52
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:403
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:52
FFV1Context::packed_at_lsb
int packed_at_lsb
Definition: ffv1.h:121
avcodec.h
FFV1Context::avctx
AVCodecContext * avctx
Definition: ffv1.h:79
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:381
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:440
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:408
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:413
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:158
AVCodecContext
main external API structure.
Definition: avcodec.h:383
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:1491
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:422
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:105
temp
else temp
Definition: vf_mcdeint.c:248
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:1302
desc
const char * desc
Definition: libsvtav1.c:79
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:77
MAX_QUANT_TABLES
#define MAX_QUANT_TABLES
Definition: ffv1.h:51
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:69
FFV1Context
Definition: ffv1.h:77
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FFV1Context::transparency
int transparency
Definition: ffv1.h:90
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
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, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:362
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
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
FFV1Context::micro_version
int micro_version
Definition: ffv1.h:86
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:410
h
h
Definition: vp9dsp_template.c:2038
RangeCoder
Definition: mss3.c:61
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:414
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:323
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:386
PlaneContext::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:67
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:97
decode_slice_header
static int decode_slice_header(const FFV1Context *f, FFV1Context *fs)
Definition: ffv1dec.c:164
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:120
FFV1Context::version
int version
Definition: ffv1.h:85
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:166
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:412
Generated on Wed Aug 24 2022 21:37:33 for FFmpeg by   doxygen 1.8.17