git.sesse.net Git - ffmpeg/blob - libavcodec/cuviddec.c

   1 /*
   2  * Nvidia CUVID decoder
   3  * Copyright (c) 2016 Timo Rothenpieler <timo@rothenpieler.org>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "compat/cuda/dynlink_loader.h"
  23
  24 #include "libavutil/buffer.h"
  25 #include "libavutil/mathematics.h"
  26 #include "libavutil/hwcontext.h"
  27 #include "libavutil/hwcontext_cuda_internal.h"
  28 #include "libavutil/cuda_check.h"
  29 #include "libavutil/fifo.h"
  30 #include "libavutil/log.h"
  31 #include "libavutil/opt.h"
  32 #include "libavutil/pixdesc.h"
  33
  34 #include "avcodec.h"
  35 #include "decode.h"
  36 #include "hwconfig.h"
  37 #include "nvdec.h"
  38 #include "internal.h"
  39
  40 #if !NVDECAPI_CHECK_VERSION(9, 0)
  41 #define cudaVideoSurfaceFormat_YUV444 2
  42 #define cudaVideoSurfaceFormat_YUV444_16Bit 3
  43 #endif
  44
  45 #if NVDECAPI_CHECK_VERSION(11, 0)
  46 #define CUVID_HAS_AV1_SUPPORT
  47 #endif
  48
  49 typedef struct CuvidContext
  50 {
  51     AVClass *avclass;
  52
  53     CUvideodecoder cudecoder;
  54     CUvideoparser cuparser;
  55
  56     char *cu_gpu;
  57     int nb_surfaces;
  58     int drop_second_field;
  59     char *crop_expr;
  60     char *resize_expr;
  61
  62     struct {
  63         int left;
  64         int top;
  65         int right;
  66         int bottom;
  67     } crop;
  68
  69     struct {
  70         int width;
  71         int height;
  72     } resize;
  73
  74     AVBufferRef *hwdevice;
  75     AVBufferRef *hwframe;
  76
  77     AVFifoBuffer *frame_queue;
  78
  79     int deint_mode;
  80     int deint_mode_current;
  81     int64_t prev_pts;
  82     int progressive_sequence;
  83
  84     int internal_error;
  85     int decoder_flushing;
  86
  87     int *key_frame;
  88
  89     cudaVideoCodec codec_type;
  90     cudaVideoChromaFormat chroma_format;
  91
  92     CUVIDDECODECAPS caps8, caps10, caps12;
  93
  94     CUVIDPARSERPARAMS cuparseinfo;
  95     CUVIDEOFORMATEX *cuparse_ext;
  96
  97     CudaFunctions *cudl;
  98     CuvidFunctions *cvdl;
  99 } CuvidContext;
 100
 101 typedef struct CuvidParsedFrame
 102 {
 103     CUVIDPARSERDISPINFO dispinfo;
 104     int second_field;
 105     int is_deinterlacing;
 106 } CuvidParsedFrame;
 107
 108 #define CHECK_CU(x) FF_CUDA_CHECK_DL(avctx, ctx->cudl, x)
 109
 110 static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT* format)
 111 {
 112     AVCodecContext *avctx = opaque;
 113     CuvidContext *ctx = avctx->priv_data;
 114     AVHWFramesContext *hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
 115     CUVIDDECODECAPS *caps = NULL;
 116     CUVIDDECODECREATEINFO cuinfo;
 117     int surface_fmt;
 118     int chroma_444;
 119
 120     int old_width = avctx->width;
 121     int old_height = avctx->height;
 122
 123     enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
 124                                        AV_PIX_FMT_NONE,  // Will be updated below
 125                                        AV_PIX_FMT_NONE };
 126
 127     av_log(avctx, AV_LOG_TRACE, "pfnSequenceCallback, progressive_sequence=%d\n", format->progressive_sequence);
 128
 129     memset(&cuinfo, 0, sizeof(cuinfo));
 130
 131     ctx->internal_error = 0;
 132
 133     avctx->coded_width = cuinfo.ulWidth = format->coded_width;
 134     avctx->coded_height = cuinfo.ulHeight = format->coded_height;
 135
 136     // apply cropping
 137     cuinfo.display_area.left = format->display_area.left + ctx->crop.left;
 138     cuinfo.display_area.top = format->display_area.top + ctx->crop.top;
 139     cuinfo.display_area.right = format->display_area.right - ctx->crop.right;
 140     cuinfo.display_area.bottom = format->display_area.bottom - ctx->crop.bottom;
 141
 142     // width and height need to be set before calling ff_get_format
 143     if (ctx->resize_expr) {
 144         avctx->width = ctx->resize.width;
 145         avctx->height = ctx->resize.height;
 146     } else {
 147         avctx->width = cuinfo.display_area.right - cuinfo.display_area.left;
 148         avctx->height = cuinfo.display_area.bottom - cuinfo.display_area.top;
 149     }
 150
 151     // target width/height need to be multiples of two
 152     cuinfo.ulTargetWidth = avctx->width = (avctx->width + 1) & ~1;
 153     cuinfo.ulTargetHeight = avctx->height = (avctx->height + 1) & ~1;
 154
 155     // aspect ratio conversion, 1:1, depends on scaled resolution
 156     cuinfo.target_rect.left = 0;
 157     cuinfo.target_rect.top = 0;
 158     cuinfo.target_rect.right = cuinfo.ulTargetWidth;
 159     cuinfo.target_rect.bottom = cuinfo.ulTargetHeight;
 160
 161     chroma_444 = format->chroma_format == cudaVideoChromaFormat_444;
 162
 163     switch (format->bit_depth_luma_minus8) {
 164     case 0: // 8-bit
 165         pix_fmts[1] = chroma_444 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_NV12;
 166         caps = &ctx->caps8;
 167         break;
 168     case 2: // 10-bit
 169         pix_fmts[1] = chroma_444 ? AV_PIX_FMT_YUV444P16 : AV_PIX_FMT_P010;
 170         caps = &ctx->caps10;
 171         break;
 172     case 4: // 12-bit
 173         pix_fmts[1] = chroma_444 ? AV_PIX_FMT_YUV444P16 : AV_PIX_FMT_P016;
 174         caps = &ctx->caps12;
 175         break;
 176     default:
 177         break;
 178     }
 179
 180     if (!caps || !caps->bIsSupported) {
 181         av_log(avctx, AV_LOG_ERROR, "unsupported bit depth: %d\n",
 182                format->bit_depth_luma_minus8 + 8);
 183         ctx->internal_error = AVERROR(EINVAL);
 184         return 0;
 185     }
 186
 187     surface_fmt = ff_get_format(avctx, pix_fmts);
 188     if (surface_fmt < 0) {
 189         av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", surface_fmt);
 190         ctx->internal_error = AVERROR(EINVAL);
 191         return 0;
 192     }
 193
 194     av_log(avctx, AV_LOG_VERBOSE, "Formats: Original: %s | HW: %s | SW: %s\n",
 195            av_get_pix_fmt_name(avctx->pix_fmt),
 196            av_get_pix_fmt_name(surface_fmt),
 197            av_get_pix_fmt_name(avctx->sw_pix_fmt));
 198
 199     avctx->pix_fmt = surface_fmt;
 200
 201     // Update our hwframe ctx, as the get_format callback might have refreshed it!
 202     if (avctx->hw_frames_ctx) {
 203         av_buffer_unref(&ctx->hwframe);
 204
 205         ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
 206         if (!ctx->hwframe) {
 207             ctx->internal_error = AVERROR(ENOMEM);
 208             return 0;
 209         }
 210
 211         hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
 212     }
 213
 214     ff_set_sar(avctx, av_div_q(
 215         (AVRational){ format->display_aspect_ratio.x, format->display_aspect_ratio.y },
 216         (AVRational){ avctx->width, avctx->height }));
 217
 218     ctx->deint_mode_current = format->progressive_sequence
 219                               ? cudaVideoDeinterlaceMode_Weave
 220                               : ctx->deint_mode;
 221
 222     ctx->progressive_sequence = format->progressive_sequence;
 223
 224     if (!format->progressive_sequence && ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave)
 225         avctx->flags |= AV_CODEC_FLAG_INTERLACED_DCT;
 226     else
 227         avctx->flags &= ~AV_CODEC_FLAG_INTERLACED_DCT;
 228
 229     if (format->video_signal_description.video_full_range_flag)
 230         avctx->color_range = AVCOL_RANGE_JPEG;
 231     else
 232         avctx->color_range = AVCOL_RANGE_MPEG;
 233
 234     avctx->color_primaries = format->video_signal_description.color_primaries;
 235     avctx->color_trc = format->video_signal_description.transfer_characteristics;
 236     avctx->colorspace = format->video_signal_description.matrix_coefficients;
 237
 238     if (format->bitrate)
 239         avctx->bit_rate = format->bitrate;
 240
 241     if (format->frame_rate.numerator && format->frame_rate.denominator) {
 242         avctx->framerate.num = format->frame_rate.numerator;
 243         avctx->framerate.den = format->frame_rate.denominator;
 244     }
 245
 246     if (ctx->cudecoder
 247             && avctx->coded_width == format->coded_width
 248             && avctx->coded_height == format->coded_height
 249             && avctx->width == old_width
 250             && avctx->height == old_height
 251             && ctx->chroma_format == format->chroma_format
 252             && ctx->codec_type == format->codec)
 253         return 1;
 254
 255     if (ctx->cudecoder) {
 256         av_log(avctx, AV_LOG_TRACE, "Re-initializing decoder\n");
 257         ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder));
 258         if (ctx->internal_error < 0)
 259             return 0;
 260         ctx->cudecoder = NULL;
 261     }
 262
 263     if (hwframe_ctx->pool && (
 264             hwframe_ctx->width < avctx->width ||
 265             hwframe_ctx->height < avctx->height ||
 266             hwframe_ctx->format != AV_PIX_FMT_CUDA ||
 267             hwframe_ctx->sw_format != avctx->sw_pix_fmt)) {
 268         av_log(avctx, AV_LOG_ERROR, "AVHWFramesContext is already initialized with incompatible parameters\n");
 269         av_log(avctx, AV_LOG_DEBUG, "width: %d <-> %d\n", hwframe_ctx->width, avctx->width);
 270         av_log(avctx, AV_LOG_DEBUG, "height: %d <-> %d\n", hwframe_ctx->height, avctx->height);
 271         av_log(avctx, AV_LOG_DEBUG, "format: %s <-> cuda\n", av_get_pix_fmt_name(hwframe_ctx->format));
 272         av_log(avctx, AV_LOG_DEBUG, "sw_format: %s <-> %s\n",
 273                av_get_pix_fmt_name(hwframe_ctx->sw_format), av_get_pix_fmt_name(avctx->sw_pix_fmt));
 274         ctx->internal_error = AVERROR(EINVAL);
 275         return 0;
 276     }
 277
 278     ctx->chroma_format = format->chroma_format;
 279
 280     cuinfo.CodecType = ctx->codec_type = format->codec;
 281     cuinfo.ChromaFormat = format->chroma_format;
 282
 283     switch (avctx->sw_pix_fmt) {
 284     case AV_PIX_FMT_NV12:
 285         cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
 286         break;
 287     case AV_PIX_FMT_P010:
 288     case AV_PIX_FMT_P016:
 289         cuinfo.OutputFormat = cudaVideoSurfaceFormat_P016;
 290         break;
 291     case AV_PIX_FMT_YUV444P:
 292         cuinfo.OutputFormat = cudaVideoSurfaceFormat_YUV444;
 293         break;
 294     case AV_PIX_FMT_YUV444P16:
 295         cuinfo.OutputFormat = cudaVideoSurfaceFormat_YUV444_16Bit;
 296         break;
 297     default:
 298         av_log(avctx, AV_LOG_ERROR, "Unsupported output format: %s\n",
 299                av_get_pix_fmt_name(avctx->sw_pix_fmt));
 300         ctx->internal_error = AVERROR(EINVAL);
 301         return 0;
 302     }
 303
 304     cuinfo.ulNumDecodeSurfaces = ctx->nb_surfaces;
 305     cuinfo.ulNumOutputSurfaces = 1;
 306     cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
 307     cuinfo.bitDepthMinus8 = format->bit_depth_luma_minus8;
 308     cuinfo.DeinterlaceMode = ctx->deint_mode_current;
 309
 310     if (ctx->deint_mode_current != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field)
 311         avctx->framerate = av_mul_q(avctx->framerate, (AVRational){2, 1});
 312
 313     ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidCreateDecoder(&ctx->cudecoder, &cuinfo));
 314     if (ctx->internal_error < 0)
 315         return 0;
 316
 317     if (!hwframe_ctx->pool) {
 318         hwframe_ctx->format = AV_PIX_FMT_CUDA;
 319         hwframe_ctx->sw_format = avctx->sw_pix_fmt;
 320         hwframe_ctx->width = avctx->width;
 321         hwframe_ctx->height = avctx->height;
 322
 323         if ((ctx->internal_error = av_hwframe_ctx_init(ctx->hwframe)) < 0) {
 324             av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_init failed\n");
 325             return 0;
 326         }
 327     }
 328
 329     return 1;
 330 }
 331
 332 static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS* picparams)
 333 {
 334     AVCodecContext *avctx = opaque;
 335     CuvidContext *ctx = avctx->priv_data;
 336
 337     av_log(avctx, AV_LOG_TRACE, "pfnDecodePicture\n");
 338
 339     ctx->key_frame[picparams->CurrPicIdx] = picparams->intra_pic_flag;
 340
 341     ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDecodePicture(ctx->cudecoder, picparams));
 342     if (ctx->internal_error < 0)
 343         return 0;
 344
 345     return 1;
 346 }
 347
 348 static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO* dispinfo)
 349 {
 350     AVCodecContext *avctx = opaque;
 351     CuvidContext *ctx = avctx->priv_data;
 352     CuvidParsedFrame parsed_frame = { { 0 } };
 353
 354     parsed_frame.dispinfo = *dispinfo;
 355     ctx->internal_error = 0;
 356
 357     // For some reason, dispinfo->progressive_frame is sometimes wrong.
 358     parsed_frame.dispinfo.progressive_frame = ctx->progressive_sequence;
 359
 360     if (ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave) {
 361         av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
 362     } else {
 363         parsed_frame.is_deinterlacing = 1;
 364         av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
 365         if (!ctx->drop_second_field) {
 366             parsed_frame.second_field = 1;
 367             av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
 368         }
 369     }
 370
 371     return 1;
 372 }
 373
 374 static int cuvid_is_buffer_full(AVCodecContext *avctx)
 375 {
 376     CuvidContext *ctx = avctx->priv_data;
 377
 378     int delay = ctx->cuparseinfo.ulMaxDisplayDelay;
 379     if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field)
 380         delay *= 2;
 381
 382     return (av_fifo_size(ctx->frame_queue) / sizeof(CuvidParsedFrame)) + delay >= ctx->nb_surfaces;
 383 }
 384
 385 static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
 386 {
 387     CuvidContext *ctx = avctx->priv_data;
 388     AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
 389     AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
 390     CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
 391     CUVIDSOURCEDATAPACKET cupkt;
 392     int ret = 0, eret = 0, is_flush = ctx->decoder_flushing;
 393
 394     av_log(avctx, AV_LOG_TRACE, "cuvid_decode_packet\n");
 395
 396     if (is_flush && avpkt && avpkt->size)
 397         return AVERROR_EOF;
 398
 399     if (cuvid_is_buffer_full(avctx) && avpkt && avpkt->size)
 400         return AVERROR(EAGAIN);
 401
 402     ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
 403     if (ret < 0) {
 404         return ret;
 405     }
 406
 407     memset(&cupkt, 0, sizeof(cupkt));
 408
 409     if (avpkt && avpkt->size) {
 410         cupkt.payload_size = avpkt->size;
 411         cupkt.payload = avpkt->data;
 412
 413         if (avpkt->pts != AV_NOPTS_VALUE) {
 414             cupkt.flags = CUVID_PKT_TIMESTAMP;
 415             if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
 416                 cupkt.timestamp = av_rescale_q(avpkt->pts, avctx->pkt_timebase, (AVRational){1, 10000000});
 417             else
 418                 cupkt.timestamp = avpkt->pts;
 419         }
 420     } else {
 421         cupkt.flags = CUVID_PKT_ENDOFSTREAM;
 422         ctx->decoder_flushing = 1;
 423     }
 424
 425     ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &cupkt));
 426
 427     if (ret < 0)
 428         goto error;
 429
 430     // cuvidParseVideoData doesn't return an error just because stuff failed...
 431     if (ctx->internal_error) {
 432         av_log(avctx, AV_LOG_ERROR, "cuvid decode callback error\n");
 433         ret = ctx->internal_error;
 434         goto error;
 435     }
 436
 437 error:
 438     eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
 439
 440     if (eret < 0)
 441         return eret;
 442     else if (ret < 0)
 443         return ret;
 444     else if (is_flush)
 445         return AVERROR_EOF;
 446     else
 447         return 0;
 448 }
 449
 450 static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
 451 {
 452     CuvidContext *ctx = avctx->priv_data;
 453     AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
 454     AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
 455     CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
 456     CUdeviceptr mapped_frame = 0;
 457     int ret = 0, eret = 0;
 458
 459     av_log(avctx, AV_LOG_TRACE, "cuvid_output_frame\n");
 460
 461     if (ctx->decoder_flushing) {
 462         ret = cuvid_decode_packet(avctx, NULL);
 463         if (ret < 0 && ret != AVERROR_EOF)
 464             return ret;
 465     }
 466
 467     if (!cuvid_is_buffer_full(avctx)) {
 468         AVPacket pkt = {0};
 469         ret = ff_decode_get_packet(avctx, &pkt);
 470         if (ret < 0 && ret != AVERROR_EOF)
 471             return ret;
 472         ret = cuvid_decode_packet(avctx, &pkt);
 473         av_packet_unref(&pkt);
 474         // cuvid_is_buffer_full() should avoid this.
 475         if (ret == AVERROR(EAGAIN))
 476             ret = AVERROR_EXTERNAL;
 477         if (ret < 0 && ret != AVERROR_EOF)
 478             return ret;
 479     }
 480
 481     ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
 482     if (ret < 0)
 483         return ret;
 484
 485     if (av_fifo_size(ctx->frame_queue)) {
 486         const AVPixFmtDescriptor *pixdesc;
 487         CuvidParsedFrame parsed_frame;
 488         CUVIDPROCPARAMS params;
 489         unsigned int pitch = 0;
 490         int offset = 0;
 491         int i;
 492
 493         av_fifo_generic_read(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
 494
 495         memset(&params, 0, sizeof(params));
 496         params.progressive_frame = parsed_frame.dispinfo.progressive_frame;
 497         params.second_field = parsed_frame.second_field;
 498         params.top_field_first = parsed_frame.dispinfo.top_field_first;
 499
 500         ret = CHECK_CU(ctx->cvdl->cuvidMapVideoFrame(ctx->cudecoder, parsed_frame.dispinfo.picture_index, &mapped_frame, &pitch, &params));
 501         if (ret < 0)
 502             goto error;
 503
 504         if (avctx->pix_fmt == AV_PIX_FMT_CUDA) {
 505             ret = av_hwframe_get_buffer(ctx->hwframe, frame, 0);
 506             if (ret < 0) {
 507                 av_log(avctx, AV_LOG_ERROR, "av_hwframe_get_buffer failed\n");
 508                 goto error;
 509             }
 510
 511             ret = ff_decode_frame_props(avctx, frame);
 512             if (ret < 0) {
 513                 av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props failed\n");
 514                 goto error;
 515             }
 516
 517             pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
 518
 519             for (i = 0; i < pixdesc->nb_components; i++) {
 520                 int height = avctx->height >> (i ? pixdesc->log2_chroma_h : 0);
 521                 CUDA_MEMCPY2D cpy = {
 522                     .srcMemoryType = CU_MEMORYTYPE_DEVICE,
 523                     .dstMemoryType = CU_MEMORYTYPE_DEVICE,
 524                     .srcDevice     = mapped_frame,
 525                     .dstDevice     = (CUdeviceptr)frame->data[i],
 526                     .srcPitch      = pitch,
 527                     .dstPitch      = frame->linesize[i],
 528                     .srcY          = offset,
 529                     .WidthInBytes  = FFMIN(pitch, frame->linesize[i]),
 530                     .Height        = height,
 531                 };
 532
 533                 ret = CHECK_CU(ctx->cudl->cuMemcpy2DAsync(&cpy, device_hwctx->stream));
 534                 if (ret < 0)
 535                     goto error;
 536
 537                 offset += height;
 538             }
 539         } else if (avctx->pix_fmt == AV_PIX_FMT_NV12      ||
 540                    avctx->pix_fmt == AV_PIX_FMT_P010      ||
 541                    avctx->pix_fmt == AV_PIX_FMT_P016      ||
 542                    avctx->pix_fmt == AV_PIX_FMT_YUV444P   ||
 543                    avctx->pix_fmt == AV_PIX_FMT_YUV444P16) {
 544             unsigned int offset = 0;
 545             AVFrame *tmp_frame = av_frame_alloc();
 546             if (!tmp_frame) {
 547                 av_log(avctx, AV_LOG_ERROR, "av_frame_alloc failed\n");
 548                 ret = AVERROR(ENOMEM);
 549                 goto error;
 550             }
 551
 552             pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
 553
 554             tmp_frame->format        = AV_PIX_FMT_CUDA;
 555             tmp_frame->hw_frames_ctx = av_buffer_ref(ctx->hwframe);
 556             tmp_frame->width         = avctx->width;
 557             tmp_frame->height        = avctx->height;
 558
 559             /*
 560              * Note that the following logic would not work for three plane
 561              * YUV420 because the pitch value is different for the chroma
 562              * planes.
 563              */
 564             for (i = 0; i < pixdesc->nb_components; i++) {
 565                 tmp_frame->data[i]     = (uint8_t*)mapped_frame + offset;
 566                 tmp_frame->linesize[i] = pitch;
 567                 offset += pitch * (avctx->height >> (i ? pixdesc->log2_chroma_h : 0));
 568             }
 569
 570             ret = ff_get_buffer(avctx, frame, 0);
 571             if (ret < 0) {
 572                 av_log(avctx, AV_LOG_ERROR, "ff_get_buffer failed\n");
 573                 av_frame_free(&tmp_frame);
 574                 goto error;
 575             }
 576
 577             ret = av_hwframe_transfer_data(frame, tmp_frame, 0);
 578             if (ret) {
 579                 av_log(avctx, AV_LOG_ERROR, "av_hwframe_transfer_data failed\n");
 580                 av_frame_free(&tmp_frame);
 581                 goto error;
 582             }
 583             av_frame_free(&tmp_frame);
 584         } else {
 585             ret = AVERROR_BUG;
 586             goto error;
 587         }
 588
 589         frame->key_frame = ctx->key_frame[parsed_frame.dispinfo.picture_index];
 590         frame->width = avctx->width;
 591         frame->height = avctx->height;
 592         if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
 593             frame->pts = av_rescale_q(parsed_frame.dispinfo.timestamp, (AVRational){1, 10000000}, avctx->pkt_timebase);
 594         else
 595             frame->pts = parsed_frame.dispinfo.timestamp;
 596
 597         if (parsed_frame.second_field) {
 598             if (ctx->prev_pts == INT64_MIN) {
 599                 ctx->prev_pts = frame->pts;
 600                 frame->pts += (avctx->pkt_timebase.den * avctx->framerate.den) / (avctx->pkt_timebase.num * avctx->framerate.num);
 601             } else {
 602                 int pts_diff = (frame->pts - ctx->prev_pts) / 2;
 603                 ctx->prev_pts = frame->pts;
 604                 frame->pts += pts_diff;
 605             }
 606         }
 607
 608         /* CUVIDs opaque reordering breaks the internal pkt logic.
 609          * So set pkt_pts and clear all the other pkt_ fields.
 610          */
 611 #if FF_API_PKT_PTS
 612 FF_DISABLE_DEPRECATION_WARNINGS
 613         frame->pkt_pts = frame->pts;
 614 FF_ENABLE_DEPRECATION_WARNINGS
 615 #endif
 616         frame->pkt_pos = -1;
 617         frame->pkt_duration = 0;
 618         frame->pkt_size = -1;
 619
 620         frame->interlaced_frame = !parsed_frame.is_deinterlacing && !parsed_frame.dispinfo.progressive_frame;
 621
 622         if (frame->interlaced_frame)
 623             frame->top_field_first = parsed_frame.dispinfo.top_field_first;
 624     } else if (ctx->decoder_flushing) {
 625         ret = AVERROR_EOF;
 626     } else {
 627         ret = AVERROR(EAGAIN);
 628     }
 629
 630 error:
 631     if (mapped_frame)
 632         eret = CHECK_CU(ctx->cvdl->cuvidUnmapVideoFrame(ctx->cudecoder, mapped_frame));
 633
 634     eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
 635
 636     if (eret < 0)
 637         return eret;
 638     else
 639         return ret;
 640 }
 641
 642 static int cuvid_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
 643 {
 644     CuvidContext *ctx = avctx->priv_data;
 645     AVFrame *frame = data;
 646     int ret = 0;
 647
 648     av_log(avctx, AV_LOG_TRACE, "cuvid_decode_frame\n");
 649
 650     if (ctx->deint_mode_current != cudaVideoDeinterlaceMode_Weave) {
 651         av_log(avctx, AV_LOG_ERROR, "Deinterlacing is not supported via the old API\n");
 652         return AVERROR(EINVAL);
 653     }
 654
 655     if (!ctx->decoder_flushing) {
 656         ret = cuvid_decode_packet(avctx, avpkt);
 657         if (ret < 0)
 658             return ret;
 659     }
 660
 661     ret = cuvid_output_frame(avctx, frame);
 662     if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
 663         *got_frame = 0;
 664     } else if (ret < 0) {
 665         return ret;
 666     } else {
 667         *got_frame = 1;
 668     }
 669
 670     return 0;
 671 }
 672
 673 static av_cold int cuvid_decode_end(AVCodecContext *avctx)
 674 {
 675     CuvidContext *ctx = avctx->priv_data;
 676     AVHWDeviceContext *device_ctx = (AVHWDeviceContext *)ctx->hwdevice->data;
 677     AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
 678     CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
 679
 680     av_fifo_freep(&ctx->frame_queue);
 681
 682     ctx->cudl->cuCtxPushCurrent(cuda_ctx);
 683
 684     if (ctx->cuparser)
 685         ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
 686
 687     if (ctx->cudecoder)
 688         ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
 689
 690     ctx->cudl->cuCtxPopCurrent(&dummy);
 691
 692     ctx->cudl = NULL;
 693
 694     av_buffer_unref(&ctx->hwframe);
 695     av_buffer_unref(&ctx->hwdevice);
 696
 697     av_freep(&ctx->key_frame);
 698     av_freep(&ctx->cuparse_ext);
 699
 700     cuvid_free_functions(&ctx->cvdl);
 701
 702     return 0;
 703 }
 704
 705 static int cuvid_test_capabilities(AVCodecContext *avctx,
 706                                    const CUVIDPARSERPARAMS *cuparseinfo,
 707                                    int probed_width,
 708                                    int probed_height,
 709                                    int bit_depth)
 710 {
 711     CuvidContext *ctx = avctx->priv_data;
 712     CUVIDDECODECAPS *caps;
 713     int res8 = 0, res10 = 0, res12 = 0;
 714
 715     if (!ctx->cvdl->cuvidGetDecoderCaps) {
 716         av_log(avctx, AV_LOG_WARNING, "Used Nvidia driver is too old to perform a capability check.\n");
 717         av_log(avctx, AV_LOG_WARNING, "The minimum required version is "
 718 #if defined(_WIN32) || defined(__CYGWIN__)
 719             "378.66"
 720 #else
 721             "378.13"
 722 #endif
 723             ". Continuing blind.\n");
 724         ctx->caps8.bIsSupported = ctx->caps10.bIsSupported = 1;
 725         // 12 bit was not supported before the capability check was introduced, so disable it.
 726         ctx->caps12.bIsSupported = 0;
 727         return 0;
 728     }
 729
 730     ctx->caps8.eCodecType = ctx->caps10.eCodecType = ctx->caps12.eCodecType
 731         = cuparseinfo->CodecType;
 732     ctx->caps8.eChromaFormat = ctx->caps10.eChromaFormat = ctx->caps12.eChromaFormat
 733         = cudaVideoChromaFormat_420;
 734
 735     ctx->caps8.nBitDepthMinus8 = 0;
 736     ctx->caps10.nBitDepthMinus8 = 2;
 737     ctx->caps12.nBitDepthMinus8 = 4;
 738
 739     res8 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps8));
 740     res10 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps10));
 741     res12 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps12));
 742
 743     av_log(avctx, AV_LOG_VERBOSE, "CUVID capabilities for %s:\n", avctx->codec->name);
 744     av_log(avctx, AV_LOG_VERBOSE, "8 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
 745            ctx->caps8.bIsSupported, ctx->caps8.nMinWidth, ctx->caps8.nMaxWidth, ctx->caps8.nMinHeight, ctx->caps8.nMaxHeight);
 746     av_log(avctx, AV_LOG_VERBOSE, "10 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
 747            ctx->caps10.bIsSupported, ctx->caps10.nMinWidth, ctx->caps10.nMaxWidth, ctx->caps10.nMinHeight, ctx->caps10.nMaxHeight);
 748     av_log(avctx, AV_LOG_VERBOSE, "12 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
 749            ctx->caps12.bIsSupported, ctx->caps12.nMinWidth, ctx->caps12.nMaxWidth, ctx->caps12.nMinHeight, ctx->caps12.nMaxHeight);
 750
 751     switch (bit_depth) {
 752     case 10:
 753         caps = &ctx->caps10;
 754         if (res10 < 0)
 755             return res10;
 756         break;
 757     case 12:
 758         caps = &ctx->caps12;
 759         if (res12 < 0)
 760             return res12;
 761         break;
 762     default:
 763         caps = &ctx->caps8;
 764         if (res8 < 0)
 765             return res8;
 766     }
 767
 768     if (!ctx->caps8.bIsSupported) {
 769         av_log(avctx, AV_LOG_ERROR, "Codec %s is not supported.\n", avctx->codec->name);
 770         return AVERROR(EINVAL);
 771     }
 772
 773     if (!caps->bIsSupported) {
 774         av_log(avctx, AV_LOG_ERROR, "Bit depth %d is not supported.\n", bit_depth);
 775         return AVERROR(EINVAL);
 776     }
 777
 778     if (probed_width > caps->nMaxWidth || probed_width < caps->nMinWidth) {
 779         av_log(avctx, AV_LOG_ERROR, "Video width %d not within range from %d to %d\n",
 780                probed_width, caps->nMinWidth, caps->nMaxWidth);
 781         return AVERROR(EINVAL);
 782     }
 783
 784     if (probed_height > caps->nMaxHeight || probed_height < caps->nMinHeight) {
 785         av_log(avctx, AV_LOG_ERROR, "Video height %d not within range from %d to %d\n",
 786                probed_height, caps->nMinHeight, caps->nMaxHeight);
 787         return AVERROR(EINVAL);
 788     }
 789
 790     if ((probed_width * probed_height) / 256 > caps->nMaxMBCount) {
 791         av_log(avctx, AV_LOG_ERROR, "Video macroblock count %d exceeds maximum of %d\n",
 792                (int)(probed_width * probed_height) / 256, caps->nMaxMBCount);
 793         return AVERROR(EINVAL);
 794     }
 795
 796     return 0;
 797 }
 798
 799 static av_cold int cuvid_decode_init(AVCodecContext *avctx)
 800 {
 801     CuvidContext *ctx = avctx->priv_data;
 802     AVCUDADeviceContext *device_hwctx;
 803     AVHWDeviceContext *device_ctx;
 804     AVHWFramesContext *hwframe_ctx;
 805     CUVIDSOURCEDATAPACKET seq_pkt;
 806     CUcontext cuda_ctx = NULL;
 807     CUcontext dummy;
 808     uint8_t *extradata;
 809     int extradata_size;
 810     int ret = 0;
 811
 812     enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
 813                                        AV_PIX_FMT_NV12,
 814                                        AV_PIX_FMT_NONE };
 815
 816     int probed_width = avctx->coded_width ? avctx->coded_width : 1280;
 817     int probed_height = avctx->coded_height ? avctx->coded_height : 720;
 818     int probed_bit_depth = 8;
 819
 820     const AVPixFmtDescriptor *probe_desc = av_pix_fmt_desc_get(avctx->pix_fmt);
 821     if (probe_desc && probe_desc->nb_components)
 822         probed_bit_depth = probe_desc->comp[0].depth;
 823
 824     // Accelerated transcoding scenarios with 'ffmpeg' require that the
 825     // pix_fmt be set to AV_PIX_FMT_CUDA early. The sw_pix_fmt, and the
 826     // pix_fmt for non-accelerated transcoding, do not need to be correct
 827     // but need to be set to something. We arbitrarily pick NV12.
 828     ret = ff_get_format(avctx, pix_fmts);
 829     if (ret < 0) {
 830         av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", ret);
 831         return ret;
 832     }
 833     avctx->pix_fmt = ret;
 834
 835     if (ctx->resize_expr && sscanf(ctx->resize_expr, "%dx%d",
 836                                    &ctx->resize.width, &ctx->resize.height) != 2) {
 837         av_log(avctx, AV_LOG_ERROR, "Invalid resize expressions\n");
 838         ret = AVERROR(EINVAL);
 839         goto error;
 840     }
 841
 842     if (ctx->crop_expr && sscanf(ctx->crop_expr, "%dx%dx%dx%d",
 843                                  &ctx->crop.top, &ctx->crop.bottom,
 844                                  &ctx->crop.left, &ctx->crop.right) != 4) {
 845         av_log(avctx, AV_LOG_ERROR, "Invalid cropping expressions\n");
 846         ret = AVERROR(EINVAL);
 847         goto error;
 848     }
 849
 850     ret = cuvid_load_functions(&ctx->cvdl, avctx);
 851     if (ret < 0) {
 852         av_log(avctx, AV_LOG_ERROR, "Failed loading nvcuvid.\n");
 853         goto error;
 854     }
 855
 856     ctx->frame_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(CuvidParsedFrame));
 857     if (!ctx->frame_queue) {
 858         ret = AVERROR(ENOMEM);
 859         goto error;
 860     }
 861
 862     if (avctx->hw_frames_ctx) {
 863         ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
 864         if (!ctx->hwframe) {
 865             ret = AVERROR(ENOMEM);
 866             goto error;
 867         }
 868
 869         hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
 870
 871         ctx->hwdevice = av_buffer_ref(hwframe_ctx->device_ref);
 872         if (!ctx->hwdevice) {
 873             ret = AVERROR(ENOMEM);
 874             goto error;
 875         }
 876     } else {
 877         if (avctx->hw_device_ctx) {
 878             ctx->hwdevice = av_buffer_ref(avctx->hw_device_ctx);
 879             if (!ctx->hwdevice) {
 880                 ret = AVERROR(ENOMEM);
 881                 goto error;
 882             }
 883         } else {
 884             ret = av_hwdevice_ctx_create(&ctx->hwdevice, AV_HWDEVICE_TYPE_CUDA, ctx->cu_gpu, NULL, 0);
 885             if (ret < 0)
 886                 goto error;
 887         }
 888
 889         ctx->hwframe = av_hwframe_ctx_alloc(ctx->hwdevice);
 890         if (!ctx->hwframe) {
 891             av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
 892             ret = AVERROR(ENOMEM);
 893             goto error;
 894         }
 895
 896         hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
 897     }
 898
 899     device_ctx = hwframe_ctx->device_ctx;
 900     device_hwctx = device_ctx->hwctx;
 901
 902     cuda_ctx = device_hwctx->cuda_ctx;
 903     ctx->cudl = device_hwctx->internal->cuda_dl;
 904
 905     memset(&ctx->cuparseinfo, 0, sizeof(ctx->cuparseinfo));
 906     memset(&seq_pkt, 0, sizeof(seq_pkt));
 907
 908     switch (avctx->codec->id) {
 909 #if CONFIG_H264_CUVID_DECODER
 910     case AV_CODEC_ID_H264:
 911         ctx->cuparseinfo.CodecType = cudaVideoCodec_H264;
 912         break;
 913 #endif
 914 #if CONFIG_HEVC_CUVID_DECODER
 915     case AV_CODEC_ID_HEVC:
 916         ctx->cuparseinfo.CodecType = cudaVideoCodec_HEVC;
 917         break;
 918 #endif
 919 #if CONFIG_MJPEG_CUVID_DECODER
 920     case AV_CODEC_ID_MJPEG:
 921         ctx->cuparseinfo.CodecType = cudaVideoCodec_JPEG;
 922         break;
 923 #endif
 924 #if CONFIG_MPEG1_CUVID_DECODER
 925     case AV_CODEC_ID_MPEG1VIDEO:
 926         ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG1;
 927         break;
 928 #endif
 929 #if CONFIG_MPEG2_CUVID_DECODER
 930     case AV_CODEC_ID_MPEG2VIDEO:
 931         ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG2;
 932         break;
 933 #endif
 934 #if CONFIG_MPEG4_CUVID_DECODER
 935     case AV_CODEC_ID_MPEG4:
 936         ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
 937         break;
 938 #endif
 939 #if CONFIG_VP8_CUVID_DECODER
 940     case AV_CODEC_ID_VP8:
 941         ctx->cuparseinfo.CodecType = cudaVideoCodec_VP8;
 942         break;
 943 #endif
 944 #if CONFIG_VP9_CUVID_DECODER
 945     case AV_CODEC_ID_VP9:
 946         ctx->cuparseinfo.CodecType = cudaVideoCodec_VP9;
 947         break;
 948 #endif
 949 #if CONFIG_VC1_CUVID_DECODER
 950     case AV_CODEC_ID_VC1:
 951         ctx->cuparseinfo.CodecType = cudaVideoCodec_VC1;
 952         break;
 953 #endif
 954 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
 955     case AV_CODEC_ID_AV1:
 956         ctx->cuparseinfo.CodecType = cudaVideoCodec_AV1;
 957         break;
 958 #endif
 959     default:
 960         av_log(avctx, AV_LOG_ERROR, "Invalid CUVID codec!\n");
 961         return AVERROR_BUG;
 962     }
 963
 964     if (avctx->codec->bsfs) {
 965         const AVCodecParameters *par = avctx->internal->bsf->par_out;
 966         extradata = par->extradata;
 967         extradata_size = par->extradata_size;
 968     } else {
 969         extradata = avctx->extradata;
 970         extradata_size = avctx->extradata_size;
 971     }
 972
 973     ctx->cuparse_ext = av_mallocz(sizeof(*ctx->cuparse_ext)
 974             + FFMAX(extradata_size - (int)sizeof(ctx->cuparse_ext->raw_seqhdr_data), 0));
 975     if (!ctx->cuparse_ext) {
 976         ret = AVERROR(ENOMEM);
 977         goto error;
 978     }
 979
 980     if (extradata_size > 0)
 981         memcpy(ctx->cuparse_ext->raw_seqhdr_data, extradata, extradata_size);
 982     ctx->cuparse_ext->format.seqhdr_data_length = extradata_size;
 983
 984     ctx->cuparseinfo.pExtVideoInfo = ctx->cuparse_ext;
 985
 986     ctx->key_frame = av_mallocz(ctx->nb_surfaces * sizeof(int));
 987     if (!ctx->key_frame) {
 988         ret = AVERROR(ENOMEM);
 989         goto error;
 990     }
 991
 992     ctx->cuparseinfo.ulMaxNumDecodeSurfaces = ctx->nb_surfaces;
 993     ctx->cuparseinfo.ulMaxDisplayDelay = 4;
 994     ctx->cuparseinfo.pUserData = avctx;
 995     ctx->cuparseinfo.pfnSequenceCallback = cuvid_handle_video_sequence;
 996     ctx->cuparseinfo.pfnDecodePicture = cuvid_handle_picture_decode;
 997     ctx->cuparseinfo.pfnDisplayPicture = cuvid_handle_picture_display;
 998
 999     ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
