FFmpeg  4.4.5
libdav1d.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018 Ronald S. Bultje <rsbultje gmail com>
3  * Copyright (c) 2018 James Almer <jamrial gmail com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <dav1d/dav1d.h>
23 
24 #include "libavutil/avassert.h"
27 #include "libavutil/imgutils.h"
28 #include "libavutil/opt.h"
29 
30 #include "atsc_a53.h"
31 #include "avcodec.h"
32 #include "bytestream.h"
33 #include "decode.h"
34 #include "internal.h"
35 
36 #define FF_DAV1D_VERSION_AT_LEAST(x,y) \
37  (DAV1D_API_VERSION_MAJOR > (x) || DAV1D_API_VERSION_MAJOR == (x) && DAV1D_API_VERSION_MINOR >= (y))
38 
39 typedef struct Libdav1dContext {
40  AVClass *class;
41  Dav1dContext *c;
43  int pool_size;
44 
45  Dav1dData data;
52 
53 static const enum AVPixelFormat pix_fmt[][3] = {
54  [DAV1D_PIXEL_LAYOUT_I400] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12 },
55  [DAV1D_PIXEL_LAYOUT_I420] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV420P12 },
56  [DAV1D_PIXEL_LAYOUT_I422] = { AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV422P12 },
57  [DAV1D_PIXEL_LAYOUT_I444] = { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV444P12 },
58 };
59 
60 static const enum AVPixelFormat pix_fmt_rgb[3] = {
62 };
63 
64 static void libdav1d_log_callback(void *opaque, const char *fmt, va_list vl)
65 {
66  AVCodecContext *c = opaque;
67 
68  av_vlog(c, AV_LOG_ERROR, fmt, vl);
69 }
70 
71 static int libdav1d_picture_allocator(Dav1dPicture *p, void *cookie)
72 {
73  Libdav1dContext *dav1d = cookie;
74  enum AVPixelFormat format = pix_fmt[p->p.layout][p->seq_hdr->hbd];
75  int ret, linesize[4], h = FFALIGN(p->p.h, 128), w = FFALIGN(p->p.w, 128);
76  uint8_t *aligned_ptr, *data[4];
77  AVBufferRef *buf;
78 
79  ret = av_image_get_buffer_size(format, w, h, DAV1D_PICTURE_ALIGNMENT);
80  if (ret < 0)
81  return ret;
82 
83  if (ret != dav1d->pool_size) {
84  av_buffer_pool_uninit(&dav1d->pool);
85  // Use twice the amount of required padding bytes for aligned_ptr below.
86  dav1d->pool = av_buffer_pool_init(ret + DAV1D_PICTURE_ALIGNMENT * 2, NULL);
87  if (!dav1d->pool) {
88  dav1d->pool_size = 0;
89  return AVERROR(ENOMEM);
90  }
91  dav1d->pool_size = ret;
92  }
93  buf = av_buffer_pool_get(dav1d->pool);
94  if (!buf)
95  return AVERROR(ENOMEM);
96 
97  // libdav1d requires DAV1D_PICTURE_ALIGNMENT aligned buffers, which av_malloc()
98  // doesn't guarantee for example when AVX is disabled at configure time.
99  // Use the extra DAV1D_PICTURE_ALIGNMENT padding bytes in the buffer to align it
100  // if required.
101  aligned_ptr = (uint8_t *)FFALIGN((uintptr_t)buf->data, DAV1D_PICTURE_ALIGNMENT);
102  ret = av_image_fill_arrays(data, linesize, aligned_ptr, format, w, h,
103  DAV1D_PICTURE_ALIGNMENT);
104  if (ret < 0) {
105  av_buffer_unref(&buf);
106  return ret;
107  }
108 
109  p->data[0] = data[0];
110  p->data[1] = data[1];
111  p->data[2] = data[2];
112  p->stride[0] = linesize[0];
113  p->stride[1] = linesize[1];
114  p->allocator_data = buf;
115 
116  return 0;
117 }
118 
119 static void libdav1d_picture_release(Dav1dPicture *p, void *cookie)
120 {
121  AVBufferRef *buf = p->allocator_data;
122 
123  av_buffer_unref(&buf);
124 }
125 
127 {
128  Libdav1dContext *dav1d = c->priv_data;
129  Dav1dSettings s;
130 #if FF_DAV1D_VERSION_AT_LEAST(6,0)
131  int threads = c->thread_count;
132 #else
133  int threads = (c->thread_count ? c->thread_count : av_cpu_count()) * 3 / 2;
134 #endif
135  int res;
136 
137  av_log(c, AV_LOG_INFO, "libdav1d %s\n", dav1d_version());
138 
139  dav1d_default_settings(&s);
140  s.logger.cookie = c;
141  s.logger.callback = libdav1d_log_callback;
142  s.allocator.cookie = dav1d;
143  s.allocator.alloc_picture_callback = libdav1d_picture_allocator;
144  s.allocator.release_picture_callback = libdav1d_picture_release;
145  s.frame_size_limit = c->max_pixels;
146  if (dav1d->apply_grain >= 0)
147  s.apply_grain = dav1d->apply_grain;
148  else if (c->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN)
149  s.apply_grain = 0;
150 
151  s.all_layers = dav1d->all_layers;
152  if (dav1d->operating_point >= 0)
153  s.operating_point = dav1d->operating_point;
154 
155 #if FF_DAV1D_VERSION_AT_LEAST(6,0)
156  if (dav1d->frame_threads || dav1d->tile_threads)
157  s.n_threads = FFMAX(dav1d->frame_threads, dav1d->tile_threads);
158  else
159  s.n_threads = FFMIN(threads, DAV1D_MAX_THREADS);
160  s.max_frame_delay = (c->flags & AV_CODEC_FLAG_LOW_DELAY) ? 1 : 0;
161  av_log(c, AV_LOG_DEBUG, "Using %d threads, %d max_frame_delay\n",
162  s.n_threads, s.max_frame_delay);
163 #else
164  s.n_tile_threads = dav1d->tile_threads
165  ? dav1d->tile_threads
166  : FFMIN(floor(sqrt(threads)), DAV1D_MAX_TILE_THREADS);
167  s.n_frame_threads = dav1d->frame_threads
168  ? dav1d->frame_threads
169  : FFMIN(ceil(threads / s.n_tile_threads), DAV1D_MAX_FRAME_THREADS);
170  av_log(c, AV_LOG_DEBUG, "Using %d frame threads, %d tile threads\n",
171  s.n_frame_threads, s.n_tile_threads);
172 #endif
173 
174  res = dav1d_open(&dav1d->c, &s);
175  if (res < 0)
176  return AVERROR(ENOMEM);
177 
178  return 0;
179 }
180 
182 {
183  Libdav1dContext *dav1d = c->priv_data;
184 
185  dav1d_data_unref(&dav1d->data);
186  dav1d_flush(dav1d->c);
187 }
188 
189 static void libdav1d_data_free(const uint8_t *data, void *opaque) {
190  AVBufferRef *buf = opaque;
191 
192  av_buffer_unref(&buf);
193 }
194 
195 static void libdav1d_user_data_free(const uint8_t *data, void *opaque) {
196  av_assert0(data == opaque);
197  av_free(opaque);
198 }
199 
201 {
202  Libdav1dContext *dav1d = c->priv_data;
203  Dav1dData *data = &dav1d->data;
204  Dav1dPicture pic = { 0 }, *p = &pic;
205  int res;
206 
207  if (!data->sz) {
208  AVPacket pkt = { 0 };
209 
210  res = ff_decode_get_packet(c, &pkt);
211  if (res < 0 && res != AVERROR_EOF)
212  return res;
213 
214  if (pkt.size) {
215  res = dav1d_data_wrap(data, pkt.data, pkt.size, libdav1d_data_free, pkt.buf);
216  if (res < 0) {
218  return res;
219  }
220 
221  data->m.timestamp = pkt.pts;
222  data->m.offset = pkt.pos;
223  data->m.duration = pkt.duration;
224 
225  pkt.buf = NULL;
227 
228  if (c->reordered_opaque != AV_NOPTS_VALUE) {
229  uint8_t *reordered_opaque = av_malloc(sizeof(c->reordered_opaque));
230  if (!reordered_opaque) {
231  dav1d_data_unref(data);
232  return AVERROR(ENOMEM);
233  }
234 
235  memcpy(reordered_opaque, &c->reordered_opaque, sizeof(c->reordered_opaque));
236  res = dav1d_data_wrap_user_data(data, reordered_opaque,
237  libdav1d_user_data_free, reordered_opaque);
238  if (res < 0) {
239  av_free(reordered_opaque);
240  dav1d_data_unref(data);
241  return res;
242  }
243  }
244  }
245  }
246 
247  res = dav1d_send_data(dav1d->c, data);
248  if (res < 0) {
249  if (res == AVERROR(EINVAL))
250  res = AVERROR_INVALIDDATA;
251  if (res != AVERROR(EAGAIN)) {
252  dav1d_data_unref(data);
253  return res;
254  }
255  }
256 
257  res = dav1d_get_picture(dav1d->c, p);
258  if (res < 0) {
259  if (res == AVERROR(EINVAL))
260  res = AVERROR_INVALIDDATA;
261  else if (res == AVERROR(EAGAIN) && c->internal->draining)
262  res = AVERROR_EOF;
263 
264  return res;
265  }
266 
267  av_assert0(p->data[0] && p->allocator_data);
268 
269  // This requires the custom allocator above
270  frame->buf[0] = av_buffer_ref(p->allocator_data);
271  if (!frame->buf[0]) {
272  dav1d_picture_unref(p);
273  return AVERROR(ENOMEM);
274  }
275 
276  frame->data[0] = p->data[0];
277  frame->data[1] = p->data[1];
278  frame->data[2] = p->data[2];
279  frame->linesize[0] = p->stride[0];
280  frame->linesize[1] = p->stride[1];
281  frame->linesize[2] = p->stride[1];
282 
283  c->profile = p->seq_hdr->profile;
284  c->level = ((p->seq_hdr->operating_points[0].major_level - 2) << 2)
285  | p->seq_hdr->operating_points[0].minor_level;
286  frame->width = p->p.w;
287  frame->height = p->p.h;
288  if (c->width != p->p.w || c->height != p->p.h) {
289  res = ff_set_dimensions(c, p->p.w, p->p.h);
290  if (res < 0)
291  goto fail;
292  }
293 
296  frame->height * (int64_t)p->frame_hdr->render_width,
297  frame->width * (int64_t)p->frame_hdr->render_height,
298  INT_MAX);
300 
301  switch (p->seq_hdr->chr) {
302  case DAV1D_CHR_VERTICAL:
303  frame->chroma_location = c->chroma_sample_location = AVCHROMA_LOC_LEFT;
304  break;
305  case DAV1D_CHR_COLOCATED:
306  frame->chroma_location = c->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
307  break;
308  }
309  frame->colorspace = c->colorspace = (enum AVColorSpace) p->seq_hdr->mtrx;
310  frame->color_primaries = c->color_primaries = (enum AVColorPrimaries) p->seq_hdr->pri;
311  frame->color_trc = c->color_trc = (enum AVColorTransferCharacteristic) p->seq_hdr->trc;
312  frame->color_range = c->color_range = p->seq_hdr->color_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
313 
314  if (p->p.layout == DAV1D_PIXEL_LAYOUT_I444 &&
315  p->seq_hdr->mtrx == DAV1D_MC_IDENTITY &&
316  p->seq_hdr->pri == DAV1D_COLOR_PRI_BT709 &&
317  p->seq_hdr->trc == DAV1D_TRC_SRGB)
318  frame->format = c->pix_fmt = pix_fmt_rgb[p->seq_hdr->hbd];
319  else
320  frame->format = c->pix_fmt = pix_fmt[p->p.layout][p->seq_hdr->hbd];
321 
322  if (p->m.user_data.data)
323  memcpy(&frame->reordered_opaque, p->m.user_data.data, sizeof(frame->reordered_opaque));
324  else
326 
327  if (p->seq_hdr->num_units_in_tick && p->seq_hdr->time_scale) {
328  av_reduce(&c->framerate.den, &c->framerate.num,
329  p->seq_hdr->num_units_in_tick, p->seq_hdr->time_scale, INT_MAX);
330  if (p->seq_hdr->equal_picture_interval)
331  c->ticks_per_frame = p->seq_hdr->num_ticks_per_picture;
332  }
333 
334  // match timestamps and packet size
335  frame->pts = p->m.timestamp;
336 #if FF_API_PKT_PTS
338  frame->pkt_pts = p->m.timestamp;
340 #endif
341  frame->pkt_dts = p->m.timestamp;
342  frame->pkt_pos = p->m.offset;
343  frame->pkt_size = p->m.size;
344  frame->pkt_duration = p->m.duration;
345  frame->key_frame = p->frame_hdr->frame_type == DAV1D_FRAME_TYPE_KEY;
346 
347  switch (p->frame_hdr->frame_type) {
348  case DAV1D_FRAME_TYPE_KEY:
349  case DAV1D_FRAME_TYPE_INTRA:
351  break;
352  case DAV1D_FRAME_TYPE_INTER:
354  break;
355  case DAV1D_FRAME_TYPE_SWITCH:
357  break;
358  default:
359  res = AVERROR_INVALIDDATA;
360  goto fail;
361  }
362 
363  if (p->mastering_display) {
365  if (!mastering) {
366  res = AVERROR(ENOMEM);
367  goto fail;
368  }
369 
370  for (int i = 0; i < 3; i++) {
371  mastering->display_primaries[i][0] = av_make_q(p->mastering_display->primaries[i][0], 1 << 16);
372  mastering->display_primaries[i][1] = av_make_q(p->mastering_display->primaries[i][1], 1 << 16);
373  }
374  mastering->white_point[0] = av_make_q(p->mastering_display->white_point[0], 1 << 16);
375  mastering->white_point[1] = av_make_q(p->mastering_display->white_point[1], 1 << 16);
376 
377  mastering->max_luminance = av_make_q(p->mastering_display->max_luminance, 1 << 8);
378  mastering->min_luminance = av_make_q(p->mastering_display->min_luminance, 1 << 14);
379 
380  mastering->has_primaries = 1;
381  mastering->has_luminance = 1;
382  }
383  if (p->content_light) {
385  if (!light) {
386  res = AVERROR(ENOMEM);
387  goto fail;
388  }
389  light->MaxCLL = p->content_light->max_content_light_level;
390  light->MaxFALL = p->content_light->max_frame_average_light_level;
391  }
392  if (p->itut_t35) {
393  GetByteContext gb;
394  unsigned int user_identifier;
395 
396  bytestream2_init(&gb, p->itut_t35->payload, p->itut_t35->payload_size);
397  bytestream2_skip(&gb, 1); // terminal provider code
398  bytestream2_skip(&gb, 1); // terminal provider oriented code
399  user_identifier = bytestream2_get_be32(&gb);
400  switch (user_identifier) {
401  case MKBETAG('G', 'A', '9', '4'): { // closed captions
402  AVBufferRef *buf = NULL;
403 
404  res = ff_parse_a53_cc(&buf, gb.buffer, bytestream2_get_bytes_left(&gb));
405  if (res < 0)
406  goto fail;
407  if (!res)
408  break;
409 
411  av_buffer_unref(&buf);
412 
413  c->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
414  break;
415  }
416  default: // ignore unsupported identifiers
417  break;
418  }
419  }
420  if (p->frame_hdr->film_grain.present && (!dav1d->apply_grain ||
421  (c->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN))) {
423  if (!fgp) {
424  res = AVERROR(ENOMEM);
425  goto fail;
426  }
427 
429  fgp->seed = p->frame_hdr->film_grain.data.seed;
430  fgp->codec.aom.num_y_points = p->frame_hdr->film_grain.data.num_y_points;
431  fgp->codec.aom.chroma_scaling_from_luma = p->frame_hdr->film_grain.data.chroma_scaling_from_luma;
432  fgp->codec.aom.scaling_shift = p->frame_hdr->film_grain.data.scaling_shift;
433  fgp->codec.aom.ar_coeff_lag = p->frame_hdr->film_grain.data.ar_coeff_lag;
434  fgp->codec.aom.ar_coeff_shift = p->frame_hdr->film_grain.data.ar_coeff_shift;
435  fgp->codec.aom.grain_scale_shift = p->frame_hdr->film_grain.data.grain_scale_shift;
436  fgp->codec.aom.overlap_flag = p->frame_hdr->film_grain.data.overlap_flag;
437  fgp->codec.aom.limit_output_range = p->frame_hdr->film_grain.data.clip_to_restricted_range;
438 
439  memcpy(&fgp->codec.aom.y_points, &p->frame_hdr->film_grain.data.y_points,
440  sizeof(fgp->codec.aom.y_points));
441  memcpy(&fgp->codec.aom.num_uv_points, &p->frame_hdr->film_grain.data.num_uv_points,
442  sizeof(fgp->codec.aom.num_uv_points));
443  memcpy(&fgp->codec.aom.uv_points, &p->frame_hdr->film_grain.data.uv_points,
444  sizeof(fgp->codec.aom.uv_points));
445  memcpy(&fgp->codec.aom.ar_coeffs_y, &p->frame_hdr->film_grain.data.ar_coeffs_y,
446  sizeof(fgp->codec.aom.ar_coeffs_y));
447  memcpy(&fgp->codec.aom.ar_coeffs_uv[0], &p->frame_hdr->film_grain.data.ar_coeffs_uv[0],
448  sizeof(fgp->codec.aom.ar_coeffs_uv[0]));
449  memcpy(&fgp->codec.aom.ar_coeffs_uv[1], &p->frame_hdr->film_grain.data.ar_coeffs_uv[1],
450  sizeof(fgp->codec.aom.ar_coeffs_uv[1]));
451  memcpy(&fgp->codec.aom.uv_mult, &p->frame_hdr->film_grain.data.uv_mult,
452  sizeof(fgp->codec.aom.uv_mult));
453  memcpy(&fgp->codec.aom.uv_mult_luma, &p->frame_hdr->film_grain.data.uv_luma_mult,
454  sizeof(fgp->codec.aom.uv_mult_luma));
455  memcpy(&fgp->codec.aom.uv_offset, &p->frame_hdr->film_grain.data.uv_offset,
456  sizeof(fgp->codec.aom.uv_offset));
457  }
458 
459  res = 0;
460 fail:
461  dav1d_picture_unref(p);
462  if (res < 0)
464  return res;
465 }
466 
468 {
469  Libdav1dContext *dav1d = c->priv_data;
470 
471  av_buffer_pool_uninit(&dav1d->pool);
472  dav1d_data_unref(&dav1d->data);
473  dav1d_close(&dav1d->c);
474 
475  return 0;
476 }
477 
478 #ifndef DAV1D_MAX_FRAME_THREADS
479 #define DAV1D_MAX_FRAME_THREADS DAV1D_MAX_THREADS
480 #endif
481 #ifndef DAV1D_MAX_TILE_THREADS
482 #define DAV1D_MAX_TILE_THREADS DAV1D_MAX_THREADS
483 #endif
484 
485 #define OFFSET(x) offsetof(Libdav1dContext, x)
486 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
487 static const AVOption libdav1d_options[] = {
488  { "tilethreads", "Tile threads", OFFSET(tile_threads), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, DAV1D_MAX_TILE_THREADS, VD },
489  { "framethreads", "Frame threads", OFFSET(frame_threads), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, DAV1D_MAX_FRAME_THREADS, VD },
490  { "filmgrain", "Apply Film Grain", OFFSET(apply_grain), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD | AV_OPT_FLAG_DEPRECATED },
491  { "oppoint", "Select an operating point of the scalable bitstream", OFFSET(operating_point), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 31, VD },
492  { "alllayers", "Output all spatial layers", OFFSET(all_layers), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
493  { NULL }
494 };
495 
496 static const AVClass libdav1d_class = {
497  .class_name = "libdav1d decoder",
498  .item_name = av_default_item_name,
499  .option = libdav1d_options,
500  .version = LIBAVUTIL_VERSION_INT,
501 };
502 
504  .name = "libdav1d",
505  .long_name = NULL_IF_CONFIG_SMALL("dav1d AV1 decoder by VideoLAN"),
506  .type = AVMEDIA_TYPE_VIDEO,
507  .id = AV_CODEC_ID_AV1,
508  .priv_data_size = sizeof(Libdav1dContext),
509  .init = libdav1d_init,
510  .close = libdav1d_close,
516  .priv_class = &libdav1d_class,
517  .wrapper_name = "libdav1d",
518 };
static void flush(AVCodecContext *avctx)
static const char *const format[]
Definition: af_aiir.c:456
int ff_parse_a53_cc(AVBufferRef **pbuf, const uint8_t *data, int size)
Parse a data array for ATSC A53 Part 4 Closed Captions and store them in an AVBufferRef.
Definition: atsc_a53.c:68
#define av_cold
Definition: attributes.h:88
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:2185
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
#define s(width, name)
Definition: cbs_vp9.c:257
#define fail()
Definition: checkasm.h:133
#define FFMIN(a, b)
Definition: common.h:105
#define MKBETAG(a, b, c, d)
Definition: common.h:479
#define FFMAX(a, b)
Definition: common.h:103
#define NULL
Definition: coverity.c:32
long long int64_t
Definition: coverity.c:34
int av_cpu_count(void)
Definition: cpu.c:275
static CopyRet receive_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame)
Definition: crystalhd.c:560
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:222
static AVFrame * frame
AVFilmGrainParams * av_film_grain_params_create_side_data(AVFrame *frame)
Allocate a complete AVFilmGrainParams and add it to the frame.
@ AV_FILM_GRAIN_PARAMS_AV1
The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
@ AV_OPT_TYPE_INT
Definition: opt.h:225
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:122
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:77
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:417
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:325
@ AV_CODEC_ID_AV1
Definition: codec_id.h:279
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:125
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
AVBufferPool * av_buffer_pool_init(buffer_size_t size, AVBufferRef *(*alloc)(buffer_size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:269
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:379
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:314
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
AVFrameSideData * av_frame_new_side_data_from_buf(AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef *buf)
Add a new side data to a frame from an existing AVBufferRef.
Definition: frame.c:694
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
void av_vlog(void *avcl, int level, const char *fmt, va_list vl)
Send the specified message to the log if the level is less than or equal to the current av_log_level.
Definition: log.c:424
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
Return the size in bytes of the amount of data required to store an image with the given parameters.
Definition: imgutils.c:466
int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4], const uint8_t *src, enum AVPixelFormat pix_fmt, int width, int height, int align)
Setup the data pointers and linesizes based on the specified image parameters and the provided array.
Definition: imgutils.c:446
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
@ AV_PICTURE_TYPE_SP
Switching Predicted.
Definition: avutil.h:279
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
misc image utilities
int i
Definition: input.c:407
#define FF_CODEC_CAP_SETS_PKT_DTS
Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set AVFrame.pkt_dts manually.
Definition: internal.h:56
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:99
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:84
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:80
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
static void libdav1d_data_free(const uint8_t *data, void *opaque)
Definition: libdav1d.c:189
static int libdav1d_picture_allocator(Dav1dPicture *p, void *cookie)
Definition: libdav1d.c:71
static av_cold int libdav1d_init(AVCodecContext *c)
Definition: libdav1d.c:126
static enum AVPixelFormat pix_fmt_rgb[3]
Definition: libdav1d.c:60
#define DAV1D_MAX_FRAME_THREADS
Definition: libdav1d.c:479
static void libdav1d_user_data_free(const uint8_t *data, void *opaque)
Definition: libdav1d.c:195
AVCodec ff_libdav1d_decoder
Definition: libdav1d.c:503
static void libdav1d_picture_release(Dav1dPicture *p, void *cookie)
Definition: libdav1d.c:119
static const AVOption libdav1d_options[]
Definition: libdav1d.c:487
static const AVClass libdav1d_class
Definition: libdav1d.c:496
#define VD
Definition: libdav1d.c:486
static av_cold int libdav1d_close(AVCodecContext *c)
Definition: libdav1d.c:467
static void libdav1d_log_callback(void *opaque, const char *fmt, va_list vl)
Definition: libdav1d.c:64
static void libdav1d_flush(AVCodecContext *c)
Definition: libdav1d.c:181
#define OFFSET(x)
Definition: libdav1d.c:485
static enum AVPixelFormat pix_fmt[][3]
Definition: libdav1d.c:53
#define DAV1D_MAX_TILE_THREADS
Definition: libdav1d.c:482
static int libdav1d_receive_frame(AVCodecContext *c, AVFrame *frame)
Definition: libdav1d.c:200
uint8_t w
Definition: llviddspenc.c:39
#define FFALIGN(x, a)
Definition: macros.h:48
AVMasteringDisplayMetadata * av_mastering_display_metadata_create_side_data(AVFrame *frame)
Allocate a complete AVMasteringDisplayMetadata and add it to the frame.
AVContentLightMetadata * av_content_light_metadata_create_side_data(AVFrame *frame)
Allocate a complete AVContentLightMetadata and add it to the frame.
const char data[16]
Definition: mxf.c:142
AVOptions.
#define AV_OPT_FLAG_DEPRECATED
set if option is deprecated, users should refer to AVOption.help text for more information
Definition: opt.h:295
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:609
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:607
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:569
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:586
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:403
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:381
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:380
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:458
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:483
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:512
The buffer pool.
A reference to a data buffer.
Definition: buffer.h:84
uint8_t * data
The data buffer.
Definition: buffer.h:92
Describe the class of an AVClass context structure.
Definition: log.h:67
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
main external API structure.
Definition: avcodec.h:536
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
unsigned MaxFALL
Max average light level per frame (cd/m^2).
unsigned MaxCLL
Max content light level (cd/m^2).
int chroma_scaling_from_luma
Signals whether to derive the chroma scaling function from the luma.
int limit_output_range
Signals to clip to limited color levels after film grain application.
int scaling_shift
Specifies the shift applied to the chroma components.
int grain_scale_shift
Signals the down shift applied to the generated gaussian numbers during synthesis.
int num_uv_points[2]
If chroma_scaling_from_luma is set to 0, signals the chroma scaling function parameters.
int overlap_flag
Signals whether to overlap film grain blocks.
int ar_coeff_lag
Specifies the auto-regression lag.
int uv_offset[2]
Offset used for component scaling function.
int ar_coeff_shift
Specifies the range of the auto-regressive coefficients.
uint8_t uv_points[2][10][2]
int8_t ar_coeffs_uv[2][25]
Chroma auto-regression coefficients.
int uv_mult[2]
Specifies the luma/chroma multipliers for the index to the component scaling function.
uint8_t y_points[14][2]
int8_t ar_coeffs_y[24]
Luma auto-regression coefficients.
int num_y_points
Number of points, and the scale and value for each point of the piecewise linear scaling function for...
This structure describes how to handle film grain synthesis in video for specific codecs.
AVFilmGrainAOMParams aom
enum AVFilmGrainParamsType type
Specifies the codec for which this structure is valid.
uint64_t seed
Seed to use for the synthesis process, if the codec allows for it.
union AVFilmGrainParams::@294 codec
Additional fields may be added both here and in any structure included.
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
enum AVChromaLocation chroma_location
Definition: frame.h:575
int width
Definition: frame.h:376
attribute_deprecated int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
Definition: frame.h:419
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown.
Definition: frame.h:597
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:589
int pkt_size
size of the corresponding packet containing the compressed frame.
Definition: frame.h:633
int height
Definition: frame.h:376
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:509
enum AVColorPrimaries color_primaries
Definition: frame.h:564
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:406
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:562
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:573
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:427
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:566
int64_t reordered_opaque
reordered opaque 64 bits (generally an integer or a double precision float PTS but can be anything).
Definition: frame.h:485
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:391
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
Mastering display metadata capable of representing the color volume of the display used to master the...
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:352
int size
Definition: packet.h:370
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:389
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
const uint8_t * buffer
Definition: bytestream.h:34
int tile_threads
Definition: libdav1d.c:46
AVBufferPool * pool
Definition: libdav1d.c:42
Dav1dData data
Definition: libdav1d.c:45
int frame_threads
Definition: libdav1d.c:47
Dav1dContext * c
Definition: libdav1d.c:41
int operating_point
Definition: libdav1d.c:49
#define av_free(p)
#define av_malloc(s)
#define av_log(a,...)
AVPacket * pkt
Definition: movenc.c:59
if(ret< 0)
Definition: vf_mcdeint.c:282
static double c[64]