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 #define VPX_CODEC_DISABLE_COMPAT 1

27 #include <vpx/vpx_decoder.h>

28 #include <vpx/vpx_frame_buffer.h>

29 #include <vpx/vp8dx.h>

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"

41 typedef struct VPxDecoderContext {

42 struct vpx_codec_ctx decoder;

43 struct vpx_codec_ctx decoder_alpha;

44 AVBufferPool *pool;

45 size_t pool_size;

46 int has_alpha_channel;

47 } VPxContext;

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;

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 }

66 buf = av_buffer_pool_get(ctx->pool);

67 if (!buf)

68 return AVERROR(ENOMEM);

70 fb->priv = buf;

71 fb->size = ctx->pool_size;

72 fb->data = buf->data;

74 return 0;

75 }

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 }

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

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

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

113 AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M,

114 AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB,

115 };

116 #if VPX_IMAGE_ABI_VERSION >= 4

117 static const enum AVColorRange color_ranges[] = {

118 AVCOL_RANGE_MPEG, AVCOL_RANGE_JPEG

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 ?

144 AV_PIX_FMT_GBRP : AV_PIX_FMT_YUV444P;

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 ?

183 AV_PIX_FMT_GBRP10 : AV_PIX_FMT_YUV444P10;

184 return 0;

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

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

187 AV_PIX_FMT_GBRP12 : AV_PIX_FMT_YUV444P12;

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,

232 AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,

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() : vpx_codec_vp9_dx()

246 #elif CONFIG_LIBVPX_VP8_DECODER

247 vpx_codec_vp8_dx()

248 #else

249 vpx_codec_vp9_dx()

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

354 }

355

356 const AVCodec ff_libvpx_vp8_decoder = {

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,

365 .capabilities = AV_CODEC_CAP_OTHER_THREADS | AV_CODEC_CAP_DR1,

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

376 }

377

378 AVCodec ff_libvpx_vp9_decoder = {

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,

389 .init_static_data = ff_vp9_init_static,

390 .profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),

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

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

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:597

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

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

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

VPxDecoderContext

Definition: libvpxdec.c:41

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:338

init

static int init

Definition: av_tx.c:47

AVCOL_SPC_BT470BG

@ AVCOL_SPC_BT470BG

also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601

Definition: pixfmt.h:529

AVCOL_SPC_RESERVED

@ AVCOL_SPC_RESERVED

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

Definition: pixfmt.h:527

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

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

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

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

planes

static const struct @321 planes[]

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

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

av_cpu_count

int av_cpu_count(void)

Definition: cpu.c:191

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

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

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

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:271

AVCOL_SPC_BT2020_NCL

@ AVCOL_SPC_BT2020_NCL

ITU-R BT2020 non-constant luminance system.

Definition: pixfmt.h:534

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

AV_PIX_FMT_GBRP12

#define AV_PIX_FMT_GBRP12

Definition: pixfmt.h:421

AVColorSpace

YUV colorspace type.

Definition: pixfmt.h:523

common.h

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

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

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

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

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

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