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 #define VPX_CODEC_DISABLE_COMPAT 1
27 #include <vpx/vpx_decoder.h>
28 #include <vpx/vpx_frame_buffer.h>
29 #include <vpx/vp8dx.h>
30 
31 #include "libavutil/common.h"
32 #include "libavutil/cpu.h"
33 #include "libavutil/imgutils.h"
34 #include "libavutil/intreadwrite.h"
35 #include "avcodec.h"
36 #include "decode.h"
37 #include "internal.h"
38 #include "libvpx.h"
39 #include "profiles.h"
40 
41 typedef struct VPxDecoderContext {
42  struct vpx_codec_ctx decoder;
43  struct vpx_codec_ctx decoder_alpha;
45  size_t pool_size;
47 } VPxContext;
48 
49 
50 static int get_frame_buffer(void *priv, size_t min_size, vpx_codec_frame_buffer_t *fb)
51 {
52  VPxContext *ctx = priv;
53  AVBufferRef *buf;
54 
55  if (min_size > ctx->pool_size) {
56  av_buffer_pool_uninit(&ctx->pool);
57  /* According to the libvpx docs the buffer must be zeroed out. */
58  ctx->pool = av_buffer_pool_init(min_size, av_buffer_allocz);
59  if (!ctx->pool) {
60  ctx->pool_size = 0;
61  return AVERROR(ENOMEM);
62  }
63  ctx->pool_size = min_size;
64  }
65 
66  buf = av_buffer_pool_get(ctx->pool);
67  if (!buf)
68  return AVERROR(ENOMEM);
69 
70  fb->priv = buf;
71  fb->size = ctx->pool_size;
72  fb->data = buf->data;
73 
74  return 0;
75 }
76 
77 static int release_frame_buffer(void *priv, vpx_codec_frame_buffer_t *fb)
78 {
79  AVBufferRef *buf = fb->priv;
80  av_buffer_unref(&buf);
81  return 0;
82 }
83 
84 static av_cold int vpx_init(AVCodecContext *avctx,
85  struct vpx_codec_ctx* decoder,
86  const struct vpx_codec_iface *iface)
87 {
88  struct vpx_codec_dec_cfg deccfg = {
89  .threads = FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), 16)
90  };
91 
92  av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str());
93  av_log(avctx, AV_LOG_VERBOSE, "%s\n", vpx_codec_build_config());
94 
95  if (vpx_codec_dec_init(decoder, iface, &deccfg, 0) != VPX_CODEC_OK) {
96  const char *error = vpx_codec_error(decoder);
97  av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder: %s\n",
98  error);
99  return AVERROR(EINVAL);
100  }
101 
102  if (avctx->codec_id == AV_CODEC_ID_VP9)
103  vpx_codec_set_frame_buffer_functions(decoder, get_frame_buffer, release_frame_buffer, avctx->priv_data);
104 
105  return 0;
106 }
107 
108 // returns 0 on success, AVERROR_INVALIDDATA otherwise
109 static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img,
110  int has_alpha_channel)
111 {
112  static const enum AVColorSpace colorspaces[8] = {
115  };
116 #if VPX_IMAGE_ABI_VERSION >= 4
117  static const enum AVColorRange color_ranges[] = {
119  };
120  avctx->color_range = color_ranges[img->range];
121 #endif
122  avctx->colorspace = colorspaces[img->cs];
123  if (avctx->codec_id == AV_CODEC_ID_VP8 && img->fmt != VPX_IMG_FMT_I420)
124  return AVERROR_INVALIDDATA;
125  switch (img->fmt) {
126  case VPX_IMG_FMT_I420:
127  if (avctx->codec_id == AV_CODEC_ID_VP9)
128  avctx->profile = FF_PROFILE_VP9_0;
129  avctx->pix_fmt =
130  has_alpha_channel ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
131  return 0;
132 #if CONFIG_LIBVPX_VP9_DECODER
133  case VPX_IMG_FMT_I422:
134  avctx->profile = FF_PROFILE_VP9_1;
135  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
136  return 0;
137  case VPX_IMG_FMT_I440:
138  avctx->profile = FF_PROFILE_VP9_1;
139  avctx->pix_fmt = AV_PIX_FMT_YUV440P;
140  return 0;
141  case VPX_IMG_FMT_I444:
142  avctx->profile = FF_PROFILE_VP9_1;
143  avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
145  return 0;
146  case VPX_IMG_FMT_I42016:
147  avctx->profile = FF_PROFILE_VP9_2;
148  if (img->bit_depth == 10) {
149  avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
150  return 0;
151  } else if (img->bit_depth == 12) {
152  avctx->pix_fmt = AV_PIX_FMT_YUV420P12;
153  return 0;
154  } else {
155  return AVERROR_INVALIDDATA;
156  }
157  case VPX_IMG_FMT_I42216:
158  avctx->profile = FF_PROFILE_VP9_3;
159  if (img->bit_depth == 10) {
160  avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
161  return 0;
162  } else if (img->bit_depth == 12) {
163  avctx->pix_fmt = AV_PIX_FMT_YUV422P12;
164  return 0;
165  } else {
166  return AVERROR_INVALIDDATA;
167  }
168  case VPX_IMG_FMT_I44016:
169  avctx->profile = FF_PROFILE_VP9_3;
170  if (img->bit_depth == 10) {
171  avctx->pix_fmt = AV_PIX_FMT_YUV440P10;
172  return 0;
173  } else if (img->bit_depth == 12) {
174  avctx->pix_fmt = AV_PIX_FMT_YUV440P12;
175  return 0;
176  } else {
177  return AVERROR_INVALIDDATA;
178  }
179  case VPX_IMG_FMT_I44416:
180  avctx->profile = FF_PROFILE_VP9_3;
181  if (img->bit_depth == 10) {
182  avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
184  return 0;
185  } else if (img->bit_depth == 12) {
186  avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
188  return 0;
189  } else {
190  return AVERROR_INVALIDDATA;
191  }
192 #endif
193  default:
194  return AVERROR_INVALIDDATA;
195  }
196 }
197 
198 static int decode_frame(AVCodecContext *avctx, vpx_codec_ctx_t *decoder,
199  uint8_t *data, uint32_t data_sz)
200 {
201  if (vpx_codec_decode(decoder, data, data_sz, NULL, 0) != VPX_CODEC_OK) {
202  const char *error = vpx_codec_error(decoder);
203  const char *detail = vpx_codec_error_detail(decoder);
204 
205  av_log(avctx, AV_LOG_ERROR, "Failed to decode frame: %s\n", error);
206  if (detail) {
207  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n",
208  detail);
209  }
210  return AVERROR_INVALIDDATA;
211  }
212  return 0;
213 }
214 
215 static int vpx_decode(AVCodecContext *avctx,
216  void *data, int *got_frame, AVPacket *avpkt)
217 {
218  VPxContext *ctx = avctx->priv_data;
219  AVFrame *picture = data;
220  const void *iter = NULL;
221  const void *iter_alpha = NULL;
222  struct vpx_image *img, *img_alpha;
223  int ret;
224  uint8_t *side_data = NULL;
225  size_t side_data_size;
226 
227  ret = decode_frame(avctx, &ctx->decoder, avpkt->data, avpkt->size);
228  if (ret)
229  return ret;
230 
231  side_data = av_packet_get_side_data(avpkt,
233  &side_data_size);
234  if (side_data_size >= 8) {
235  const uint64_t additional_id = AV_RB64(side_data);
236  side_data += 8;
237  side_data_size -= 8;
238  if (additional_id == 1) { // 1 stands for alpha channel data.
239  if (!ctx->has_alpha_channel) {
240  ctx->has_alpha_channel = 1;
241  ret = vpx_init(avctx,
242  &ctx->decoder_alpha,
243 #if CONFIG_LIBVPX_VP8_DECODER && CONFIG_LIBVPX_VP9_DECODER
244  (avctx->codec_id == AV_CODEC_ID_VP8) ?
245  &vpx_codec_vp8_dx_algo : &vpx_codec_vp9_dx_algo
246 #elif CONFIG_LIBVPX_VP8_DECODER
247  &vpx_codec_vp8_dx_algo
248 #else
249  &vpx_codec_vp9_dx_algo
250 #endif
251  );
252  if (ret)
253  return ret;
254  }
255  ret = decode_frame(avctx, &ctx->decoder_alpha, side_data,
256  side_data_size);
257  if (ret)
258  return ret;
259  }
260  }
261 
262  if ((img = vpx_codec_get_frame(&ctx->decoder, &iter)) &&
263  (!ctx->has_alpha_channel ||
264  (img_alpha = vpx_codec_get_frame(&ctx->decoder_alpha, &iter_alpha)))) {
265  uint8_t *planes[4];
266  int linesizes[4];
267 
268  if (img->d_w > img->w || img->d_h > img->h) {
269  av_log(avctx, AV_LOG_ERROR, "Display dimensions %dx%d exceed storage %dx%d\n",
270  img->d_w, img->d_h, img->w, img->h);
271  return AVERROR_EXTERNAL;
272  }
273 
274  if ((ret = set_pix_fmt(avctx, img, ctx->has_alpha_channel)) < 0) {
275  av_log(avctx, AV_LOG_ERROR, "Unsupported output colorspace (%d) / bit_depth (%d)\n",
276  img->fmt, img->bit_depth);
277  return ret;
278  }
279 
280  if ((int) img->d_w != avctx->width || (int) img->d_h != avctx->height) {
281  av_log(avctx, AV_LOG_INFO, "dimension change! %dx%d -> %dx%d\n",
282  avctx->width, avctx->height, img->d_w, img->d_h);
283  ret = ff_set_dimensions(avctx, img->d_w, img->d_h);
284  if (ret < 0)
285  return ret;
286  }
287 
288  if (ctx->has_alpha_channel &&
289  (img->d_w != img_alpha->d_w ||
290  img->d_h != img_alpha->d_h ||
291  img->bit_depth != img_alpha->bit_depth)) {
292  av_log(avctx, AV_LOG_ERROR,
293  "Video dimensions %dx%d@%dbpc differ from alpha dimensions %dx%d@%dbpc\n",
294  img->d_w, img->d_h, img->bit_depth,
295  img_alpha->d_w, img_alpha->d_h, img_alpha->bit_depth);
296  return AVERROR_INVALIDDATA;
297  }
298 
299  planes[0] = img->planes[VPX_PLANE_Y];
300  planes[1] = img->planes[VPX_PLANE_U];
301  planes[2] = img->planes[VPX_PLANE_V];
302  planes[3] =
303  ctx->has_alpha_channel ? img_alpha->planes[VPX_PLANE_Y] : NULL;
304  linesizes[0] = img->stride[VPX_PLANE_Y];
305  linesizes[1] = img->stride[VPX_PLANE_U];
306  linesizes[2] = img->stride[VPX_PLANE_V];
307  linesizes[3] =
308  ctx->has_alpha_channel ? img_alpha->stride[VPX_PLANE_Y] : 0;
309 
310  if (img->fb_priv && (!ctx->has_alpha_channel || img_alpha->fb_priv)) {
311  ret = ff_decode_frame_props(avctx, picture);
312  if (ret < 0)
313  return ret;
314  picture->buf[0] = av_buffer_ref(img->fb_priv);
315  if (!picture->buf[0])
316  return AVERROR(ENOMEM);
317  if (ctx->has_alpha_channel) {
318  picture->buf[1] = av_buffer_ref(img_alpha->fb_priv);
319  if (!picture->buf[1]) {
320  av_frame_unref(picture);
321  return AVERROR(ENOMEM);
322  }
323  }
324  for (int i = 0; i < 4; i++) {
325  picture->data[i] = planes[i];
326  picture->linesize[i] = linesizes[i];
327  }
328  } else {
329  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
330  return ret;
331  av_image_copy(picture->data, picture->linesize, (const uint8_t**)planes,
332  linesizes, avctx->pix_fmt, img->d_w, img->d_h);
333  }
334  *got_frame = 1;
335  }
336  return avpkt->size;
337 }
338 
339 static av_cold int vpx_free(AVCodecContext *avctx)
340 {
341  VPxContext *ctx = avctx->priv_data;
342  vpx_codec_destroy(&ctx->decoder);
343  if (ctx->has_alpha_channel)
344  vpx_codec_destroy(&ctx->decoder_alpha);
345  av_buffer_pool_uninit(&ctx->pool);
346  return 0;
347 }
348 
349 #if CONFIG_LIBVPX_VP8_DECODER
350 static av_cold int vp8_init(AVCodecContext *avctx)
351 {
352  VPxContext *ctx = avctx->priv_data;
353  return vpx_init(avctx, &ctx->decoder, &vpx_codec_vp8_dx_algo);
354 }
355 
357  .name = "libvpx",
358  .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),
359  .type = AVMEDIA_TYPE_VIDEO,
360  .id = AV_CODEC_ID_VP8,
361  .priv_data_size = sizeof(VPxContext),
362  .init = vp8_init,
363  .close = vpx_free,
364  .decode = vpx_decode,
366  .caps_internal = FF_CODEC_CAP_AUTO_THREADS,
367  .wrapper_name = "libvpx",
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_algo);
376 }
377 
379  .name = "libvpx-vp9",
380  .long_name = NULL_IF_CONFIG_SMALL("libvpx VP9"),
381  .type = AVMEDIA_TYPE_VIDEO,
382  .id = AV_CODEC_ID_VP9,
383  .priv_data_size = sizeof(VPxContext),
384  .init = vp9_init,
385  .close = vpx_free,
386  .decode = vpx_decode,
387  .capabilities = AV_CODEC_CAP_OTHER_THREADS,
388  .caps_internal = FF_CODEC_CAP_AUTO_THREADS,
391  .wrapper_name = "libvpx",
392 };
393 #endif /* CONFIG_LIBVPX_VP9_DECODER */
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AVCodec
AVCodec.
Definition: codec.h:202
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
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
vp9_init
static av_cold int vp9_init(AVFormatContext *ctx, int st_index, PayloadContext *data)
Definition: rtpdec_vp9.c:34
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
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:960
FF_PROFILE_VP9_0
#define FF_PROFILE_VP9_0
Definition: avcodec.h:1608
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:89
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:303
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:576
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
release_frame_buffer
static int release_frame_buffer(void *priv, vpx_codec_frame_buffer_t *fb)
Definition: libvpxdec.c:77
data
const char data[16]
Definition: mxf.c:143
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:389
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:503
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:477
VPxDecoderContext
Definition: libvpxdec.c:41
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
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:508
AVCOL_SPC_RESERVED
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition: pixfmt.h:506
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:330
init_static_data
static av_cold void init_static_data(void)
Definition: mv30.c:660
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1440
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:405
set_pix_fmt
static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img, int has_alpha_channel)
Definition: libvpxdec.c:109
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:392
planes
static const struct @318 planes[]
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:387
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
VPxDecoderContext::has_alpha_channel
int has_alpha_channel
Definition: libvpxdec.c:46
intreadwrite.h
FF_PROFILE_VP9_3
#define FF_PROFILE_VP9_3
Definition: avcodec.h:1611
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:509
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:393
FF_PROFILE_VP9_2
#define FF_PROFILE_VP9_2
Definition: avcodec.h:1610
NULL
#define NULL
Definition: coverity.c:32
VPxDecoderContext::pool
AVBufferPool * pool
Definition: libvpxdec.c:44
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:967
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
ff_vp9_init_static
av_cold void ff_vp9_init_static(AVCodec *codec)
Definition: libvpx.c:68
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:391
vpx_free
static av_cold int vpx_free(AVCodecContext *avctx)
Definition: libvpxdec.c:339
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:390
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:185
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:81
VPxDecoderContext::decoder
struct vpx_codec_ctx decoder
Definition: libvpxdec.c:42
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
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:374
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
cpu.h
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:394
vpx_init
static av_cold int vpx_init(AVCodecContext *avctx, struct vpx_codec_ctx *decoder, const struct vpx_codec_iface *iface)
Definition: libvpxdec.c:84
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:396
img
#define img
Definition: vf_colormatrix.c:116
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
ff_libvpx_vp8_decoder
const AVCodec ff_libvpx_vp8_decoder
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:510
i
int i
Definition: input.c:406
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:513
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:246
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:406
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:502
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:437
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
VPxDecoderContext::decoder_alpha
struct vpx_codec_ctx decoder_alpha
Definition: libvpxdec.c:43
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:505
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:559
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:1609
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:393
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:1489
AVCodecContext
main external API structure.
Definition: avcodec.h:383
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
vpx_decode
static int vpx_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: libvpxdec.c:215
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1525
get_frame_buffer
static int get_frame_buffer(void *priv, size_t min_size, vpx_codec_frame_buffer_t *fb)
Definition: libvpxdec.c:50
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:429
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
decode_frame
static int decode_frame(AVCodecContext *avctx, vpx_codec_ctx_t *decoder, uint8_t *data, uint32_t data_sz)
Definition: libvpxdec.c:198
VPxDecoderContext::pool_size
size_t pool_size
Definition: libvpxdec.c:45
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
ff_libvpx_vp9_decoder
AVCodec ff_libvpx_vp9_decoder
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:86
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
@ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
Data found in BlockAdditional element of matroska container.
Definition: packet.h:191
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
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, size in bytes of each picture line.
Definition: frame.h:334
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:395
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:504
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:541
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