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(), 16)
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 = FF_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 = FF_PROFILE_VP9_1;
137  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
138  return 0;
139  case VPX_IMG_FMT_I440:
140  avctx->profile = FF_PROFILE_VP9_1;
141  avctx->pix_fmt = AV_PIX_FMT_YUV440P;
142  return 0;
143  case VPX_IMG_FMT_I444:
144  avctx->profile = FF_PROFILE_VP9_1;
145  avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
147  return 0;
148  case VPX_IMG_FMT_I42016:
149  avctx->profile = FF_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 = FF_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 = FF_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 = FF_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  av_frame_unref(picture);
322  return AVERROR(ENOMEM);
323  }
324  }
325  for (int i = 0; i < 4; i++) {
326  picture->data[i] = planes[i];
327  picture->linesize[i] = linesizes[i];
328  }
329  } else {
330  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
331  return ret;
332  av_image_copy(picture->data, picture->linesize, (const uint8_t**)planes,
333  linesizes, avctx->pix_fmt, img->d_w, img->d_h);
334  }
335  *got_frame = 1;
336  }
337  return avpkt->size;
338 }
339 
340 static av_cold int vpx_free(AVCodecContext *avctx)
341 {
342  VPxContext *ctx = avctx->priv_data;
343  vpx_codec_destroy(&ctx->decoder);
344  if (ctx->has_alpha_channel)
345  vpx_codec_destroy(&ctx->decoder_alpha);
346  av_buffer_pool_uninit(&ctx->pool);
347  return 0;
348 }
349 
350 #if CONFIG_LIBVPX_VP8_DECODER
351 static av_cold int vp8_init(AVCodecContext *avctx)
352 {
353  VPxContext *ctx = avctx->priv_data;
354  return vpx_init(avctx, &ctx->decoder, vpx_codec_vp8_dx());
355 }
356 
358  .p.name = "libvpx",
359  CODEC_LONG_NAME("libvpx VP8"),
360  .p.type = AVMEDIA_TYPE_VIDEO,
361  .p.id = AV_CODEC_ID_VP8,
362  .p.capabilities = AV_CODEC_CAP_OTHER_THREADS | AV_CODEC_CAP_DR1,
363  .p.wrapper_name = "libvpx",
364  .priv_data_size = sizeof(VPxContext),
365  .init = vp8_init,
366  .close = vpx_free,
368  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
370 };
371 #endif /* CONFIG_LIBVPX_VP8_DECODER */
372 
373 #if CONFIG_LIBVPX_VP9_DECODER
374 static av_cold int vp9_init(AVCodecContext *avctx)
375 {
376  VPxContext *ctx = avctx->priv_data;
377  return vpx_init(avctx, &ctx->decoder, vpx_codec_vp9_dx());
378 }
379 
381  .p.name = "libvpx-vp9",
382  CODEC_LONG_NAME("libvpx VP9"),
383  .p.type = AVMEDIA_TYPE_VIDEO,
384  .p.id = AV_CODEC_ID_VP9,
385  .p.capabilities = AV_CODEC_CAP_OTHER_THREADS,
386  .p.profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),
387  .p.wrapper_name = "libvpx",
388  .priv_data_size = sizeof(VPxContext),
389  .init = vp9_init,
390  .close = vpx_free,
392  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
394  .init_static_data = ff_vp9_init_static,
395 };
396 #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:200
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:1633
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:661
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:79
data
const char data[16]
Definition: mxf.c:146
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:459
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:34
FFCodec
Definition: codec_internal.h:119
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:588
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
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:91
VPxDecoderContext
Definition: libvpxdec.c:43
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
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:593
AVCOL_SPC_RESERVED
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition: pixfmt.h:591
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:331
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1466
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:475
set_pix_fmt
static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img, int has_alpha_channel)
Definition: libvpxdec.c:111
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:462
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:48
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
intreadwrite.h
FF_PROFILE_VP9_3
#define FF_PROFILE_VP9_3
Definition: avcodec.h:1636
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:594
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
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
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
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
planes
static const struct @345 planes[]
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:408
FF_PROFILE_VP9_2
#define FF_PROFILE_VP9_2
Definition: avcodec.h:1635
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: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:461
vpx_free
static av_cold int vpx_free(AVCodecContext *avctx)
Definition: libvpxdec.c:340
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:460
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:206
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:1420
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:115
codec_internal.h
cpu.h
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:464
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:466
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:595
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:598
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:476
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:587
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:45
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:590
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:644
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:1634
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:463
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:1264
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:1550
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:71
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: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
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
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: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: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:465
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:589
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:626
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