| /* | |
| * 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 | |
| */ | |
| #include "config_components.h" | |
| #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 "codec_internal.h" | |
| #include "decode.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(), MAX_VPX_THREADS) | |
| }; | |
| 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 = AV_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 = AV_PROFILE_VP9_1; | |
| avctx->pix_fmt = AV_PIX_FMT_YUV422P; | |
| return 0; | |
| case VPX_IMG_FMT_I440: | |
| avctx->profile = AV_PROFILE_VP9_1; | |
| avctx->pix_fmt = AV_PIX_FMT_YUV440P; | |
| return 0; | |
| case VPX_IMG_FMT_I444: | |
| avctx->profile = AV_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 = AV_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 = AV_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 = AV_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 = AV_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, | |
| const 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, AVFrame *picture, | |
| int *got_frame, AVPacket *avpkt) | |
| { | |
| VPxContext *ctx = avctx->priv_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]) | |
| 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_copy2(picture->data, picture->linesize, 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 FFCodec ff_libvpx_vp8_decoder = { | |
| .p.name = "libvpx", | |
| CODEC_LONG_NAME("libvpx VP8"), | |
| .p.type = AVMEDIA_TYPE_VIDEO, | |
| .p.id = AV_CODEC_ID_VP8, | |
| .p.capabilities = AV_CODEC_CAP_OTHER_THREADS | AV_CODEC_CAP_DR1, | |
| .p.wrapper_name = "libvpx", | |
| .priv_data_size = sizeof(VPxContext), | |
| .init = vp8_init, | |
| .close = vpx_free, | |
| FF_CODEC_DECODE_CB(vpx_decode), | |
| .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE | | |
| FF_CODEC_CAP_AUTO_THREADS, | |
| }; | |
| #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()); | |
| } | |
| const FFCodec ff_libvpx_vp9_decoder = { | |
| .p.name = "libvpx-vp9", | |
| CODEC_LONG_NAME("libvpx VP9"), | |
| .p.type = AVMEDIA_TYPE_VIDEO, | |
| .p.id = AV_CODEC_ID_VP9, | |
| .p.capabilities = AV_CODEC_CAP_OTHER_THREADS, | |
| .p.profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles), | |
| .p.wrapper_name = "libvpx", | |
| .priv_data_size = sizeof(VPxContext), | |
| .init = vp9_init, | |
| .close = vpx_free, | |
| FF_CODEC_DECODE_CB(vpx_decode), | |
| .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE | | |
| FF_CODEC_CAP_AUTO_THREADS, | |
| }; | |
| #endif /* CONFIG_LIBVPX_VP9_DECODER */ |