FFmpeg
libvpxdec.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2010, Google, Inc.
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * VP8/9 decoder support via libvpx
24  */
25 
26 #include "config_components.h"
27 
28 #define VPX_CODEC_DISABLE_COMPAT 1
29 #include <vpx/vpx_decoder.h>
30 #include <vpx/vpx_frame_buffer.h>
31 #include <vpx/vp8dx.h>
32 
33 #include "libavutil/common.h"
34 #include "libavutil/cpu.h"
35 #include "libavutil/imgutils.h"
36 #include "libavutil/intreadwrite.h"
37 #include "avcodec.h"
38 #include "codec_internal.h"
39 #include "decode.h"
40 #include "internal.h"
41 #include "libvpx.h"
42 #include "profiles.h"
43 
44 typedef struct VPxDecoderContext {
45  struct vpx_codec_ctx decoder;
46  struct vpx_codec_ctx decoder_alpha;
48  size_t pool_size;
50 } VPxContext;
51 
52 
53 static int get_frame_buffer(void *priv, size_t min_size, vpx_codec_frame_buffer_t *fb)
54 {
55  VPxContext *ctx = priv;
56  AVBufferRef *buf;
57 
58  if (min_size > ctx->pool_size) {
59  av_buffer_pool_uninit(&ctx->pool);
60  /* According to the libvpx docs the buffer must be zeroed out. */
61  ctx->pool = av_buffer_pool_init(min_size, av_buffer_allocz);
62  if (!ctx->pool) {
63  ctx->pool_size = 0;
64  return AVERROR(ENOMEM);
65  }
66  ctx->pool_size = min_size;
67  }
68 
69  buf = av_buffer_pool_get(ctx->pool);
70  if (!buf)
71  return AVERROR(ENOMEM);
72 
73  fb->priv = buf;
74  fb->size = ctx->pool_size;
75  fb->data = buf->data;
76 
77  return 0;
78 }
79 
80 static int release_frame_buffer(void *priv, vpx_codec_frame_buffer_t *fb)
81 {
82  AVBufferRef *buf = fb->priv;
83  av_buffer_unref(&buf);
84  return 0;
85 }
86 
87 static av_cold int vpx_init(AVCodecContext *avctx,
88  struct vpx_codec_ctx* decoder,
89  const struct vpx_codec_iface *iface)
90 {
91  struct vpx_codec_dec_cfg deccfg = {
92  .threads = FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), 16)
93  };
94 
95  av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str());
96  av_log(avctx, AV_LOG_VERBOSE, "%s\n", vpx_codec_build_config());
97 
98  if (vpx_codec_dec_init(decoder, iface, &deccfg, 0) != VPX_CODEC_OK) {
99  const char *error = vpx_codec_error(decoder);
100  av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder: %s\n",
101  error);
102  return AVERROR(EINVAL);
103  }
104 
105  if (avctx->codec_id == AV_CODEC_ID_VP9)
106  vpx_codec_set_frame_buffer_functions(decoder, get_frame_buffer, release_frame_buffer, avctx->priv_data);
107 
108  return 0;
109 }
110 
111 // returns 0 on success, AVERROR_INVALIDDATA otherwise
112 static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img,
113  int has_alpha_channel)
114 {
115  static const enum AVColorSpace colorspaces[8] = {
118  };
119 #if VPX_IMAGE_ABI_VERSION >= 4
120  static const enum AVColorRange color_ranges[] = {
122  };
123  avctx->color_range = color_ranges[img->range];
124 #endif
125  avctx->colorspace = colorspaces[img->cs];
126  if (avctx->codec_id == AV_CODEC_ID_VP8 && img->fmt != VPX_IMG_FMT_I420)
127  return AVERROR_INVALIDDATA;
128  switch (img->fmt) {
129  case VPX_IMG_FMT_I420:
130  if (avctx->codec_id == AV_CODEC_ID_VP9)
131  avctx->profile = FF_PROFILE_VP9_0;
132  avctx->pix_fmt =
133  has_alpha_channel ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
134  return 0;
135 #if CONFIG_LIBVPX_VP9_DECODER
136  case VPX_IMG_FMT_I422:
137  avctx->profile = FF_PROFILE_VP9_1;
138  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
139  return 0;
140  case VPX_IMG_FMT_I440:
141  avctx->profile = FF_PROFILE_VP9_1;
142  avctx->pix_fmt = AV_PIX_FMT_YUV440P;
143  return 0;
144  case VPX_IMG_FMT_I444:
145  avctx->profile = FF_PROFILE_VP9_1;
146  avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
148  return 0;
149  case VPX_IMG_FMT_I42016:
150  avctx->profile = FF_PROFILE_VP9_2;
151  if (img->bit_depth == 10) {
152  avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
153  return 0;
154  } else if (img->bit_depth == 12) {
155  avctx->pix_fmt = AV_PIX_FMT_YUV420P12;
156  return 0;
157  } else {
158  return AVERROR_INVALIDDATA;
159  }
160  case VPX_IMG_FMT_I42216:
161  avctx->profile = FF_PROFILE_VP9_3;
162  if (img->bit_depth == 10) {
163  avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
164  return 0;
165  } else if (img->bit_depth == 12) {
166  avctx->pix_fmt = AV_PIX_FMT_YUV422P12;
167  return 0;
168  } else {
169  return AVERROR_INVALIDDATA;
170  }
171  case VPX_IMG_FMT_I44016:
172  avctx->profile = FF_PROFILE_VP9_3;
173  if (img->bit_depth == 10) {
174  avctx->pix_fmt = AV_PIX_FMT_YUV440P10;
175  return 0;
176  } else if (img->bit_depth == 12) {
177  avctx->pix_fmt = AV_PIX_FMT_YUV440P12;
178  return 0;
179  } else {
180  return AVERROR_INVALIDDATA;
181  }
182  case VPX_IMG_FMT_I44416:
183  avctx->profile = FF_PROFILE_VP9_3;
184  if (img->bit_depth == 10) {
185  avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
187  return 0;
188  } else if (img->bit_depth == 12) {
189  avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
191  return 0;
192  } else {
193  return AVERROR_INVALIDDATA;
194  }
195 #endif
196  default:
197  return AVERROR_INVALIDDATA;
198  }
199 }
200 
201 static int decode_frame(AVCodecContext *avctx, vpx_codec_ctx_t *decoder,
202  const uint8_t *data, uint32_t data_sz)
203 {
204  if (vpx_codec_decode(decoder, data, data_sz, NULL, 0) != VPX_CODEC_OK) {
205  const char *error = vpx_codec_error(decoder);
206  const char *detail = vpx_codec_error_detail(decoder);
207 
208  av_log(avctx, AV_LOG_ERROR, "Failed to decode frame: %s\n", error);
209  if (detail) {
210  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n",
211  detail);
212  }
213  return AVERROR_INVALIDDATA;
214  }
215  return 0;
216 }
217 
218 static int vpx_decode(AVCodecContext *avctx, AVFrame *picture,
219  int *got_frame, AVPacket *avpkt)
220 {
221  VPxContext *ctx = avctx->priv_data;
222  const void *iter = NULL;
223  const void *iter_alpha = NULL;
224  struct vpx_image *img, *img_alpha;
225  int ret;
226  uint8_t *side_data = NULL;
227  size_t side_data_size;
228 
229  ret = decode_frame(avctx, &ctx->decoder, avpkt->data, avpkt->size);
230  if (ret)
231  return ret;
232 
233  side_data = av_packet_get_side_data(avpkt,
235  &side_data_size);
236  if (side_data_size >= 8) {
237  const uint64_t additional_id = AV_RB64(side_data);
238  side_data += 8;
239  side_data_size -= 8;
240  if (additional_id == 1) { // 1 stands for alpha channel data.
241  if (!ctx->has_alpha_channel) {
242  ctx->has_alpha_channel = 1;
243  ret = vpx_init(avctx,
244  &ctx->decoder_alpha,
245 #if CONFIG_LIBVPX_VP8_DECODER && CONFIG_LIBVPX_VP9_DECODER
246  (avctx->codec_id == AV_CODEC_ID_VP8) ?
247  vpx_codec_vp8_dx() : vpx_codec_vp9_dx()
248 #elif CONFIG_LIBVPX_VP8_DECODER
249  vpx_codec_vp8_dx()
250 #else
251  vpx_codec_vp9_dx()
252 #endif
253  );
254  if (ret)
255  return ret;
256  }
257  ret = decode_frame(avctx, &ctx->decoder_alpha, side_data,
258  side_data_size);
259  if (ret)
260  return ret;
261  }
262  }
263 
264  if ((img = vpx_codec_get_frame(&ctx->decoder, &iter)) &&
265  (!ctx->has_alpha_channel ||
266  (img_alpha = vpx_codec_get_frame(&ctx->decoder_alpha, &iter_alpha)))) {
267  uint8_t *planes[4];
268  int linesizes[4];
269 
270  if (img->d_w > img->w || img->d_h > img->h) {
271  av_log(avctx, AV_LOG_ERROR, "Display dimensions %dx%d exceed storage %dx%d\n",
272  img->d_w, img->d_h, img->w, img->h);
273  return AVERROR_EXTERNAL;
274  }
275 
276  if ((ret = set_pix_fmt(avctx, img, ctx->has_alpha_channel)) < 0) {
277  av_log(avctx, AV_LOG_ERROR, "Unsupported output colorspace (%d) / bit_depth (%d)\n",
278  img->fmt, img->bit_depth);
279  return ret;
280  }
281 
282  if ((int) img->d_w != avctx->width || (int) img->d_h != avctx->height) {
283  av_log(avctx, AV_LOG_INFO, "dimension change! %dx%d -> %dx%d\n",
284  avctx->width, avctx->height, img->d_w, img->d_h);
285  ret = ff_set_dimensions(avctx, img->d_w, img->d_h);
286  if (ret < 0)
287  return ret;
288  }
289 
290  if (ctx->has_alpha_channel &&
291  (img->d_w != img_alpha->d_w ||
292  img->d_h != img_alpha->d_h ||
293  img->bit_depth != img_alpha->bit_depth)) {
294  av_log(avctx, AV_LOG_ERROR,
295  "Video dimensions %dx%d@%dbpc differ from alpha dimensions %dx%d@%dbpc\n",
296  img->d_w, img->d_h, img->bit_depth,
297  img_alpha->d_w, img_alpha->d_h, img_alpha->bit_depth);
298  return AVERROR_INVALIDDATA;
299  }
300 
301  planes[0] = img->planes[VPX_PLANE_Y];
302  planes[1] = img->planes[VPX_PLANE_U];
303  planes[2] = img->planes[VPX_PLANE_V];
304  planes[3] =
305  ctx->has_alpha_channel ? img_alpha->planes[VPX_PLANE_Y] : NULL;
306  linesizes[0] = img->stride[VPX_PLANE_Y];
307  linesizes[1] = img->stride[VPX_PLANE_U];
308  linesizes[2] = img->stride[VPX_PLANE_V];
309  linesizes[3] =
310  ctx->has_alpha_channel ? img_alpha->stride[VPX_PLANE_Y] : 0;
311 
312  if (img->fb_priv && (!ctx->has_alpha_channel || img_alpha->fb_priv)) {
313  ret = ff_decode_frame_props(avctx, picture);
314  if (ret < 0)
315  return ret;
316  picture->buf[0] = av_buffer_ref(img->fb_priv);
317  if (!picture->buf[0])
318  return AVERROR(ENOMEM);
319  if (ctx->has_alpha_channel) {
320  picture->buf[1] = av_buffer_ref(img_alpha->fb_priv);
321  if (!picture->buf[1]) {
322  av_frame_unref(picture);
323  return AVERROR(ENOMEM);
324  }
325  }
326  for (int i = 0; i < 4; i++) {
327  picture->data[i] = planes[i];
328  picture->linesize[i] = linesizes[i];
329  }
330  } else {
331  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
332  return ret;
333  av_image_copy(picture->data, picture->linesize, (const uint8_t**)planes,
334  linesizes, avctx->pix_fmt, img->d_w, img->d_h);
335  }
336  *got_frame = 1;
337  }
338  return avpkt->size;
339 }
340 
341 static av_cold int vpx_free(AVCodecContext *avctx)
342 {
343  VPxContext *ctx = avctx->priv_data;
344  vpx_codec_destroy(&ctx->decoder);
345  if (ctx->has_alpha_channel)
346  vpx_codec_destroy(&ctx->decoder_alpha);
347  av_buffer_pool_uninit(&ctx->pool);
348  return 0;
349 }
350 
351 #if CONFIG_LIBVPX_VP8_DECODER
352 static av_cold int vp8_init(AVCodecContext *avctx)
353 {
354  VPxContext *ctx = avctx->priv_data;
355  return vpx_init(avctx, &ctx->decoder, vpx_codec_vp8_dx());
356 }
357 
359  .p.name = "libvpx",
360  .p.long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),
361  .p.type = AVMEDIA_TYPE_VIDEO,
362  .p.id = AV_CODEC_ID_VP8,
363  .p.capabilities = AV_CODEC_CAP_OTHER_THREADS | AV_CODEC_CAP_DR1,
364  .p.wrapper_name = "libvpx",
365  .priv_data_size = sizeof(VPxContext),
366  .init = vp8_init,
367  .close = vpx_free,
369  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
371 };
372 #endif /* CONFIG_LIBVPX_VP8_DECODER */
373 
374 #if CONFIG_LIBVPX_VP9_DECODER
375 static av_cold int vp9_init(AVCodecContext *avctx)
376 {
377  VPxContext *ctx = avctx->priv_data;
378  return vpx_init(avctx, &ctx->decoder, vpx_codec_vp9_dx());
379 }
380 
382  .p.name = "libvpx-vp9",
383  .p.long_name = NULL_IF_CONFIG_SMALL("libvpx VP9"),
384  .p.type = AVMEDIA_TYPE_VIDEO,
385  .p.id = AV_CODEC_ID_VP9,
386  .p.capabilities = AV_CODEC_CAP_OTHER_THREADS,
387  .p.profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),
388  .p.wrapper_name = "libvpx",
389  .priv_data_size = sizeof(VPxContext),
390  .init = vp9_init,
391  .close = vpx_free,
393  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
395  .init_static_data = ff_vp9_init_static,
396 };
397 #endif /* CONFIG_LIBVPX_VP9_DECODER */
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
av_buffer_pool_init
AVBufferPool * av_buffer_pool_init(size_t size, AVBufferRef *(*alloc)(size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:280
vp9_init
static av_cold int vp9_init(AVFormatContext *ctx, int st_index, PayloadContext *data)
Definition: rtpdec_vp9.c:34
ff_libvpx_vp8_decoder
const FFCodec ff_libvpx_vp8_decoder
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_frame
static int decode_frame(AVCodecContext *avctx, vpx_codec_ctx_t *decoder, const uint8_t *data, uint32_t data_sz)
Definition: libvpxdec.c:201
ff_vp9_init_static
av_cold void ff_vp9_init_static(FFCodec *codec)
Definition: libvpx.c:69
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:975
FF_PROFILE_VP9_0
#define FF_PROFILE_VP9_0
Definition: avcodec.h:1639
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:88
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:606
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
release_frame_buffer
static int release_frame_buffer(void *priv, vpx_codec_frame_buffer_t *fb)
Definition: libvpxdec.c:80
data
const char data[16]
Definition: mxf.c:146
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:411
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:33
FFCodec
Definition: codec_internal.h:118
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:533
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:525
VPxDecoderContext
Definition: libvpxdec.c:44
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
init
static int init
Definition: av_tx.c:47
AVCOL_SPC_BT470BG
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
Definition: pixfmt.h:538
AVCOL_SPC_RESERVED
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition: pixfmt.h:536
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:331
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1472
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:427
set_pix_fmt
static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img, int has_alpha_channel)
Definition: libvpxdec.c:112
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:414
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:384
ff_libvpx_vp9_decoder
FFCodec ff_libvpx_vp9_decoder
VPxDecoderContext::has_alpha_channel
int has_alpha_channel
Definition: libvpxdec.c:49
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
intreadwrite.h
FF_PROFILE_VP9_3
#define FF_PROFILE_VP9_3
Definition: avcodec.h:1642
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AVCOL_SPC_SMPTE170M
@ AVCOL_SPC_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
Definition: pixfmt.h:539
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:218
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:127
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:408
FF_PROFILE_VP9_2
#define FF_PROFILE_VP9_2
Definition: avcodec.h:1641
vpx_decode
static int vpx_decode(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition: libvpxdec.c:218
NULL
#define NULL
Definition: coverity.c:32
VPxDecoderContext::pool
AVBufferPool * pool
Definition: libvpxdec.c:47
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:982
av_buffer_unref
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:139
profiles.h
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:322
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:413
vpx_free
static av_cold int vpx_free(AVCodecContext *avctx)
Definition: libvpxdec.c:341
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:412
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:195
VPxDecoderContext::decoder
struct vpx_codec_ctx decoder
Definition: libvpxdec.c:45
planes
static const struct @335 planes[]
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1462
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
codec_internal.h
cpu.h
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:416
vpx_init
static av_cold int vpx_init(AVCodecContext *avctx, struct vpx_codec_ctx *decoder, const struct vpx_codec_iface *iface)
Definition: libvpxdec.c:87
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:418
img
#define img
Definition: vf_colormatrix.c:116
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AVCOL_SPC_SMPTE240M
@ AVCOL_SPC_SMPTE240M
derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries
Definition: pixfmt.h:540
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:543
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: avpacket.c:251
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:428
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:532
common.h
fb
#define fb(width, name)
Definition: cbs_av1.c:549
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:487
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
VPxDecoderContext::decoder_alpha
struct vpx_codec_ctx decoder_alpha
Definition: libvpxdec.c:46
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:535
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:589
avcodec.h
av_buffer_allocz
AVBufferRef * av_buffer_allocz(size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:93
ret
ret
Definition: filter_design.txt:187
FF_PROFILE_VP9_1
#define FF_PROFILE_VP9_1
Definition: avcodec.h:1640
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:415
ff_decode_frame_props
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: decode.c:1306
AVCodecContext
main external API structure.
Definition: avcodec.h:398
av_image_copy
void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
Definition: imgutils.c:422
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1556
get_frame_buffer
static int get_frame_buffer(void *priv, size_t min_size, vpx_codec_frame_buffer_t *fb)
Definition: libvpxdec.c:53
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
VPxDecoderContext::pool_size
size_t pool_size
Definition: libvpxdec.c:48
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
ff_set_dimensions
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:90
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:72
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
@ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
Data found in BlockAdditional element of matroska container.
Definition: packet.h:192
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
imgutils.h
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:190
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
av_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
libvpx.h
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:417
vp8_init
static av_cold int vp8_init(AVFormatContext *s, int st_index, PayloadContext *vp8)
Definition: rtpdec_vp8.c:263
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:534
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:571
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95
ff_vp9_profiles
const AVProfile ff_vp9_profiles[]
Definition: profiles.c:139