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;
701 if (!parsed_frame.is_deinterlacing && !parsed_frame.dispinfo.progressive_frame)
706 }
else if (
ctx->decoder_flushing) {
717 eret =
CHECK_CU(
ctx->cvdl->cuvidUnmapVideoFrame(
ctx->cudecoder, mapped_frame));
732 CUcontext
dummy, cuda_ctx = device_hwctx ? device_hwctx->cuda_ctx :
NULL;
737 ctx->cudl->cuCtxPushCurrent(cuda_ctx);
740 ctx->cvdl->cuvidDestroyVideoParser(
ctx->cuparser);
743 ctx->cvdl->cuvidDestroyDecoder(
ctx->cudecoder);
756 cuvid_free_functions(&
ctx->cvdl);
762 const CUVIDPARSERPARAMS *cuparseinfo,
765 int bit_depth,
int is_yuv422,
int is_yuv444)
768 CUVIDDECODECAPS *caps;
769 int res8 = 0, res10 = 0, res12 = 0;
771 if (!
ctx->cvdl->cuvidGetDecoderCaps) {
772 av_log(avctx,
AV_LOG_WARNING,
"Used Nvidia driver is too old to perform a capability check.\n");
774 #
if defined(_WIN32) || defined(__CYGWIN__)
779 ". Continuing blind.\n");
780 ctx->caps8.bIsSupported =
ctx->caps10.bIsSupported = 1;
782 ctx->caps12.bIsSupported = 0;
786 ctx->caps8.eCodecType =
ctx->caps10.eCodecType =
ctx->caps12.eCodecType
787 = cuparseinfo->CodecType;
789 ctx->caps8.eChromaFormat =
ctx->caps10.eChromaFormat =
ctx->caps12.eChromaFormat
790 = is_yuv444 ? cudaVideoChromaFormat_444 :
791 #ifdef NVDEC_HAVE_422_SUPPORT
792 (is_yuv422 ? cudaVideoChromaFormat_422 : cudaVideoChromaFormat_420);
794 cudaVideoChromaFormat_420;
797 ctx->caps8.nBitDepthMinus8 = 0;
798 ctx->caps10.nBitDepthMinus8 = 2;
799 ctx->caps12.nBitDepthMinus8 = 4;
806 av_log(avctx,
AV_LOG_VERBOSE,
"8 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
807 ctx->caps8.bIsSupported,
ctx->caps8.nMinWidth,
ctx->caps8.nMaxWidth,
ctx->caps8.nMinHeight,
ctx->caps8.nMaxHeight);
808 av_log(avctx,
AV_LOG_VERBOSE,
"10 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
809 ctx->caps10.bIsSupported,
ctx->caps10.nMinWidth,
ctx->caps10.nMaxWidth,
ctx->caps10.nMinHeight,
ctx->caps10.nMaxHeight);
810 av_log(avctx,
AV_LOG_VERBOSE,
"12 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
811 ctx->caps12.bIsSupported,
ctx->caps12.nMinWidth,
ctx->caps12.nMaxWidth,
ctx->caps12.nMinHeight,
ctx->caps12.nMaxHeight);
830 if (!
ctx->caps8.bIsSupported) {
835 if (!caps->bIsSupported) {
840 if (probed_width > caps->nMaxWidth || probed_width < caps->nMinWidth) {
842 probed_width, caps->nMinWidth, caps->nMaxWidth);
846 if (probed_height > caps->nMaxHeight || probed_height < caps->nMinHeight) {
848 probed_height, caps->nMinHeight, caps->nMaxHeight);
852 if ((probed_width * probed_height) / 256 > caps->nMaxMBCount) {
854 (
int)(probed_width * probed_height) / 256, caps->nMaxMBCount);
867 CUVIDSOURCEDATAPACKET seq_pkt;
868 CUcontext cuda_ctx =
NULL;
880 int probed_bit_depth = 8, is_yuv444 = 0, is_yuv422 = 0;
884 probed_bit_depth = probe_desc->
comp[0].
depth;
889 #ifdef NVDEC_HAVE_422_SUPPORT
895 switch (probed_bit_depth) {
919 if (
ctx->resize_expr && sscanf(
ctx->resize_expr,
"%dx%d",
920 &
ctx->resize.width, &
ctx->resize.height) != 2) {
926 if (
ctx->crop_expr && sscanf(
ctx->crop_expr,
"%dx%dx%dx%d",
927 &
ctx->crop.top, &
ctx->crop.bottom,
928 &
ctx->crop.left, &
ctx->crop.right) != 4) {
934 ret = cuvid_load_functions(&
ctx->cvdl, avctx);
941 if(
ctx->nb_surfaces < 0)
945 if (!
ctx->frame_queue) {
960 if (!
ctx->hwdevice) {
967 if (!
ctx->hwdevice) {
988 device_hwctx = device_ctx->
hwctx;
993 memset(&
ctx->cuparseinfo, 0,
sizeof(
ctx->cuparseinfo));
994 memset(&seq_pkt, 0,
sizeof(seq_pkt));
997 #if CONFIG_H264_CUVID_DECODER
999 ctx->cuparseinfo.CodecType = cudaVideoCodec_H264;
1002 #if CONFIG_HEVC_CUVID_DECODER
1004 ctx->cuparseinfo.CodecType = cudaVideoCodec_HEVC;
1007 #if CONFIG_MJPEG_CUVID_DECODER
1009 ctx->cuparseinfo.CodecType = cudaVideoCodec_JPEG;
1012 #if CONFIG_MPEG1_CUVID_DECODER
1014 ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG1;
1017 #if CONFIG_MPEG2_CUVID_DECODER
1019 ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG2;
1022 #if CONFIG_MPEG4_CUVID_DECODER
1024 ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
1027 #if CONFIG_VP8_CUVID_DECODER
1029 ctx->cuparseinfo.CodecType = cudaVideoCodec_VP8;
1032 #if CONFIG_VP9_CUVID_DECODER
1034 ctx->cuparseinfo.CodecType = cudaVideoCodec_VP9;
1037 #if CONFIG_VC1_CUVID_DECODER
1039 ctx->cuparseinfo.CodecType = cudaVideoCodec_VC1;
1042 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
1044 ctx->cuparseinfo.CodecType = cudaVideoCodec_AV1;
1065 extradata_size > 4 &&
1066 extradata[0] & 0x80) {
1068 extradata_size -= 4;
1072 +
FFMAX(extradata_size - (
int)
sizeof(
ctx->cuparse_ext->raw_seqhdr_data), 0));
1073 if (!
ctx->cuparse_ext) {
1078 if (extradata_size > 0)
1079 memcpy(
ctx->cuparse_ext->raw_seqhdr_data, extradata, extradata_size);
1080 ctx->cuparse_ext->format.seqhdr_data_length = extradata_size;
1082 ctx->cuparseinfo.pExtVideoInfo =
ctx->cuparse_ext;
1085 if (!
ctx->key_frame) {
1090 ctx->cuparseinfo.ulMaxNumDecodeSurfaces = 1;
1092 ctx->cuparseinfo.pUserData = avctx;
1104 probed_bit_depth, is_yuv422, is_yuv444);
1112 seq_pkt.payload =
ctx->cuparse_ext->raw_seqhdr_data;
1113 seq_pkt.payload_size =
ctx->cuparse_ext->format.seqhdr_data_length;
1115 if (seq_pkt.payload && seq_pkt.payload_size) {
1125 ctx->prev_pts = INT64_MIN;
1142 CUcontext
dummy, cuda_ctx = device_hwctx->cuda_ctx;
1143 CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
1152 if (
ctx->cudecoder) {
1153 ctx->cvdl->cuvidDestroyDecoder(
ctx->cudecoder);
1157 if (
ctx->cuparser) {
1158 ctx->cvdl->cuvidDestroyVideoParser(
ctx->cuparser);
1166 seq_pkt.payload =
ctx->cuparse_ext->raw_seqhdr_data;
1167 seq_pkt.payload_size =
ctx->cuparse_ext->format.seqhdr_data_length;
1169 if (seq_pkt.payload && seq_pkt.payload_size) {
1179 ctx->prev_pts = INT64_MIN;
1180 ctx->decoder_flushing = 0;
1187 #define OFFSET(x) offsetof(CuvidContext, x)
1188 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1190 {
"deint",
"Set deinterlacing mode",
OFFSET(deint_mode),
AV_OPT_TYPE_INT, { .i64 = cudaVideoDeinterlaceMode_Weave }, cudaVideoDeinterlaceMode_Weave, cudaVideoDeinterlaceMode_Adaptive,
VD, .unit =
"deint" },
1191 {
"weave",
"Weave deinterlacing (do nothing)", 0,
AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Weave }, 0, 0,
VD, .unit =
"deint" },
1192 {
"bob",
"Bob deinterlacing", 0,
AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob }, 0, 0,
VD, .unit =
"deint" },
1193 {
"adaptive",
"Adaptive deinterlacing", 0,
AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0,
VD, .unit =
"deint" },
1196 {
"drop_second_field",
"Drop second field when deinterlacing",
OFFSET(drop_second_field),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VD },
1216 #define DEFINE_CUVID_CODEC(x, X, bsf_name) \
1217 static const AVClass x##_cuvid_class = { \
1218 .class_name = #x "_cuvid", \
1219 .item_name = av_default_item_name, \
1220 .option = options, \
1221 .version = LIBAVUTIL_VERSION_INT, \
1223 const FFCodec ff_##x##_cuvid_decoder = { \
1224 .p.name = #x "_cuvid", \
1225 CODEC_LONG_NAME("Nvidia CUVID " #X " decoder"), \
1226 .p.type = AVMEDIA_TYPE_VIDEO, \
1227 .p.id = AV_CODEC_ID_##X, \
1228 .priv_data_size = sizeof(CuvidContext), \
1229 .p.priv_class = &x##_cuvid_class, \
1230 .init = cuvid_decode_init, \
1231 .close = cuvid_decode_end, \
1232 FF_CODEC_RECEIVE_FRAME_CB(cuvid_output_frame), \
1233 .flush = cuvid_flush, \
1235 .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
1236 .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE | \
1237 FF_CODEC_CAP_SETS_FRAME_PROPS, \
1238 .hw_configs = cuvid_hw_configs, \
1239 .p.wrapper_name = "cuvid", \
1242 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
1246 #if CONFIG_HEVC_CUVID_DECODER
1250 #if CONFIG_H264_CUVID_DECODER
1254 #if CONFIG_MJPEG_CUVID_DECODER
1258 #if CONFIG_MPEG1_CUVID_DECODER
1262 #if CONFIG_MPEG2_CUVID_DECODER
1266 #if CONFIG_MPEG4_CUVID_DECODER
1270 #if CONFIG_VP8_CUVID_DECODER
1274 #if CONFIG_VP9_CUVID_DECODER
1278 #if CONFIG_VC1_CUVID_DECODER