/* * Copyright (c) 2010, Google, Inc. * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /** * @file * VP8/9 decoder support via libvpx */ #define VPX_CODEC_DISABLE_COMPAT 1 #include <vpx/vpx_decoder.h> #include <vpx/vpx_frame_buffer.h> #include <vpx/vp8dx.h> #include "libavutil/common.h" #include "libavutil/cpu.h" #include "libavutil/imgutils.h" #include "libavutil/intreadwrite.h" #include "avcodec.h" #include "decode.h" #include "internal.h" #include "libvpx.h" #include "profiles.h" typedef struct VPxDecoderContext { struct vpx_codec_ctx decoder; struct vpx_codec_ctx decoder_alpha; AVBufferPool *pool; size_t pool_size; int has_alpha_channel; } VPxContext; static int get_frame_buffer(void *priv, size_t min_size, vpx_codec_frame_buffer_t *fb) { VPxContext *ctx = priv; AVBufferRef *buf; if (min_size > ctx->pool_size) { av_buffer_pool_uninit(&ctx->pool); /* According to the libvpx docs the buffer must be zeroed out. */ ctx->pool = av_buffer_pool_init(min_size, av_buffer_allocz); if (!ctx->pool) { ctx->pool_size = 0; return AVERROR(ENOMEM); } ctx->pool_size = min_size; } buf = av_buffer_pool_get(ctx->pool); if (!buf) return AVERROR(ENOMEM); fb->priv = buf; fb->size = ctx->pool_size; fb->data = buf->data; return 0; } static int release_frame_buffer(void *priv, vpx_codec_frame_buffer_t *fb) { AVBufferRef *buf = fb->priv; av_buffer_unref(&buf); return 0; } static av_cold int vpx_init(AVCodecContext *avctx, struct vpx_codec_ctx* decoder, const struct vpx_codec_iface *iface) { struct vpx_codec_dec_cfg deccfg = { .threads = FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), 16) }; av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str()); av_log(avctx, AV_LOG_VERBOSE, "%s\n", vpx_codec_build_config()); if (vpx_codec_dec_init(decoder, iface, &deccfg, 0) != VPX_CODEC_OK) { const char *error = vpx_codec_error(decoder); av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder: %s\n", error); return AVERROR(EINVAL); } if (avctx->codec_id == AV_CODEC_ID_VP9) vpx_codec_set_frame_buffer_functions(decoder, get_frame_buffer, release_frame_buffer, avctx->priv_data); return 0; } // returns 0 on success, AVERROR_INVALIDDATA otherwise static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img, int has_alpha_channel) { static const enum AVColorSpace colorspaces[8] = { AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M, AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB, }; #if VPX_IMAGE_ABI_VERSION >= 4 static const enum AVColorRange color_ranges[] = { AVCOL_RANGE_MPEG, AVCOL_RANGE_JPEG }; avctx->color_range = color_ranges[img->range]; #endif avctx->colorspace = colorspaces[img->cs]; if (avctx->codec_id == AV_CODEC_ID_VP8 && img->fmt != VPX_IMG_FMT_I420) return AVERROR_INVALIDDATA; switch (img->fmt) { case VPX_IMG_FMT_I420: if (avctx->codec_id == AV_CODEC_ID_VP9) avctx->profile = FF_PROFILE_VP9_0; avctx->pix_fmt = has_alpha_channel ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P; return 0; #if CONFIG_LIBVPX_VP9_DECODER case VPX_IMG_FMT_I422: avctx->profile = FF_PROFILE_VP9_1; avctx->pix_fmt = AV_PIX_FMT_YUV422P; return 0; case VPX_IMG_FMT_I440: avctx->profile = FF_PROFILE_VP9_1; avctx->pix_fmt = AV_PIX_FMT_YUV440P; return 0; case VPX_IMG_FMT_I444: avctx->profile = FF_PROFILE_VP9_1; avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ? AV_PIX_FMT_GBRP : AV_PIX_FMT_YUV444P; return 0; case VPX_IMG_FMT_I42016: avctx->profile = FF_PROFILE_VP9_2; if (img->bit_depth == 10) { avctx->pix_fmt = AV_PIX_FMT_YUV420P10; return 0; } else if (img->bit_depth == 12) { avctx->pix_fmt = AV_PIX_FMT_YUV420P12; return 0; } else { return AVERROR_INVALIDDATA; } case VPX_IMG_FMT_I42216: avctx->profile = FF_PROFILE_VP9_3; if (img->bit_depth == 10) { avctx->pix_fmt = AV_PIX_FMT_YUV422P10; return 0; } else if (img->bit_depth == 12) { avctx->pix_fmt = AV_PIX_FMT_YUV422P12; return 0; } else { return AVERROR_INVALIDDATA; } case VPX_IMG_FMT_I44016: avctx->profile = FF_PROFILE_VP9_3; if (img->bit_depth == 10) { avctx->pix_fmt = AV_PIX_FMT_YUV440P10; return 0; } else if (img->bit_depth == 12) { avctx->pix_fmt = AV_PIX_FMT_YUV440P12; return 0; } else { return AVERROR_INVALIDDATA; } case VPX_IMG_FMT_I44416: avctx->profile = FF_PROFILE_VP9_3; if (img->bit_depth == 10) { avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ? AV_PIX_FMT_GBRP10 : AV_PIX_FMT_YUV444P10; return 0; } else if (img->bit_depth == 12) { avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ? AV_PIX_FMT_GBRP12 : AV_PIX_FMT_YUV444P12; return 0; } else { return AVERROR_INVALIDDATA; } #endif default: return AVERROR_INVALIDDATA; } } static int decode_frame(AVCodecContext *avctx, vpx_codec_ctx_t *decoder, uint8_t *data, uint32_t data_sz) { if (vpx_codec_decode(decoder, data, data_sz, NULL, 0) != VPX_CODEC_OK) { const char *error = vpx_codec_error(decoder); const char *detail = vpx_codec_error_detail(decoder); av_log(avctx, AV_LOG_ERROR, "Failed to decode frame: %s\n", error); if (detail) { av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail); } return AVERROR_INVALIDDATA; } return 0; } static int vpx_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt) { VPxContext *ctx = avctx->priv_data; AVFrame *picture = data; const void *iter = NULL; const void *iter_alpha = NULL; struct vpx_image *img, *img_alpha; int ret; uint8_t *side_data = NULL; size_t side_data_size; ret = decode_frame(avctx, &ctx->decoder, avpkt->data, avpkt->size); if (ret) return ret; side_data = av_packet_get_side_data(avpkt, AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, &side_data_size); if (side_data_size >= 8) { const uint64_t additional_id = AV_RB64(side_data); side_data += 8; side_data_size -= 8; if (additional_id == 1) { // 1 stands for alpha channel data. if (!ctx->has_alpha_channel) { ctx->has_alpha_channel = 1; ret = vpx_init(avctx, &ctx->decoder_alpha, #if CONFIG_LIBVPX_VP8_DECODER && CONFIG_LIBVPX_VP9_DECODER (avctx->codec_id == AV_CODEC_ID_VP8) ? vpx_codec_vp8_dx() : vpx_codec_vp9_dx() #elif CONFIG_LIBVPX_VP8_DECODER vpx_codec_vp8_dx() #else vpx_codec_vp9_dx() #endif ); if (ret) return ret; } ret = decode_frame(avctx, &ctx->decoder_alpha, side_data, side_data_size); if (ret) return ret; } } if ((img = vpx_codec_get_frame(&ctx->decoder, &iter)) && (!ctx->has_alpha_channel || (img_alpha = vpx_codec_get_frame(&ctx->decoder_alpha, &iter_alpha)))) { uint8_t *planes[4]; int linesizes[4]; if (img->d_w > img->w || img->d_h > img->h) { av_log(avctx, AV_LOG_ERROR, "Display dimensions %dx%d exceed storage %dx%d\n", img->d_w, img->d_h, img->w, img->h); return AVERROR_EXTERNAL; } if ((ret = set_pix_fmt(avctx, img, ctx->has_alpha_channel)) < 0) { av_log(avctx, AV_LOG_ERROR, "Unsupported output colorspace (%d) / bit_depth (%d)\n", img->fmt, img->bit_depth); return ret; } if ((int) img->d_w != avctx->width || (int) img->d_h != avctx->height) { av_log(avctx, AV_LOG_INFO, "dimension change! %dx%d -> %dx%d\n", avctx->width, avctx->height, img->d_w, img->d_h); ret = ff_set_dimensions(avctx, img->d_w, img->d_h); if (ret < 0) return ret; } if (ctx->has_alpha_channel && (img->d_w != img_alpha->d_w || img->d_h != img_alpha->d_h || img->bit_depth != img_alpha->bit_depth)) { av_log(avctx, AV_LOG_ERROR, "Video dimensions %dx%d@%dbpc differ from alpha dimensions %dx%d@%dbpc\n", img->d_w, img->d_h, img->bit_depth, img_alpha->d_w, img_alpha->d_h, img_alpha->bit_depth); return AVERROR_INVALIDDATA; } planes[0] = img->planes[VPX_PLANE_Y]; planes[1] = img->planes[VPX_PLANE_U]; planes[2] = img->planes[VPX_PLANE_V]; planes[3] = ctx->has_alpha_channel ? img_alpha->planes[VPX_PLANE_Y] : NULL; linesizes[0] = img->stride[VPX_PLANE_Y]; linesizes[1] = img->stride[VPX_PLANE_U]; linesizes[2] = img->stride[VPX_PLANE_V]; linesizes[3] = ctx->has_alpha_channel ? img_alpha->stride[VPX_PLANE_Y] : 0; if (img->fb_priv && (!ctx->has_alpha_channel || img_alpha->fb_priv)) { ret = ff_decode_frame_props(avctx, picture); if (ret < 0) return ret; picture->buf[0] = av_buffer_ref(img->fb_priv); if (!picture->buf[0]) return AVERROR(ENOMEM); if (ctx->has_alpha_channel) { picture->buf[1] = av_buffer_ref(img_alpha->fb_priv); if (!picture->buf[1]) { av_frame_unref(picture); return AVERROR(ENOMEM); } } for (int i = 0; i < 4; i++) { picture->data[i] = planes[i]; picture->linesize[i] = linesizes[i]; } } else { if ((ret = ff_get_buffer(avctx, picture, 0)) < 0) return ret; av_image_copy(picture->data, picture->linesize, (const uint8_t**)planes, linesizes, avctx->pix_fmt, img->d_w, img->d_h); } *got_frame = 1; } return avpkt->size; } static av_cold int vpx_free(AVCodecContext *avctx) { VPxContext *ctx = avctx->priv_data; vpx_codec_destroy(&ctx->decoder); if (ctx->has_alpha_channel) vpx_codec_destroy(&ctx->decoder_alpha); av_buffer_pool_uninit(&ctx->pool); return 0; } #if CONFIG_LIBVPX_VP8_DECODER static av_cold int vp8_init(AVCodecContext *avctx) { VPxContext *ctx = avctx->priv_data; return vpx_init(avctx, &ctx->decoder, vpx_codec_vp8_dx()); } const AVCodec ff_libvpx_vp8_decoder = { .name = "libvpx", .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"), .type = AVMEDIA_TYPE_VIDEO, .id = AV_CODEC_ID_VP8, .priv_data_size = sizeof(VPxContext), .init = vp8_init, .close = vpx_free, .decode = vpx_decode, .capabilities = AV_CODEC_CAP_OTHER_THREADS | AV_CODEC_CAP_DR1, .caps_internal = FF_CODEC_CAP_AUTO_THREADS, .wrapper_name = "libvpx", }; #endif /* CONFIG_LIBVPX_VP8_DECODER */ #if CONFIG_LIBVPX_VP9_DECODER static av_cold int vp9_init(AVCodecContext *avctx) { VPxContext *ctx = avctx->priv_data; return vpx_init(avctx, &ctx->decoder, vpx_codec_vp9_dx()); } AVCodec ff_libvpx_vp9_decoder = { .name = "libvpx-vp9", .long_name = NULL_IF_CONFIG_SMALL("libvpx VP9"), .type = AVMEDIA_TYPE_VIDEO, .id = AV_CODEC_ID_VP9, .priv_data_size = sizeof(VPxContext), .init = vp9_init, .close = vpx_free, .decode = vpx_decode, .capabilities = AV_CODEC_CAP_OTHER_THREADS, .caps_internal = FF_CODEC_CAP_AUTO_THREADS, .init_static_data = ff_vp9_init_static, .profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles), .wrapper_name = "libvpx", }; #endif /* CONFIG_LIBVPX_VP9_DECODER */