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 "codec_internal.h"
35 #include "get_bits.h"
36 #include "rangecoder.h"
37 #include "golomb.h"
38 #include "mathops.h"
39 #include "ffv1.h"
40 #include "thread.h"
41 #include "threadframe.h"
42 
43 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state,
44  int is_signed)
45 {
46  if (get_rac(c, state + 0))
47  return 0;
48  else {
49  int i, e;
50  unsigned a;
51  e = 0;
52  while (get_rac(c, state + 1 + FFMIN(e, 9))) { // 1..10
53  e++;
54  if (e > 31)
55  return AVERROR_INVALIDDATA;
56  }
57 
58  a = 1;
59  for (i = e - 1; i >= 0; i--)
60  a += a + get_rac(c, state + 22 + FFMIN(i, 9)); // 22..31
61 
62  e = -(is_signed && get_rac(c, state + 11 + FFMIN(e, 10))); // 11..21
63  return (a ^ e) - e;
64  }
65 }
66 
67 static av_noinline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
68 {
69  return get_symbol_inline(c, state, is_signed);
70 }
71 
72 static inline int get_vlc_symbol(GetBitContext *gb, VlcState *const state,
73  int bits)
74 {
75  int k, i, v, ret;
76 
77  i = state->count;
78  k = 0;
79  while (i < state->error_sum) { // FIXME: optimize
80  k++;
81  i += i;
82  }
83 
84  v = get_sr_golomb(gb, k, 12, bits);
85  ff_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
86  v, state->bias, state->error_sum, state->drift, state->count, k);
87 
88  v ^= ((2 * state->drift + state->count) >> 31);
89 
90  ret = fold(v + state->bias, bits);
91 
92  update_vlc_state(state, v);
93 
94  return ret;
95 }
96 
97 static int is_input_end(FFV1Context *s)
98 {
99  if (s->ac != AC_GOLOMB_RICE) {
100  RangeCoder *const c = &s->c;
101  if (c->overread > MAX_OVERREAD)
102  return AVERROR_INVALIDDATA;
103  } else {
104  if (get_bits_left(&s->gb) < 1)
105  return AVERROR_INVALIDDATA;
106  }
107  return 0;
108 }
109 
110 #define TYPE int16_t
111 #define RENAME(name) name
112 #include "ffv1dec_template.c"
113 #undef TYPE
114 #undef RENAME
115 
116 #define TYPE int32_t
117 #define RENAME(name) name ## 32
118 #include "ffv1dec_template.c"
119 
120 static int decode_plane(FFV1Context *s, uint8_t *src,
121  int w, int h, int stride, int plane_index,
122  int pixel_stride)
123 {
124  int x, y;
125  int16_t *sample[2];
126  sample[0] = s->sample_buffer + 3;
127  sample[1] = s->sample_buffer + w + 6 + 3;
128 
129  s->run_index = 0;
130 
131  memset(s->sample_buffer, 0, 2 * (w + 6) * sizeof(*s->sample_buffer));
132 
133  for (y = 0; y < h; y++) {
134  int16_t *temp = sample[0]; // FIXME: try a normal buffer
135 
136  sample[0] = sample[1];
137  sample[1] = temp;
138 
139  sample[1][-1] = sample[0][0];
140  sample[0][w] = sample[0][w - 1];
141 
142  if (s->avctx->bits_per_raw_sample <= 8) {
143  int ret = decode_line(s, w, sample, plane_index, 8);
144  if (ret < 0)
145  return ret;
146  for (x = 0; x < w; x++)
147  src[x*pixel_stride + stride * y] = sample[1][x];
148  } else {
149  int ret = decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
150  if (ret < 0)
151  return ret;
152  if (s->packed_at_lsb) {
153  for (x = 0; x < w; x++) {
154  ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x];
155  }
156  } else {
157  for (x = 0; x < w; x++) {
158  ((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);
159  }
160  }
161  }
162  }
163  return 0;
164 }
165 
166 static int decode_slice_header(const FFV1Context *f, FFV1Context *fs)
167 {
168  RangeCoder *c = &fs->c;
169  uint8_t state[CONTEXT_SIZE];
170  unsigned ps, i, context_count;
171  memset(state, 128, sizeof(state));
172 
173  av_assert0(f->version > 2);
174 
175  fs->slice_x = get_symbol(c, state, 0) * f->width ;
176  fs->slice_y = get_symbol(c, state, 0) * f->height;
177  fs->slice_width = (get_symbol(c, state, 0) + 1) * f->width + fs->slice_x;
178  fs->slice_height = (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y;
179 
180  fs->slice_x /= f->num_h_slices;
181  fs->slice_y /= f->num_v_slices;
182  fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
183  fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
184  if ((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
185  return -1;
186  if ( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
187  || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
188  return -1;
189 
190  if (fs->ac == AC_GOLOMB_RICE && fs->slice_width >= (1<<23))
191  return AVERROR_INVALIDDATA;
192 
193  for (i = 0; i < f->plane_count; i++) {
194  PlaneContext * const p = &fs->plane[i];
195  int idx = get_symbol(c, state, 0);
196  if (idx >= (unsigned)f->quant_table_count) {
197  av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
198  return -1;
199  }
200  p->quant_table_index = idx;
201  memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
202  context_count = f->context_count[idx];
203 
204  if (p->context_count < context_count) {
205  av_freep(&p->state);
206  av_freep(&p->vlc_state);
207  }
208  p->context_count = context_count;
209  }
210 
211  ps = get_symbol(c, state, 0);
212  if (ps == 1) {
213  f->cur->interlaced_frame = 1;
214  f->cur->top_field_first = 1;
215  } else if (ps == 2) {
216  f->cur->interlaced_frame = 1;
217  f->cur->top_field_first = 0;
218  } else if (ps == 3) {
219  f->cur->interlaced_frame = 0;
220  }
221  f->cur->sample_aspect_ratio.num = get_symbol(c, state, 0);
222  f->cur->sample_aspect_ratio.den = get_symbol(c, state, 0);
223 
224  if (av_image_check_sar(f->width, f->height,
225  f->cur->sample_aspect_ratio) < 0) {
226  av_log(f->avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
227  f->cur->sample_aspect_ratio.num,
228  f->cur->sample_aspect_ratio.den);
229  f->cur->sample_aspect_ratio = (AVRational){ 0, 1 };
230  }
231 
232  if (fs->version > 3) {
233  fs->slice_reset_contexts = get_rac(c, state);
234  fs->slice_coding_mode = get_symbol(c, state, 0);
235  if (fs->slice_coding_mode != 1) {
236  fs->slice_rct_by_coef = get_symbol(c, state, 0);
237  fs->slice_rct_ry_coef = get_symbol(c, state, 0);
238  if ((uint64_t)fs->slice_rct_by_coef + (uint64_t)fs->slice_rct_ry_coef > 4) {
239  av_log(f->avctx, AV_LOG_ERROR, "slice_rct_y_coef out of range\n");
240  return AVERROR_INVALIDDATA;
241  }
242  }
243  }
244 
245  return 0;
246 }
247 
248 static int decode_slice(AVCodecContext *c, void *arg)
249 {
250  FFV1Context *fs = *(void **)arg;
251  FFV1Context *f = fs->avctx->priv_data;
252  int width, height, x, y, ret;
253  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
254  AVFrame * const p = f->cur;
255  int i, si;
256 
257  for( si=0; fs != f->slice_context[si]; si ++)
258  ;
259 
260  if(f->fsrc && !p->key_frame)
261  ff_thread_await_progress(&f->last_picture, si, 0);
262 
263  if(f->fsrc && !p->key_frame) {
264  FFV1Context *fssrc = f->fsrc->slice_context[si];
265  FFV1Context *fsdst = f->slice_context[si];
266  av_assert1(fsdst->plane_count == fssrc->plane_count);
267  av_assert1(fsdst == fs);
268 
269  if (!p->key_frame)
270  fsdst->slice_damaged |= fssrc->slice_damaged;
271 
272  for (i = 0; i < f->plane_count; i++) {
273  PlaneContext *psrc = &fssrc->plane[i];
274  PlaneContext *pdst = &fsdst->plane[i];
275 
276  av_free(pdst->state);
277  av_free(pdst->vlc_state);
278  memcpy(pdst, psrc, sizeof(*pdst));
279  pdst->state = NULL;
280  pdst->vlc_state = NULL;
281 
282  if (fssrc->ac) {
283  pdst->state = av_malloc_array(CONTEXT_SIZE, psrc->context_count);
284  memcpy(pdst->state, psrc->state, CONTEXT_SIZE * psrc->context_count);
285  } else {
286  pdst->vlc_state = av_malloc_array(sizeof(*pdst->vlc_state), psrc->context_count);
287  memcpy(pdst->vlc_state, psrc->vlc_state, sizeof(*pdst->vlc_state) * psrc->context_count);
288  }
289  }
290  }
291 
292  fs->slice_rct_by_coef = 1;
293  fs->slice_rct_ry_coef = 1;
294 
295  if (f->version > 2) {
296  if (ff_ffv1_init_slice_state(f, fs) < 0)
297  return AVERROR(ENOMEM);
298  if (decode_slice_header(f, fs) < 0) {
299  fs->slice_x = fs->slice_y = fs->slice_height = fs->slice_width = 0;
300  fs->slice_damaged = 1;
301  return AVERROR_INVALIDDATA;
302  }
303  }
304  if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0)
305  return ret;
306  if (f->cur->key_frame || fs->slice_reset_contexts)
307  ff_ffv1_clear_slice_state(f, fs);
308 
309  width = fs->slice_width;
310  height = fs->slice_height;
311  x = fs->slice_x;
312  y = fs->slice_y;
313 
314  if (fs->ac == AC_GOLOMB_RICE) {
315  if (f->version == 3 && f->micro_version > 1 || f->version > 3)
316  get_rac(&fs->c, (uint8_t[]) { 129 });
317  fs->ac_byte_count = f->version > 2 || (!x && !y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0;
318  init_get_bits(&fs->gb,
319  fs->c.bytestream_start + fs->ac_byte_count,
320  (fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count) * 8);
321  }
322 
323  av_assert1(width && height);
324  if (f->colorspace == 0 && (f->chroma_planes || !fs->transparency)) {
325  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
326  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
327  const int cx = x >> f->chroma_h_shift;
328  const int cy = y >> f->chroma_v_shift;
329  decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
330 
331  if (f->chroma_planes) {
332  decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
333  decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
334  }
335  if (fs->transparency)
336  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);
337  } else if (f->colorspace == 0) {
338  decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0] , width, height, p->linesize[0], 0, 2);
339  decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0] + 1, width, height, p->linesize[0], 1, 2);
340  } else if (f->use32bit) {
341  uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0],
342  p->data[1] + ps * x + y * p->linesize[1],
343  p->data[2] + ps * x + y * p->linesize[2],
344  p->data[3] + ps * x + y * p->linesize[3] };
345  decode_rgb_frame32(fs, planes, width, height, p->linesize);
346  } else {
347  uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0],
348  p->data[1] + ps * x + y * p->linesize[1],
349  p->data[2] + ps * x + y * p->linesize[2],
350  p->data[3] + ps * x + y * p->linesize[3] };
351  decode_rgb_frame(fs, planes, width, height, p->linesize);
352  }
353  if (fs->ac != AC_GOLOMB_RICE && f->version > 2) {
354  int v;
355  get_rac(&fs->c, (uint8_t[]) { 129 });
356  v = fs->c.bytestream_end - fs->c.bytestream - 2 - 5*f->ec;
357  if (v) {
358  av_log(f->avctx, AV_LOG_ERROR, "bytestream end mismatching by %d\n", v);
359  fs->slice_damaged = 1;
360  }
361  }
362 
363  emms_c();
364 
365  ff_thread_report_progress(&f->picture, si, 0);
366 
367  return 0;
368 }
369 
370 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
371 {
372  int v;
373  int i = 0;
374  uint8_t state[CONTEXT_SIZE];
375 
376  memset(state, 128, sizeof(state));
377 
378  for (v = 0; i < 128; v++) {
379  unsigned len = get_symbol(c, state, 0) + 1U;
380 
381  if (len > 128 - i || !len)
382  return AVERROR_INVALIDDATA;
383 
384  while (len--) {
385  quant_table[i] = scale * v;
386  i++;
387  }
388  }
389 
390  for (i = 1; i < 128; i++)
391  quant_table[256 - i] = -quant_table[i];
392  quant_table[128] = -quant_table[127];
393 
394  return 2 * v - 1;
395 }
396 
397 static int read_quant_tables(RangeCoder *c,
398  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
399 {
400  int i;
401  int context_count = 1;
402 
403  for (i = 0; i < 5; i++) {
404  int ret = read_quant_table(c, quant_table[i], context_count);
405  if (ret < 0)
406  return ret;
407  context_count *= ret;
408  if (context_count > 32768U) {
409  return AVERROR_INVALIDDATA;
410  }
411  }
412  return (context_count + 1) / 2;
413 }
414 
415 static int read_extra_header(FFV1Context *f)
416 {
417  RangeCoder *const c = &f->c;
418  uint8_t state[CONTEXT_SIZE];
419  int i, j, k, ret;
420  uint8_t state2[32][CONTEXT_SIZE];
421  unsigned crc = 0;
422 
423  memset(state2, 128, sizeof(state2));
424  memset(state, 128, sizeof(state));
425 
426  ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
427  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
428 
429  f->version = get_symbol(c, state, 0);
430  if (f->version < 2) {
431  av_log(f->avctx, AV_LOG_ERROR, "Invalid version in global header\n");
432  return AVERROR_INVALIDDATA;
433  }
434  if (f->version > 2) {
435  c->bytestream_end -= 4;
436  f->micro_version = get_symbol(c, state, 0);
437  if (f->micro_version < 0)
438  return AVERROR_INVALIDDATA;
439  }
440  f->ac = get_symbol(c, state, 0);
441 
442  if (f->ac == AC_RANGE_CUSTOM_TAB) {
443  for (i = 1; i < 256; i++)
444  f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i];
445  }
446 
447  f->colorspace = get_symbol(c, state, 0); //YUV cs type
448  f->avctx->bits_per_raw_sample = get_symbol(c, state, 0);
449  f->chroma_planes = get_rac(c, state);
450  f->chroma_h_shift = get_symbol(c, state, 0);
451  f->chroma_v_shift = get_symbol(c, state, 0);
452  f->transparency = get_rac(c, state);
453  f->plane_count = 1 + (f->chroma_planes || f->version<4) + f->transparency;
454  f->num_h_slices = 1 + get_symbol(c, state, 0);
455  f->num_v_slices = 1 + get_symbol(c, state, 0);
456 
457  if (f->chroma_h_shift > 4U || f->chroma_v_shift > 4U) {
458  av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
459  f->chroma_h_shift, f->chroma_v_shift);
460  return AVERROR_INVALIDDATA;
461  }
462 
463  if (f->num_h_slices > (unsigned)f->width || !f->num_h_slices ||
464  f->num_v_slices > (unsigned)f->height || !f->num_v_slices
465  ) {
466  av_log(f->avctx, AV_LOG_ERROR, "slice count invalid\n");
467  return AVERROR_INVALIDDATA;
468  }
469 
470  f->quant_table_count = get_symbol(c, state, 0);
471  if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES || !f->quant_table_count) {
472  av_log(f->avctx, AV_LOG_ERROR, "quant table count %d is invalid\n", f->quant_table_count);
473  f->quant_table_count = 0;
474  return AVERROR_INVALIDDATA;
475  }
476 
477  for (i = 0; i < f->quant_table_count; i++) {
478  f->context_count[i] = read_quant_tables(c, f->quant_tables[i]);
479  if (f->context_count[i] < 0) {
480  av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
481  return AVERROR_INVALIDDATA;
482  }
483  }
484  if ((ret = ff_ffv1_allocate_initial_states(f)) < 0)
485  return ret;
486 
487  for (i = 0; i < f->quant_table_count; i++)
488  if (get_rac(c, state)) {
489  for (j = 0; j < f->context_count[i]; j++)
490  for (k = 0; k < CONTEXT_SIZE; k++) {
491  int pred = j ? f->initial_states[i][j - 1][k] : 128;
492  f->initial_states[i][j][k] =
493  (pred + get_symbol(c, state2[k], 1)) & 0xFF;
494  }
495  }
496 
497  if (f->version > 2) {
498  f->ec = get_symbol(c, state, 0);
499  if (f->micro_version > 2)
500  f->intra = get_symbol(c, state, 0);
501  }
502 
503  if (f->version > 2) {
504  unsigned v;
505  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0,
506  f->avctx->extradata, f->avctx->extradata_size);
507  if (v || f->avctx->extradata_size < 4) {
508  av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
509  return AVERROR_INVALIDDATA;
510  }
511  crc = AV_RB32(f->avctx->extradata + f->avctx->extradata_size - 4);
512  }
513 
514  if (f->avctx->debug & FF_DEBUG_PICT_INFO)
515  av_log(f->avctx, AV_LOG_DEBUG,
516  "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",
517  f->version, f->micro_version,
518  f->ac,
519  f->colorspace,
520  f->avctx->bits_per_raw_sample,
521  f->chroma_planes, f->chroma_h_shift, f->chroma_v_shift,
522  f->transparency,
523  f->num_h_slices, f->num_v_slices,
524  f->quant_table_count,
525  f->ec,
526  f->intra,
527  crc
528  );
529  return 0;
530 }
531 
532 static int read_header(FFV1Context *f)
533 {
534  uint8_t state[CONTEXT_SIZE];
535  int i, j, context_count = -1; //-1 to avoid warning
536  RangeCoder *const c = &f->slice_context[0]->c;
537 
538  memset(state, 128, sizeof(state));
539 
540  if (f->version < 2) {
541  int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sample;
542  unsigned v= get_symbol(c, state, 0);
543  if (v >= 2) {
544  av_log(f->avctx, AV_LOG_ERROR, "invalid version %d in ver01 header\n", v);
545  return AVERROR_INVALIDDATA;
546  }
547  f->version = v;
548  f->ac = get_symbol(c, state, 0);
549 
550  if (f->ac == AC_RANGE_CUSTOM_TAB) {
551  for (i = 1; i < 256; i++) {
552  int st = get_symbol(c, state, 1) + c->one_state[i];
553  if (st < 1 || st > 255) {
554  av_log(f->avctx, AV_LOG_ERROR, "invalid state transition %d\n", st);
555  return AVERROR_INVALIDDATA;
556  }
557  f->state_transition[i] = st;
558  }
559  }
560 
561  colorspace = get_symbol(c, state, 0); //YUV cs type
562  bits_per_raw_sample = f->version > 0 ? get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample;
563  chroma_planes = get_rac(c, state);
564  chroma_h_shift = get_symbol(c, state, 0);
565  chroma_v_shift = get_symbol(c, state, 0);
566  transparency = get_rac(c, state);
567  if (colorspace == 0 && f->avctx->skip_alpha)
568  transparency = 0;
569 
570  if (f->plane_count) {
571  if (colorspace != f->colorspace ||
572  bits_per_raw_sample != f->avctx->bits_per_raw_sample ||
573  chroma_planes != f->chroma_planes ||
574  chroma_h_shift != f->chroma_h_shift ||
575  chroma_v_shift != f->chroma_v_shift ||
576  transparency != f->transparency) {
577  av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n");
578  return AVERROR_INVALIDDATA;
579  }
580  }
581 
582  if (chroma_h_shift > 4U || chroma_v_shift > 4U) {
583  av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
584  chroma_h_shift, chroma_v_shift);
585  return AVERROR_INVALIDDATA;
586  }
587 
588  f->colorspace = colorspace;
589  f->avctx->bits_per_raw_sample = bits_per_raw_sample;
590  f->chroma_planes = chroma_planes;
591  f->chroma_h_shift = chroma_h_shift;
592  f->chroma_v_shift = chroma_v_shift;
593  f->transparency = transparency;
594 
595  f->plane_count = 2 + f->transparency;
596  }
597 
598  if (f->colorspace == 0) {
599  if (!f->transparency && !f->chroma_planes) {
600  if (f->avctx->bits_per_raw_sample <= 8)
601  f->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
602  else if (f->avctx->bits_per_raw_sample == 9) {
603  f->packed_at_lsb = 1;
604  f->avctx->pix_fmt = AV_PIX_FMT_GRAY9;
605  } else if (f->avctx->bits_per_raw_sample == 10) {
606  f->packed_at_lsb = 1;
607  f->avctx->pix_fmt = AV_PIX_FMT_GRAY10;
608  } else if (f->avctx->bits_per_raw_sample == 12) {
609  f->packed_at_lsb = 1;
610  f->avctx->pix_fmt = AV_PIX_FMT_GRAY12;
611  } else if (f->avctx->bits_per_raw_sample == 16) {
612  f->packed_at_lsb = 1;
613  f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
614  } else if (f->avctx->bits_per_raw_sample < 16) {
615  f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
616  } else
617  return AVERROR(ENOSYS);
618  } else if (f->transparency && !f->chroma_planes) {
619  if (f->avctx->bits_per_raw_sample <= 8)
620  f->avctx->pix_fmt = AV_PIX_FMT_YA8;
621  else
622  return AVERROR(ENOSYS);
623  } else if (f->avctx->bits_per_raw_sample<=8 && !f->transparency) {
624  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
625  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P; break;
626  case 0x01: f->avctx->pix_fmt = AV_PIX_FMT_YUV440P; break;
627  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P; break;
628  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P; break;
629  case 0x20: f->avctx->pix_fmt = AV_PIX_FMT_YUV411P; break;
630  case 0x22: f->avctx->pix_fmt = AV_PIX_FMT_YUV410P; break;
631  }
632  } else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency) {
633  switch(16*f->chroma_h_shift + f->chroma_v_shift) {
634  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P; break;
635  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P; break;
636  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P; break;
637  }
638  } else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency) {
639  f->packed_at_lsb = 1;
640  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
641  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P9; break;
642  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P9; break;
643  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P9; break;
644  }
645  } else if (f->avctx->bits_per_raw_sample == 9 && f->transparency) {
646  f->packed_at_lsb = 1;
647  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
648  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P9; break;
649  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P9; break;
650  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P9; break;
651  }
652  } else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency) {
653  f->packed_at_lsb = 1;
654  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
655  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P10; break;
656  case 0x01: f->avctx->pix_fmt = AV_PIX_FMT_YUV440P10; break;
657  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P10; break;
658  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P10; break;
659  }
660  } else if (f->avctx->bits_per_raw_sample == 10 && f->transparency) {
661  f->packed_at_lsb = 1;
662  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
663  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P10; break;
664  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P10; break;
665  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P10; break;
666  }
667  } else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency) {
668  f->packed_at_lsb = 1;
669  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
670  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P12; break;
671  case 0x01: f->avctx->pix_fmt = AV_PIX_FMT_YUV440P12; break;
672  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P12; break;
673  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P12; break;
674  }
675  } else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency) {
676  f->packed_at_lsb = 1;
677  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
678  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P14; break;
679  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P14; break;
680  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P14; break;
681  }
682  } else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency){
683  f->packed_at_lsb = 1;
684  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
685  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P16; break;
686  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P16; break;
687  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P16; break;
688  }
689  } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency){
690  f->packed_at_lsb = 1;
691  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
692  case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P16; break;
693  case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P16; break;
694  case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16; break;
695  }
696  }
697  } else if (f->colorspace == 1) {
698  if (f->chroma_h_shift || f->chroma_v_shift) {
699  av_log(f->avctx, AV_LOG_ERROR,
700  "chroma subsampling not supported in this colorspace\n");
701  return AVERROR(ENOSYS);
702  }
703  if ( f->avctx->bits_per_raw_sample <= 8 && !f->transparency)
704  f->avctx->pix_fmt = AV_PIX_FMT_0RGB32;
705  else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency)
706  f->avctx->pix_fmt = AV_PIX_FMT_RGB32;
707  else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency)
708  f->avctx->pix_fmt = AV_PIX_FMT_GBRP9;
709  else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency)
710  f->avctx->pix_fmt = AV_PIX_FMT_GBRP10;
711  else if (f->avctx->bits_per_raw_sample == 10 && f->transparency)
712  f->avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
713  else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency)
714  f->avctx->pix_fmt = AV_PIX_FMT_GBRP12;
715  else if (f->avctx->bits_per_raw_sample == 12 && f->transparency)
716  f->avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
717  else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency)
718  f->avctx->pix_fmt = AV_PIX_FMT_GBRP14;
719  else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency) {
720  f->avctx->pix_fmt = AV_PIX_FMT_GBRP16;
721  f->use32bit = 1;
722  }
723  else if (f->avctx->bits_per_raw_sample == 16 && f->transparency) {
724  f->avctx->pix_fmt = AV_PIX_FMT_GBRAP16;
725  f->use32bit = 1;
726  }
727  } else {
728  av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
729  return AVERROR(ENOSYS);
730  }
731  if (f->avctx->pix_fmt == AV_PIX_FMT_NONE) {
732  av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
733  return AVERROR(ENOSYS);
734  }
735 
736  ff_dlog(f->avctx, "%d %d %d\n",
737  f->chroma_h_shift, f->chroma_v_shift, f->avctx->pix_fmt);
738  if (f->version < 2) {
739  context_count = read_quant_tables(c, f->quant_table);
740  if (context_count < 0) {
741  av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
742  return AVERROR_INVALIDDATA;
743  }
744  f->slice_count = f->max_slice_count;
745  } else if (f->version < 3) {
746  f->slice_count = get_symbol(c, state, 0);
747  } else {
748  const uint8_t *p = c->bytestream_end;
749  for (f->slice_count = 0;
750  f->slice_count < MAX_SLICES && 3 + 5*!!f->ec < p - c->bytestream_start;
751  f->slice_count++) {
752  int trailer = 3 + 5*!!f->ec;
753  int size = AV_RB24(p-trailer);
754  if (size + trailer > p - c->bytestream_start)
755  break;
756  p -= size + trailer;
757  }
758  }
759  if (f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0 || f->slice_count > f->max_slice_count) {
760  av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid (max=%d)\n", f->slice_count, f->max_slice_count);
761  return AVERROR_INVALIDDATA;
762  }
763 
764  for (j = 0; j < f->slice_count; j++) {
765  FFV1Context *fs = f->slice_context[j];
766  fs->ac = f->ac;
767  fs->packed_at_lsb = f->packed_at_lsb;
768 
769  fs->slice_damaged = 0;
770 
771  if (f->version == 2) {
772  fs->slice_x = get_symbol(c, state, 0) * f->width ;
773  fs->slice_y = get_symbol(c, state, 0) * f->height;
774  fs->slice_width = (get_symbol(c, state, 0) + 1) * f->width + fs->slice_x;
775  fs->slice_height = (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y;
776 
777  fs->slice_x /= f->num_h_slices;
778  fs->slice_y /= f->num_v_slices;
779  fs->slice_width = fs->slice_width / f->num_h_slices - fs->slice_x;
780  fs->slice_height = fs->slice_height / f->num_v_slices - fs->slice_y;
781  if ((unsigned)fs->slice_width > f->width ||
782  (unsigned)fs->slice_height > f->height)
783  return AVERROR_INVALIDDATA;
784  if ( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
785  || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
786  return AVERROR_INVALIDDATA;
787  }
788 
789  for (i = 0; i < f->plane_count; i++) {
790  PlaneContext *const p = &fs->plane[i];
791 
792  if (f->version == 2) {
793  int idx = get_symbol(c, state, 0);
794  if (idx >= (unsigned)f->quant_table_count) {
795  av_log(f->avctx, AV_LOG_ERROR,
796  "quant_table_index out of range\n");
797  return AVERROR_INVALIDDATA;
798  }
799  p->quant_table_index = idx;
800  memcpy(p->quant_table, f->quant_tables[idx],
801  sizeof(p->quant_table));
802  context_count = f->context_count[idx];
803  } else {
804  memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
805  }
806 
807  if (f->version <= 2) {
808  av_assert0(context_count >= 0);
809  if (p->context_count < context_count) {
810  av_freep(&p->state);
811  av_freep(&p->vlc_state);
812  }
813  p->context_count = context_count;
814  }
815  }
816  }
817  return 0;
818 }
819 
820 static av_cold int decode_init(AVCodecContext *avctx)
821 {
822  FFV1Context *f = avctx->priv_data;
823  int ret;
824 
825  if ((ret = ff_ffv1_common_init(avctx)) < 0)
826  return ret;
827 
828  if (avctx->extradata_size > 0 && (ret = read_extra_header(f)) < 0)
829  return ret;
830 
831  if ((ret = ff_ffv1_init_slice_contexts(f)) < 0)
832  return ret;
833 
834  return 0;
835 }
836 
837 static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
838  int *got_frame, AVPacket *avpkt)
839 {
840  uint8_t *buf = avpkt->data;
841  int buf_size = avpkt->size;
842  FFV1Context *f = avctx->priv_data;
843  RangeCoder *const c = &f->slice_context[0]->c;
844  int i, ret;
845  uint8_t keystate = 128;
846  uint8_t *buf_p;
847  AVFrame *p;
848 
849  if (f->last_picture.f)
850  ff_thread_release_ext_buffer(avctx, &f->last_picture);
851  FFSWAP(ThreadFrame, f->picture, f->last_picture);
852 
853  f->cur = p = f->picture.f;
854 
855  if (f->version < 3 && avctx->field_order > AV_FIELD_PROGRESSIVE) {
856  /* we have interlaced material flagged in container */
857  p->interlaced_frame = 1;
858  if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
859  p->top_field_first = 1;
860  }
861 
862  f->avctx = avctx;
863  ff_init_range_decoder(c, buf, buf_size);
864  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
865 
866  p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P
867  if (get_rac(c, &keystate)) {
868  p->key_frame = 1;
869  f->key_frame_ok = 0;
870  if ((ret = read_header(f)) < 0)
871  return ret;
872  f->key_frame_ok = 1;
873  } else {
874  if (!f->key_frame_ok) {
875  av_log(avctx, AV_LOG_ERROR,
876  "Cannot decode non-keyframe without valid keyframe\n");
877  return AVERROR_INVALIDDATA;
878  }
879  p->key_frame = 0;
880  }
881 
882  if (f->ac != AC_GOLOMB_RICE) {
883  if (buf_size < avctx->width * avctx->height / (128*8))
884  return AVERROR_INVALIDDATA;
885  } else {
886  int w = avctx->width;
887  int s = 1 + w / (1<<23);
888 
889  w /= s;
890 
891  for (i = 0; w > (1<<ff_log2_run[i]); i++)
892  w -= ff_log2_run[i];
893  if (buf_size < (avctx->height + i + 6) / 8 * s)
894  return AVERROR_INVALIDDATA;
895  }
896 
897  ret = ff_thread_get_ext_buffer(avctx, &f->picture, AV_GET_BUFFER_FLAG_REF);
898  if (ret < 0)
899  return ret;
900 
901  if (avctx->debug & FF_DEBUG_PICT_INFO)
902  av_log(avctx, AV_LOG_DEBUG, "ver:%d keyframe:%d coder:%d ec:%d slices:%d bps:%d\n",
903  f->version, p->key_frame, f->ac, f->ec, f->slice_count, f->avctx->bits_per_raw_sample);
904 
905  ff_thread_finish_setup(avctx);
906 
907  buf_p = buf + buf_size;
908  for (i = f->slice_count - 1; i >= 0; i--) {
909  FFV1Context *fs = f->slice_context[i];
910  int trailer = 3 + 5*!!f->ec;
911  int v;
912 
913  if (i || f->version > 2) {
914  if (trailer > buf_p - buf) v = INT_MAX;
915  else v = AV_RB24(buf_p-trailer) + trailer;
916  } else v = buf_p - c->bytestream_start;
917  if (buf_p - c->bytestream_start < v) {
918  av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
919  ff_thread_report_progress(&f->picture, INT_MAX, 0);
920  return AVERROR_INVALIDDATA;
921  }
922  buf_p -= v;
923 
924  if (f->ec) {
925  unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, v);
926  if (crc) {
927  int64_t ts = avpkt->pts != AV_NOPTS_VALUE ? avpkt->pts : avpkt->dts;
928  av_log(f->avctx, AV_LOG_ERROR, "slice CRC mismatch %X!", crc);
929  if (ts != AV_NOPTS_VALUE && avctx->pkt_timebase.num) {
930  av_log(f->avctx, AV_LOG_ERROR, "at %f seconds\n", ts*av_q2d(avctx->pkt_timebase));
931  } else if (ts != AV_NOPTS_VALUE) {
932  av_log(f->avctx, AV_LOG_ERROR, "at %"PRId64"\n", ts);
933  } else {
934  av_log(f->avctx, AV_LOG_ERROR, "\n");
935  }
936  fs->slice_damaged = 1;
937  }
938  if (avctx->debug & FF_DEBUG_PICT_INFO) {
939  av_log(avctx, AV_LOG_DEBUG, "slice %d, CRC: 0x%08"PRIX32"\n", i, AV_RB32(buf_p + v - 4));
940  }
941  }
942 
943  if (i) {
944  ff_init_range_decoder(&fs->c, buf_p, v);
945  } else
946  fs->c.bytestream_end = buf_p + v;
947 
948  fs->avctx = avctx;
949  }
950 
951  avctx->execute(avctx,
952  decode_slice,
953  &f->slice_context[0],
954  NULL,
955  f->slice_count,
956  sizeof(void*));
957 
958  for (i = f->slice_count - 1; i >= 0; i--) {
959  FFV1Context *fs = f->slice_context[i];
960  int j;
961  if (fs->slice_damaged && f->last_picture.f->data[0]) {
962  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
963  const uint8_t *src[4];
964  uint8_t *dst[4];
965  ff_thread_await_progress(&f->last_picture, INT_MAX, 0);
966  for (j = 0; j < desc->nb_components; j++) {
967  int pixshift = desc->comp[j].depth > 8;
968  int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
969  int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
970  dst[j] = p->data[j] + p->linesize[j] *
971  (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
972  src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] *
973  (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
974 
975  }
976  if (desc->flags & AV_PIX_FMT_FLAG_PAL) {
977  dst[1] = p->data[1];
978  src[1] = f->last_picture.f->data[1];
979  }
980  av_image_copy(dst, p->linesize, src,
981  f->last_picture.f->linesize,
982  avctx->pix_fmt,
983  fs->slice_width,
984  fs->slice_height);
985  }
986  }
987  ff_thread_report_progress(&f->picture, INT_MAX, 0);
988 
989  if (f->last_picture.f)
990  ff_thread_release_ext_buffer(avctx, &f->last_picture);
991  if ((ret = av_frame_ref(rframe, f->picture.f)) < 0)
992  return ret;
993 
994  *got_frame = 1;
995 
996  return buf_size;
997 }
998 
999 static void copy_fields(FFV1Context *fsdst, const FFV1Context *fssrc,
1000  const FFV1Context *fsrc)
1001 {
1002  fsdst->version = fsrc->version;
1003  fsdst->micro_version = fsrc->micro_version;
1004  fsdst->chroma_planes = fsrc->chroma_planes;
1005  fsdst->chroma_h_shift = fsrc->chroma_h_shift;
1006  fsdst->chroma_v_shift = fsrc->chroma_v_shift;
1007  fsdst->transparency = fsrc->transparency;
1008  fsdst->plane_count = fsrc->plane_count;
1009  fsdst->ac = fsrc->ac;
1010  fsdst->colorspace = fsrc->colorspace;
1011 
1012  fsdst->ec = fsrc->ec;
1013  fsdst->intra = fsrc->intra;
1014  fsdst->slice_damaged = fssrc->slice_damaged;
1015  fsdst->key_frame_ok = fsrc->key_frame_ok;
1016 
1017  fsdst->packed_at_lsb = fsrc->packed_at_lsb;
1018  fsdst->slice_count = fsrc->slice_count;
1019  if (fsrc->version<3){
1020  fsdst->slice_x = fssrc->slice_x;
1021  fsdst->slice_y = fssrc->slice_y;
1022  fsdst->slice_width = fssrc->slice_width;
1023  fsdst->slice_height = fssrc->slice_height;
1024  }
1025 }
1026 
1027 #if HAVE_THREADS
1028 static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1029 {
1030  FFV1Context *fsrc = src->priv_data;
1031  FFV1Context *fdst = dst->priv_data;
1032  int i, ret;
1033 
1034  if (dst == src)
1035  return 0;
1036 
1037  {
1038  ThreadFrame picture = fdst->picture, last_picture = fdst->last_picture;
1039  uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
1040  struct FFV1Context *slice_context[MAX_SLICES];
1041  memcpy(initial_states, fdst->initial_states, sizeof(fdst->initial_states));
1042  memcpy(slice_context, fdst->slice_context , sizeof(fdst->slice_context));
1043 
1044  memcpy(fdst, fsrc, sizeof(*fdst));
1045  memcpy(fdst->initial_states, initial_states, sizeof(fdst->initial_states));
1046  memcpy(fdst->slice_context, slice_context , sizeof(fdst->slice_context));
1047  fdst->picture = picture;
1048  fdst->last_picture = last_picture;
1049  for (i = 0; i<fdst->num_h_slices * fdst->num_v_slices; i++) {
1050  FFV1Context *fssrc = fsrc->slice_context[i];
1051  FFV1Context *fsdst = fdst->slice_context[i];
1052  copy_fields(fsdst, fssrc, fsrc);
1053  }
1054  av_assert0(!fdst->plane[0].state);
1055  av_assert0(!fdst->sample_buffer);
1056  }
1057 
1058  av_assert1(fdst->max_slice_count == fsrc->max_slice_count);
1059 
1060 
1061  ff_thread_release_ext_buffer(dst, &fdst->picture);
1062  if (fsrc->picture.f->data[0]) {
1063  if ((ret = ff_thread_ref_frame(&fdst->picture, &fsrc->picture)) < 0)
1064  return ret;
1065  }
1066 
1067  fdst->fsrc = fsrc;
1068 
1069  return 0;
1070 }
1071 #endif
1072 
1073 const FFCodec ff_ffv1_decoder = {
1074  .p.name = "ffv1",
1075  .p.long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1076  .p.type = AVMEDIA_TYPE_VIDEO,
1077  .p.id = AV_CODEC_ID_FFV1,
1078  .priv_data_size = sizeof(FFV1Context),
1079  .init = decode_init,
1080  .close = ff_ffv1_close,
1081  FF_CODEC_DECODE_CB(decode_frame),
1082  .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
1083  .p.capabilities = AV_CODEC_CAP_DR1 /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/ |
1084  AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
1085  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
1086  FF_CODEC_CAP_ALLOCATE_PROGRESS,
1087 };
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:449
read_extra_header
static int read_extra_header(FFV1Context *f)
Definition: ffv1dec.c:415
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:428
FFV1Context::chroma_v_shift
int chroma_v_shift
Definition: ffv1.h:85
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FFV1Context::key_frame_ok
int key_frame_ok
Definition: ffv1.h:113
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:156
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: codec_internal.h:39
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
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:248
opt.h
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:133
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:1141
is_input_end
static int is_input_end(FFV1Context *s)
Definition: ffv1dec.c:97
FFV1Context::context_count
int context_count[MAX_QUANT_TABLES]
Definition: ffv1.h:100
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2662
MAX_OVERREAD
#define MAX_OVERREAD
Definition: lagarithrac.h:50
FFV1Context::ec
int ec
Definition: ffv1.h:110
FFV1Context::gb
GetBitContext gb
Definition: ffv1.h:77
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:441
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:325
pixdesc.h
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:36
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:448
w
uint8_t w
Definition: llviddspenc.c:38
FFV1Context::last_picture
ThreadFrame last_picture
Definition: ffv1.h:90
AVPacket::data
uint8_t * data
Definition: packet.h:374
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:443
AVCodecContext::field_order
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:995
FFV1Context::slice_x
int slice_x
Definition: ffv1.h:129
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:482
last_picture
enum AVPictureType last_picture
Definition: movenc.c:69
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:406
PlaneContext::state
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:66
FFCodec
Definition: codec_internal.h:112
FFV1Context::num_h_slices
int num_h_slices
Definition: ffv1.h:126
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:122
read_quant_table
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
Definition: ffv1dec.c:370
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:52
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:444
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
thread.h
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: threadframe.h:28
FFV1Context::chroma_h_shift
int chroma_h_shift
Definition: ffv1.h:85
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1323
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:386
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
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:440
AV_FIELD_TT
@ AV_FIELD_TT
Definition: codec_par.h:40
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:424
U
#define U(x)
Definition: vp56_arith.h:37
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:422
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:450
GetBitContext
Definition: get_bits.h:61
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:404
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:417
av_noinline
#define av_noinline
Definition: attributes.h:72
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:45
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:390
get_symbol_inline
static av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed)
Definition: ffv1dec.c:43
AV_FIELD_TB
@ AV_FIELD_TB
Definition: codec_par.h:42
FFV1Context::chroma_planes
int chroma_planes
Definition: ffv1.h:84
PlaneContext::context_count
int context_count
Definition: ffv1.h:65
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:168
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:409
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:418
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:595
FFV1Context::bits_per_raw_sample
int bits_per_raw_sample
Definition: ffv1.h:116
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:426
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:491
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
s
#define s(width, name)
Definition: cbs_vp9.c:256
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:427
FFV1Context::slice_count
int slice_count
Definition: ffv1.h:123
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:419
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
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:367
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)
Definition: ffv1dec.c:837
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:97
FFV1Context::max_slice_count
int max_slice_count
Definition: ffv1.h:124
FFV1Context::slice_damaged
int slice_damaged
Definition: ffv1.h:112
bits
uint8_t bits
Definition: vp3data.h:141
FFV1Context::intra
int intra
Definition: ffv1.h:111
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
FFV1Context::fsrc
struct FFV1Context * fsrc
Definition: ffv1.h:91
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:403
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:397
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:417
get_bits.h
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:145
FFV1Context::ac
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:95
get_vlc_symbol
static int get_vlc_symbol(GetBitContext *gb, VlcState *const state, int bits)
Definition: ffv1dec.c:72
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:94
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:891
arg
const char * arg
Definition: jacosubdec.c:67
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:387
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
threadframe.h
FFV1Context::slice_height
int slice_height
Definition: ffv1.h:128
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:425
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:532
get_symbol
static av_noinline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
Definition: ffv1dec.c:67
NULL
#define NULL
Definition: coverity.c:32
PlaneContext::vlc_state
VlcState * vlc_state
Definition: ffv1.h:67
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:50
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:258
FFV1Context::num_v_slices
int num_v_slices
Definition: ffv1.h:125
FFV1Context::colorspace
int colorspace
Definition: ffv1.h:104
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
ff_ffv1_decoder
const FFCodec ff_ffv1_decoder
Definition: ffv1dec.c:1073
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:408
mathops.h
PlaneContext
Definition: ffv1.h:62
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:407
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:421
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
planes
static const struct @328 planes[]
VlcState
Definition: ffv1.h:55
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
FFV1Context::slice_width
int slice_width
Definition: ffv1.h:127
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
f
f
Definition: af_crystalizer.c:122
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
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
AVPacket::size
int size
Definition: packet.h:375
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:343
codec_internal.h
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:411
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:196
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:1746
sample
#define sample
Definition: flacdsp_template.c:44
FFV1Context::picture
ThreadFrame picture
Definition: ffv1.h:90
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
FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: codec_internal.h:66
state
static struct @327 state
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:413
FFV1Context::sample_buffer
int16_t * sample_buffer
Definition: ffv1.h:105
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
height
#define height
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:379
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:445
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:64
FFV1Context::initial_states
uint8_t(*[MAX_QUANT_TABLES] initial_states)[32]
Definition: ffv1.h:102
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:477
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:120
copy_fields
static void copy_fields(FFV1Context *fsdst, const FFV1Context *fssrc, const FFV1Context *fsrc)
Definition: ffv1dec.c:999
ff_ffv1_init_slice_state
av_cold int ff_ffv1_init_slice_state(const FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:61
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:367
av_flatten
#define av_flatten
Definition: attributes.h:96
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:423
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
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
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: codec_internal.h:31
FFV1Context::slice_y
int slice_y
Definition: ffv1.h:130
ffv1.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
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::height
int height
Definition: avcodec.h:562
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:599
ff_thread_get_ext_buffer
int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around ff_get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1043
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:405
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:48
FFV1Context::packed_at_lsb
int packed_at_lsb
Definition: ffv1.h:117
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
FFV1Context::avctx
AVCodecContext * avctx
Definition: ffv1.h:75
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:383
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:442
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:410
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:415
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:153
AVCodecContext
main external API structure.
Definition: avcodec.h:389
MAX_SLICES
#define MAX_SLICES
Definition: dxva2_hevc.c:31
ThreadFrame
Definition: threadframe.h:27
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:1514
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:820
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:1322
desc
const char * desc
Definition: libsvtav1.c:83
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
MAX_QUANT_TABLES
#define MAX_QUANT_TABLES
Definition: ffv1.h:47
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:39
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:73
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFV1Context::transparency
int transparency
Definition: ffv1.h:86
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:416
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
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
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:562
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:111
ff_log2_run
const uint8_t ff_log2_run[41]
Definition: mathtables.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:370
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:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
FFV1Context::micro_version
int micro_version
Definition: ffv1.h:82
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:412
h
h
Definition: vp9dsp_template.c:2038
RangeCoder
Definition: mss3.c:62
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:416
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:388
PlaneContext::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:63
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:166
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:81
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:414
Generated on Wed Aug 24 2022 21:41:25 for FFmpeg by   doxygen 1.8.17