22 #include "config_components.h"
45 #if !NVDECAPI_CHECK_VERSION(9, 0)
46 #define cudaVideoSurfaceFormat_YUV444 2
47 #define cudaVideoSurfaceFormat_YUV444_16Bit 3
50 #if NVDECAPI_CHECK_VERSION(11, 0)
51 #define CUVID_HAS_AV1_SUPPORT
117 #define CHECK_CU(x) FF_CUDA_CHECK_DL(avctx, ctx->cudl, x)
120 #define CUVID_MAX_DISPLAY_DELAY (4)
123 #define CUVID_DEFAULT_NUM_SURFACES (CUVID_MAX_DISPLAY_DELAY + 1)
130 CUVIDDECODECAPS *caps =
NULL;
131 CUVIDDECODECREATEINFO cuinfo;
134 int old_nb_surfaces, fifo_size_inc, fifo_size_mul = 1;
136 int old_width = avctx->
width;
137 int old_height = avctx->
height;
145 memset(&cuinfo, 0,
sizeof(cuinfo));
147 ctx->internal_error = 0;
149 avctx->coded_width = cuinfo.ulWidth =
format->coded_width;
150 avctx->coded_height = cuinfo.ulHeight =
format->coded_height;
153 cuinfo.display_area.left =
format->display_area.left +
ctx->crop.left;
154 cuinfo.display_area.top =
format->display_area.top +
ctx->crop.top;
155 cuinfo.display_area.right =
format->display_area.right -
ctx->crop.right;
156 cuinfo.display_area.bottom =
format->display_area.bottom -
ctx->crop.bottom;
159 if (
ctx->resize_expr) {
160 avctx->width =
ctx->resize.width;
161 avctx->height =
ctx->resize.height;
163 avctx->width = cuinfo.display_area.right - cuinfo.display_area.left;
164 avctx->height = cuinfo.display_area.bottom - cuinfo.display_area.top;
168 cuinfo.ulTargetWidth = avctx->width = (avctx->width + 1) & ~1;
169 cuinfo.ulTargetHeight = avctx->height = (avctx->height + 1) & ~1;
172 cuinfo.target_rect.left = 0;
173 cuinfo.target_rect.top = 0;
174 cuinfo.target_rect.right = cuinfo.ulTargetWidth;
175 cuinfo.target_rect.bottom = cuinfo.ulTargetHeight;
177 chroma_444 =
format->chroma_format == cudaVideoChromaFormat_444;
179 switch (
format->bit_depth_luma_minus8) {
183 #ifdef NVDEC_HAVE_422_SUPPORT
184 }
else if (
format->chroma_format == cudaVideoChromaFormat_422) {
195 #ifdef NVDEC_HAVE_422_SUPPORT
196 }
else if (
format->chroma_format == cudaVideoChromaFormat_422) {
207 #ifdef NVDEC_HAVE_422_SUPPORT
208 }
else if (
format->chroma_format == cudaVideoChromaFormat_422) {
220 if (!caps || !caps->bIsSupported) {
222 format->bit_depth_luma_minus8 + 8);
228 if (surface_fmt < 0) {
239 avctx->pix_fmt = surface_fmt;
242 if (avctx->hw_frames_ctx) {
258 ctx->deint_mode_current =
format->progressive_sequence
259 ? cudaVideoDeinterlaceMode_Weave
262 ctx->progressive_sequence =
format->progressive_sequence;
264 if (!
format->progressive_sequence &&
ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave)
269 if (
format->video_signal_description.video_full_range_flag)
275 avctx->color_trc =
format->video_signal_description.transfer_characteristics;
279 avctx->bit_rate =
format->bitrate;
281 if (
format->frame_rate.numerator &&
format->frame_rate.denominator) {
282 avctx->framerate.num =
format->frame_rate.numerator;
283 avctx->framerate.den =
format->frame_rate.denominator;
287 && avctx->coded_width ==
format->coded_width
288 && avctx->coded_height ==
format->coded_height
289 && avctx->
width == old_width
290 && avctx->height == old_height
291 &&
ctx->chroma_format ==
format->chroma_format
295 if (
ctx->cudecoder) {
298 if (
ctx->internal_error < 0)
303 if (hwframe_ctx->pool && (
304 hwframe_ctx->width < avctx->width ||
305 hwframe_ctx->height < avctx->height ||
307 hwframe_ctx->sw_format != avctx->sw_pix_fmt)) {
308 av_log(avctx,
AV_LOG_ERROR,
"AVHWFramesContext is already initialized with incompatible parameters\n");
310 av_log(avctx,
AV_LOG_DEBUG,
"height: %d <-> %d\n", hwframe_ctx->height, avctx->height);
318 ctx->chroma_format =
format->chroma_format;
320 cuinfo.CodecType =
ctx->codec_type =
format->codec;
321 cuinfo.ChromaFormat =
format->chroma_format;
323 switch (avctx->sw_pix_fmt) {
325 cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
329 cuinfo.OutputFormat = cudaVideoSurfaceFormat_P016;
331 #ifdef NVDEC_HAVE_422_SUPPORT
333 cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV16;
336 cuinfo.OutputFormat = cudaVideoSurfaceFormat_P216;
352 if (
ctx->deint_mode_current != cudaVideoDeinterlaceMode_Weave && !
ctx->drop_second_field) {
357 old_nb_surfaces =
ctx->nb_surfaces;
359 if (avctx->extra_hw_frames > 0)
360 ctx->nb_surfaces += avctx->extra_hw_frames;
363 if (fifo_size_inc > 0 &&
av_fifo_grow2(
ctx->frame_queue, fifo_size_inc) < 0) {
364 av_log(avctx,
AV_LOG_ERROR,
"Failed to grow frame queue on video sequence callback\n");
370 av_log(avctx,
AV_LOG_ERROR,
"Failed to grow key frame array on video sequence callback\n");
375 cuinfo.ulNumDecodeSurfaces =
ctx->nb_surfaces;
376 cuinfo.ulNumOutputSurfaces = 1;
377 cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
378 cuinfo.bitDepthMinus8 =
format->bit_depth_luma_minus8;
379 cuinfo.DeinterlaceMode =
ctx->deint_mode_current;
381 ctx->internal_error =
CHECK_CU(
ctx->cvdl->cuvidCreateDecoder(&
ctx->cudecoder, &cuinfo));
382 if (
ctx->internal_error < 0)
385 if (!hwframe_ctx->pool) {
387 hwframe_ctx->sw_format = avctx->sw_pix_fmt;
388 hwframe_ctx->width = avctx->width;
389 hwframe_ctx->height = avctx->height;
397 if(
ctx->cuparseinfo.ulMaxNumDecodeSurfaces != cuinfo.ulNumDecodeSurfaces) {
398 ctx->cuparseinfo.ulMaxNumDecodeSurfaces = cuinfo.ulNumDecodeSurfaces;
399 return cuinfo.ulNumDecodeSurfaces;
412 if(picparams->intra_pic_flag)
413 ctx->key_frame[picparams->CurrPicIdx] = picparams->intra_pic_flag;
415 ctx->internal_error =
CHECK_CU(
ctx->cvdl->cuvidDecodePicture(
ctx->cudecoder, picparams));
416 if (
ctx->internal_error < 0)
429 ctx->internal_error = 0;
432 parsed_frame.
dispinfo.progressive_frame =
ctx->progressive_sequence;
434 if (
ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave) {
439 if (!
ctx->drop_second_field) {
453 if (
ctx->deint_mode != cudaVideoDeinterlaceMode_Weave && !
ctx->drop_second_field)
465 CUcontext
dummy, cuda_ctx = device_hwctx->cuda_ctx;
466 CUVIDSOURCEDATAPACKET cupkt;
467 int ret = 0, eret = 0, is_flush =
ctx->decoder_flushing;
471 if (is_flush && avpkt && avpkt->
size)
482 memset(&cupkt, 0,
sizeof(cupkt));
484 if (avpkt && avpkt->
size) {
485 cupkt.payload_size = avpkt->
size;
486 cupkt.payload = avpkt->
data;
489 cupkt.flags = CUVID_PKT_TIMESTAMP;
493 cupkt.timestamp = avpkt->
pts;
496 cupkt.flags = CUVID_PKT_ENDOFSTREAM;
497 ctx->decoder_flushing = 1;
506 if (
ctx->internal_error) {
508 ret =
ctx->internal_error;
530 CUcontext
dummy, cuda_ctx = device_hwctx->cuda_ctx;
532 CUdeviceptr mapped_frame = 0;
533 int ret = 0, eret = 0;
537 if (
ctx->decoder_flushing) {
563 CUVIDPROCPARAMS params;
564 unsigned int pitch = 0;
568 memset(¶ms, 0,
sizeof(params));
569 params.progressive_frame = parsed_frame.dispinfo.progressive_frame;
570 params.second_field = parsed_frame.second_field;
571 params.top_field_first = parsed_frame.dispinfo.top_field_first;
573 ret =
CHECK_CU(
ctx->cvdl->cuvidMapVideoFrame(
ctx->cudecoder, parsed_frame.dispinfo.picture_index, &mapped_frame, &pitch, ¶ms));
594 CUDA_MEMCPY2D cpy = {
595 .srcMemoryType = CU_MEMORYTYPE_DEVICE,
596 .dstMemoryType = CU_MEMORYTYPE_DEVICE,
597 .srcDevice = mapped_frame,
598 .dstDevice = (CUdeviceptr)
frame->data[
i],
600 .dstPitch =
frame->linesize[
i],
606 ret =
CHECK_CU(
ctx->cudl->cuMemcpy2DAsync(&cpy, device_hwctx->stream));
615 #ifdef NVDEC_HAVE_422_SUPPORT
648 tmp_frame->
data[
i] = (uint8_t*)mapped_frame +
offset;
672 if (
ctx->key_frame[parsed_frame.dispinfo.picture_index])
676 ctx->key_frame[parsed_frame.dispinfo.picture_index] = 0;
683 frame->pts = parsed_frame.dispinfo.timestamp;
685 if (parsed_frame.second_field) {
686 if (
ctx->prev_pts == INT64_MIN) {
690 int pts_diff = (
frame->pts -
ctx->prev_pts) / 2;
692 frame->pts += pts_diff;
703 frame->pkt_size = -1;
707 if (!parsed_frame.is_deinterlacing && !parsed_frame.dispinfo.progressive_frame)
712 }
else if (
ctx->decoder_flushing) {
723 eret =
CHECK_CU(
ctx->cvdl->cuvidUnmapVideoFrame(
ctx->cudecoder, mapped_frame));
738 CUcontext
dummy, cuda_ctx = device_hwctx ? device_hwctx->cuda_ctx :
NULL;
743 ctx->cudl->cuCtxPushCurrent(cuda_ctx);
746 ctx->cvdl->cuvidDestroyVideoParser(
ctx->cuparser);
749 ctx->cvdl->cuvidDestroyDecoder(
ctx->cudecoder);
762 cuvid_free_functions(&
ctx->cvdl);
768 const CUVIDPARSERPARAMS *cuparseinfo,
771 int bit_depth,
int is_yuv422,
int is_yuv444)
774 CUVIDDECODECAPS *caps;
775 int res8 = 0, res10 = 0, res12 = 0;
777 if (!
ctx->cvdl->cuvidGetDecoderCaps) {
778 av_log(avctx,
AV_LOG_WARNING,
"Used Nvidia driver is too old to perform a capability check.\n");
780 #
if defined(_WIN32) || defined(__CYGWIN__)
785 ". Continuing blind.\n");
786 ctx->caps8.bIsSupported =
ctx->caps10.bIsSupported = 1;
788 ctx->caps12.bIsSupported = 0;
792 ctx->caps8.eCodecType =
ctx->caps10.eCodecType =
ctx->caps12.eCodecType
793 = cuparseinfo->CodecType;
795 ctx->caps8.eChromaFormat =
ctx->caps10.eChromaFormat =
ctx->caps12.eChromaFormat
796 = is_yuv444 ? cudaVideoChromaFormat_444 :
797 #ifdef NVDEC_HAVE_422_SUPPORT
798 (is_yuv422 ? cudaVideoChromaFormat_422 : cudaVideoChromaFormat_420);
800 cudaVideoChromaFormat_420;
803 ctx->caps8.nBitDepthMinus8 = 0;
804 ctx->caps10.nBitDepthMinus8 = 2;
805 ctx->caps12.nBitDepthMinus8 = 4;
812 av_log(avctx,
AV_LOG_VERBOSE,
"8 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
813 ctx->caps8.bIsSupported,
ctx->caps8.nMinWidth,
ctx->caps8.nMaxWidth,
ctx->caps8.nMinHeight,
ctx->caps8.nMaxHeight);
814 av_log(avctx,
AV_LOG_VERBOSE,
"10 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
815 ctx->caps10.bIsSupported,
ctx->caps10.nMinWidth,
ctx->caps10.nMaxWidth,
ctx->caps10.nMinHeight,
ctx->caps10.nMaxHeight);
816 av_log(avctx,
AV_LOG_VERBOSE,
"12 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
817 ctx->caps12.bIsSupported,
ctx->caps12.nMinWidth,
ctx->caps12.nMaxWidth,
ctx->caps12.nMinHeight,
ctx->caps12.nMaxHeight);
836 if (!
ctx->caps8.bIsSupported) {
841 if (!caps->bIsSupported) {
846 if (probed_width > caps->nMaxWidth || probed_width < caps->nMinWidth) {
848 probed_width, caps->nMinWidth, caps->nMaxWidth);
852 if (probed_height > caps->nMaxHeight || probed_height < caps->nMinHeight) {
854 probed_height, caps->nMinHeight, caps->nMaxHeight);
858 if ((probed_width * probed_height) / 256 > caps->nMaxMBCount) {
860 (
int)(probed_width * probed_height) / 256, caps->nMaxMBCount);
873 CUVIDSOURCEDATAPACKET seq_pkt;
874 CUcontext cuda_ctx =
NULL;
886 int probed_bit_depth = 8, is_yuv444 = 0, is_yuv422 = 0;
890 probed_bit_depth = probe_desc->
comp[0].
depth;
895 #ifdef NVDEC_HAVE_422_SUPPORT
901 switch (probed_bit_depth) {
925 if (
ctx->resize_expr && sscanf(
ctx->resize_expr,
"%dx%d",
926 &
ctx->resize.width, &
ctx->resize.height) != 2) {
932 if (
ctx->crop_expr && sscanf(
ctx->crop_expr,
"%dx%dx%dx%d",
933 &
ctx->crop.top, &
ctx->crop.bottom,
934 &
ctx->crop.left, &
ctx->crop.right) != 4) {
940 ret = cuvid_load_functions(&
ctx->cvdl, avctx);
947 if(
ctx->nb_surfaces < 0)
951 if (!
ctx->frame_queue) {
966 if (!
ctx->hwdevice) {
973 if (!
ctx->hwdevice) {
994 device_hwctx = device_ctx->
hwctx;
999 memset(&
ctx->cuparseinfo, 0,
sizeof(
ctx->cuparseinfo));
1000 memset(&seq_pkt, 0,
sizeof(seq_pkt));
1003 #if CONFIG_H264_CUVID_DECODER
1005 ctx->cuparseinfo.CodecType = cudaVideoCodec_H264;
1008 #if CONFIG_HEVC_CUVID_DECODER
1010 ctx->cuparseinfo.CodecType = cudaVideoCodec_HEVC;
1013 #if CONFIG_MJPEG_CUVID_DECODER
1015 ctx->cuparseinfo.CodecType = cudaVideoCodec_JPEG;
1018 #if CONFIG_MPEG1_CUVID_DECODER
1020 ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG1;
1023 #if CONFIG_MPEG2_CUVID_DECODER
1025 ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG2;
1028 #if CONFIG_MPEG4_CUVID_DECODER
1030 ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
1033 #if CONFIG_VP8_CUVID_DECODER
1035 ctx->cuparseinfo.CodecType = cudaVideoCodec_VP8;
1038 #if CONFIG_VP9_CUVID_DECODER
1040 ctx->cuparseinfo.CodecType = cudaVideoCodec_VP9;
1043 #if CONFIG_VC1_CUVID_DECODER
1045 ctx->cuparseinfo.CodecType = cudaVideoCodec_VC1;
1048 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
1050 ctx->cuparseinfo.CodecType = cudaVideoCodec_AV1;
1071 extradata_size > 4 &&
1072 extradata[0] & 0x80) {
1074 extradata_size -= 4;
1078 +
FFMAX(extradata_size - (
int)
sizeof(
ctx->cuparse_ext->raw_seqhdr_data), 0));
1079 if (!
ctx->cuparse_ext) {
1084 if (extradata_size > 0)
1085 memcpy(
ctx->cuparse_ext->raw_seqhdr_data, extradata, extradata_size);
1086 ctx->cuparse_ext->format.seqhdr_data_length = extradata_size;
1088 ctx->cuparseinfo.pExtVideoInfo =
ctx->cuparse_ext;
1091 if (!
ctx->key_frame) {
1096 ctx->cuparseinfo.ulMaxNumDecodeSurfaces = 1;
1098 ctx->cuparseinfo.pUserData = avctx;
1110 probed_bit_depth, is_yuv422, is_yuv444);
1118 seq_pkt.payload =
ctx->cuparse_ext->raw_seqhdr_data;
1119 seq_pkt.payload_size =
ctx->cuparse_ext->format.seqhdr_data_length;
1121 if (seq_pkt.payload && seq_pkt.payload_size) {
1131 ctx->prev_pts = INT64_MIN;
1148 CUcontext
dummy, cuda_ctx = device_hwctx->cuda_ctx;
1149 CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
1158 if (
ctx->cudecoder) {
1159 ctx->cvdl->cuvidDestroyDecoder(
ctx->cudecoder);
1163 if (
ctx->cuparser) {
1164 ctx->cvdl->cuvidDestroyVideoParser(
ctx->cuparser);
1172 seq_pkt.payload =
ctx->cuparse_ext->raw_seqhdr_data;
1173 seq_pkt.payload_size =
ctx->cuparse_ext->format.seqhdr_data_length;
1175 if (seq_pkt.payload && seq_pkt.payload_size) {
1185 ctx->prev_pts = INT64_MIN;
1186 ctx->decoder_flushing = 0;
1193 #define OFFSET(x) offsetof(CuvidContext, x)
1194 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1196 {
"deint",
"Set deinterlacing mode",
OFFSET(deint_mode),
AV_OPT_TYPE_INT, { .i64 = cudaVideoDeinterlaceMode_Weave }, cudaVideoDeinterlaceMode_Weave, cudaVideoDeinterlaceMode_Adaptive,
VD, .unit =
"deint" },
1197 {
"weave",
"Weave deinterlacing (do nothing)", 0,
AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Weave }, 0, 0,
VD, .unit =
"deint" },
1198 {
"bob",
"Bob deinterlacing", 0,
AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob }, 0, 0,
VD, .unit =
"deint" },
1199 {
"adaptive",
"Adaptive deinterlacing", 0,
AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0,
VD, .unit =
"deint" },
1202 {
"drop_second_field",
"Drop second field when deinterlacing",
OFFSET(drop_second_field),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VD },
1222 #define DEFINE_CUVID_CODEC(x, X, bsf_name) \
1223 static const AVClass x##_cuvid_class = { \
1224 .class_name = #x "_cuvid", \
1225 .item_name = av_default_item_name, \
1226 .option = options, \
1227 .version = LIBAVUTIL_VERSION_INT, \
1229 const FFCodec ff_##x##_cuvid_decoder = { \
1230 .p.name = #x "_cuvid", \
1231 CODEC_LONG_NAME("Nvidia CUVID " #X " decoder"), \
1232 .p.type = AVMEDIA_TYPE_VIDEO, \
1233 .p.id = AV_CODEC_ID_##X, \
1234 .priv_data_size = sizeof(CuvidContext), \
1235 .p.priv_class = &x##_cuvid_class, \
1236 .init = cuvid_decode_init, \
1237 .close = cuvid_decode_end, \
1238 FF_CODEC_RECEIVE_FRAME_CB(cuvid_output_frame), \
1239 .flush = cuvid_flush, \
1241 .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
1242 .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE | \
1243 FF_CODEC_CAP_SETS_FRAME_PROPS, \
1244 .hw_configs = cuvid_hw_configs, \
1245 .p.wrapper_name = "cuvid", \
1248 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
1252 #if CONFIG_HEVC_CUVID_DECODER
1256 #if CONFIG_H264_CUVID_DECODER
1260 #if CONFIG_MJPEG_CUVID_DECODER
1264 #if CONFIG_MPEG1_CUVID_DECODER
1268 #if CONFIG_MPEG2_CUVID_DECODER
1272 #if CONFIG_MPEG4_CUVID_DECODER
1276 #if CONFIG_VP8_CUVID_DECODER
1280 #if CONFIG_VP9_CUVID_DECODER
1284 #if CONFIG_VC1_CUVID_DECODER