1000     if (ret < 0)
1001         goto error;
1002
1003     ret = cuvid_test_capabilities(avctx, &ctx->cuparseinfo,
1004                                   probed_width,
1005                                   probed_height,
1006                                   probed_bit_depth);
1007     if (ret < 0)
1008         goto error;
1009
1010     ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
1011     if (ret < 0)
1012         goto error;
1013
1014     seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
1015     seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
1016
1017     if (seq_pkt.payload && seq_pkt.payload_size) {
1018         ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
1019         if (ret < 0)
1020             goto error;
1021     }
1022
1023     ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
1024     if (ret < 0)
1025         goto error;
1026
1027     ctx->prev_pts = INT64_MIN;
1028
1029     if (!avctx->pkt_timebase.num || !avctx->pkt_timebase.den)
1030         av_log(avctx, AV_LOG_WARNING, "Invalid pkt_timebase, passing timestamps as-is.\n");
1031
1032     return 0;
1033
1034 error:
1035     cuvid_decode_end(avctx);
1036     return ret;
1037 }
1038
1039 static void cuvid_flush(AVCodecContext *avctx)
1040 {
1041     CuvidContext *ctx = avctx->priv_data;
1042     AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
1043     AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
1044     CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
1045     CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
1046     int ret;
1047
1048     ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
1049     if (ret < 0)
1050         goto error;
1051
1052     av_fifo_freep(&ctx->frame_queue);
1053
1054     ctx->frame_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(CuvidParsedFrame));
1055     if (!ctx->frame_queue) {
1056         av_log(avctx, AV_LOG_ERROR, "Failed to recreate frame queue on flush\n");
1057         return;
1058     }
1059
1060     if (ctx->cudecoder) {
1061         ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
1062         ctx->cudecoder = NULL;
1063     }
1064
1065     if (ctx->cuparser) {
1066         ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
1067         ctx->cuparser = NULL;
1068     }
1069
1070     ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
1071     if (ret < 0)
1072         goto error;
1073
1074     seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
1075     seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
1076
1077     if (seq_pkt.payload && seq_pkt.payload_size) {
1078         ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
1079         if (ret < 0)
1080             goto error;
1081     }
1082
1083     ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
1084     if (ret < 0)
1085         goto error;
1086
1087     ctx->prev_pts = INT64_MIN;
1088     ctx->decoder_flushing = 0;
1089
1090     return;
1091  error:
1092     av_log(avctx, AV_LOG_ERROR, "CUDA reinit on flush failed\n");
1093 }
1094
1095 #define OFFSET(x) offsetof(CuvidContext, x)
1096 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1097 static const AVOption options[] = {
1098     { "deint",    "Set deinterlacing mode", OFFSET(deint_mode), AV_OPT_TYPE_INT,   { .i64 = cudaVideoDeinterlaceMode_Weave    }, cudaVideoDeinterlaceMode_Weave, cudaVideoDeinterlaceMode_Adaptive, VD, "deint" },
1099     { "weave",    "Weave deinterlacing (do nothing)",        0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Weave    }, 0, 0, VD, "deint" },
1100     { "bob",      "Bob deinterlacing",                       0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob      }, 0, 0, VD, "deint" },
1101     { "adaptive", "Adaptive deinterlacing",                  0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0, VD, "deint" },
1102     { "gpu",      "GPU to be used for decoding", OFFSET(cu_gpu), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1103     { "surfaces", "Maximum surfaces to be used for decoding", OFFSET(nb_surfaces), AV_OPT_TYPE_INT, { .i64 = 25 }, 0, INT_MAX, VD },
1104     { "drop_second_field", "Drop second field when deinterlacing", OFFSET(drop_second_field), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
1105     { "crop",     "Crop (top)x(bottom)x(left)x(right)", OFFSET(crop_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1106     { "resize",   "Resize (width)x(height)", OFFSET(resize_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1107     { NULL }
1108 };
1109
1110 static const AVCodecHWConfigInternal *const cuvid_hw_configs[] = {
1111     &(const AVCodecHWConfigInternal) {
1112         .public = {
1113             .pix_fmt     = AV_PIX_FMT_CUDA,
1114             .methods     = AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX |
1115                            AV_CODEC_HW_CONFIG_METHOD_INTERNAL,
1116             .device_type = AV_HWDEVICE_TYPE_CUDA
1117         },
1118         .hwaccel = NULL,
1119     },
1120     NULL
1121 };
1122
1123 #define DEFINE_CUVID_CODEC(x, X, bsf_name) \
1124     static const AVClass x##_cuvid_class = { \
1125         .class_name = #x "_cuvid", \
1126         .item_name = av_default_item_name, \
1127         .option = options, \
1128         .version = LIBAVUTIL_VERSION_INT, \
1129     }; \
1130     AVCodec ff_##x##_cuvid_decoder = { \
1131         .name           = #x "_cuvid", \
1132         .long_name      = NULL_IF_CONFIG_SMALL("Nvidia CUVID " #X " decoder"), \
1133         .type           = AVMEDIA_TYPE_VIDEO, \
1134         .id             = AV_CODEC_ID_##X, \
1135         .priv_data_size = sizeof(CuvidContext), \
1136         .priv_class     = &x##_cuvid_class, \
1137         .init           = cuvid_decode_init, \
1138         .close          = cuvid_decode_end, \
1139         .decode         = cuvid_decode_frame, \
1140         .receive_frame  = cuvid_output_frame, \
1141         .flush          = cuvid_flush, \
1142         .bsfs           = bsf_name, \
1143         .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
1144         .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_CUDA, \
1145                                                         AV_PIX_FMT_NV12, \
1146                                                         AV_PIX_FMT_P010, \
1147                                                         AV_PIX_FMT_P016, \
1148                                                         AV_PIX_FMT_NONE }, \
1149         .hw_configs     = cuvid_hw_configs, \
1150         .wrapper_name   = "cuvid", \
1151     };
1152
1153 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
1154 DEFINE_CUVID_CODEC(av1, AV1, NULL)
1155 #endif
1156
1157 #if CONFIG_HEVC_CUVID_DECODER
1158 DEFINE_CUVID_CODEC(hevc, HEVC, "hevc_mp4toannexb")
1159 #endif
1160
1161 #if CONFIG_H264_CUVID_DECODER
1162 DEFINE_CUVID_CODEC(h264, H264, "h264_mp4toannexb")
1163 #endif
1164
1165 #if CONFIG_MJPEG_CUVID_DECODER
1166 DEFINE_CUVID_CODEC(mjpeg, MJPEG, NULL)
1167 #endif
1168
1169 #if CONFIG_MPEG1_CUVID_DECODER
1170 DEFINE_CUVID_CODEC(mpeg1, MPEG1VIDEO, NULL)
1171 #endif
1172
1173 #if CONFIG_MPEG2_CUVID_DECODER
1174 DEFINE_CUVID_CODEC(mpeg2, MPEG2VIDEO, NULL)
1175 #endif
1176
1177 #if CONFIG_MPEG4_CUVID_DECODER
1178 DEFINE_CUVID_CODEC(mpeg4, MPEG4, NULL)
1179 #endif
1180
1181 #if CONFIG_VP8_CUVID_DECODER
1182 DEFINE_CUVID_CODEC(vp8, VP8, NULL)
1183 #endif
1184
1185 #if CONFIG_VP9_CUVID_DECODER
1186 DEFINE_CUVID_CODEC(vp9, VP9, NULL)
1187 #endif
1188
1189 #if CONFIG_VC1_CUVID_DECODER
1190 DEFINE_CUVID_CODEC(vc1, VC1, NULL)
1191 #endif