FFmpeg
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"
26 #include "libavutil/imgutils.h"
27 #include "libavutil/opt.h"
28 
29 #include "avcodec.h"
30 #include "decode.h"
31 #include "internal.h"
32 
33 typedef struct Libdav1dContext {
34  AVClass *class;
35  Dav1dContext *c;
37  int pool_size;
38 
39  Dav1dData data;
44 
45 static const enum AVPixelFormat pix_fmt[][3] = {
46  [DAV1D_PIXEL_LAYOUT_I400] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12 },
47  [DAV1D_PIXEL_LAYOUT_I420] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV420P12 },
48  [DAV1D_PIXEL_LAYOUT_I422] = { AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV422P12 },
49  [DAV1D_PIXEL_LAYOUT_I444] = { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV444P12 },
50 };
51 
52 static const enum AVPixelFormat pix_fmt_rgb[3] = {
54 };
55 
56 static void libdav1d_log_callback(void *opaque, const char *fmt, va_list vl)
57 {
58  AVCodecContext *c = opaque;
59 
60  av_vlog(c, AV_LOG_ERROR, fmt, vl);
61 }
62 
63 static int libdav1d_picture_allocator(Dav1dPicture *p, void *cookie)
64 {
65  Libdav1dContext *dav1d = cookie;
66  enum AVPixelFormat format = pix_fmt[p->p.layout][p->seq_hdr->hbd];
67  int ret, linesize[4], h = FFALIGN(p->p.h, 128);
68  uint8_t *aligned_ptr, *data[4];
70 
71  ret = av_image_fill_arrays(data, linesize, NULL, format, FFALIGN(p->p.w, 128),
72  h, DAV1D_PICTURE_ALIGNMENT);
73  if (ret < 0)
74  return ret;
75 
76  if (ret != dav1d->pool_size) {
77  av_buffer_pool_uninit(&dav1d->pool);
78  // Use twice the amount of required padding bytes for aligned_ptr below.
79  dav1d->pool = av_buffer_pool_init(ret + DAV1D_PICTURE_ALIGNMENT * 2, NULL);
80  if (!dav1d->pool) {
81  dav1d->pool_size = 0;
82  return AVERROR(ENOMEM);
83  }
84  dav1d->pool_size = ret;
85  }
86  buf = av_buffer_pool_get(dav1d->pool);
87  if (!buf)
88  return AVERROR(ENOMEM);
89 
90  // libdav1d requires DAV1D_PICTURE_ALIGNMENT aligned buffers, which av_malloc()
91  // doesn't guarantee for example when AVX is disabled at configure time.
92  // Use the extra DAV1D_PICTURE_ALIGNMENT padding bytes in the buffer to align it
93  // if required.
94  aligned_ptr = (uint8_t *)FFALIGN((uintptr_t)buf->data, DAV1D_PICTURE_ALIGNMENT);
95  ret = av_image_fill_pointers(data, format, h, aligned_ptr, linesize);
96  if (ret < 0) {
97  av_buffer_unref(&buf);
98  return ret;
99  }
100 
101  p->data[0] = data[0];
102  p->data[1] = data[1];
103  p->data[2] = data[2];
104  p->stride[0] = linesize[0];
105  p->stride[1] = linesize[1];
106  p->allocator_data = buf;
107 
108  return 0;
109 }
110 
111 static void libdav1d_picture_release(Dav1dPicture *p, void *cookie)
112 {
113  AVBufferRef *buf = p->allocator_data;
114 
115  av_buffer_unref(&buf);
116 }
117 
119 {
120  Libdav1dContext *dav1d = c->priv_data;
121  Dav1dSettings s;
122  int threads = (c->thread_count ? c->thread_count : av_cpu_count()) * 3 / 2;
123  int res;
124 
125  av_log(c, AV_LOG_INFO, "libdav1d %s\n", dav1d_version());
126 
127  dav1d_default_settings(&s);
128  s.logger.cookie = c;
129  s.logger.callback = libdav1d_log_callback;
130  s.allocator.cookie = dav1d;
131  s.allocator.alloc_picture_callback = libdav1d_picture_allocator;
132  s.allocator.release_picture_callback = libdav1d_picture_release;
133  s.frame_size_limit = c->max_pixels;
134  s.apply_grain = dav1d->apply_grain;
135 
136  s.n_tile_threads = dav1d->tile_threads
137  ? dav1d->tile_threads
138  : FFMIN(floor(sqrt(threads)), DAV1D_MAX_TILE_THREADS);
139  s.n_frame_threads = dav1d->frame_threads
140  ? dav1d->frame_threads
141  : FFMIN(ceil(threads / s.n_tile_threads), DAV1D_MAX_FRAME_THREADS);
142  av_log(c, AV_LOG_DEBUG, "Using %d frame threads, %d tile threads\n",
143  s.n_frame_threads, s.n_tile_threads);
144 
145  res = dav1d_open(&dav1d->c, &s);
146  if (res < 0)
147  return AVERROR(ENOMEM);
148 
149  return 0;
150 }
151 
153 {
154  Libdav1dContext *dav1d = c->priv_data;
155 
156  dav1d_data_unref(&dav1d->data);
157  dav1d_flush(dav1d->c);
158 }
159 
160 static void libdav1d_data_free(const uint8_t *data, void *opaque) {
161  AVBufferRef *buf = opaque;
162 
163  av_buffer_unref(&buf);
164 }
165 
167 {
168  Libdav1dContext *dav1d = c->priv_data;
169  Dav1dData *data = &dav1d->data;
170  Dav1dPicture pic = { 0 }, *p = &pic;
171  int res;
172 
173  if (!data->sz) {
174  AVPacket pkt = { 0 };
175 
176  res = ff_decode_get_packet(c, &pkt);
177  if (res < 0 && res != AVERROR_EOF)
178  return res;
179 
180  if (pkt.size) {
181  res = dav1d_data_wrap(data, pkt.data, pkt.size, libdav1d_data_free, pkt.buf);
182  if (res < 0) {
183  av_packet_unref(&pkt);
184  return res;
185  }
186 
187  data->m.timestamp = pkt.pts;
188  data->m.offset = pkt.pos;
189  data->m.duration = pkt.duration;
190 
191  pkt.buf = NULL;
192  av_packet_unref(&pkt);
193  }
194  }
195 
196  res = dav1d_send_data(dav1d->c, data);
197  if (res < 0) {
198  if (res == AVERROR(EINVAL))
199  res = AVERROR_INVALIDDATA;
200  if (res != AVERROR(EAGAIN))
201  return res;
202  }
203 
204  res = dav1d_get_picture(dav1d->c, p);
205  if (res < 0) {
206  if (res == AVERROR(EINVAL))
207  res = AVERROR_INVALIDDATA;
208  else if (res == AVERROR(EAGAIN) && c->internal->draining)
209  res = AVERROR_EOF;
210 
211  return res;
212  }
213 
214  av_assert0(p->data[0] && p->allocator_data);
215 
216  // This requires the custom allocator above
217  frame->buf[0] = av_buffer_ref(p->allocator_data);
218  if (!frame->buf[0]) {
219  dav1d_picture_unref(p);
220  return AVERROR(ENOMEM);
221  }
222 
223  frame->data[0] = p->data[0];
224  frame->data[1] = p->data[1];
225  frame->data[2] = p->data[2];
226  frame->linesize[0] = p->stride[0];
227  frame->linesize[1] = p->stride[1];
228  frame->linesize[2] = p->stride[1];
229 
230  c->profile = p->seq_hdr->profile;
231  c->level = ((p->seq_hdr->operating_points[0].major_level - 2) << 2)
232  | p->seq_hdr->operating_points[0].minor_level;
233  frame->width = p->p.w;
234  frame->height = p->p.h;
235  if (c->width != p->p.w || c->height != p->p.h) {
236  res = ff_set_dimensions(c, p->p.w, p->p.h);
237  if (res < 0)
238  goto fail;
239  }
240 
241  switch (p->seq_hdr->chr) {
242  case DAV1D_CHR_VERTICAL:
244  break;
245  case DAV1D_CHR_COLOCATED:
247  break;
248  }
249  frame->colorspace = c->colorspace = (enum AVColorSpace) p->seq_hdr->mtrx;
250  frame->color_primaries = c->color_primaries = (enum AVColorPrimaries) p->seq_hdr->pri;
251  frame->color_trc = c->color_trc = (enum AVColorTransferCharacteristic) p->seq_hdr->trc;
252  frame->color_range = c->color_range = p->seq_hdr->color_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
253 
254  if (p->p.layout == DAV1D_PIXEL_LAYOUT_I444 &&
255  p->seq_hdr->mtrx == DAV1D_MC_IDENTITY &&
256  p->seq_hdr->pri == DAV1D_COLOR_PRI_BT709 &&
257  p->seq_hdr->trc == DAV1D_TRC_SRGB)
258  frame->format = c->pix_fmt = pix_fmt_rgb[p->seq_hdr->hbd];
259  else
260  frame->format = c->pix_fmt = pix_fmt[p->p.layout][p->seq_hdr->hbd];
261 
262  // match timestamps and packet size
263  frame->pts = frame->best_effort_timestamp = p->m.timestamp;
264 #if FF_API_PKT_PTS
266  frame->pkt_pts = p->m.timestamp;
268 #endif
269  frame->pkt_dts = p->m.timestamp;
270  frame->pkt_pos = p->m.offset;
271  frame->pkt_size = p->m.size;
272  frame->pkt_duration = p->m.duration;
273  frame->key_frame = p->frame_hdr->frame_type == DAV1D_FRAME_TYPE_KEY;
274 
275  switch (p->frame_hdr->frame_type) {
276  case DAV1D_FRAME_TYPE_KEY:
277  case DAV1D_FRAME_TYPE_INTRA:
278  frame->pict_type = AV_PICTURE_TYPE_I;
279  break;
280  case DAV1D_FRAME_TYPE_INTER:
281  frame->pict_type = AV_PICTURE_TYPE_P;
282  break;
283  case DAV1D_FRAME_TYPE_SWITCH:
284  frame->pict_type = AV_PICTURE_TYPE_SP;
285  break;
286  default:
287  res = AVERROR_INVALIDDATA;
288  goto fail;
289  }
290 
291  if (p->mastering_display) {
293  if (!mastering) {
294  res = AVERROR(ENOMEM);
295  goto fail;
296  }
297 
298  for (int i = 0; i < 3; i++) {
299  mastering->display_primaries[i][0] = av_make_q(p->mastering_display->primaries[i][0], 1 << 16);
300  mastering->display_primaries[i][1] = av_make_q(p->mastering_display->primaries[i][1], 1 << 16);
301  }
302  mastering->white_point[0] = av_make_q(p->mastering_display->white_point[0], 1 << 16);
303  mastering->white_point[1] = av_make_q(p->mastering_display->white_point[1], 1 << 16);
304 
305  mastering->max_luminance = av_make_q(p->mastering_display->max_luminance, 1 << 8);
306  mastering->min_luminance = av_make_q(p->mastering_display->min_luminance, 1 << 14);
307 
308  mastering->has_primaries = 1;
309  mastering->has_luminance = 1;
310  }
311  if (p->content_light) {
313  if (!light) {
314  res = AVERROR(ENOMEM);
315  goto fail;
316  }
317  light->MaxCLL = p->content_light->max_content_light_level;
318  light->MaxFALL = p->content_light->max_frame_average_light_level;
319  }
320 
321  res = 0;
322 fail:
323  dav1d_picture_unref(p);
324  if (res < 0)
325  av_frame_unref(frame);
326  return res;
327 }
328 
330 {
331  Libdav1dContext *dav1d = c->priv_data;
332 
333  av_buffer_pool_uninit(&dav1d->pool);
334  dav1d_data_unref(&dav1d->data);
335  dav1d_close(&dav1d->c);
336 
337  return 0;
338 }
339 
340 #define OFFSET(x) offsetof(Libdav1dContext, x)
341 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
342 static const AVOption libdav1d_options[] = {
343  { "tilethreads", "Tile threads", OFFSET(tile_threads), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, DAV1D_MAX_TILE_THREADS, VD },
344  { "framethreads", "Frame threads", OFFSET(frame_threads), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, DAV1D_MAX_FRAME_THREADS, VD },
345  { "filmgrain", "Apply Film Grain", OFFSET(apply_grain), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VD },
346  { NULL }
347 };
348 
349 static const AVClass libdav1d_class = {
350  .class_name = "libdav1d decoder",
351  .item_name = av_default_item_name,
352  .option = libdav1d_options,
353  .version = LIBAVUTIL_VERSION_INT,
354 };
355 
357  .name = "libdav1d",
358  .long_name = NULL_IF_CONFIG_SMALL("dav1d AV1 decoder by VideoLAN"),
359  .type = AVMEDIA_TYPE_VIDEO,
360  .id = AV_CODEC_ID_AV1,
361  .priv_data_size = sizeof(Libdav1dContext),
362  .init = libdav1d_init,
363  .close = libdav1d_close,
368  .priv_class = &libdav1d_class,
369  .wrapper_name = "libdav1d",
370 };
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
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
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:543
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
unsigned MaxCLL
Max content light level (cd/m^2).
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
int av_cpu_count(void)
Definition: cpu.c:267
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:566
const char * fmt
Definition: avisynth_c.h:861
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1497
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:104
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:486
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2200
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
int size
Definition: avcodec.h:1478
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:411
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:403
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
static AVPacket pkt
static CopyRet receive_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame)
Definition: crystalhd.c:560
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:1049
int profile
profile
Definition: avcodec.h:2898
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 format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
AVCodec.
Definition: avcodec.h:3481
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:467
Dav1dData data
Definition: libdav1d.c:39
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:368
static void libdav1d_picture_release(Dav1dPicture *p, void *cookie)
Definition: libdav1d.c:111
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:369
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
#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: avcodec.h:1006
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#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:40
uint8_t
#define av_cold
Definition: attributes.h:82
AVOptions.
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:496
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1495
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:329
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
uint8_t * data
Definition: avcodec.h:1477
static enum AVPixelFormat pix_fmt_rgb[3]
Definition: libdav1d.c:52
static void libdav1d_flush(AVCodecContext *c)
Definition: libdav1d.c:152
#define AVERROR_EOF
End of file.
Definition: error.h:55
int frame_threads
Definition: libdav1d.c:41
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:443
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2207
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
The buffer pool.
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:539
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1460
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:550
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:3292
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
#define fail()
Definition: checkasm.h:120
Dav1dContext * c
Definition: libdav1d.c:35
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
static av_cold int libdav1d_init(AVCodecContext *c)
Definition: libdav1d.c:118
AVMasteringDisplayMetadata * av_mastering_display_metadata_create_side_data(AVFrame *frame)
Allocate a complete AVMasteringDisplayMetadata and add it to the frame.
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define FFMIN(a, b)
Definition: common.h:96
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
int width
picture width / height.
Definition: avcodec.h:1738
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:545
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2179
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
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:3018
static const AVOption libdav1d_options[]
Definition: libdav1d.c:342
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:195
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2824
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:522
if(ret)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:368
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height, uint8_t *ptr, const int linesizes[4])
Fill plane data pointers for an image with pixel format pix_fmt and height height.
Definition: imgutils.c:111
Libavcodec external API header.
int tile_threads
Definition: libdav1d.c:40
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown...
Definition: frame.h:574
static void libdav1d_data_free(const uint8_t *data, void *opaque)
Definition: libdav1d.c:160
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
main external API structure.
Definition: avcodec.h:1565
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
uint8_t * data
The data buffer.
Definition: buffer.h:89
static enum AVPixelFormat pix_fmt[][3]
Definition: libdav1d.c:45
void * buf
Definition: avisynth_c.h:766
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
AVContentLightMetadata * av_content_light_metadata_create_side_data(AVFrame *frame)
Allocate a complete AVContentLightMetadata and add it to the frame.
Switching Predicted.
Definition: avutil.h:279
Describe the class of an AVClass context structure.
Definition: log.h:67
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:275
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2193
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2186
Mastering display metadata capable of representing the color volume of the display used to master the...
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:373
static const AVClass libdav1d_class
Definition: libdav1d.c:349
#define OFFSET(x)
Definition: libdav1d.c:340
enum AVChromaLocation chroma_location
Definition: frame.h:552
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
Definition: frame.h:559
#define VD
Definition: libdav1d.c:341
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:404
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
#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:55
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:394
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
attribute_deprecated int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
Definition: frame.h:396
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:521
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:404
static void libdav1d_log_callback(void *opaque, const char *fmt, va_list vl)
Definition: libdav1d.c:56
A reference to a data buffer.
Definition: buffer.h:81
static int libdav1d_picture_allocator(Dav1dPicture *p, void *cookie)
Definition: libdav1d.c:63
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
AVBufferPool * av_buffer_pool_init(int size, AVBufferRef *(*alloc)(int size))
Allocate and initialize a buffer pool.
Definition: buffer.c:238
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
static av_cold int libdav1d_close(AVCodecContext *c)
Definition: libdav1d.c:329
void * priv_data
Definition: avcodec.h:1592
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1600
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
enum AVColorPrimaries color_primaries
Definition: frame.h:541
int height
Definition: frame.h:353
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:543
AVBufferPool * pool
Definition: libdav1d.c:36
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:334
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
AVCodec ff_libdav1d_decoder
Definition: libdav1d.c:356
int pkt_size
size of the corresponding packet containing the compressed frame.
Definition: frame.h:610
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
unsigned MaxFALL
Max average light level per frame (cd/m^2).
This structure stores compressed data.
Definition: avcodec.h:1454
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
Predicted.
Definition: avutil.h:275
static int libdav1d_receive_frame(AVCodecContext *c, AVFrame *frame)
Definition: libdav1d.c:166