FFmpeg: libavcodec/libvpxdec.c Source File

FFmpeg

[フレーム]

libavcodec

libvpxdec.c

Go to the documentation of this file.

1 /*

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 */

21 /**

22 * @file

23 * VP8/9 decoder support via libvpx

24 */

26 #include "config_components.h"

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>

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"

43 typedef struct VPxDecoderContext {

44 struct vpx_codec_ctx decoder;

45 struct vpx_codec_ctx decoder_alpha;

46 AVBufferPool *pool;

47 size_t pool_size;

48 int has_alpha_channel;

49 } VPxContext;

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;

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 }

68 buf = av_buffer_pool_get(ctx->pool);

69 if (!buf)

70 return AVERROR(ENOMEM);

72 fb->priv = buf;

73 fb->size = ctx->pool_size;

74 fb->data = buf->data;

76 return 0;

77 }

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 }

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 };

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());

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] = {

115 AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M,

116 AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB,

117 };

118 #if VPX_IMAGE_ABI_VERSION >= 4

119 static const enum AVColorRange color_ranges[] = {

120 AVCOL_RANGE_MPEG, AVCOL_RANGE_JPEG

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 ?

146 AV_PIX_FMT_GBRP : AV_PIX_FMT_YUV444P;

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 ?

185 AV_PIX_FMT_GBRP10 : AV_PIX_FMT_YUV444P10;

186 return 0;

187 } else if (img->bit_depth == 12) {

188 avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?

189 AV_PIX_FMT_GBRP12 : AV_PIX_FMT_YUV444P12;

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,

233 AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,

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

355 const FFCodec ff_libvpx_vp8_decoder = {

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,

365 FF_CODEC_DECODE_CB(vpx_decode),

366 .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |

367 FF_CODEC_CAP_AUTO_THREADS,

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

378 const FFCodec ff_libvpx_vp9_decoder = {

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,

389 FF_CODEC_DECODE_CB(vpx_decode),

390 .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |

391 FF_CODEC_CAP_AUTO_THREADS,

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:686

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:148

AV_PIX_FMT_YUV420P10

#define AV_PIX_FMT_YUV420P10

Definition: pixfmt.h:478

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: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:610

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:615

AVCOL_SPC_RESERVED

@ AVCOL_SPC_RESERVED

reserved for future use by ITU-T and ISO/IEC just like 15-255 are

Definition: pixfmt.h:613

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:494

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:481

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: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:616

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: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:480

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:479

av_cpu_count

int av_cpu_count(void)

Definition: cpu.c:215

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:1719

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:483

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:485

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: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:617

#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:620

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:495

AVColorSpace

YUV colorspace type.

Definition: pixfmt.h:609

common.h

#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:612

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:669

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

Definition: filter_design.txt:187

AV_PIX_FMT_YUV420P12

#define AV_PIX_FMT_YUV420P12

Definition: pixfmt.h:482

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:1559

AVCodecContext

main external API structure.

Definition: avcodec.h:451

planes

static const struct @455 planes[]

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)