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/mem.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 "progressframe.h"
41 #include "libavutil/refstruct.h"
42 #include "thread.h"
43 #include "decode.h"
44 #include "hwconfig.h"
45 #include "hwaccel_internal.h"
46 #include "config_components.h"
47 
48 static inline int get_vlc_symbol(GetBitContext *gb, VlcState *const state,
49  int bits)
50 {
51  int k, i, v, ret;
52 
53  i = state->count;
54  k = 0;
55  while (i < state->error_sum) { // FIXME: optimize
56  k++;
57  i += i;
58  }
59 
60  v = get_sr_golomb(gb, k, 12, bits);
61  ff_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
62  v, state->bias, state->error_sum, state->drift, state->count, k);
63 
64  v ^= ((2 * state->drift + state->count) >> 31);
65 
66  ret = fold(v + state->bias, bits);
67 
69 
70  return ret;
71 }
72 
73 static int is_input_end(RangeCoder *c, GetBitContext *gb, int ac)
74 {
75  if (ac != AC_GOLOMB_RICE) {
76  if (c->overread > MAX_OVERREAD)
77  return AVERROR_INVALIDDATA;
78  } else {
79  if (get_bits_left(gb) < 1)
80  return AVERROR_INVALIDDATA;
81  }
82  return 0;
83 }
84 
85 #define TYPE int16_t
86 #define RENAME(name) name
87 #include "ffv1dec_template.c"
88 #undef TYPE
89 #undef RENAME
90 
91 #define TYPE int32_t
92 #define RENAME(name) name ## 32
93 #include "ffv1dec_template.c"
94 
96  GetBitContext *gb,
97  uint8_t *src, int w, int h, int stride, int plane_index,
98  int remap_index, int pixel_stride, int ac)
99 {
100  int x, y;
101  int16_t *sample[2];
102  sample[0] = sc->sample_buffer + 3;
103  sample[1] = sc->sample_buffer + w + 6 + 3;
104 
105  sc->run_index = 0;
106 
107  memset(sc->sample_buffer, 0, 2 * (w + 6) * sizeof(*sc->sample_buffer));
108 
109  for (y = 0; y < h; y++) {
110  int16_t *temp = sample[0]; // FIXME: try a normal buffer
111 
112  sample[0] = sample[1];
113  sample[1] = temp;
114 
115  sample[1][-1] = sample[0][0];
116  sample[0][w] = sample[0][w - 1];
117 
118  if (f->avctx->bits_per_raw_sample <= 8) {
119  int ret = decode_line(f, sc, gb, w, sample, plane_index, 8, ac);
120  if (ret < 0)
121  return ret;
122  if (sc->remap)
123  for (x = 0; x < w; x++)
124  sample[1][x] = sc->fltmap[remap_index][sample[1][x]];
125  for (x = 0; x < w; x++)
126  src[x*pixel_stride + stride * y] = sample[1][x];
127  } else {
128  int ret = decode_line(f, sc, gb, w, sample, plane_index, f->avctx->bits_per_raw_sample, ac);
129  if (ret < 0)
130  return ret;
131 
132  if (sc->remap) {
133  if (f->packed_at_lsb || f->avctx->bits_per_raw_sample == 16) {
134  for (x = 0; x < w; x++) {
135  ((uint16_t*)(src + stride*y))[x*pixel_stride] = sc->fltmap[remap_index][sample[1][x] & 0xFFFF];
136  }
137  } else {
138  for (x = 0; x < w; x++) {
139  int v = sc->fltmap[remap_index][sample[1][x] & 0xFFFF];
140  ((uint16_t*)(src + stride*y))[x*pixel_stride] = v << (16 - f->avctx->bits_per_raw_sample) | v >> (2 * f->avctx->bits_per_raw_sample - 16);
141  }
142  }
143  } else {
144  if (f->packed_at_lsb || f->avctx->bits_per_raw_sample == 16) {
145  for (x = 0; x < w; x++) {
146  ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x];
147  }
148  } else {
149  for (x = 0; x < w; x++) {
150  ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x] << (16 - f->avctx->bits_per_raw_sample) | ((uint16_t **)sample)[1][x] >> (2 * f->avctx->bits_per_raw_sample - 16);
151  }
152  }
153  }
154  }
155  }
156  return 0;
157 }
158 
161 {
162  RangeCoder *c = &sc->c;
163  uint8_t state[CONTEXT_SIZE];
164  unsigned ps, context_count;
165  int sx, sy, sw, sh;
166 
167  memset(state, 128, sizeof(state));
168  sx = ff_ffv1_get_symbol(c, state, 0);
169  sy = ff_ffv1_get_symbol(c, state, 0);
170  sw = ff_ffv1_get_symbol(c, state, 0) + 1U;
171  sh = ff_ffv1_get_symbol(c, state, 0) + 1U;
172 
173  av_assert0(f->version > 2);
174 
175 
176  if (sx < 0 || sy < 0 || sw <= 0 || sh <= 0)
177  return AVERROR_INVALIDDATA;
178  if (sx > f->num_h_slices - sw || sy > f->num_v_slices - sh)
179  return AVERROR_INVALIDDATA;
180 
181  sc->slice_x = ff_slice_coord(f, f->width , sx , f->num_h_slices, f->chroma_h_shift);
182  sc->slice_y = ff_slice_coord(f, f->height, sy , f->num_v_slices, f->chroma_v_shift);
183  sc->slice_width = ff_slice_coord(f, f->width , sx + sw, f->num_h_slices, f->chroma_h_shift) - sc->slice_x;
184  sc->slice_height = ff_slice_coord(f, f->height, sy + sh, f->num_v_slices, f->chroma_v_shift) - sc->slice_y;
185 
186  av_assert0((unsigned)sc->slice_width <= f->width &&
187  (unsigned)sc->slice_height <= f->height);
188  av_assert0 ( (unsigned)sc->slice_x + (uint64_t)sc->slice_width <= f->width
189  && (unsigned)sc->slice_y + (uint64_t)sc->slice_height <= f->height);
190 
191  if (f->ac == AC_GOLOMB_RICE && sc->slice_width >= (1<<23))
192  return AVERROR_INVALIDDATA;
193 
194  for (unsigned i = 0; i < f->plane_count; i++) {
195  PlaneContext * const p = &sc->plane[i];
196  int idx = ff_ffv1_get_symbol(c, state, 0);
197  if (idx >= (unsigned)f->quant_table_count) {
198  av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
199  return -1;
200  }
201  p->quant_table_index = idx;
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 = ff_ffv1_get_symbol(c, state, 0);
212  if (ps == 1) {
215  } else if (ps == 2) {
218  } else if (ps == 3) {
219  frame->flags &= ~AV_FRAME_FLAG_INTERLACED;
220  }
221  frame->sample_aspect_ratio.num = ff_ffv1_get_symbol(c, state, 0);
222  frame->sample_aspect_ratio.den = ff_ffv1_get_symbol(c, state, 0);
223 
224  if (av_image_check_sar(f->width, f->height,
225  frame->sample_aspect_ratio) < 0) {
226  av_log(f->avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
227  frame->sample_aspect_ratio.num,
228  frame->sample_aspect_ratio.den);
229  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
230  }
231 
232  if (f->version > 3) {
235  if (sc->slice_coding_mode != 1 && f->colorspace == 1) {
238  if ((uint64_t)sc->slice_rct_by_coef + (uint64_t)sc->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  if (f->combined_version >= 0x40004) {
244  sc->remap = ff_ffv1_get_symbol(c, state, 0);
245  if (sc->remap > 2U ||
246  sc->remap && !f->flt) {
247  av_log(f->avctx, AV_LOG_ERROR, "unsupported remap %d\n", sc->remap);
248  return AVERROR_INVALIDDATA;
249  }
250  }
251  }
252 
253  return 0;
254 }
255 
257 {
258  sc->slice_damaged = 1;
259 
260  // only set this for frame threading, as for slice threading its value is
261  // not used and setting it would be a race
262  if (f->avctx->active_thread_type & FF_THREAD_FRAME)
263  f->frame_damaged = 1;
264 }
265 
267 {
268  int flip = sc->remap == 2 ? 0x7FFF : 0;
269 
270  for (int p= 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
271  int j = 0;
272  int lu = 0;
273  uint8_t state[2][32];
274  memset(state, 128, sizeof(state));
275 
276  for (int i= 0; i<65536; i++) {
277  int run = get_symbol_inline(&sc->c, state[lu], 0);
278  if (run > 65536U - i)
279  return AVERROR_INVALIDDATA;
280  if (lu) {
281  lu ^= !run;
282  while (run--) {
283  sc->fltmap[p][j++] = i ^ ((i&0x8000) ? 0 : flip);
284  i++;
285  }
286  } else {
287  i += run;
288  if (i != 65536)
289  sc->fltmap[p][j++] = i ^ ((i&0x8000) ? 0 : flip);
290  lu ^= !run;
291  }
292  }
293  }
294  return 0;
295 }
296 
297 static int decode_slice(AVCodecContext *c, void *arg)
298 {
299  FFV1Context *f = c->priv_data;
300  FFV1SliceContext *sc = arg;
301  int width, height, x, y, ret;
302  const int ps = av_pix_fmt_desc_get(f->pix_fmt)->comp[0].step;
303  AVFrame * const p = f->picture.f;
304  const int si = sc - f->slices;
305  GetBitContext gb;
306  int ac = f->ac || sc->slice_coding_mode == 1;
307 
308  if (!(p->flags & AV_FRAME_FLAG_KEY) && f->last_picture.f)
309  ff_progress_frame_await(&f->last_picture, si);
310 
311  if (f->slice_damaged[si])
312  slice_set_damaged(f, sc);
313 
314  sc->slice_rct_by_coef = 1;
315  sc->slice_rct_ry_coef = 1;
316 
317  if (f->version > 2) {
318  if (ff_ffv1_init_slice_state(f, sc) < 0)
319  return AVERROR(ENOMEM);
320  if (decode_slice_header(f, sc, p) < 0) {
321  sc->slice_x = sc->slice_y = sc->slice_height = sc->slice_width = 0;
322  slice_set_damaged(f, sc);
323  return AVERROR_INVALIDDATA;
324  }
325  }
326  if ((ret = ff_ffv1_init_slice_state(f, sc)) < 0)
327  return ret;
328  if ((p->flags & AV_FRAME_FLAG_KEY) || sc->slice_reset_contexts) {
330  } else if (sc->slice_damaged) {
331  return AVERROR_INVALIDDATA;
332  }
333 
334  width = sc->slice_width;
335  height = sc->slice_height;
336  x = sc->slice_x;
337  y = sc->slice_y;
338 
339  if (sc->remap) {
340  ret = decode_remap(f, sc);
341  if (ret < 0)
342  return ret;
343  }
344 
345  if (ac == AC_GOLOMB_RICE) {
346  if (f->combined_version >= 0x30002)
347  get_rac(&sc->c, (uint8_t[]) { 129 });
348  sc->ac_byte_count = f->version > 2 || (!x && !y) ? sc->c.bytestream - sc->c.bytestream_start - 1 : 0;
349  init_get_bits(&gb,
350  sc->c.bytestream_start + sc->ac_byte_count,
351  (sc->c.bytestream_end - sc->c.bytestream_start - sc->ac_byte_count) * 8);
352  }
353 
354  av_assert1(width && height);
355  if (f->colorspace == 0 && (f->chroma_planes || !f->transparency)) {
356  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
357  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
358  const int cx = x >> f->chroma_h_shift;
359  const int cy = y >> f->chroma_v_shift;
360  decode_plane(f, sc, &gb, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 1, ac);
361 
362  if (f->chroma_planes) {
363  decode_plane(f, sc, &gb, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1, 1, ac);
364  decode_plane(f, sc, &gb, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 2, 1, ac);
365  }
366  if (f->transparency)
367  decode_plane(f, sc, &gb, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], (f->version >= 4 && !f->chroma_planes) ? 1 : 2,
368  (f->version >= 4 && !f->chroma_planes) ? 1 : 3, 1, ac);
369  } else if (f->colorspace == 0) {
370  decode_plane(f, sc, &gb, p->data[0] + ps*x + y*p->linesize[0] , width, height, p->linesize[0], 0, 0, 2, ac);
371  decode_plane(f, sc, &gb, p->data[0] + ps*x + y*p->linesize[0] + (ps>>1), width, height, p->linesize[0], 1, 1, 2, ac);
372  } else if (f->use32bit) {
373  uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0],
374  p->data[1] + ps * x + y * p->linesize[1],
375  p->data[2] + ps * x + y * p->linesize[2],
376  p->data[3] + ps * x + y * p->linesize[3] };
377  decode_rgb_frame32(f, sc, &gb, planes, width, height, p->linesize);
378  } else {
379  uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0],
380  p->data[1] + ps * x + y * p->linesize[1],
381  p->data[2] + ps * x + y * p->linesize[2],
382  p->data[3] + ps * x + y * p->linesize[3] };
383  decode_rgb_frame(f, sc, &gb, planes, width, height, p->linesize);
384  }
385  if (ac != AC_GOLOMB_RICE && f->version > 2) {
386  int v;
387  get_rac(&sc->c, (uint8_t[]) { 129 });
388  v = sc->c.bytestream_end - sc->c.bytestream - 2 - 5*!!f->ec;
389  if (v) {
390  av_log(f->avctx, AV_LOG_ERROR, "bytestream end mismatching by %d\n", v);
391  slice_set_damaged(f, sc);
392  }
393  }
394 
395  if (sc->slice_damaged && (f->avctx->err_recognition & AV_EF_EXPLODE))
396  return AVERROR_INVALIDDATA;
397 
398  if ((c->active_thread_type & FF_THREAD_FRAME) && !f->frame_damaged)
399  ff_progress_frame_report(&f->picture, si);
400 
401  return 0;
402 }
403 
405 {
406  enum AVPixelFormat pix_fmts[] = {
407 #if CONFIG_FFV1_VULKAN_HWACCEL
409 #endif
410  f->pix_fmt,
412  };
413 
414  return ff_get_format(f->avctx, pix_fmts);
415 }
416 
418 {
419  uint8_t state[CONTEXT_SIZE];
420  int context_count = -1; //-1 to avoid warning
421  int ret;
422 
423  memset(state, 128, sizeof(state));
424 
426  if (ret < 0)
427  return ret;
428 
429  if (f->configured_pix_fmt != f->pix_fmt) {
430  f->avctx->pix_fmt = get_pixel_format(f);
431  if (f->avctx->pix_fmt < 0)
432  return AVERROR(EINVAL);
433  f->configured_pix_fmt = f->pix_fmt;
434  }
435 
436  ff_dlog(f->avctx, "%d %d %d\n",
437  f->chroma_h_shift, f->chroma_v_shift, f->pix_fmt);
438  if (f->version < 2) {
439  context_count = ff_ffv1_read_quant_tables(c, f->quant_tables[0]);
440  if (context_count < 0) {
441  av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
442  return AVERROR_INVALIDDATA;
443  }
444  f->slice_count = f->max_slice_count;
445  } else if (f->version < 3) {
446  f->slice_count = ff_ffv1_get_symbol(c, state, 0);
447  } else {
448  const uint8_t *p = c->bytestream_end;
449  for (f->slice_count = 0;
450  f->slice_count < MAX_SLICES && 3 + 5*!!f->ec < p - c->bytestream_start;
451  f->slice_count++) {
452  int trailer = 3 + 5*!!f->ec;
453  int size = AV_RB24(p-trailer);
454  if (size + trailer > p - c->bytestream_start)
455  break;
456  p -= size + trailer;
457  }
458  }
459  if (f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0 || f->slice_count > f->max_slice_count) {
460  av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid (max=%d)\n", f->slice_count, f->max_slice_count);
461  return AVERROR_INVALIDDATA;
462  }
463 
464  av_refstruct_unref(&f->slice_damaged);
465  f->slice_damaged = av_refstruct_allocz(f->slice_count * sizeof(*f->slice_damaged));
466  if (!f->slice_damaged)
467  return AVERROR(ENOMEM);
468 
469  for (int j = 0; j < f->slice_count; j++) {
470  FFV1SliceContext *sc = &f->slices[j];
471 
472  if (f->version == 2) {
473  int sx = ff_ffv1_get_symbol(c, state, 0);
474  int sy = ff_ffv1_get_symbol(c, state, 0);
475  int sw = ff_ffv1_get_symbol(c, state, 0) + 1U;
476  int sh = ff_ffv1_get_symbol(c, state, 0) + 1U;
477 
478  if (sx < 0 || sy < 0 || sw <= 0 || sh <= 0)
479  return AVERROR_INVALIDDATA;
480  if (sx > f->num_h_slices - sw || sy > f->num_v_slices - sh)
481  return AVERROR_INVALIDDATA;
482 
483  sc->slice_x = sx * (int64_t)f->width / f->num_h_slices;
484  sc->slice_y = sy * (int64_t)f->height / f->num_v_slices;
485  sc->slice_width = (sx + sw) * (int64_t)f->width / f->num_h_slices - sc->slice_x;
486  sc->slice_height = (sy + sh) * (int64_t)f->height / f->num_v_slices - sc->slice_y;
487 
488  av_assert0((unsigned)sc->slice_width <= f->width &&
489  (unsigned)sc->slice_height <= f->height);
490  av_assert0 ( (unsigned)sc->slice_x + (uint64_t)sc->slice_width <= f->width
491  && (unsigned)sc->slice_y + (uint64_t)sc->slice_height <= f->height);
492  }
493 
495  sc->plane = ff_ffv1_planes_alloc();
496  if (!sc->plane)
497  return AVERROR(ENOMEM);
498 
499  for (int i = 0; i < f->plane_count; i++) {
500  PlaneContext *const p = &sc->plane[i];
501 
502  if (f->version == 2) {
503  int idx = ff_ffv1_get_symbol(c, state, 0);
504  if (idx >= (unsigned)f->quant_table_count) {
505  av_log(f->avctx, AV_LOG_ERROR,
506  "quant_table_index out of range\n");
507  return AVERROR_INVALIDDATA;
508  }
509  p->quant_table_index = idx;
510  context_count = f->context_count[idx];
511  }
512 
513  if (f->version <= 2) {
514  av_assert0(context_count >= 0);
515  p->context_count = context_count;
516  }
517  }
518  }
519  return 0;
520 }
521 
523 {
524  FFV1Context *f = avctx->priv_data;
525  int ret;
526 
527  f->pix_fmt = AV_PIX_FMT_NONE;
528  f->configured_pix_fmt = AV_PIX_FMT_NONE;
529 
530  if ((ret = ff_ffv1_common_init(avctx, f)) < 0)
531  return ret;
532 
533  if (avctx->extradata_size > 0 && (ret = ff_ffv1_read_extra_header(f)) < 0)
534  return ret;
535 
536  if ((ret = ff_ffv1_init_slice_contexts(f)) < 0)
537  return ret;
538 
539  return 0;
540 }
541 
542 static int find_next_slice(AVCodecContext *avctx,
543  uint8_t *buf, uint8_t *buf_end, int idx,
544  uint8_t **pos, uint32_t *len)
545 {
546  FFV1Context *f = avctx->priv_data;
547 
548  /* Length field */
549  uint32_t v = buf_end - buf;
550  if (idx || f->version > 2) {
551  /* Three bytes of length, plus flush bit + CRC */
552  uint32_t trailer = 3 + 5*!!f->ec;
553  if (trailer > buf_end - buf)
554  v = INT_MAX;
555  else
556  v = AV_RB24(buf_end - trailer) + trailer;
557  }
558 
559  if (buf_end - buf < v) {
560  av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
561  ff_progress_frame_report(&f->picture, INT_MAX);
562  return AVERROR_INVALIDDATA;
563  }
564 
565  *len = v;
566  if (idx)
567  *pos = buf_end - v;
568  else
569  *pos = buf;
570 
571  return 0;
572 }
573 
575  uint8_t *buf, size_t buf_size)
576 {
577  int ret;
578  FFV1Context *f = avctx->priv_data;
579 
580  uint8_t keystate = 128;
581  ff_init_range_decoder(c, buf, buf_size);
582  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
583 
584  if (get_rac(c, &keystate)) {
585  f->key_frame = AV_FRAME_FLAG_KEY;
586  f->key_frame_ok = 0;
587  if ((ret = read_header(f, c)) < 0)
588  return ret;
589  f->key_frame_ok = 1;
590  } else {
591  if (!f->key_frame_ok) {
592  av_log(avctx, AV_LOG_ERROR,
593  "Cannot decode non-keyframe without valid keyframe\n");
594  return AVERROR_INVALIDDATA;
595  }
596  f->key_frame = 0;
597  }
598 
599  if (f->ac != AC_GOLOMB_RICE) {
600  if (buf_size < avctx->width * avctx->height / (128*8))
601  return AVERROR_INVALIDDATA;
602  } else {
603  int w = avctx->width;
604  int s = 1 + w / (1<<23);
605  int i;
606 
607  w /= s;
608 
609  for (i = 0; w > (1<<ff_log2_run[i]); i++)
610  w -= ff_log2_run[i];
611  if (buf_size < (avctx->height + i + 6) / 8 * s)
612  return AVERROR_INVALIDDATA;
613  }
614 
615  return 0;
616 }
617 
619  AVPacket *avpkt)
620 {
621  FFV1Context *f = avctx->priv_data;
622  AVFrame *p = f->picture.f;
623 
624  uint8_t *buf = avpkt->data;
625  size_t buf_size = avpkt->size;
626  uint8_t *buf_end = buf + buf_size;
627 
628  for (int i = f->slice_count - 1; i >= 0; i--) {
629  FFV1SliceContext *sc = &f->slices[i];
630 
631  uint8_t *pos;
632  uint32_t len;
633  int err = find_next_slice(avctx, buf, buf_end, i,
634  &pos, &len);
635  if (err < 0)
636  return err;
637 
638  buf_end -= len;
639 
640  sc->slice_damaged = 0;
641 
642  if (f->ec) {
643  unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, pos, len);
644  if (crc != f->crcref) {
645  int64_t ts = avpkt->pts != AV_NOPTS_VALUE ? avpkt->pts : avpkt->dts;
646  av_log(f->avctx, AV_LOG_ERROR, "slice CRC mismatch %X!", crc);
647  if (ts != AV_NOPTS_VALUE && avctx->pkt_timebase.num) {
648  av_log(f->avctx, AV_LOG_ERROR, "at %f seconds\n", ts*av_q2d(avctx->pkt_timebase));
649  } else if (ts != AV_NOPTS_VALUE) {
650  av_log(f->avctx, AV_LOG_ERROR, "at %"PRId64"\n", ts);
651  } else {
652  av_log(f->avctx, AV_LOG_ERROR, "\n");
653  }
654  slice_set_damaged(f, sc);
655  }
656  if (avctx->debug & FF_DEBUG_PICT_INFO) {
657  av_log(avctx, AV_LOG_DEBUG, "slice %d, CRC: 0x%08"PRIX32"\n", i, AV_RB32(pos + len - 4));
658  }
659  }
660 
661  if (i) {
662  ff_init_range_decoder(&sc->c, pos, len);
663  ff_build_rac_states(&sc->c, 0.05 * (1LL << 32), 256 - 8);
664  } else {
665  sc->c = c;
666  sc->c.bytestream_end = pos + len;
667  }
668  }
669 
670  avctx->execute(avctx,
671  decode_slice,
672  f->slices,
673  NULL,
674  f->slice_count,
675  sizeof(*f->slices));
676 
677  for (int i = f->slice_count - 1; i >= 0; i--) {
678  FFV1SliceContext *sc = &f->slices[i];
679  if (sc->slice_damaged && f->last_picture.f) {
680  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(f->pix_fmt);
681  const uint8_t *src[4];
682  uint8_t *dst[4];
683  ff_progress_frame_await(&f->last_picture, INT_MAX);
684  for (int j = 0; j < desc->nb_components; j++) {
685  int pixshift = desc->comp[j].depth > 8;
686  int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
687  int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
688  dst[j] = p->data[j] + p->linesize[j] *
689  (sc->slice_y >> sv) + ((sc->slice_x >> sh) << pixshift);
690  src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] *
691  (sc->slice_y >> sv) + ((sc->slice_x >> sh) << pixshift);
692 
693  }
694 
696  f->last_picture.f->linesize,
697  f->pix_fmt,
698  sc->slice_width,
699  sc->slice_height);
700 
701  f->slice_damaged[i] = 1;
702  }
703  }
704 
705  return 0;
706 }
707 
708 static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
709  int *got_frame, AVPacket *avpkt)
710 {
711  FFV1Context *f = avctx->priv_data;
712  int ret;
713  AVFrame *p;
714  const FFHWAccel *hwaccel = NULL;
715 
716  /* This is copied onto the first slice's range coder context */
717  RangeCoder c;
718 
719  ff_progress_frame_unref(&f->last_picture);
720  av_refstruct_unref(&f->hwaccel_last_picture_private);
721 
722  FFSWAP(ProgressFrame, f->picture, f->last_picture);
723  FFSWAP(void *, f->hwaccel_picture_private, f->hwaccel_last_picture_private);
724 
725  f->avctx = avctx;
726  f->frame_damaged = 0;
727 
728  ret = decode_header(avctx, &c, avpkt->data, avpkt->size);
729  if (ret < 0)
730  return ret;
731 
732  if (avctx->debug & FF_DEBUG_PICT_INFO)
733  av_log(avctx, AV_LOG_DEBUG, "ver:%d keyframe:%d coder:%d ec:%d slices:%d bps:%d\n",
734  f->version, !!f->key_frame, f->ac, f->ec, f->slice_count, f->avctx->bits_per_raw_sample);
735 
736  if (avctx->skip_frame >= AVDISCARD_ALL)
737  return avpkt->size;
738 
739  if (avctx->hwaccel)
740  hwaccel = ffhwaccel(avctx->hwaccel);
741 
742  ret = ff_progress_frame_get_buffer(avctx, &f->picture,
744  if (ret < 0)
745  return ret;
746 
747  ret = ff_hwaccel_frame_priv_alloc(avctx, &f->hwaccel_picture_private);
748  if (ret < 0)
749  return ret;
750 
751  p = f->picture.f;
752 
753  p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P
754  p->flags = (p->flags & ~AV_FRAME_FLAG_KEY) | f->key_frame;
755 
756  if (f->version < 3 && avctx->field_order > AV_FIELD_PROGRESSIVE) {
757  /* we have interlaced material flagged in container */
759  if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
761  }
762 
763  /* Start */
764  if (hwaccel) {
765  ret = hwaccel->start_frame(avctx, avpkt->buf, avpkt->data, avpkt->size);
766  if (ret < 0)
767  return ret;
768  }
769 
770  ff_thread_finish_setup(avctx);
771 
772  /* Decode slices */
773  if (hwaccel) {
774  uint8_t *buf_end = avpkt->data + avpkt->size;
775 
776  if (!(p->flags & AV_FRAME_FLAG_KEY) && f->last_picture.f)
777  ff_progress_frame_await(&f->last_picture, f->slice_count - 1);
778 
779  for (int i = f->slice_count - 1; i >= 0; i--) {
780  uint8_t *pos;
781  uint32_t len;
782  ret = find_next_slice(avctx, avpkt->data, buf_end, i,
783  &pos, &len);
784  if (ret < 0)
785  return ret;
786 
787  buf_end -= len;
788 
789  ret = hwaccel->decode_slice(avctx, pos, len);
790  if (ret < 0)
791  return ret;
792  }
793  } else {
794  ret = decode_slices(avctx, c, avpkt);
795  if (ret < 0)
796  return ret;
797  }
798 
799  /* Finalize */
800  if (hwaccel) {
801  ret = hwaccel->end_frame(avctx);
802  if (ret < 0)
803  return ret;
804  }
805 
806  ff_progress_frame_report(&f->picture, INT_MAX);
807 
808  ff_progress_frame_unref(&f->last_picture);
809  av_refstruct_unref(&f->hwaccel_last_picture_private);
810  if ((ret = av_frame_ref(rframe, f->picture.f)) < 0)
811  return ret;
812 
813  *got_frame = 1;
814 
815  return avpkt->size;
816 }
817 
818 #if HAVE_THREADS
820 {
821  FFV1Context *fsrc = src->priv_data;
822  FFV1Context *fdst = dst->priv_data;
823 
824  if (dst == src)
825  return 0;
826 
827  fdst->version = fsrc->version;
828  fdst->micro_version = fsrc->micro_version;
829  fdst->combined_version = fsrc->combined_version;
830  fdst->chroma_planes = fsrc->chroma_planes;
831  fdst->chroma_h_shift = fsrc->chroma_h_shift;
832  fdst->chroma_v_shift = fsrc->chroma_v_shift;
833  fdst->transparency = fsrc->transparency;
834  fdst->plane_count = fsrc->plane_count;
835  fdst->ac = fsrc->ac;
836  fdst->colorspace = fsrc->colorspace;
837  fdst->pix_fmt = fsrc->pix_fmt;
839 
840  fdst->ec = fsrc->ec;
841  fdst->intra = fsrc->intra;
842  fdst->key_frame_ok = fsrc->key_frame_ok;
843 
844  fdst->packed_at_lsb = fsrc->packed_at_lsb;
845  fdst->slice_count = fsrc->slice_count;
846  fdst->use32bit = fsrc->use32bit;
847  memcpy(fdst->state_transition, fsrc->state_transition,
848  sizeof(fdst->state_transition));
849 
850  // in version 1 there is a single per-keyframe quant table, so
851  // we need to propagate it between threads
852  if (fsrc->version < 2)
853  memcpy(fdst->quant_tables[0], fsrc->quant_tables[0], sizeof(fsrc->quant_tables[0]));
854 
855  for (int i = 0; i < fdst->num_h_slices * fdst->num_v_slices; i++) {
856  FFV1SliceContext *sc = &fdst->slices[i];
857  const FFV1SliceContext *sc0 = &fsrc->slices[i];
858 
859  av_refstruct_replace(&sc->plane, sc0->plane);
860 
861  if (fsrc->version < 3) {
862  sc->slice_x = sc0->slice_x;
863  sc->slice_y = sc0->slice_y;
864  sc->slice_width = sc0->slice_width;
865  sc->slice_height = sc0->slice_height;
866  }
867  }
868 
870 
872 
873  ff_progress_frame_replace(&fdst->picture, &fsrc->picture);
876 
877  return 0;
878 }
879 #endif
880 
882 {
883  FFV1Context *const s = avctx->priv_data;
884 
885  ff_progress_frame_unref(&s->picture);
886  av_refstruct_unref(&s->hwaccel_picture_private);
887 
888  ff_progress_frame_unref(&s->last_picture);
889  av_refstruct_unref(&s->hwaccel_last_picture_private);
890 
891  ff_ffv1_close(s);
892 
893  return 0;
894 }
895 
897  .p.name = "ffv1",
898  CODEC_LONG_NAME("FFmpeg video codec #1"),
899  .p.type = AVMEDIA_TYPE_VIDEO,
900  .p.id = AV_CODEC_ID_FFV1,
901  .priv_data_size = sizeof(FFV1Context),
902  .init = decode_init,
903  .close = ffv1_decode_close,
906  .p.capabilities = AV_CODEC_CAP_DR1 |
908  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
911  .hw_configs = (const AVCodecHWConfigInternal *const []) {
912 #if CONFIG_FFV1_VULKAN_HWACCEL
913  HWACCEL_VULKAN(ffv1),
914 #endif
915  NULL
916  },
917 };
hwconfig.h
ff_progress_frame_report
void ff_progress_frame_report(ProgressFrame *f, int n)
Notify later decoding threads when part of their reference frame is ready.
Definition: decode.c:1899
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1445
FFV1Context::chroma_v_shift
int chroma_v_shift
Definition: ffv1.h:122
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
FFV1SliceContext::slice_height
int slice_height
Definition: ffv1.h:78
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
FFV1Context::key_frame_ok
int key_frame_ok
Definition: ffv1.h:149
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:211
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:42
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:678
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:297
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1274
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3341
MAX_OVERREAD
#define MAX_OVERREAD
Definition: lagarithrac.h:49
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:202
FFV1SliceContext::plane
PlaneContext * plane
Definition: ffv1.h:90
FFV1Context::ec
int ec
Definition: ffv1.h:147
int64_t
long long int64_t
Definition: coverity.c:34
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:532
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
decode_plane
static int decode_plane(FFV1Context *f, FFV1SliceContext *sc, GetBitContext *gb, uint8_t *src, int w, int h, int stride, int plane_index, int remap_index, int pixel_stride, int ac)
Definition: ffv1dec.c:95
pixdesc.h
FFV1Context::configured_pix_fmt
enum AVPixelFormat configured_pix_fmt
Definition: ffv1.h:131
w
uint8_t w
Definition: llviddspenc.c:38
decode_header
static int decode_header(AVCodecContext *avctx, RangeCoder *c, uint8_t *buf, size_t buf_size)
Definition: ffv1dec.c:574
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVCodecContext::field_order
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:722
ff_progress_frame_get_buffer
int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags)
This function sets up the ProgressFrame, i.e.
Definition: decode.c:1854
rangecoder.h
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:40
PlaneContext::state
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:67
FFCodec
Definition: codec_internal.h:127
decode_remap
static int decode_remap(FFV1Context *f, FFV1SliceContext *sc)
Definition: ffv1dec.c:266
FFV1Context::num_h_slices
int num_h_slices
Definition: ffv1.h:162
FFV1Context::hwaccel_picture_private
void * hwaccel_picture_private
Definition: ffv1.h:128
RangeCoder::bytestream_end
uint8_t * bytestream_end
Definition: rangecoder.h:44
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:690
decode_line
static av_always_inline int RENAME() decode_line(FFV1Context *f, FFV1SliceContext *sc, GetBitContext *gb, int w, TYPE *sample[2], int plane_index, int bits, int ac)
Definition: ffv1dec_template.c:26
FFV1Context::quant_tables
int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE]
Definition: ffv1.h:136
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:497
thread.h
FFV1Context::chroma_h_shift
int chroma_h_shift
Definition: ffv1.h:122
FFV1SliceContext::slice_x
int slice_x
Definition: ffv1.h:79
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
ff_ffv1_read_extra_header
int ff_ffv1_read_extra_header(FFV1Context *f)
Definition: ffv1_parse.c:70
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1SliceContext *sc)
Definition: ffv1.c:198
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1415
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:431
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:674
crc.h
golomb.h
exp golomb vlc stuff
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:203
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
FFHWAccel
Definition: hwaccel_internal.h:34
FFV1Context::combined_version
int combined_version
Definition: ffv1.h:119
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1841
ffv1_decode_close
static av_cold int ffv1_decode_close(AVCodecContext *avctx)
Definition: ffv1dec.c:881
GetBitContext
Definition: get_bits.h:108
MAX_SLICES
#define MAX_SLICES
Definition: d3d12va_hevc.c:33
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:45
FFV1Context::chroma_planes
int chroma_planes
Definition: ffv1.h:121
PlaneContext::context_count
int context_count
Definition: ffv1.h:66
AVRational::num
int num
Numerator.
Definition: rational.h:59
progressframe.h
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:205
refstruct.h
decode_rgb_frame
static int RENAME() decode_rgb_frame(FFV1Context *f, FFV1SliceContext *sc, GetBitContext *gb, uint8_t *src[4], int w, int h, int stride[4])
Definition: ffv1dec_template.c:134
av_refstruct_allocz
static void * av_refstruct_allocz(size_t size)
Equivalent to av_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
avassert.h
FF_CODEC_CAP_USES_PROGRESSFRAMES
#define FF_CODEC_CAP_USES_PROGRESSFRAMES
The decoder might make use of the ProgressFrame API.
Definition: codec_internal.h:68
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
av_cold
#define av_cold
Definition: attributes.h:90
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:661
FFV1SliceContext::sample_buffer
int16_t * sample_buffer
Definition: ffv1.h:74
FFV1Context::use32bit
int use32bit
Definition: ffv1.h:145
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:538
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:341
ff_hwaccel_frame_priv_alloc
int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.
Definition: decode.c:2257
s
#define s(width, name)
Definition: cbs_vp9.c:198
FFV1Context::slice_count
int slice_count
Definition: ffv1.h:159
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
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:431
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)
Definition: ffv1dec.c:708
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
FFV1Context::max_slice_count
int max_slice_count
Definition: ffv1.h:160
bits
uint8_t bits
Definition: vp3data.h:128
FFV1Context::intra
int intra
Definition: ffv1.h:148
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
is_input_end
static int is_input_end(RangeCoder *c, GetBitContext *gb, int ac)
Definition: ffv1dec.c:73
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
ff_progress_frame_unref
void ff_progress_frame_unref(ProgressFrame *f)
Give up a reference to the underlying frame contained in a ProgressFrame and reset the ProgressFrame,...
Definition: decode.c:1882
ff_progress_frame_await
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_progress_frame_await() 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_progress_frame_report() has been called on them. This includes draw_edges(). Porting codecs to frame threading
decode.h
get_bits.h
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:200
FFV1Context::ac
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:135
get_vlc_symbol
static int get_vlc_symbol(GetBitContext *gb, VlcState *const state, int bits)
Definition: ffv1dec.c:48
FFV1Context::plane_count
int plane_count
Definition: ffv1.h:134
FFV1Context::slice_damaged
uint8_t * slice_damaged
Definition: ffv1.h:172
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
arg
const char * arg
Definition: jacosubdec.c:67
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:110
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:522
NULL
#define NULL
Definition: coverity.c:32
PlaneContext::vlc_state
VlcState * vlc_state
Definition: ffv1.h:68
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:52
run
uint8_t run
Definition: svq3.c:204
hwaccel_internal.h
FFV1Context::num_v_slices
int num_v_slices
Definition: ffv1.h:161
FFV1Context::colorspace
int colorspace
Definition: ffv1.h:140
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
ff_ffv1_decoder
const FFCodec ff_ffv1_decoder
Definition: ffv1dec.c:896
FFV1Context::slices
FFV1SliceContext * slices
Definition: ffv1.h:164
FFV1Context::state_transition
uint8_t state_transition[256]
Definition: ffv1.h:138
mathops.h
ff_ffv1_get_symbol
int ff_ffv1_get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
Definition: ffv1.c:222
PlaneContext
Definition: ffv1.h:64
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:335
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
decode_slices
static int decode_slices(AVCodecContext *avctx, RangeCoder c, AVPacket *avpkt)
Definition: ffv1dec.c:618
VlcState
Definition: ffv1.h:57
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
FFV1SliceContext::slice_width
int slice_width
Definition: ffv1.h:77
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:85
f
f
Definition: af_crystalizer.c:122
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:512
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
get_pixel_format
static enum AVPixelFormat get_pixel_format(FFV1Context *f)
Definition: ffv1dec.c:404
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
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:131
AVPacket::size
int size
Definition: packet.h:540
height
#define height
Definition: dsp.h:85
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:308
codec_internal.h
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:565
sample
#define sample
Definition: flacdsp_template.c:44
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
slice_set_damaged
static void slice_set_damaged(FFV1Context *f, FFV1SliceContext *sc)
Definition: ffv1dec.c:256
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
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: codec_internal.h:54
get_symbol_inline
static av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed)
Definition: ffv1.h:240
AVCodecHWConfigInternal
Definition: hwconfig.h:25
RangeCoder::bytestream
uint8_t * bytestream
Definition: rangecoder.h:43
FFV1Context::picture
ProgressFrame picture
Definition: ffv1.h:127
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
FFV1SliceContext::slice_rct_by_coef
int slice_rct_by_coef
Definition: ffv1.h:85
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:114
ff_ffv1_init_slice_state
av_cold int ff_ffv1_init_slice_state(const FFV1Context *f, FFV1SliceContext *sc)
Definition: ffv1.c:72
read_header
static int read_header(FFV1Context *f, RangeCoder *c)
Definition: ffv1dec.c:417
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:65
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1612
FFV1SliceContext::c
RangeCoder c
Definition: ffv1.h:92
av_refstruct_unref
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
FFV1SliceContext::slice_rct_ry_coef
int slice_rct_ry_coef
Definition: ffv1.h:86
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx, FFV1Context *s)
Definition: ffv1.c:36
ffv1.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
FFV1SliceContext
Definition: ffv1.h:73
len
int len
Definition: vorbis_enc_data.h:426
get_rac
static int get_rac(RangeCoder *c, uint8_t *const state)
Definition: rangecoder.h:118
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition: crc.h:52
AVCodecContext::height
int height
Definition: avcodec.h:632
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:669
FFV1Context::packed_at_lsb
int packed_at_lsb
Definition: ffv1.h:154
ff_ffv1_read_quant_tables
int ff_ffv1_read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1_parse.c:52
avcodec.h
stride
#define stride
Definition: h264pred_template.c:536
ret
ret
Definition: filter_design.txt:187
find_next_slice
static int find_next_slice(AVCodecContext *avctx, uint8_t *buf, uint8_t *buf_end, int idx, uint8_t **pos, uint32_t *len)
Definition: ffv1dec.c:542
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
decode_slice_header
static int decode_slice_header(const FFV1Context *f, FFV1SliceContext *sc, AVFrame *frame)
Definition: ffv1dec.c:159
FFV1SliceContext::slice_y
int slice_y
Definition: ffv1.h:80
hwaccel
static const char * hwaccel
Definition: ffplay.c:353
pos
unsigned int pos
Definition: spdifenc.c:414
planes
static const struct @482 planes[]
ff_ffv1_close
av_cold void ff_ffv1_close(FFV1Context *s)
Definition: ffv1.c:227
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
ff_slice_coord
int ff_slice_coord(const FFV1Context *f, int width, int sx, int num_h_slices, int chroma_shift)
This is intended for both width and height.
Definition: ffv1.c:127
U
#define U(x)
Definition: vpx_arith.h:37
ff_ffv1_planes_alloc
PlaneContext * ff_ffv1_planes_alloc(void)
Definition: ffv1.c:66
ff_progress_frame_replace
void ff_progress_frame_replace(ProgressFrame *dst, const ProgressFrame *src)
Do nothing if dst and src already refer to the same AVFrame; otherwise unreference dst and if src is ...
Definition: decode.c:1889
HWACCEL_VULKAN
#define HWACCEL_VULKAN(codec)
Definition: hwconfig.h:76
FFV1Context::pix_fmt
enum AVPixelFormat pix_fmt
Definition: ffv1.h:130
AVCodecContext
main external API structure.
Definition: avcodec.h:451
RangeCoder::bytestream_start
uint8_t * bytestream_start
Definition: rangecoder.h:42
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:1631
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: ffv1dec.c:522
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_refstruct_replace
void av_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:168
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. Use ff_thread_get_buffer()(or ff_progress_frame_get_buffer() in case you have inter-frame dependencies and use the ProgressFrame API) to allocate frame buffers. Call ff_progress_frame_report() 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
FFV1SliceContext::remap
int remap
Definition: ffv1.h:87
FFV1SliceContext::fltmap
uint16_t fltmap[4][65536]
Definition: ffv1.h:109
ff_ffv1_parse_header
int ff_ffv1_parse_header(FFV1Context *f, RangeCoder *c, uint8_t *state)
Definition: ffv1_parse.c:208
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
temp
else temp
Definition: vf_mcdeint.c:263
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1414
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
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:112
FFV1Context::transparency
int transparency
Definition: ffv1.h:123
ProgressFrame
The ProgressFrame structure.
Definition: progressframe.h:73
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
FFV1SliceContext::run_index
int run_index
Definition: ffv1.h:83
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
ffv1dec_template.c
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:632
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:140
ff_log2_run
const uint8_t ff_log2_run[41]
Definition: mathtables.c:116
imgutils.h
FFV1SliceContext::slice_reset_contexts
int slice_reset_contexts
Definition: ffv1.h:99
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:455
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:118
h
h
Definition: vp9dsp_template.c:2070
RangeCoder
Definition: mss3.c:63
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
width
#define width
Definition: dsp.h:85
av_image_copy
void av_image_copy(uint8_t *const dst_data[4], const int dst_linesizes[4], const uint8_t *const 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
FFV1SliceContext::ac_byte_count
int ac_byte_count
number of bytes used for AC coding
Definition: ffv1.h:94
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
FFV1SliceContext::slice_damaged
int slice_damaged
Definition: ffv1.h:100
state
static struct @481 state
FFV1SliceContext::slice_coding_mode
int slice_coding_mode
Definition: ffv1.h:84
src
#define src
Definition: vp8dsp.c:248
FFV1Context::version
int version
Definition: ffv1.h:117