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 "libvpx.h"
41 #include "profiles.h"
42 
43 typedef struct VPxDecoderContext {
44  struct vpx_codec_ctx decoder;
45  struct vpx_codec_ctx decoder_alpha;
47  size_t pool_size;
49 } VPxContext;
50 
51 
52 static int get_frame_buffer(void *priv, size_t min_size, vpx_codec_frame_buffer_t *fb)
53 {
54  VPxContext *ctx = priv;
55  AVBufferRef *buf;
56 
57  if (min_size > ctx->pool_size) {
58  av_buffer_pool_uninit(&ctx->pool);
59  /* According to the libvpx docs the buffer must be zeroed out. */
60  ctx->pool = av_buffer_pool_init(min_size, av_buffer_allocz);
61  if (!ctx->pool) {
62  ctx->pool_size = 0;
63  return AVERROR(ENOMEM);
64  }
65  ctx->pool_size = min_size;
66  }
67 
68  buf = av_buffer_pool_get(ctx->pool);
69  if (!buf)
70  return AVERROR(ENOMEM);
71 
72  fb->priv = buf;
73  fb->size = ctx->pool_size;
74  fb->data = buf->data;
75 
76  return 0;
77 }
78 
79 static int release_frame_buffer(void *priv, vpx_codec_frame_buffer_t *fb)
80 {
81  AVBufferRef *buf = fb->priv;
82  av_buffer_unref(&buf);
83  return 0;
84 }
85 
86 static av_cold int vpx_init(AVCodecContext *avctx,
87  struct vpx_codec_ctx* decoder,
88  const struct vpx_codec_iface *iface)
89 {
90  struct vpx_codec_dec_cfg deccfg = {
91  .threads = FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), MAX_VPX_THREADS)
92  };
93 
94  av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str());
95  av_log(avctx, AV_LOG_VERBOSE, "%s\n", vpx_codec_build_config());
96 
97  if (vpx_codec_dec_init(decoder, iface, &deccfg, 0) != VPX_CODEC_OK) {
98  const char *error = vpx_codec_error(decoder);
99  av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder: %s\n",
100  error);
101  return AVERROR(EINVAL);
102  }
103 
104  if (avctx->codec_id == AV_CODEC_ID_VP9)
105  vpx_codec_set_frame_buffer_functions(decoder, get_frame_buffer, release_frame_buffer, avctx->priv_data);
106 
107  return 0;
108 }
109 
110 // returns 0 on success, AVERROR_INVALIDDATA otherwise
111 static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img,
112  int has_alpha_channel)
113 {
114  static const enum AVColorSpace colorspaces[8] = {
117  };
118 #if VPX_IMAGE_ABI_VERSION >= 4
119  static const enum AVColorRange color_ranges[] = {
121  };
122  avctx->color_range = color_ranges[img->range];
123 #endif
124  avctx->colorspace = colorspaces[img->cs];
125  if (avctx->codec_id == AV_CODEC_ID_VP8 && img->fmt != VPX_IMG_FMT_I420)
126  return AVERROR_INVALIDDATA;
127  switch (img->fmt) {
128  case VPX_IMG_FMT_I420:
129  if (avctx->codec_id == AV_CODEC_ID_VP9)
130  avctx->profile = AV_PROFILE_VP9_0;
131  avctx->pix_fmt =
132  has_alpha_channel ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
133  return 0;
134 #if CONFIG_LIBVPX_VP9_DECODER
135  case VPX_IMG_FMT_I422:
136  avctx->profile = AV_PROFILE_VP9_1;
137  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
138  return 0;
139  case VPX_IMG_FMT_I440:
140  avctx->profile = AV_PROFILE_VP9_1;
141  avctx->pix_fmt = AV_PIX_FMT_YUV440P;
142  return 0;
143  case VPX_IMG_FMT_I444:
144  avctx->profile = AV_PROFILE_VP9_1;
145  avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
147  return 0;
148  case VPX_IMG_FMT_I42016:
149  avctx->profile = AV_PROFILE_VP9_2;
150  if (img->bit_depth == 10) {
151  avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
152  return 0;
153  } else if (img->bit_depth == 12) {
154  avctx->pix_fmt = AV_PIX_FMT_YUV420P12;
155  return 0;
156  } else {
157  return AVERROR_INVALIDDATA;
158  }
159  case VPX_IMG_FMT_I42216:
160  avctx->profile = AV_PROFILE_VP9_3;
161  if (img->bit_depth == 10) {
162  avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
163  return 0;
164  } else if (img->bit_depth == 12) {
165  avctx->pix_fmt = AV_PIX_FMT_YUV422P12;
166  return 0;
167  } else {
168  return AVERROR_INVALIDDATA;
169  }
170  case VPX_IMG_FMT_I44016:
171  avctx->profile = AV_PROFILE_VP9_3;
172  if (img->bit_depth == 10) {
173  avctx->pix_fmt = AV_PIX_FMT_YUV440P10;
174  return 0;
175  } else if (img->bit_depth == 12) {
176  avctx->pix_fmt = AV_PIX_FMT_YUV440P12;
177  return 0;
178  } else {
179  return AVERROR_INVALIDDATA;
180  }
181  case VPX_IMG_FMT_I44416:
182  avctx->profile = AV_PROFILE_VP9_3;
183  if (img->bit_depth == 10) {
184  avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
186  return 0;
187  } else if (img->bit_depth == 12) {
188  avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
190  return 0;
191  } else {
192  return AVERROR_INVALIDDATA;
193  }
194 #endif
195  default:
196  return AVERROR_INVALIDDATA;
197  }
198 }
199 
200 static int decode_frame(AVCodecContext *avctx, vpx_codec_ctx_t *decoder,
201  const uint8_t *data, uint32_t data_sz)
202 {
203  if (vpx_codec_decode(decoder, data, data_sz, NULL, 0) != VPX_CODEC_OK) {
204  const char *error = vpx_codec_error(decoder);
205  const char *detail = vpx_codec_error_detail(decoder);
206 
207  av_log(avctx, AV_LOG_ERROR, "Failed to decode frame: %s\n", error);
208  if (detail) {
209  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n",
210  detail);
211  }
212  return AVERROR_INVALIDDATA;
213  }
214  return 0;
215 }
216 
217 static int vpx_decode(AVCodecContext *avctx, AVFrame *picture,
218  int *got_frame, AVPacket *avpkt)
219 {
220  VPxContext *ctx = avctx->priv_data;
221  const void *iter = NULL;
222  const void *iter_alpha = NULL;
223  struct vpx_image *img, *img_alpha;
224  int ret;
225  uint8_t *side_data = NULL;
226  size_t side_data_size;
227 
228  ret = decode_frame(avctx, &ctx->decoder, avpkt->data, avpkt->size);
229  if (ret)
230  return ret;
231 
232  side_data = av_packet_get_side_data(avpkt,
234  &side_data_size);
235  if (side_data_size >= 8) {
236  const uint64_t additional_id = AV_RB64(side_data);
237  side_data += 8;
238  side_data_size -= 8;
239  if (additional_id == 1) { // 1 stands for alpha channel data.
240  if (!ctx->has_alpha_channel) {
241  ctx->has_alpha_channel = 1;
242  ret = vpx_init(avctx,
243  &ctx->decoder_alpha,
244 #if CONFIG_LIBVPX_VP8_DECODER && CONFIG_LIBVPX_VP9_DECODER
245  (avctx->codec_id == AV_CODEC_ID_VP8) ?
246  vpx_codec_vp8_dx() : vpx_codec_vp9_dx()
247 #elif CONFIG_LIBVPX_VP8_DECODER
248  vpx_codec_vp8_dx()
249 #else
250  vpx_codec_vp9_dx()
251 #endif
252  );
253  if (ret)
254  return ret;
255  }
256  ret = decode_frame(avctx, &ctx->decoder_alpha, side_data,
257  side_data_size);
258  if (ret)
259  return ret;
260  }
261  }
262 
263  if ((img = vpx_codec_get_frame(&ctx->decoder, &iter)) &&
264  (!ctx->has_alpha_channel ||
265  (img_alpha = vpx_codec_get_frame(&ctx->decoder_alpha, &iter_alpha)))) {
266  uint8_t *planes[4];
267  int linesizes[4];
268 
269  if (img->d_w > img->w || img->d_h > img->h) {
270  av_log(avctx, AV_LOG_ERROR, "Display dimensions %dx%d exceed storage %dx%d\n",
271  img->d_w, img->d_h, img->w, img->h);
272  return AVERROR_EXTERNAL;
273  }
274 
275  if ((ret = set_pix_fmt(avctx, img, ctx->has_alpha_channel)) < 0) {
276  av_log(avctx, AV_LOG_ERROR, "Unsupported output colorspace (%d) / bit_depth (%d)\n",
277  img->fmt, img->bit_depth);
278  return ret;
279  }
280 
281  if ((int) img->d_w != avctx->width || (int) img->d_h != avctx->height) {
282  av_log(avctx, AV_LOG_INFO, "dimension change! %dx%d -> %dx%d\n",
283  avctx->width, avctx->height, img->d_w, img->d_h);
284  ret = ff_set_dimensions(avctx, img->d_w, img->d_h);
285  if (ret < 0)
286  return ret;
287  }
288 
289  if (ctx->has_alpha_channel &&
290  (img->d_w != img_alpha->d_w ||
291  img->d_h != img_alpha->d_h ||
292  img->bit_depth != img_alpha->bit_depth)) {
293  av_log(avctx, AV_LOG_ERROR,
294  "Video dimensions %dx%d@%dbpc differ from alpha dimensions %dx%d@%dbpc\n",
295  img->d_w, img->d_h, img->bit_depth,
296  img_alpha->d_w, img_alpha->d_h, img_alpha->bit_depth);
297  return AVERROR_INVALIDDATA;
298  }
299 
300  planes[0] = img->planes[VPX_PLANE_Y];
301  planes[1] = img->planes[VPX_PLANE_U];
302  planes[2] = img->planes[VPX_PLANE_V];
303  planes[3] =
304  ctx->has_alpha_channel ? img_alpha->planes[VPX_PLANE_Y] : NULL;
305  linesizes[0] = img->stride[VPX_PLANE_Y];
306  linesizes[1] = img->stride[VPX_PLANE_U];
307  linesizes[2] = img->stride[VPX_PLANE_V];
308  linesizes[3] =
309  ctx->has_alpha_channel ? img_alpha->stride[VPX_PLANE_Y] : 0;
310 
311  if (img->fb_priv && (!ctx->has_alpha_channel || img_alpha->fb_priv)) {
312  ret = ff_decode_frame_props(avctx, picture);
313  if (ret < 0)
314  return ret;
315  picture->buf[0] = av_buffer_ref(img->fb_priv);
316  if (!picture->buf[0])
317  return AVERROR(ENOMEM);
318  if (ctx->has_alpha_channel) {
319  picture->buf[1] = av_buffer_ref(img_alpha->fb_priv);
320  if (!picture->buf[1])
321  return AVERROR(ENOMEM);
322  }
323  for (int i = 0; i < 4; i++) {
324  picture->data[i] = planes[i];
325  picture->linesize[i] = linesizes[i];
326  }
327  } else {
328  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
329  return ret;
330  av_image_copy2(picture->data, picture->linesize, planes,
331  linesizes, avctx->pix_fmt, img->d_w, img->d_h);
332  }
333  *got_frame = 1;
334  }
335  return avpkt->size;
336 }
337 
338 static av_cold int vpx_free(AVCodecContext *avctx)
339 {
340  VPxContext *ctx = avctx->priv_data;
341  vpx_codec_destroy(&ctx->decoder);
342  if (ctx->has_alpha_channel)
343  vpx_codec_destroy(&ctx->decoder_alpha);
344  av_buffer_pool_uninit(&ctx->pool);
345  return 0;
346 }
347 
348 #if CONFIG_LIBVPX_VP8_DECODER
349 static av_cold int vp8_init(AVCodecContext *avctx)
350 {
351  VPxContext *ctx = avctx->priv_data;
352  return vpx_init(avctx, &ctx->decoder, vpx_codec_vp8_dx());
353 }
354 
356  .p.name = "libvpx",
357  CODEC_LONG_NAME("libvpx VP8"),
358  .p.type = AVMEDIA_TYPE_VIDEO,
359  .p.id = AV_CODEC_ID_VP8,
360  .p.capabilities = AV_CODEC_CAP_OTHER_THREADS | AV_CODEC_CAP_DR1,
361  .p.wrapper_name = "libvpx",
362  .priv_data_size = sizeof(VPxContext),
363  .init = vp8_init,
364  .close = vpx_free,
366  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
368 };
369 #endif /* CONFIG_LIBVPX_VP8_DECODER */
370 
371 #if CONFIG_LIBVPX_VP9_DECODER
372 static av_cold int vp9_init(AVCodecContext *avctx)
373 {
374  VPxContext *ctx = avctx->priv_data;
375  return vpx_init(avctx, &ctx->decoder, vpx_codec_vp9_dx());
376 }
377 
379  .p.name = "libvpx-vp9",
380  CODEC_LONG_NAME("libvpx VP9"),
381  .p.type = AVMEDIA_TYPE_VIDEO,
382  .p.id = AV_CODEC_ID_VP9,
383  .p.capabilities = AV_CODEC_CAP_OTHER_THREADS,
384  .p.profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),
385  .p.wrapper_name = "libvpx",
386  .priv_data_size = sizeof(VPxContext),
387  .init = vp9_init,
388  .close = vpx_free,
390  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
392 };
393 #endif /* CONFIG_LIBVPX_VP9_DECODER */
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
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:283
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:200
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:691
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:88
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_PROFILE_VP9_1
#define AV_PROFILE_VP9_1
Definition: defs.h:155
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:717
AVPacket::data
uint8_t * data
Definition: packet.h:539
release_frame_buffer
static int release_frame_buffer(void *priv, vpx_codec_frame_buffer_t *fb)
Definition: libvpxdec.c:79
data
const char data[16]
Definition: mxf.c:149
planes
static const struct @467 planes[]
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:502
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:35
FFCodec
Definition: codec_internal.h:127
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
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:641
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
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:602
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:94
VPxDecoderContext
Definition: libvpxdec.c:43
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
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:646
AVCOL_SPC_RESERVED
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition: pixfmt.h:644
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:331
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1593
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:518
set_pix_fmt
static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img, int has_alpha_channel)
Definition: libvpxdec.c:111
AV_PROFILE_VP9_3
#define AV_PROFILE_VP9_3
Definition: defs.h:157
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:505
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_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:390
VPxDecoderContext::has_alpha_channel
int has_alpha_channel
Definition: libvpxdec.c:48
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
intreadwrite.h
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:108
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:647
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:222
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:124
ff_libvpx_vp9_decoder
const FFCodec ff_libvpx_vp9_decoder
ctx
AVFormatContext * ctx
Definition: movenc.c:49
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:73
MAX_VPX_THREADS
#define MAX_VPX_THREADS
Definition: libvpx.h:24
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
vpx_decode
static int vpx_decode(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition: libvpxdec.c:217
NULL
#define NULL
Definition: coverity.c:32
VPxDecoderContext::pool
AVBufferPool * pool
Definition: libvpxdec.c:46
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:701
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:328
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:504
vpx_free
static av_cold int vpx_free(AVCodecContext *avctx)
Definition: libvpxdec.c:338
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:503
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:221
VPxDecoderContext::decoder
struct vpx_codec_ctx decoder
Definition: libvpxdec.c:44
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1697
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:540
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:94
codec_internal.h
cpu.h
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:507
vpx_init
static av_cold int vpx_init(AVCodecContext *avctx, struct vpx_codec_ctx *decoder, const struct vpx_codec_iface *iface)
Definition: libvpxdec.c:86
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:509
img
#define img
Definition: vf_colormatrix.c:114
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:220
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:648
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:651
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: packet.c:252
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:519
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:640
common.h
fb
#define fb(width, name)
Definition: cbs_av1.c:593
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
VPxDecoderContext::decoder_alpha
struct vpx_codec_ctx decoder_alpha
Definition: libvpxdec.c:45
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:643
AVCodecContext::height
int height
Definition: avcodec.h:624
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:700
avcodec.h
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
@ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
Data found in BlockAdditional element of matroska container.
Definition: packet.h:188
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
AV_PROFILE_VP9_2
#define AV_PROFILE_VP9_2
Definition: defs.h:156
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:506
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:1564
AVCodecContext
main external API structure.
Definition: avcodec.h:451
av_image_copy2
static void av_image_copy2(uint8_t *const dst_data[4], const int dst_linesizes[4], uint8_t *const src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Wrapper around av_image_copy() to workaround the limitation that the conversion from uint8_t * const ...
Definition: imgutils.h:184
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1650
get_frame_buffer
static int get_frame_buffer(void *priv, size_t min_size, vpx_codec_frame_buffer_t *fb)
Definition: libvpxdec.c:52
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:78
AV_PROFILE_VP9_0
#define AV_PROFILE_VP9_0
Definition: defs.h:154
VPxDecoderContext::pool_size
size_t pool_size
Definition: libvpxdec.c:47
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
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:77
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:73
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
imgutils.h
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
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:434
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:508
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:642
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:682
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:155