ffmpeg/FFmpeg
1
0
Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2024-09-19 21:06:42 +00:00
Code Issues Packages Projects Releases Wiki Activity
01f58f3646
FFmpeg/libavcodec/libvpxdec.c
OvchinnikovDmitrii c13d959343 lavc/libvpx: increase thread limit to 64 
This change improves the performance and multicore scalability of the vp9
codec for streaming single-pass encoded videos by taking advantage of up
to 64 cores in the system. The current thread limit for ffmpeg codecs is 16
(MAX_AUTO_THREADS in pthread_internal.h) due to a limitation in H.264 codec
that prevents more than 16 threads being used.

Experiments show that increasing the thread limit to 64 for vp9 improves
the performance for encoding 4K raw videos for streaming by up to 47%
compared to 16 threads, and from 20-30% for 32 threads, with the same quality
as measured by the VMAF score.

Rationale for this change:
Vp9 uses tiling to split the video frame into multiple columns; tiles must
be at least 256 pixels wide, so there is a limit to how many tiles can be
used. The tiles can be processed in parallel, and more tiles mean more CPU
threads can be used. 4K videos can make use of 16 threads, and 8K videos
can use 32. Row-mt can double the number of threads so 64 threads can be used.

Signed-off-by: James Zern <jzern@google.com>
2023-01-17 14:02:55 -08:00

397 lines
13 KiB
C
Raw Blame History

/*
* 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 = 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,
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]) {
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 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());
}
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,
.init_static_data = ff_vp9_init_static,
};
#endif /* CONFIG_LIBVPX_VP9_DECODER */
Reference in New Issue View Git Blame Copy Permalink