2016-06-04 19:06:52 +02:00
|
|
|
/*
|
|
|
|
* Nvidia CUVID decoder
|
|
|
|
* Copyright (c) 2016 Timo Rothenpieler <timo@rothenpieler.org>
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2022-02-23 14:56:49 +02:00
|
|
|
#include "config_components.h"
|
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
#include "compat/cuda/dynlink_loader.h"
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
#include "libavutil/buffer.h"
|
|
|
|
#include "libavutil/mathematics.h"
|
|
|
|
#include "libavutil/hwcontext.h"
|
2016-10-10 12:53:49 +02:00
|
|
|
#include "libavutil/hwcontext_cuda_internal.h"
|
2018-11-11 08:47:28 +02:00
|
|
|
#include "libavutil/cuda_check.h"
|
2016-06-04 19:06:52 +02:00
|
|
|
#include "libavutil/fifo.h"
|
|
|
|
#include "libavutil/log.h"
|
2016-09-18 02:42:52 +02:00
|
|
|
#include "libavutil/opt.h"
|
2016-11-22 18:20:37 +02:00
|
|
|
#include "libavutil/pixdesc.h"
|
2016-06-04 19:06:52 +02:00
|
|
|
|
|
|
|
#include "avcodec.h"
|
2022-05-09 22:30:11 +02:00
|
|
|
#include "bsf.h"
|
2022-03-16 19:18:28 +02:00
|
|
|
#include "codec_internal.h"
|
2017-04-23 01:08:42 +02:00
|
|
|
#include "decode.h"
|
2020-04-13 17:33:14 +02:00
|
|
|
#include "hwconfig.h"
|
2018-10-07 18:10:00 +02:00
|
|
|
#include "nvdec.h"
|
2016-06-04 19:06:52 +02:00
|
|
|
#include "internal.h"
|
|
|
|
|
2018-10-07 18:10:00 +02:00
|
|
|
#if !NVDECAPI_CHECK_VERSION(9, 0)
|
|
|
|
#define cudaVideoSurfaceFormat_YUV444 2
|
|
|
|
#define cudaVideoSurfaceFormat_YUV444_16Bit 3
|
|
|
|
#endif
|
|
|
|
|
2020-09-03 13:52:08 +02:00
|
|
|
#if NVDECAPI_CHECK_VERSION(11, 0)
|
|
|
|
#define CUVID_HAS_AV1_SUPPORT
|
|
|
|
#endif
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
typedef struct CuvidContext
|
|
|
|
{
|
2016-09-18 02:42:52 +02:00
|
|
|
AVClass *avclass;
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
CUvideodecoder cudecoder;
|
|
|
|
CUvideoparser cuparser;
|
|
|
|
|
2021-09-23 23:19:24 +02:00
|
|
|
/* This packet coincides with AVCodecInternal.in_pkt
|
|
|
|
* and is not owned by us. */
|
|
|
|
AVPacket *pkt;
|
|
|
|
|
2016-09-29 19:40:42 +02:00
|
|
|
char *cu_gpu;
|
2016-11-21 14:16:39 +02:00
|
|
|
int nb_surfaces;
|
2017-02-12 22:22:46 +02:00
|
|
|
int drop_second_field;
|
2017-03-05 16:32:36 +02:00
|
|
|
char *crop_expr;
|
|
|
|
char *resize_expr;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
int left;
|
|
|
|
int top;
|
|
|
|
int right;
|
|
|
|
int bottom;
|
|
|
|
} crop;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
int width;
|
|
|
|
int height;
|
|
|
|
} resize;
|
2016-09-29 19:40:42 +02:00
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
AVBufferRef *hwdevice;
|
|
|
|
AVBufferRef *hwframe;
|
|
|
|
|
2022-01-05 16:26:33 +02:00
|
|
|
AVFifo *frame_queue;
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-09-18 02:42:52 +02:00
|
|
|
int deint_mode;
|
2017-02-12 19:47:07 +02:00
|
|
|
int deint_mode_current;
|
2016-09-18 02:42:52 +02:00
|
|
|
int64_t prev_pts;
|
2019-04-22 19:26:24 +02:00
|
|
|
int progressive_sequence;
|
2016-09-18 02:42:52 +02:00
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
int internal_error;
|
2016-09-18 00:52:10 +02:00
|
|
|
int decoder_flushing;
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2018-01-18 08:46:19 +02:00
|
|
|
int *key_frame;
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
cudaVideoCodec codec_type;
|
|
|
|
cudaVideoChromaFormat chroma_format;
|
2016-09-04 18:47:29 +02:00
|
|
|
|
2017-05-08 22:02:38 +02:00
|
|
|
CUVIDDECODECAPS caps8, caps10, caps12;
|
|
|
|
|
2016-09-04 18:47:29 +02:00
|
|
|
CUVIDPARSERPARAMS cuparseinfo;
|
2020-09-29 23:19:23 +02:00
|
|
|
CUVIDEOFORMATEX *cuparse_ext;
|
2016-10-10 12:53:49 +02:00
|
|
|
|
|
|
|
CudaFunctions *cudl;
|
|
|
|
CuvidFunctions *cvdl;
|
2016-06-04 19:06:52 +02:00
|
|
|
} CuvidContext;
|
|
|
|
|
2016-09-18 02:42:52 +02:00
|
|
|
typedef struct CuvidParsedFrame
|
|
|
|
{
|
|
|
|
CUVIDPARSERDISPINFO dispinfo;
|
|
|
|
int second_field;
|
|
|
|
int is_deinterlacing;
|
|
|
|
} CuvidParsedFrame;
|
|
|
|
|
2018-11-11 08:47:28 +02:00
|
|
|
#define CHECK_CU(x) FF_CUDA_CHECK_DL(avctx, ctx->cudl, x)
|
2016-06-04 19:06:52 +02:00
|
|
|
|
|
|
|
static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT* format)
|
|
|
|
{
|
|
|
|
AVCodecContext *avctx = opaque;
|
|
|
|
CuvidContext *ctx = avctx->priv_data;
|
|
|
|
AVHWFramesContext *hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
|
2017-05-08 22:02:38 +02:00
|
|
|
CUVIDDECODECAPS *caps = NULL;
|
2016-06-04 19:06:52 +02:00
|
|
|
CUVIDDECODECREATEINFO cuinfo;
|
2016-11-22 18:20:37 +02:00
|
|
|
int surface_fmt;
|
2018-10-07 18:10:00 +02:00
|
|
|
int chroma_444;
|
2016-11-22 18:20:37 +02:00
|
|
|
|
2017-03-05 16:32:36 +02:00
|
|
|
int old_width = avctx->width;
|
|
|
|
int old_height = avctx->height;
|
|
|
|
|
2016-11-22 18:20:37 +02:00
|
|
|
enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
|
|
|
|
AV_PIX_FMT_NONE, // Will be updated below
|
|
|
|
AV_PIX_FMT_NONE };
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-09-18 02:42:52 +02:00
|
|
|
av_log(avctx, AV_LOG_TRACE, "pfnSequenceCallback, progressive_sequence=%d\n", format->progressive_sequence);
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2017-03-05 16:32:36 +02:00
|
|
|
memset(&cuinfo, 0, sizeof(cuinfo));
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
ctx->internal_error = 0;
|
|
|
|
|
2017-03-05 16:32:36 +02:00
|
|
|
avctx->coded_width = cuinfo.ulWidth = format->coded_width;
|
|
|
|
avctx->coded_height = cuinfo.ulHeight = format->coded_height;
|
|
|
|
|
|
|
|
// apply cropping
|
|
|
|
cuinfo.display_area.left = format->display_area.left + ctx->crop.left;
|
|
|
|
cuinfo.display_area.top = format->display_area.top + ctx->crop.top;
|
|
|
|
cuinfo.display_area.right = format->display_area.right - ctx->crop.right;
|
|
|
|
cuinfo.display_area.bottom = format->display_area.bottom - ctx->crop.bottom;
|
|
|
|
|
2017-02-14 12:47:08 +02:00
|
|
|
// width and height need to be set before calling ff_get_format
|
2017-03-05 16:32:36 +02:00
|
|
|
if (ctx->resize_expr) {
|
|
|
|
avctx->width = ctx->resize.width;
|
|
|
|
avctx->height = ctx->resize.height;
|
|
|
|
} else {
|
|
|
|
avctx->width = cuinfo.display_area.right - cuinfo.display_area.left;
|
|
|
|
avctx->height = cuinfo.display_area.bottom - cuinfo.display_area.top;
|
|
|
|
}
|
|
|
|
|
|
|
|
// target width/height need to be multiples of two
|
|
|
|
cuinfo.ulTargetWidth = avctx->width = (avctx->width + 1) & ~1;
|
|
|
|
cuinfo.ulTargetHeight = avctx->height = (avctx->height + 1) & ~1;
|
|
|
|
|
|
|
|
// aspect ratio conversion, 1:1, depends on scaled resolution
|
|
|
|
cuinfo.target_rect.left = 0;
|
|
|
|
cuinfo.target_rect.top = 0;
|
|
|
|
cuinfo.target_rect.right = cuinfo.ulTargetWidth;
|
|
|
|
cuinfo.target_rect.bottom = cuinfo.ulTargetHeight;
|
2017-02-14 12:47:08 +02:00
|
|
|
|
2018-10-07 18:10:00 +02:00
|
|
|
chroma_444 = format->chroma_format == cudaVideoChromaFormat_444;
|
|
|
|
|
2016-11-22 18:20:37 +02:00
|
|
|
switch (format->bit_depth_luma_minus8) {
|
|
|
|
case 0: // 8-bit
|
2018-10-07 18:10:00 +02:00
|
|
|
pix_fmts[1] = chroma_444 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_NV12;
|
2017-05-08 22:02:38 +02:00
|
|
|
caps = &ctx->caps8;
|
2016-11-22 18:20:37 +02:00
|
|
|
break;
|
|
|
|
case 2: // 10-bit
|
2018-10-07 18:10:00 +02:00
|
|
|
pix_fmts[1] = chroma_444 ? AV_PIX_FMT_YUV444P16 : AV_PIX_FMT_P010;
|
2017-05-08 22:02:38 +02:00
|
|
|
caps = &ctx->caps10;
|
2016-11-22 18:20:37 +02:00
|
|
|
break;
|
|
|
|
case 4: // 12-bit
|
2018-10-07 18:10:00 +02:00
|
|
|
pix_fmts[1] = chroma_444 ? AV_PIX_FMT_YUV444P16 : AV_PIX_FMT_P016;
|
2017-05-08 22:02:38 +02:00
|
|
|
caps = &ctx->caps12;
|
2016-11-22 18:20:37 +02:00
|
|
|
break;
|
|
|
|
default:
|
2017-05-08 22:02:38 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!caps || !caps->bIsSupported) {
|
2016-11-22 18:20:37 +02:00
|
|
|
av_log(avctx, AV_LOG_ERROR, "unsupported bit depth: %d\n",
|
|
|
|
format->bit_depth_luma_minus8 + 8);
|
|
|
|
ctx->internal_error = AVERROR(EINVAL);
|
|
|
|
return 0;
|
|
|
|
}
|
2017-05-08 22:02:38 +02:00
|
|
|
|
2016-11-22 18:20:37 +02:00
|
|
|
surface_fmt = ff_get_format(avctx, pix_fmts);
|
|
|
|
if (surface_fmt < 0) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", surface_fmt);
|
|
|
|
ctx->internal_error = AVERROR(EINVAL);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
av_log(avctx, AV_LOG_VERBOSE, "Formats: Original: %s | HW: %s | SW: %s\n",
|
|
|
|
av_get_pix_fmt_name(avctx->pix_fmt),
|
|
|
|
av_get_pix_fmt_name(surface_fmt),
|
|
|
|
av_get_pix_fmt_name(avctx->sw_pix_fmt));
|
|
|
|
|
|
|
|
avctx->pix_fmt = surface_fmt;
|
|
|
|
|
2017-02-09 23:29:47 +02:00
|
|
|
// Update our hwframe ctx, as the get_format callback might have refreshed it!
|
|
|
|
if (avctx->hw_frames_ctx) {
|
|
|
|
av_buffer_unref(&ctx->hwframe);
|
|
|
|
|
|
|
|
ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
|
|
|
|
if (!ctx->hwframe) {
|
|
|
|
ctx->internal_error = AVERROR(ENOMEM);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
|
|
|
|
}
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
ff_set_sar(avctx, av_div_q(
|
|
|
|
(AVRational){ format->display_aspect_ratio.x, format->display_aspect_ratio.y },
|
|
|
|
(AVRational){ avctx->width, avctx->height }));
|
|
|
|
|
2017-02-12 19:47:07 +02:00
|
|
|
ctx->deint_mode_current = format->progressive_sequence
|
|
|
|
? cudaVideoDeinterlaceMode_Weave
|
|
|
|
: ctx->deint_mode;
|
|
|
|
|
2019-04-22 19:26:24 +02:00
|
|
|
ctx->progressive_sequence = format->progressive_sequence;
|
|
|
|
|
2017-02-12 19:47:07 +02:00
|
|
|
if (!format->progressive_sequence && ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave)
|
2016-06-04 19:06:52 +02:00
|
|
|
avctx->flags |= AV_CODEC_FLAG_INTERLACED_DCT;
|
|
|
|
else
|
|
|
|
avctx->flags &= ~AV_CODEC_FLAG_INTERLACED_DCT;
|
|
|
|
|
|
|
|
if (format->video_signal_description.video_full_range_flag)
|
|
|
|
avctx->color_range = AVCOL_RANGE_JPEG;
|
|
|
|
else
|
|
|
|
avctx->color_range = AVCOL_RANGE_MPEG;
|
|
|
|
|
|
|
|
avctx->color_primaries = format->video_signal_description.color_primaries;
|
|
|
|
avctx->color_trc = format->video_signal_description.transfer_characteristics;
|
|
|
|
avctx->colorspace = format->video_signal_description.matrix_coefficients;
|
|
|
|
|
|
|
|
if (format->bitrate)
|
|
|
|
avctx->bit_rate = format->bitrate;
|
|
|
|
|
|
|
|
if (format->frame_rate.numerator && format->frame_rate.denominator) {
|
|
|
|
avctx->framerate.num = format->frame_rate.numerator;
|
|
|
|
avctx->framerate.den = format->frame_rate.denominator;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->cudecoder
|
|
|
|
&& avctx->coded_width == format->coded_width
|
|
|
|
&& avctx->coded_height == format->coded_height
|
2017-03-05 16:32:36 +02:00
|
|
|
&& avctx->width == old_width
|
|
|
|
&& avctx->height == old_height
|
2016-06-04 19:06:52 +02:00
|
|
|
&& ctx->chroma_format == format->chroma_format
|
|
|
|
&& ctx->codec_type == format->codec)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (ctx->cudecoder) {
|
2016-10-22 23:31:41 +02:00
|
|
|
av_log(avctx, AV_LOG_TRACE, "Re-initializing decoder\n");
|
2016-10-10 12:53:49 +02:00
|
|
|
ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder));
|
2016-10-22 23:31:41 +02:00
|
|
|
if (ctx->internal_error < 0)
|
|
|
|
return 0;
|
|
|
|
ctx->cudecoder = NULL;
|
2016-06-04 19:06:52 +02:00
|
|
|
}
|
|
|
|
|
2016-09-29 18:58:49 +02:00
|
|
|
if (hwframe_ctx->pool && (
|
|
|
|
hwframe_ctx->width < avctx->width ||
|
|
|
|
hwframe_ctx->height < avctx->height ||
|
|
|
|
hwframe_ctx->format != AV_PIX_FMT_CUDA ||
|
2016-11-22 18:20:37 +02:00
|
|
|
hwframe_ctx->sw_format != avctx->sw_pix_fmt)) {
|
2016-09-29 18:58:49 +02:00
|
|
|
av_log(avctx, AV_LOG_ERROR, "AVHWFramesContext is already initialized with incompatible parameters\n");
|
2017-02-09 23:19:59 +02:00
|
|
|
av_log(avctx, AV_LOG_DEBUG, "width: %d <-> %d\n", hwframe_ctx->width, avctx->width);
|
|
|
|
av_log(avctx, AV_LOG_DEBUG, "height: %d <-> %d\n", hwframe_ctx->height, avctx->height);
|
|
|
|
av_log(avctx, AV_LOG_DEBUG, "format: %s <-> cuda\n", av_get_pix_fmt_name(hwframe_ctx->format));
|
|
|
|
av_log(avctx, AV_LOG_DEBUG, "sw_format: %s <-> %s\n",
|
|
|
|
av_get_pix_fmt_name(hwframe_ctx->sw_format), av_get_pix_fmt_name(avctx->sw_pix_fmt));
|
2016-06-04 19:06:52 +02:00
|
|
|
ctx->internal_error = AVERROR(EINVAL);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx->chroma_format = format->chroma_format;
|
|
|
|
|
|
|
|
cuinfo.CodecType = ctx->codec_type = format->codec;
|
|
|
|
cuinfo.ChromaFormat = format->chroma_format;
|
2016-11-22 18:20:37 +02:00
|
|
|
|
|
|
|
switch (avctx->sw_pix_fmt) {
|
|
|
|
case AV_PIX_FMT_NV12:
|
|
|
|
cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
|
|
|
|
break;
|
|
|
|
case AV_PIX_FMT_P010:
|
|
|
|
case AV_PIX_FMT_P016:
|
|
|
|
cuinfo.OutputFormat = cudaVideoSurfaceFormat_P016;
|
|
|
|
break;
|
2018-10-07 18:10:00 +02:00
|
|
|
case AV_PIX_FMT_YUV444P:
|
|
|
|
cuinfo.OutputFormat = cudaVideoSurfaceFormat_YUV444;
|
|
|
|
break;
|
|
|
|
case AV_PIX_FMT_YUV444P16:
|
|
|
|
cuinfo.OutputFormat = cudaVideoSurfaceFormat_YUV444_16Bit;
|
|
|
|
break;
|
2016-11-22 18:20:37 +02:00
|
|
|
default:
|
2018-10-07 18:10:00 +02:00
|
|
|
av_log(avctx, AV_LOG_ERROR, "Unsupported output format: %s\n",
|
|
|
|
av_get_pix_fmt_name(avctx->sw_pix_fmt));
|
2016-11-22 18:20:37 +02:00
|
|
|
ctx->internal_error = AVERROR(EINVAL);
|
|
|
|
return 0;
|
|
|
|
}
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-11-21 14:16:39 +02:00
|
|
|
cuinfo.ulNumDecodeSurfaces = ctx->nb_surfaces;
|
2016-06-04 19:06:52 +02:00
|
|
|
cuinfo.ulNumOutputSurfaces = 1;
|
|
|
|
cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
|
2016-09-03 21:52:52 +02:00
|
|
|
cuinfo.bitDepthMinus8 = format->bit_depth_luma_minus8;
|
2017-02-12 19:47:07 +02:00
|
|
|
cuinfo.DeinterlaceMode = ctx->deint_mode_current;
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2017-02-12 22:22:46 +02:00
|
|
|
if (ctx->deint_mode_current != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field)
|
2016-09-18 02:42:52 +02:00
|
|
|
avctx->framerate = av_mul_q(avctx->framerate, (AVRational){2, 1});
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidCreateDecoder(&ctx->cudecoder, &cuinfo));
|
2016-06-04 19:06:52 +02:00
|
|
|
if (ctx->internal_error < 0)
|
|
|
|
return 0;
|
|
|
|
|
2016-09-04 18:47:29 +02:00
|
|
|
if (!hwframe_ctx->pool) {
|
|
|
|
hwframe_ctx->format = AV_PIX_FMT_CUDA;
|
2016-11-22 18:20:37 +02:00
|
|
|
hwframe_ctx->sw_format = avctx->sw_pix_fmt;
|
2016-10-04 12:58:42 +02:00
|
|
|
hwframe_ctx->width = avctx->width;
|
|
|
|
hwframe_ctx->height = avctx->height;
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-09-04 18:47:29 +02:00
|
|
|
if ((ctx->internal_error = av_hwframe_ctx_init(ctx->hwframe)) < 0) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_init failed\n");
|
|
|
|
return 0;
|
|
|
|
}
|
2016-06-04 19:06:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS* picparams)
|
|
|
|
{
|
|
|
|
AVCodecContext *avctx = opaque;
|
|
|
|
CuvidContext *ctx = avctx->priv_data;
|
|
|
|
|
|
|
|
av_log(avctx, AV_LOG_TRACE, "pfnDecodePicture\n");
|
|
|
|
|
2021-06-11 12:27:30 +02:00
|
|
|
if(picparams->intra_pic_flag)
|
|
|
|
ctx->key_frame[picparams->CurrPicIdx] = picparams->intra_pic_flag;
|
2018-01-18 08:46:19 +02:00
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDecodePicture(ctx->cudecoder, picparams));
|
2016-06-04 19:06:52 +02:00
|
|
|
if (ctx->internal_error < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO* dispinfo)
|
|
|
|
{
|
|
|
|
AVCodecContext *avctx = opaque;
|
|
|
|
CuvidContext *ctx = avctx->priv_data;
|
2016-12-12 12:44:36 +02:00
|
|
|
CuvidParsedFrame parsed_frame = { { 0 } };
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-12-12 12:44:36 +02:00
|
|
|
parsed_frame.dispinfo = *dispinfo;
|
2016-06-04 19:06:52 +02:00
|
|
|
ctx->internal_error = 0;
|
|
|
|
|
2019-04-22 19:26:24 +02:00
|
|
|
// For some reason, dispinfo->progressive_frame is sometimes wrong.
|
|
|
|
parsed_frame.dispinfo.progressive_frame = ctx->progressive_sequence;
|
|
|
|
|
2017-02-12 19:47:07 +02:00
|
|
|
if (ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave) {
|
2022-01-05 16:26:33 +02:00
|
|
|
av_fifo_write(ctx->frame_queue, &parsed_frame, 1);
|
2016-09-18 02:42:52 +02:00
|
|
|
} else {
|
|
|
|
parsed_frame.is_deinterlacing = 1;
|
2022-01-05 16:26:33 +02:00
|
|
|
av_fifo_write(ctx->frame_queue, &parsed_frame, 1);
|
2017-02-12 22:22:46 +02:00
|
|
|
if (!ctx->drop_second_field) {
|
|
|
|
parsed_frame.second_field = 1;
|
2022-01-05 16:26:33 +02:00
|
|
|
av_fifo_write(ctx->frame_queue, &parsed_frame, 1);
|
2017-02-12 22:22:46 +02:00
|
|
|
}
|
2016-09-18 02:42:52 +02:00
|
|
|
}
|
2016-06-04 19:06:52 +02:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-04-23 01:08:42 +02:00
|
|
|
static int cuvid_is_buffer_full(AVCodecContext *avctx)
|
|
|
|
{
|
|
|
|
CuvidContext *ctx = avctx->priv_data;
|
|
|
|
|
2018-10-13 23:44:30 +02:00
|
|
|
int delay = ctx->cuparseinfo.ulMaxDisplayDelay;
|
|
|
|
if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field)
|
|
|
|
delay *= 2;
|
|
|
|
|
2022-01-05 16:26:33 +02:00
|
|
|
return av_fifo_can_read(ctx->frame_queue) + delay >= ctx->nb_surfaces;
|
2017-04-23 01:08:42 +02:00
|
|
|
}
|
|
|
|
|
2016-09-18 00:52:10 +02:00
|
|
|
static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
|
2016-06-04 19:06:52 +02:00
|
|
|
{
|
|
|
|
CuvidContext *ctx = avctx->priv_data;
|
|
|
|
AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
|
|
|
|
AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
|
|
|
|
CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
|
|
|
|
CUVIDSOURCEDATAPACKET cupkt;
|
2016-09-18 00:52:10 +02:00
|
|
|
int ret = 0, eret = 0, is_flush = ctx->decoder_flushing;
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-09-18 00:52:10 +02:00
|
|
|
av_log(avctx, AV_LOG_TRACE, "cuvid_decode_packet\n");
|
|
|
|
|
|
|
|
if (is_flush && avpkt && avpkt->size)
|
|
|
|
return AVERROR_EOF;
|
|
|
|
|
2017-04-23 01:08:42 +02:00
|
|
|
if (cuvid_is_buffer_full(avctx) && avpkt && avpkt->size)
|
2016-09-18 00:52:10 +02:00
|
|
|
return AVERROR(EAGAIN);
|
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
|
2016-06-04 19:06:52 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&cupkt, 0, sizeof(cupkt));
|
|
|
|
|
2016-09-18 00:52:10 +02:00
|
|
|
if (avpkt && avpkt->size) {
|
2016-06-04 19:06:52 +02:00
|
|
|
cupkt.payload_size = avpkt->size;
|
|
|
|
cupkt.payload = avpkt->data;
|
|
|
|
|
|
|
|
if (avpkt->pts != AV_NOPTS_VALUE) {
|
|
|
|
cupkt.flags = CUVID_PKT_TIMESTAMP;
|
2016-09-09 16:35:48 +02:00
|
|
|
if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
|
|
|
|
cupkt.timestamp = av_rescale_q(avpkt->pts, avctx->pkt_timebase, (AVRational){1, 10000000});
|
|
|
|
else
|
|
|
|
cupkt.timestamp = avpkt->pts;
|
2016-06-04 19:06:52 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
cupkt.flags = CUVID_PKT_ENDOFSTREAM;
|
2016-09-18 00:52:10 +02:00
|
|
|
ctx->decoder_flushing = 1;
|
2016-06-04 19:06:52 +02:00
|
|
|
}
|
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &cupkt));
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-09-18 00:52:10 +02:00
|
|
|
if (ret < 0)
|
2016-09-10 21:51:01 +02:00
|
|
|
goto error;
|
|
|
|
|
|
|
|
// cuvidParseVideoData doesn't return an error just because stuff failed...
|
|
|
|
if (ctx->internal_error) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "cuvid decode callback error\n");
|
|
|
|
ret = ctx->internal_error;
|
2016-06-04 19:06:52 +02:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2016-09-18 00:52:10 +02:00
|
|
|
error:
|
2016-10-10 12:53:49 +02:00
|
|
|
eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
|
2016-09-18 00:52:10 +02:00
|
|
|
|
|
|
|
if (eret < 0)
|
|
|
|
return eret;
|
|
|
|
else if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
else if (is_flush)
|
|
|
|
return AVERROR_EOF;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
|
|
|
|
{
|
|
|
|
CuvidContext *ctx = avctx->priv_data;
|
|
|
|
AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
|
|
|
|
AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
|
|
|
|
CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
|
2022-01-05 16:26:33 +02:00
|
|
|
CuvidParsedFrame parsed_frame;
|
2016-09-18 00:52:10 +02:00
|
|
|
CUdeviceptr mapped_frame = 0;
|
|
|
|
int ret = 0, eret = 0;
|
|
|
|
|
|
|
|
av_log(avctx, AV_LOG_TRACE, "cuvid_output_frame\n");
|
|
|
|
|
|
|
|
if (ctx->decoder_flushing) {
|
|
|
|
ret = cuvid_decode_packet(avctx, NULL);
|
|
|
|
if (ret < 0 && ret != AVERROR_EOF)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-04-23 01:08:42 +02:00
|
|
|
if (!cuvid_is_buffer_full(avctx)) {
|
2021-09-23 23:19:24 +02:00
|
|
|
AVPacket *const pkt = ctx->pkt;
|
|
|
|
ret = ff_decode_get_packet(avctx, pkt);
|
2017-04-23 01:08:42 +02:00
|
|
|
if (ret < 0 && ret != AVERROR_EOF)
|
|
|
|
return ret;
|
2021-09-23 23:19:24 +02:00
|
|
|
ret = cuvid_decode_packet(avctx, pkt);
|
|
|
|
av_packet_unref(pkt);
|
2017-04-23 01:08:42 +02:00
|
|
|
// cuvid_is_buffer_full() should avoid this.
|
|
|
|
if (ret == AVERROR(EAGAIN))
|
|
|
|
ret = AVERROR_EXTERNAL;
|
|
|
|
if (ret < 0 && ret != AVERROR_EOF)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
|
2016-09-18 00:52:10 +02:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2022-01-05 16:26:33 +02:00
|
|
|
if (av_fifo_read(ctx->frame_queue, &parsed_frame, 1) >= 0) {
|
2018-10-07 18:10:00 +02:00
|
|
|
const AVPixFmtDescriptor *pixdesc;
|
2016-06-04 19:06:52 +02:00
|
|
|
CUVIDPROCPARAMS params;
|
|
|
|
unsigned int pitch = 0;
|
|
|
|
int offset = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
memset(¶ms, 0, sizeof(params));
|
2016-09-18 02:42:52 +02:00
|
|
|
params.progressive_frame = parsed_frame.dispinfo.progressive_frame;
|
|
|
|
params.second_field = parsed_frame.second_field;
|
|
|
|
params.top_field_first = parsed_frame.dispinfo.top_field_first;
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cvdl->cuvidMapVideoFrame(ctx->cudecoder, parsed_frame.dispinfo.picture_index, &mapped_frame, &pitch, ¶ms));
|
2016-06-04 19:06:52 +02:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
if (avctx->pix_fmt == AV_PIX_FMT_CUDA) {
|
|
|
|
ret = av_hwframe_get_buffer(ctx->hwframe, frame, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "av_hwframe_get_buffer failed\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ff_decode_frame_props(avctx, frame);
|
|
|
|
if (ret < 0) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props failed\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2018-10-07 18:10:00 +02:00
|
|
|
pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
|
|
|
|
|
|
|
|
for (i = 0; i < pixdesc->nb_components; i++) {
|
|
|
|
int height = avctx->height >> (i ? pixdesc->log2_chroma_h : 0);
|
2016-06-04 19:06:52 +02:00
|
|
|
CUDA_MEMCPY2D cpy = {
|
|
|
|
.srcMemoryType = CU_MEMORYTYPE_DEVICE,
|
|
|
|
.dstMemoryType = CU_MEMORYTYPE_DEVICE,
|
|
|
|
.srcDevice = mapped_frame,
|
|
|
|
.dstDevice = (CUdeviceptr)frame->data[i],
|
|
|
|
.srcPitch = pitch,
|
|
|
|
.dstPitch = frame->linesize[i],
|
|
|
|
.srcY = offset,
|
|
|
|
.WidthInBytes = FFMIN(pitch, frame->linesize[i]),
|
2018-10-07 18:10:00 +02:00
|
|
|
.Height = height,
|
2016-06-04 19:06:52 +02:00
|
|
|
};
|
|
|
|
|
2018-05-08 13:56:51 +02:00
|
|
|
ret = CHECK_CU(ctx->cudl->cuMemcpy2DAsync(&cpy, device_hwctx->stream));
|
2016-06-04 19:06:52 +02:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2018-10-07 18:10:00 +02:00
|
|
|
offset += height;
|
2016-06-04 19:06:52 +02:00
|
|
|
}
|
2018-10-07 18:10:00 +02:00
|
|
|
} else if (avctx->pix_fmt == AV_PIX_FMT_NV12 ||
|
|
|
|
avctx->pix_fmt == AV_PIX_FMT_P010 ||
|
|
|
|
avctx->pix_fmt == AV_PIX_FMT_P016 ||
|
|
|
|
avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
|
|
|
|
avctx->pix_fmt == AV_PIX_FMT_YUV444P16) {
|
|
|
|
unsigned int offset = 0;
|
2016-06-04 19:06:52 +02:00
|
|
|
AVFrame *tmp_frame = av_frame_alloc();
|
|
|
|
if (!tmp_frame) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "av_frame_alloc failed\n");
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2018-10-07 18:10:00 +02:00
|
|
|
pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
tmp_frame->format = AV_PIX_FMT_CUDA;
|
|
|
|
tmp_frame->hw_frames_ctx = av_buffer_ref(ctx->hwframe);
|
2020-12-13 19:57:19 +02:00
|
|
|
if (!tmp_frame->hw_frames_ctx) {
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
av_frame_free(&tmp_frame);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
tmp_frame->width = avctx->width;
|
|
|
|
tmp_frame->height = avctx->height;
|
|
|
|
|
2018-10-07 18:10:00 +02:00
|
|
|
/*
|
|
|
|
* Note that the following logic would not work for three plane
|
|
|
|
* YUV420 because the pitch value is different for the chroma
|
|
|
|
* planes.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < pixdesc->nb_components; i++) {
|
|
|
|
tmp_frame->data[i] = (uint8_t*)mapped_frame + offset;
|
|
|
|
tmp_frame->linesize[i] = pitch;
|
|
|
|
offset += pitch * (avctx->height >> (i ? pixdesc->log2_chroma_h : 0));
|
|
|
|
}
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
ret = ff_get_buffer(avctx, frame, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "ff_get_buffer failed\n");
|
|
|
|
av_frame_free(&tmp_frame);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = av_hwframe_transfer_data(frame, tmp_frame, 0);
|
|
|
|
if (ret) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "av_hwframe_transfer_data failed\n");
|
|
|
|
av_frame_free(&tmp_frame);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
av_frame_free(&tmp_frame);
|
|
|
|
} else {
|
|
|
|
ret = AVERROR_BUG;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2018-01-18 08:46:19 +02:00
|
|
|
frame->key_frame = ctx->key_frame[parsed_frame.dispinfo.picture_index];
|
2021-06-11 12:27:30 +02:00
|
|
|
ctx->key_frame[parsed_frame.dispinfo.picture_index] = 0;
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
frame->width = avctx->width;
|
|
|
|
frame->height = avctx->height;
|
2016-09-09 16:35:48 +02:00
|
|
|
if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
|
2016-09-18 02:42:52 +02:00
|
|
|
frame->pts = av_rescale_q(parsed_frame.dispinfo.timestamp, (AVRational){1, 10000000}, avctx->pkt_timebase);
|
2016-09-09 16:35:48 +02:00
|
|
|
else
|
2016-09-18 02:42:52 +02:00
|
|
|
frame->pts = parsed_frame.dispinfo.timestamp;
|
|
|
|
|
|
|
|
if (parsed_frame.second_field) {
|
|
|
|
if (ctx->prev_pts == INT64_MIN) {
|
|
|
|
ctx->prev_pts = frame->pts;
|
|
|
|
frame->pts += (avctx->pkt_timebase.den * avctx->framerate.den) / (avctx->pkt_timebase.num * avctx->framerate.num);
|
|
|
|
} else {
|
|
|
|
int pts_diff = (frame->pts - ctx->prev_pts) / 2;
|
|
|
|
ctx->prev_pts = frame->pts;
|
|
|
|
frame->pts += pts_diff;
|
|
|
|
}
|
|
|
|
}
|
2016-06-04 19:06:52 +02:00
|
|
|
|
|
|
|
/* CUVIDs opaque reordering breaks the internal pkt logic.
|
|
|
|
* So set pkt_pts and clear all the other pkt_ fields.
|
|
|
|
*/
|
2022-07-11 10:20:12 +02:00
|
|
|
frame->duration = 0;
|
lavu/frame: deprecate AVFrame.pkt_{pos,size}
These fields are supposed to store information about the packet the
frame was decoded from, specifically the byte offset it was stored at
and its size.
However,
- the fields are highly ad-hoc - there is no strong reason why
specifically those (and not any other) packet properties should have a
dedicated field in AVFrame; unlike e.g. the timestamps, there is no
fundamental link between coded packet offset/size and decoded frames
- they only make sense for frames produced by decoding demuxed packets,
and even then it is not always the case that the encoded data was
stored in the file as a contiguous sequence of bytes (in order for pos
to be well-defined)
- pkt_pos was added without much explanation, apparently to allow
passthrough of this information through lavfi in order to handle byte
seeking in ffplay. That is now implemented using arbitrary user data
passthrough in AVFrame.opaque_ref.
- several filters use pkt_pos as a variable available to user-supplied
expressions, but there seems to be no established motivation for using them.
- pkt_size was added for use in ffprobe, but that too is now handled
without using this field. Additonally, the values of this field
produced by libavcodec are flawed, as described in the previous
ffprobe conversion commit.
In summary - these fields are ill-defined and insufficiently motivated,
so deprecate them.
2023-03-10 11:48:34 +02:00
|
|
|
#if FF_API_FRAME_PKT
|
|
|
|
FF_DISABLE_DEPRECATION_WARNINGS
|
|
|
|
frame->pkt_pos = -1;
|
2017-04-22 10:54:58 +02:00
|
|
|
frame->pkt_size = -1;
|
lavu/frame: deprecate AVFrame.pkt_{pos,size}
These fields are supposed to store information about the packet the
frame was decoded from, specifically the byte offset it was stored at
and its size.
However,
- the fields are highly ad-hoc - there is no strong reason why
specifically those (and not any other) packet properties should have a
dedicated field in AVFrame; unlike e.g. the timestamps, there is no
fundamental link between coded packet offset/size and decoded frames
- they only make sense for frames produced by decoding demuxed packets,
and even then it is not always the case that the encoded data was
stored in the file as a contiguous sequence of bytes (in order for pos
to be well-defined)
- pkt_pos was added without much explanation, apparently to allow
passthrough of this information through lavfi in order to handle byte
seeking in ffplay. That is now implemented using arbitrary user data
passthrough in AVFrame.opaque_ref.
- several filters use pkt_pos as a variable available to user-supplied
expressions, but there seems to be no established motivation for using them.
- pkt_size was added for use in ffprobe, but that too is now handled
without using this field. Additonally, the values of this field
produced by libavcodec are flawed, as described in the previous
ffprobe conversion commit.
In summary - these fields are ill-defined and insufficiently motivated,
so deprecate them.
2023-03-10 11:48:34 +02:00
|
|
|
FF_ENABLE_DEPRECATION_WARNINGS
|
|
|
|
#endif
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-09-18 02:42:52 +02:00
|
|
|
frame->interlaced_frame = !parsed_frame.is_deinterlacing && !parsed_frame.dispinfo.progressive_frame;
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-09-18 02:42:52 +02:00
|
|
|
if (frame->interlaced_frame)
|
|
|
|
frame->top_field_first = parsed_frame.dispinfo.top_field_first;
|
2016-09-18 00:52:10 +02:00
|
|
|
} else if (ctx->decoder_flushing) {
|
|
|
|
ret = AVERROR_EOF;
|
2016-06-04 19:06:52 +02:00
|
|
|
} else {
|
2016-09-18 00:52:10 +02:00
|
|
|
ret = AVERROR(EAGAIN);
|
2016-06-04 19:06:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
error:
|
2020-12-13 20:08:13 +02:00
|
|
|
if (ret < 0)
|
|
|
|
av_frame_unref(frame);
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
if (mapped_frame)
|
2016-10-10 12:53:49 +02:00
|
|
|
eret = CHECK_CU(ctx->cvdl->cuvidUnmapVideoFrame(ctx->cudecoder, mapped_frame));
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
|
2016-06-04 19:06:52 +02:00
|
|
|
|
|
|
|
if (eret < 0)
|
|
|
|
return eret;
|
|
|
|
else
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static av_cold int cuvid_decode_end(AVCodecContext *avctx)
|
|
|
|
{
|
|
|
|
CuvidContext *ctx = avctx->priv_data;
|
2022-06-24 16:42:01 +02:00
|
|
|
AVHWDeviceContext *device_ctx = ctx->hwdevice ? (AVHWDeviceContext *)ctx->hwdevice->data : NULL;
|
|
|
|
AVCUDADeviceContext *device_hwctx = device_ctx ? device_ctx->hwctx : NULL;
|
|
|
|
CUcontext dummy, cuda_ctx = device_hwctx ? device_hwctx->cuda_ctx : NULL;
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2022-01-05 16:26:33 +02:00
|
|
|
av_fifo_freep2(&ctx->frame_queue);
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2022-06-24 16:42:01 +02:00
|
|
|
if (cuda_ctx) {
|
|
|
|
ctx->cudl->cuCtxPushCurrent(cuda_ctx);
|
2020-11-20 05:23:43 +02:00
|
|
|
|
2022-06-24 16:42:01 +02:00
|
|
|
if (ctx->cuparser)
|
|
|
|
ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2022-06-24 16:42:01 +02:00
|
|
|
if (ctx->cudecoder)
|
|
|
|
ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
|
2016-10-10 12:53:49 +02:00
|
|
|
|
2022-06-24 16:42:01 +02:00
|
|
|
ctx->cudl->cuCtxPopCurrent(&dummy);
|
|
|
|
}
|
2020-11-20 05:23:43 +02:00
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ctx->cudl = NULL;
|
2016-06-04 19:06:52 +02:00
|
|
|
|
|
|
|
av_buffer_unref(&ctx->hwframe);
|
|
|
|
av_buffer_unref(&ctx->hwdevice);
|
|
|
|
|
2018-01-18 08:46:19 +02:00
|
|
|
av_freep(&ctx->key_frame);
|
2020-09-29 23:19:23 +02:00
|
|
|
av_freep(&ctx->cuparse_ext);
|
2018-01-18 08:46:19 +02:00
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
cuvid_free_functions(&ctx->cvdl);
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-08 22:02:38 +02:00
|
|
|
static int cuvid_test_capabilities(AVCodecContext *avctx,
|
|
|
|
const CUVIDPARSERPARAMS *cuparseinfo,
|
|
|
|
int probed_width,
|
|
|
|
int probed_height,
|
|
|
|
int bit_depth)
|
2016-06-04 19:06:52 +02:00
|
|
|
{
|
2016-10-10 12:53:49 +02:00
|
|
|
CuvidContext *ctx = avctx->priv_data;
|
2017-05-08 22:02:38 +02:00
|
|
|
CUVIDDECODECAPS *caps;
|
|
|
|
int res8 = 0, res10 = 0, res12 = 0;
|
|
|
|
|
2017-06-01 12:29:35 +02:00
|
|
|
if (!ctx->cvdl->cuvidGetDecoderCaps) {
|
|
|
|
av_log(avctx, AV_LOG_WARNING, "Used Nvidia driver is too old to perform a capability check.\n");
|
|
|
|
av_log(avctx, AV_LOG_WARNING, "The minimum required version is "
|
|
|
|
#if defined(_WIN32) || defined(__CYGWIN__)
|
|
|
|
"378.66"
|
|
|
|
#else
|
|
|
|
"378.13"
|
|
|
|
#endif
|
|
|
|
". Continuing blind.\n");
|
|
|
|
ctx->caps8.bIsSupported = ctx->caps10.bIsSupported = 1;
|
|
|
|
// 12 bit was not supported before the capability check was introduced, so disable it.
|
|
|
|
ctx->caps12.bIsSupported = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-08 22:02:38 +02:00
|
|
|
ctx->caps8.eCodecType = ctx->caps10.eCodecType = ctx->caps12.eCodecType
|
|
|
|
= cuparseinfo->CodecType;
|
|
|
|
ctx->caps8.eChromaFormat = ctx->caps10.eChromaFormat = ctx->caps12.eChromaFormat
|
|
|
|
= cudaVideoChromaFormat_420;
|
|
|
|
|
|
|
|
ctx->caps8.nBitDepthMinus8 = 0;
|
|
|
|
ctx->caps10.nBitDepthMinus8 = 2;
|
|
|
|
ctx->caps12.nBitDepthMinus8 = 4;
|
|
|
|
|
|
|
|
res8 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps8));
|
|
|
|
res10 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps10));
|
|
|
|
res12 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps12));
|
|
|
|
|
|
|
|
av_log(avctx, AV_LOG_VERBOSE, "CUVID capabilities for %s:\n", avctx->codec->name);
|
|
|
|
av_log(avctx, AV_LOG_VERBOSE, "8 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
|
|
|
|
ctx->caps8.bIsSupported, ctx->caps8.nMinWidth, ctx->caps8.nMaxWidth, ctx->caps8.nMinHeight, ctx->caps8.nMaxHeight);
|
|
|
|
av_log(avctx, AV_LOG_VERBOSE, "10 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
|
|
|
|
ctx->caps10.bIsSupported, ctx->caps10.nMinWidth, ctx->caps10.nMaxWidth, ctx->caps10.nMinHeight, ctx->caps10.nMaxHeight);
|
|
|
|
av_log(avctx, AV_LOG_VERBOSE, "12 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
|
|
|
|
ctx->caps12.bIsSupported, ctx->caps12.nMinWidth, ctx->caps12.nMaxWidth, ctx->caps12.nMinHeight, ctx->caps12.nMaxHeight);
|
|
|
|
|
|
|
|
switch (bit_depth) {
|
|
|
|
case 10:
|
|
|
|
caps = &ctx->caps10;
|
|
|
|
if (res10 < 0)
|
|
|
|
return res10;
|
|
|
|
break;
|
|
|
|
case 12:
|
|
|
|
caps = &ctx->caps12;
|
|
|
|
if (res12 < 0)
|
|
|
|
return res12;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
caps = &ctx->caps8;
|
|
|
|
if (res8 < 0)
|
|
|
|
return res8;
|
|
|
|
}
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2017-05-08 22:02:38 +02:00
|
|
|
if (!ctx->caps8.bIsSupported) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "Codec %s is not supported.\n", avctx->codec->name);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2017-05-08 22:02:38 +02:00
|
|
|
if (!caps->bIsSupported) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "Bit depth %d is not supported.\n", bit_depth);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2017-05-08 22:02:38 +02:00
|
|
|
if (probed_width > caps->nMaxWidth || probed_width < caps->nMinWidth) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "Video width %d not within range from %d to %d\n",
|
|
|
|
probed_width, caps->nMinWidth, caps->nMaxWidth);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2017-05-08 22:02:38 +02:00
|
|
|
if (probed_height > caps->nMaxHeight || probed_height < caps->nMinHeight) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "Video height %d not within range from %d to %d\n",
|
|
|
|
probed_height, caps->nMinHeight, caps->nMaxHeight);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2019-05-03 10:11:11 +02:00
|
|
|
if ((probed_width * probed_height) / 256 > caps->nMaxMBCount) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "Video macroblock count %d exceeds maximum of %d\n",
|
|
|
|
(int)(probed_width * probed_height) / 256, caps->nMaxMBCount);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static av_cold int cuvid_decode_init(AVCodecContext *avctx)
|
|
|
|
{
|
|
|
|
CuvidContext *ctx = avctx->priv_data;
|
|
|
|
AVCUDADeviceContext *device_hwctx;
|
|
|
|
AVHWDeviceContext *device_ctx;
|
|
|
|
AVHWFramesContext *hwframe_ctx;
|
|
|
|
CUVIDSOURCEDATAPACKET seq_pkt;
|
|
|
|
CUcontext cuda_ctx = NULL;
|
|
|
|
CUcontext dummy;
|
2020-09-29 23:19:23 +02:00
|
|
|
uint8_t *extradata;
|
2020-10-01 21:09:34 +02:00
|
|
|
int extradata_size;
|
2016-06-04 19:06:52 +02:00
|
|
|
int ret = 0;
|
|
|
|
|
2016-11-23 22:10:32 +02:00
|
|
|
enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
|
|
|
|
AV_PIX_FMT_NV12,
|
|
|
|
AV_PIX_FMT_NONE };
|
|
|
|
|
2017-01-23 01:20:05 +02:00
|
|
|
int probed_width = avctx->coded_width ? avctx->coded_width : 1280;
|
|
|
|
int probed_height = avctx->coded_height ? avctx->coded_height : 720;
|
2017-05-08 22:02:38 +02:00
|
|
|
int probed_bit_depth = 8;
|
|
|
|
|
|
|
|
const AVPixFmtDescriptor *probe_desc = av_pix_fmt_desc_get(avctx->pix_fmt);
|
|
|
|
if (probe_desc && probe_desc->nb_components)
|
|
|
|
probed_bit_depth = probe_desc->comp[0].depth;
|
2017-01-23 01:20:05 +02:00
|
|
|
|
2021-09-23 23:19:24 +02:00
|
|
|
ctx->pkt = avctx->internal->in_pkt;
|
2016-11-23 22:10:32 +02:00
|
|
|
// Accelerated transcoding scenarios with 'ffmpeg' require that the
|
|
|
|
// pix_fmt be set to AV_PIX_FMT_CUDA early. The sw_pix_fmt, and the
|
|
|
|
// pix_fmt for non-accelerated transcoding, do not need to be correct
|
|
|
|
// but need to be set to something. We arbitrarily pick NV12.
|
|
|
|
ret = ff_get_format(avctx, pix_fmts);
|
|
|
|
if (ret < 0) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
avctx->pix_fmt = ret;
|
|
|
|
|
2017-03-05 16:32:36 +02:00
|
|
|
if (ctx->resize_expr && sscanf(ctx->resize_expr, "%dx%d",
|
|
|
|
&ctx->resize.width, &ctx->resize.height) != 2) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid resize expressions\n");
|
|
|
|
ret = AVERROR(EINVAL);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->crop_expr && sscanf(ctx->crop_expr, "%dx%dx%dx%d",
|
|
|
|
&ctx->crop.top, &ctx->crop.bottom,
|
|
|
|
&ctx->crop.left, &ctx->crop.right) != 4) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid cropping expressions\n");
|
|
|
|
ret = AVERROR(EINVAL);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2017-11-18 19:16:14 +02:00
|
|
|
ret = cuvid_load_functions(&ctx->cvdl, avctx);
|
2016-10-10 12:53:49 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "Failed loading nvcuvid.\n");
|
|
|
|
goto error;
|
|
|
|
}
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2022-01-05 16:26:33 +02:00
|
|
|
ctx->frame_queue = av_fifo_alloc2(ctx->nb_surfaces, sizeof(CuvidParsedFrame), 0);
|
2016-06-04 19:06:52 +02:00
|
|
|
if (!ctx->frame_queue) {
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (avctx->hw_frames_ctx) {
|
|
|
|
ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
|
|
|
|
if (!ctx->hwframe) {
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
|
|
|
|
|
|
|
|
ctx->hwdevice = av_buffer_ref(hwframe_ctx->device_ref);
|
|
|
|
if (!ctx->hwdevice) {
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
} else {
|
2017-05-05 00:15:21 +02:00
|
|
|
if (avctx->hw_device_ctx) {
|
|
|
|
ctx->hwdevice = av_buffer_ref(avctx->hw_device_ctx);
|
|
|
|
if (!ctx->hwdevice) {
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ret = av_hwdevice_ctx_create(&ctx->hwdevice, AV_HWDEVICE_TYPE_CUDA, ctx->cu_gpu, NULL, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
}
|
2016-06-04 19:06:52 +02:00
|
|
|
|
|
|
|
ctx->hwframe = av_hwframe_ctx_alloc(ctx->hwdevice);
|
|
|
|
if (!ctx->hwframe) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto error;
|
|
|
|
}
|
2016-09-29 19:40:42 +02:00
|
|
|
|
|
|
|
hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
|
2016-06-04 19:06:52 +02:00
|
|
|
}
|
|
|
|
|
2016-09-29 19:40:42 +02:00
|
|
|
device_ctx = hwframe_ctx->device_ctx;
|
|
|
|
device_hwctx = device_ctx->hwctx;
|
2016-10-10 12:53:49 +02:00
|
|
|
|
2016-09-29 19:40:42 +02:00
|
|
|
cuda_ctx = device_hwctx->cuda_ctx;
|
2016-10-10 12:53:49 +02:00
|
|
|
ctx->cudl = device_hwctx->internal->cuda_dl;
|
2016-09-29 19:40:42 +02:00
|
|
|
|
2016-09-04 18:47:29 +02:00
|
|
|
memset(&ctx->cuparseinfo, 0, sizeof(ctx->cuparseinfo));
|
2016-06-04 19:06:52 +02:00
|
|
|
memset(&seq_pkt, 0, sizeof(seq_pkt));
|
|
|
|
|
|
|
|
switch (avctx->codec->id) {
|
|
|
|
#if CONFIG_H264_CUVID_DECODER
|
|
|
|
case AV_CODEC_ID_H264:
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cuparseinfo.CodecType = cudaVideoCodec_H264;
|
2016-06-04 19:06:52 +02:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if CONFIG_HEVC_CUVID_DECODER
|
|
|
|
case AV_CODEC_ID_HEVC:
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cuparseinfo.CodecType = cudaVideoCodec_HEVC;
|
2016-06-04 19:06:52 +02:00
|
|
|
break;
|
|
|
|
#endif
|
2016-09-04 18:47:28 +02:00
|
|
|
#if CONFIG_MJPEG_CUVID_DECODER
|
|
|
|
case AV_CODEC_ID_MJPEG:
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cuparseinfo.CodecType = cudaVideoCodec_JPEG;
|
2016-09-04 18:47:28 +02:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if CONFIG_MPEG1_CUVID_DECODER
|
|
|
|
case AV_CODEC_ID_MPEG1VIDEO:
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG1;
|
2016-09-04 18:47:28 +02:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if CONFIG_MPEG2_CUVID_DECODER
|
|
|
|
case AV_CODEC_ID_MPEG2VIDEO:
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG2;
|
2016-09-04 18:47:28 +02:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if CONFIG_MPEG4_CUVID_DECODER
|
|
|
|
case AV_CODEC_ID_MPEG4:
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
|
2016-09-04 18:47:28 +02:00
|
|
|
break;
|
|
|
|
#endif
|
2016-06-04 19:06:52 +02:00
|
|
|
#if CONFIG_VP8_CUVID_DECODER
|
|
|
|
case AV_CODEC_ID_VP8:
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cuparseinfo.CodecType = cudaVideoCodec_VP8;
|
2016-06-04 19:06:52 +02:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if CONFIG_VP9_CUVID_DECODER
|
|
|
|
case AV_CODEC_ID_VP9:
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cuparseinfo.CodecType = cudaVideoCodec_VP9;
|
2016-06-04 19:06:52 +02:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if CONFIG_VC1_CUVID_DECODER
|
|
|
|
case AV_CODEC_ID_VC1:
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cuparseinfo.CodecType = cudaVideoCodec_VC1;
|
2016-06-04 19:06:52 +02:00
|
|
|
break;
|
2020-09-03 13:52:08 +02:00
|
|
|
#endif
|
|
|
|
#if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
|
|
|
|
case AV_CODEC_ID_AV1:
|
|
|
|
ctx->cuparseinfo.CodecType = cudaVideoCodec_AV1;
|
|
|
|
break;
|
2016-06-04 19:06:52 +02:00
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid CUVID codec!\n");
|
|
|
|
return AVERROR_BUG;
|
|
|
|
}
|
|
|
|
|
2022-03-16 22:09:54 +02:00
|
|
|
if (ffcodec(avctx->codec)->bsfs) {
|
2020-04-25 23:48:21 +02:00
|
|
|
const AVCodecParameters *par = avctx->internal->bsf->par_out;
|
2020-09-29 23:19:23 +02:00
|
|
|
extradata = par->extradata;
|
|
|
|
extradata_size = par->extradata_size;
|
2020-10-01 21:09:34 +02:00
|
|
|
} else {
|
2020-09-29 23:19:23 +02:00
|
|
|
extradata = avctx->extradata;
|
|
|
|
extradata_size = avctx->extradata_size;
|
2016-06-04 19:06:52 +02:00
|
|
|
}
|
|
|
|
|
2022-06-24 06:04:04 +02:00
|
|
|
// Check first bit to determine whether it's AV1CodecConfigurationRecord.
|
|
|
|
// Skip first 4 bytes of AV1CodecConfigurationRecord to keep configOBUs
|
|
|
|
// only, otherwise cuvidParseVideoData report unknown error.
|
|
|
|
if (avctx->codec->id == AV_CODEC_ID_AV1 &&
|
|
|
|
extradata_size > 4 &&
|
|
|
|
extradata[0] & 0x80) {
|
|
|
|
extradata += 4;
|
|
|
|
extradata_size -= 4;
|
|
|
|
}
|
|
|
|
|
2020-09-29 23:19:23 +02:00
|
|
|
ctx->cuparse_ext = av_mallocz(sizeof(*ctx->cuparse_ext)
|
2020-10-01 21:09:34 +02:00
|
|
|
+ FFMAX(extradata_size - (int)sizeof(ctx->cuparse_ext->raw_seqhdr_data), 0));
|
2020-09-29 23:19:23 +02:00
|
|
|
if (!ctx->cuparse_ext) {
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2020-10-01 21:09:34 +02:00
|
|
|
if (extradata_size > 0)
|
|
|
|
memcpy(ctx->cuparse_ext->raw_seqhdr_data, extradata, extradata_size);
|
2020-10-01 20:20:48 +02:00
|
|
|
ctx->cuparse_ext->format.seqhdr_data_length = extradata_size;
|
2020-09-29 23:19:23 +02:00
|
|
|
|
|
|
|
ctx->cuparseinfo.pExtVideoInfo = ctx->cuparse_ext;
|
|
|
|
|
2018-01-18 08:46:19 +02:00
|
|
|
ctx->key_frame = av_mallocz(ctx->nb_surfaces * sizeof(int));
|
|
|
|
if (!ctx->key_frame) {
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2016-11-21 14:16:39 +02:00
|
|
|
ctx->cuparseinfo.ulMaxNumDecodeSurfaces = ctx->nb_surfaces;
|
2021-02-20 00:33:25 +02:00
|
|
|
ctx->cuparseinfo.ulMaxDisplayDelay = (avctx->flags & AV_CODEC_FLAG_LOW_DELAY) ? 0 : 4;
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cuparseinfo.pUserData = avctx;
|
|
|
|
ctx->cuparseinfo.pfnSequenceCallback = cuvid_handle_video_sequence;
|
|
|
|
ctx->cuparseinfo.pfnDecodePicture = cuvid_handle_picture_decode;
|
|
|
|
ctx->cuparseinfo.pfnDisplayPicture = cuvid_handle_picture_display;
|
2016-06-04 19:06:52 +02:00
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
|
2016-06-04 19:06:52 +02:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2017-05-08 22:02:38 +02:00
|
|
|
ret = cuvid_test_capabilities(avctx, &ctx->cuparseinfo,
|
|
|
|
probed_width,
|
|
|
|
probed_height,
|
|
|
|
probed_bit_depth);
|
2016-06-04 19:06:52 +02:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
|
2016-06-04 19:06:52 +02:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2020-09-29 23:19:23 +02:00
|
|
|
seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
|
|
|
|
seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
|
2016-06-04 19:06:52 +02:00
|
|
|
|
|
|
|
if (seq_pkt.payload && seq_pkt.payload_size) {
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
|
2016-06-04 19:06:52 +02:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
|
2016-06-04 19:06:52 +02:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2016-09-18 02:42:52 +02:00
|
|
|
ctx->prev_pts = INT64_MIN;
|
|
|
|
|
2016-09-09 16:35:48 +02:00
|
|
|
if (!avctx->pkt_timebase.num || !avctx->pkt_timebase.den)
|
|
|
|
av_log(avctx, AV_LOG_WARNING, "Invalid pkt_timebase, passing timestamps as-is.\n");
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
cuvid_decode_end(avctx);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-09-04 18:47:29 +02:00
|
|
|
static void cuvid_flush(AVCodecContext *avctx)
|
|
|
|
{
|
|
|
|
CuvidContext *ctx = avctx->priv_data;
|
|
|
|
AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
|
|
|
|
AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
|
|
|
|
CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
|
2016-09-15 04:56:07 +02:00
|
|
|
CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
|
2016-09-04 18:47:29 +02:00
|
|
|
int ret;
|
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
|
2016-09-04 18:47:29 +02:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2022-01-05 16:26:33 +02:00
|
|
|
av_fifo_reset2(ctx->frame_queue);
|
2016-09-04 18:47:29 +02:00
|
|
|
|
|
|
|
if (ctx->cudecoder) {
|
2016-10-10 12:53:49 +02:00
|
|
|
ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cudecoder = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->cuparser) {
|
2016-10-10 12:53:49 +02:00
|
|
|
ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
|
2016-09-04 18:47:29 +02:00
|
|
|
ctx->cuparser = NULL;
|
|
|
|
}
|
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
|
2016-09-04 18:47:29 +02:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2020-09-29 23:19:23 +02:00
|
|
|
seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
|
|
|
|
seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
|
2016-09-15 04:56:07 +02:00
|
|
|
|
|
|
|
if (seq_pkt.payload && seq_pkt.payload_size) {
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
|
2016-09-15 04:56:07 +02:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2016-10-10 12:53:49 +02:00
|
|
|
ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
|
2016-09-04 18:47:29 +02:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2016-09-18 00:52:10 +02:00
|
|
|
ctx->prev_pts = INT64_MIN;
|
|
|
|
ctx->decoder_flushing = 0;
|
|
|
|
|
2016-09-04 18:47:29 +02:00
|
|
|
return;
|
|
|
|
error:
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "CUDA reinit on flush failed\n");
|
|
|
|
}
|
|
|
|
|
2016-09-18 02:42:52 +02:00
|
|
|
#define OFFSET(x) offsetof(CuvidContext, x)
|
|
|
|
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
|
|
|
|
static const AVOption options[] = {
|
|
|
|
{ "deint", "Set deinterlacing mode", OFFSET(deint_mode), AV_OPT_TYPE_INT, { .i64 = cudaVideoDeinterlaceMode_Weave }, cudaVideoDeinterlaceMode_Weave, cudaVideoDeinterlaceMode_Adaptive, VD, "deint" },
|
|
|
|
{ "weave", "Weave deinterlacing (do nothing)", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Weave }, 0, 0, VD, "deint" },
|
|
|
|
{ "bob", "Bob deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob }, 0, 0, VD, "deint" },
|
|
|
|
{ "adaptive", "Adaptive deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0, VD, "deint" },
|
2016-09-29 19:40:42 +02:00
|
|
|
{ "gpu", "GPU to be used for decoding", OFFSET(cu_gpu), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
|
2016-11-21 14:16:39 +02:00
|
|
|
{ "surfaces", "Maximum surfaces to be used for decoding", OFFSET(nb_surfaces), AV_OPT_TYPE_INT, { .i64 = 25 }, 0, INT_MAX, VD },
|
2017-02-12 22:22:46 +02:00
|
|
|
{ "drop_second_field", "Drop second field when deinterlacing", OFFSET(drop_second_field), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
|
2017-03-05 16:32:36 +02:00
|
|
|
{ "crop", "Crop (top)x(bottom)x(left)x(right)", OFFSET(crop_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
|
|
|
|
{ "resize", "Resize (width)x(height)", OFFSET(resize_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
|
2016-09-18 02:42:52 +02:00
|
|
|
{ NULL }
|
|
|
|
};
|
|
|
|
|
2020-11-08 20:51:15 +02:00
|
|
|
static const AVCodecHWConfigInternal *const cuvid_hw_configs[] = {
|
2017-10-26 01:18:40 +02:00
|
|
|
&(const AVCodecHWConfigInternal) {
|
|
|
|
.public = {
|
|
|
|
.pix_fmt = AV_PIX_FMT_CUDA,
|
|
|
|
.methods = AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX |
|
|
|
|
AV_CODEC_HW_CONFIG_METHOD_INTERNAL,
|
|
|
|
.device_type = AV_HWDEVICE_TYPE_CUDA
|
|
|
|
},
|
|
|
|
.hwaccel = NULL,
|
|
|
|
},
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2020-03-01 04:57:48 +02:00
|
|
|
#define DEFINE_CUVID_CODEC(x, X, bsf_name) \
|
2016-09-18 02:42:52 +02:00
|
|
|
static const AVClass x##_cuvid_class = { \
|
|
|
|
.class_name = #x "_cuvid", \
|
|
|
|
.item_name = av_default_item_name, \
|
|
|
|
.option = options, \
|
|
|
|
.version = LIBAVUTIL_VERSION_INT, \
|
|
|
|
}; \
|
2022-03-16 22:09:54 +02:00
|
|
|
const FFCodec ff_##x##_cuvid_decoder = { \
|
|
|
|
.p.name = #x "_cuvid", \
|
2022-08-29 13:38:02 +02:00
|
|
|
CODEC_LONG_NAME("Nvidia CUVID " #X " decoder"), \
|
2022-03-16 22:09:54 +02:00
|
|
|
.p.type = AVMEDIA_TYPE_VIDEO, \
|
|
|
|
.p.id = AV_CODEC_ID_##X, \
|
2016-06-04 19:06:52 +02:00
|
|
|
.priv_data_size = sizeof(CuvidContext), \
|
2022-03-16 22:09:54 +02:00
|
|
|
.p.priv_class = &x##_cuvid_class, \
|
2016-06-04 19:06:52 +02:00
|
|
|
.init = cuvid_decode_init, \
|
|
|
|
.close = cuvid_decode_end, \
|
2022-03-30 23:28:24 +02:00
|
|
|
FF_CODEC_RECEIVE_FRAME_CB(cuvid_output_frame), \
|
2016-09-04 18:47:29 +02:00
|
|
|
.flush = cuvid_flush, \
|
2020-03-01 04:57:48 +02:00
|
|
|
.bsfs = bsf_name, \
|
2022-03-16 22:09:54 +02:00
|
|
|
.p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
|
2022-07-09 22:25:41 +02:00
|
|
|
.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE | \
|
|
|
|
FF_CODEC_CAP_SETS_FRAME_PROPS, \
|
2022-03-16 22:09:54 +02:00
|
|
|
.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_CUDA, \
|
2016-06-04 19:06:52 +02:00
|
|
|
AV_PIX_FMT_NV12, \
|
2016-11-22 18:20:37 +02:00
|
|
|
AV_PIX_FMT_P010, \
|
|
|
|
AV_PIX_FMT_P016, \
|
2016-06-04 19:06:52 +02:00
|
|
|
AV_PIX_FMT_NONE }, \
|
2017-10-26 01:18:40 +02:00
|
|
|
.hw_configs = cuvid_hw_configs, \
|
2022-03-16 22:09:54 +02:00
|
|
|
.p.wrapper_name = "cuvid", \
|
2016-06-04 19:06:52 +02:00
|
|
|
};
|
|
|
|
|
2020-09-03 13:52:08 +02:00
|
|
|
#if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
|
|
|
|
DEFINE_CUVID_CODEC(av1, AV1, NULL)
|
|
|
|
#endif
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
#if CONFIG_HEVC_CUVID_DECODER
|
2020-03-01 04:57:48 +02:00
|
|
|
DEFINE_CUVID_CODEC(hevc, HEVC, "hevc_mp4toannexb")
|
2016-06-04 19:06:52 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_H264_CUVID_DECODER
|
2020-03-01 04:57:48 +02:00
|
|
|
DEFINE_CUVID_CODEC(h264, H264, "h264_mp4toannexb")
|
2016-06-04 19:06:52 +02:00
|
|
|
#endif
|
|
|
|
|
2016-09-04 18:47:28 +02:00
|
|
|
#if CONFIG_MJPEG_CUVID_DECODER
|
2020-03-01 04:57:48 +02:00
|
|
|
DEFINE_CUVID_CODEC(mjpeg, MJPEG, NULL)
|
2016-09-04 18:47:28 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_MPEG1_CUVID_DECODER
|
2020-03-01 04:57:48 +02:00
|
|
|
DEFINE_CUVID_CODEC(mpeg1, MPEG1VIDEO, NULL)
|
2016-09-04 18:47:28 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_MPEG2_CUVID_DECODER
|
2020-03-01 04:57:48 +02:00
|
|
|
DEFINE_CUVID_CODEC(mpeg2, MPEG2VIDEO, NULL)
|
2016-09-04 18:47:28 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_MPEG4_CUVID_DECODER
|
2020-03-01 04:57:48 +02:00
|
|
|
DEFINE_CUVID_CODEC(mpeg4, MPEG4, NULL)
|
2016-09-04 18:47:28 +02:00
|
|
|
#endif
|
|
|
|
|
2016-06-04 19:06:52 +02:00
|
|
|
#if CONFIG_VP8_CUVID_DECODER
|
2020-03-01 04:57:48 +02:00
|
|
|
DEFINE_CUVID_CODEC(vp8, VP8, NULL)
|
2016-06-04 19:06:52 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_VP9_CUVID_DECODER
|
2020-03-01 04:57:48 +02:00
|
|
|
DEFINE_CUVID_CODEC(vp9, VP9, NULL)
|
2016-06-04 19:06:52 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_VC1_CUVID_DECODER
|
2020-03-01 04:57:48 +02:00
|
|
|
DEFINE_CUVID_CODEC(vc1, VC1, NULL)
|
2016-06-04 19:06:52 +02:00
|
|
|
#endif
|