3 * Copyright (c) 2016 Timo Rothenpieler <timo@rothenpieler.org>
5 * This file is part of FFmpeg.
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.
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.
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
22 #include "libavutil/buffer.h"
23 #include "libavutil/mathematics.h"
24 #include "libavutil/hwcontext.h"
25 #include "libavutil/hwcontext_cuda.h"
26 #include "libavutil/fifo.h"
27 #include "libavutil/log.h"
28 #include "libavutil/opt.h"
33 #include "compat/cuda/nvcuvid.h"
35 #define MAX_FRAME_COUNT 25
37 typedef struct CuvidContext
41 CUvideodecoder cudecoder;
42 CUvideoparser cuparser;
44 AVBufferRef *hwdevice;
49 AVFifoBuffer *frame_queue;
58 cudaVideoCodec codec_type;
59 cudaVideoChromaFormat chroma_format;
61 CUVIDPARSERPARAMS cuparseinfo;
62 CUVIDEOFORMATEX cuparse_ext;
65 typedef struct CuvidParsedFrame
67 CUVIDPARSERDISPINFO dispinfo;
72 static int check_cu(AVCodecContext *avctx, CUresult err, const char *func)
75 const char *err_string;
77 av_log(avctx, AV_LOG_TRACE, "Calling %s\n", func);
79 if (err == CUDA_SUCCESS)
82 cuGetErrorName(err, &err_name);
83 cuGetErrorString(err, &err_string);
85 av_log(avctx, AV_LOG_ERROR, "%s failed", func);
86 if (err_name && err_string)
87 av_log(avctx, AV_LOG_ERROR, " -> %s: %s", err_name, err_string);
88 av_log(avctx, AV_LOG_ERROR, "\n");
90 return AVERROR_EXTERNAL;
93 #define CHECK_CU(x) check_cu(avctx, (x), #x)
95 static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT* format)
97 AVCodecContext *avctx = opaque;
98 CuvidContext *ctx = avctx->priv_data;
99 AVHWFramesContext *hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
100 CUVIDDECODECREATEINFO cuinfo;
102 av_log(avctx, AV_LOG_TRACE, "pfnSequenceCallback, progressive_sequence=%d\n", format->progressive_sequence);
104 ctx->internal_error = 0;
106 avctx->width = format->display_area.right;
107 avctx->height = format->display_area.bottom;
109 ff_set_sar(avctx, av_div_q(
110 (AVRational){ format->display_aspect_ratio.x, format->display_aspect_ratio.y },
111 (AVRational){ avctx->width, avctx->height }));
113 if (!format->progressive_sequence && ctx->deint_mode == cudaVideoDeinterlaceMode_Weave)
114 avctx->flags |= AV_CODEC_FLAG_INTERLACED_DCT;
116 avctx->flags &= ~AV_CODEC_FLAG_INTERLACED_DCT;
118 if (format->video_signal_description.video_full_range_flag)
119 avctx->color_range = AVCOL_RANGE_JPEG;
121 avctx->color_range = AVCOL_RANGE_MPEG;
123 avctx->color_primaries = format->video_signal_description.color_primaries;
124 avctx->color_trc = format->video_signal_description.transfer_characteristics;
125 avctx->colorspace = format->video_signal_description.matrix_coefficients;
128 avctx->bit_rate = format->bitrate;
130 if (format->frame_rate.numerator && format->frame_rate.denominator) {
131 avctx->framerate.num = format->frame_rate.numerator;
132 avctx->framerate.den = format->frame_rate.denominator;
136 && avctx->coded_width == format->coded_width
137 && avctx->coded_height == format->coded_height
138 && ctx->chroma_format == format->chroma_format
139 && ctx->codec_type == format->codec)
142 if (ctx->cudecoder) {
143 av_log(avctx, AV_LOG_ERROR, "re-initializing decoder is not supported\n");
144 ctx->internal_error = AVERROR(EINVAL);
148 if (hwframe_ctx->pool && !ctx->ever_flushed) {
149 av_log(avctx, AV_LOG_ERROR, "AVHWFramesContext is already initialized\n");
150 ctx->internal_error = AVERROR(EINVAL);
154 if (format->chroma_format != cudaVideoChromaFormat_420) {
155 av_log(avctx, AV_LOG_ERROR, "Chroma formats other than 420 are not supported\n");
156 ctx->internal_error = AVERROR(EINVAL);
160 avctx->coded_width = format->coded_width;
161 avctx->coded_height = format->coded_height;
163 ctx->chroma_format = format->chroma_format;
165 memset(&cuinfo, 0, sizeof(cuinfo));
167 cuinfo.CodecType = ctx->codec_type = format->codec;
168 cuinfo.ChromaFormat = format->chroma_format;
169 cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
171 cuinfo.ulWidth = avctx->coded_width;
172 cuinfo.ulHeight = avctx->coded_height;
173 cuinfo.ulTargetWidth = cuinfo.ulWidth;
174 cuinfo.ulTargetHeight = cuinfo.ulHeight;
176 cuinfo.target_rect.left = 0;
177 cuinfo.target_rect.top = 0;
178 cuinfo.target_rect.right = cuinfo.ulWidth;
179 cuinfo.target_rect.bottom = cuinfo.ulHeight;
181 cuinfo.ulNumDecodeSurfaces = MAX_FRAME_COUNT;
182 cuinfo.ulNumOutputSurfaces = 1;
183 cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
184 cuinfo.bitDepthMinus8 = format->bit_depth_luma_minus8;
186 if (format->progressive_sequence) {
187 ctx->deint_mode = cuinfo.DeinterlaceMode = cudaVideoDeinterlaceMode_Weave;
189 cuinfo.DeinterlaceMode = ctx->deint_mode;
192 if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave)
193 avctx->framerate = av_mul_q(avctx->framerate, (AVRational){2, 1});
195 ctx->internal_error = CHECK_CU(cuvidCreateDecoder(&ctx->cudecoder, &cuinfo));
196 if (ctx->internal_error < 0)
199 if (!hwframe_ctx->pool) {
200 hwframe_ctx->format = AV_PIX_FMT_CUDA;
201 hwframe_ctx->sw_format = AV_PIX_FMT_NV12;
202 hwframe_ctx->width = FFALIGN(avctx->coded_width, 32);
203 hwframe_ctx->height = FFALIGN(avctx->coded_height, 32);
205 if ((ctx->internal_error = av_hwframe_ctx_init(ctx->hwframe)) < 0) {
206 av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_init failed\n");
214 static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS* picparams)
216 AVCodecContext *avctx = opaque;
217 CuvidContext *ctx = avctx->priv_data;
219 av_log(avctx, AV_LOG_TRACE, "pfnDecodePicture\n");
221 ctx->internal_error = CHECK_CU(cuvidDecodePicture(ctx->cudecoder, picparams));
222 if (ctx->internal_error < 0)
228 static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO* dispinfo)
230 AVCodecContext *avctx = opaque;
231 CuvidContext *ctx = avctx->priv_data;
232 CuvidParsedFrame parsed_frame = { *dispinfo, 0, 0 };
234 ctx->internal_error = 0;
236 if (ctx->deint_mode == cudaVideoDeinterlaceMode_Weave) {
237 av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
239 parsed_frame.is_deinterlacing = 1;
240 av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
241 parsed_frame.second_field = 1;
242 av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
248 static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
250 CuvidContext *ctx = avctx->priv_data;
251 AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
252 AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
253 CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
254 CUVIDSOURCEDATAPACKET cupkt;
255 AVPacket filter_packet = { 0 };
256 AVPacket filtered_packet = { 0 };
257 int ret = 0, eret = 0, is_flush = ctx->decoder_flushing;
259 av_log(avctx, AV_LOG_TRACE, "cuvid_decode_packet\n");
261 if (is_flush && avpkt && avpkt->size)
264 if (av_fifo_size(ctx->frame_queue) / sizeof(CuvidParsedFrame) > MAX_FRAME_COUNT - 2 && avpkt && avpkt->size)
265 return AVERROR(EAGAIN);
267 if (ctx->bsf && avpkt && avpkt->size) {
268 if ((ret = av_packet_ref(&filter_packet, avpkt)) < 0) {
269 av_log(avctx, AV_LOG_ERROR, "av_packet_ref failed\n");
273 if ((ret = av_bsf_send_packet(ctx->bsf, &filter_packet)) < 0) {
274 av_log(avctx, AV_LOG_ERROR, "av_bsf_send_packet failed\n");
275 av_packet_unref(&filter_packet);
279 if ((ret = av_bsf_receive_packet(ctx->bsf, &filtered_packet)) < 0) {
280 av_log(avctx, AV_LOG_ERROR, "av_bsf_receive_packet failed\n");
284 avpkt = &filtered_packet;
287 ret = CHECK_CU(cuCtxPushCurrent(cuda_ctx));
289 av_packet_unref(&filtered_packet);
293 memset(&cupkt, 0, sizeof(cupkt));
295 if (avpkt && avpkt->size) {
296 cupkt.payload_size = avpkt->size;
297 cupkt.payload = avpkt->data;
299 if (avpkt->pts != AV_NOPTS_VALUE) {
300 cupkt.flags = CUVID_PKT_TIMESTAMP;
301 if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
302 cupkt.timestamp = av_rescale_q(avpkt->pts, avctx->pkt_timebase, (AVRational){1, 10000000});
304 cupkt.timestamp = avpkt->pts;
307 cupkt.flags = CUVID_PKT_ENDOFSTREAM;
308 ctx->decoder_flushing = 1;
311 ret = CHECK_CU(cuvidParseVideoData(ctx->cuparser, &cupkt));
313 av_packet_unref(&filtered_packet);
318 // cuvidParseVideoData doesn't return an error just because stuff failed...
319 if (ctx->internal_error) {
320 av_log(avctx, AV_LOG_ERROR, "cuvid decode callback error\n");
321 ret = ctx->internal_error;
326 eret = CHECK_CU(cuCtxPopCurrent(&dummy));
338 static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
340 CuvidContext *ctx = avctx->priv_data;
341 AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
342 AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
343 CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
344 CUdeviceptr mapped_frame = 0;
345 int ret = 0, eret = 0;
347 av_log(avctx, AV_LOG_TRACE, "cuvid_output_frame\n");
349 if (ctx->decoder_flushing) {
350 ret = cuvid_decode_packet(avctx, NULL);
351 if (ret < 0 && ret != AVERROR_EOF)
355 ret = CHECK_CU(cuCtxPushCurrent(cuda_ctx));
359 if (av_fifo_size(ctx->frame_queue)) {
360 CuvidParsedFrame parsed_frame;
361 CUVIDPROCPARAMS params;
362 unsigned int pitch = 0;
366 av_fifo_generic_read(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
368 memset(¶ms, 0, sizeof(params));
369 params.progressive_frame = parsed_frame.dispinfo.progressive_frame;
370 params.second_field = parsed_frame.second_field;
371 params.top_field_first = parsed_frame.dispinfo.top_field_first;
373 ret = CHECK_CU(cuvidMapVideoFrame(ctx->cudecoder, parsed_frame.dispinfo.picture_index, &mapped_frame, &pitch, ¶ms));
377 if (avctx->pix_fmt == AV_PIX_FMT_CUDA) {
378 ret = av_hwframe_get_buffer(ctx->hwframe, frame, 0);
380 av_log(avctx, AV_LOG_ERROR, "av_hwframe_get_buffer failed\n");
384 ret = ff_decode_frame_props(avctx, frame);
386 av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props failed\n");
390 for (i = 0; i < 2; i++) {
391 CUDA_MEMCPY2D cpy = {
392 .srcMemoryType = CU_MEMORYTYPE_DEVICE,
393 .dstMemoryType = CU_MEMORYTYPE_DEVICE,
394 .srcDevice = mapped_frame,
395 .dstDevice = (CUdeviceptr)frame->data[i],
397 .dstPitch = frame->linesize[i],
399 .WidthInBytes = FFMIN(pitch, frame->linesize[i]),
400 .Height = avctx->coded_height >> (i ? 1 : 0),
403 ret = CHECK_CU(cuMemcpy2D(&cpy));
407 offset += avctx->coded_height;
409 } else if (avctx->pix_fmt == AV_PIX_FMT_NV12) {
410 AVFrame *tmp_frame = av_frame_alloc();
412 av_log(avctx, AV_LOG_ERROR, "av_frame_alloc failed\n");
413 ret = AVERROR(ENOMEM);
417 tmp_frame->format = AV_PIX_FMT_CUDA;
418 tmp_frame->hw_frames_ctx = av_buffer_ref(ctx->hwframe);
419 tmp_frame->data[0] = (uint8_t*)mapped_frame;
420 tmp_frame->linesize[0] = pitch;
421 tmp_frame->data[1] = (uint8_t*)(mapped_frame + avctx->coded_height * pitch);
422 tmp_frame->linesize[1] = pitch;
423 tmp_frame->width = avctx->width;
424 tmp_frame->height = avctx->height;
426 ret = ff_get_buffer(avctx, frame, 0);
428 av_log(avctx, AV_LOG_ERROR, "ff_get_buffer failed\n");
429 av_frame_free(&tmp_frame);
433 ret = av_hwframe_transfer_data(frame, tmp_frame, 0);
435 av_log(avctx, AV_LOG_ERROR, "av_hwframe_transfer_data failed\n");
436 av_frame_free(&tmp_frame);
440 av_frame_free(&tmp_frame);
446 frame->width = avctx->width;
447 frame->height = avctx->height;
448 if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
449 frame->pts = av_rescale_q(parsed_frame.dispinfo.timestamp, (AVRational){1, 10000000}, avctx->pkt_timebase);
451 frame->pts = parsed_frame.dispinfo.timestamp;
453 if (parsed_frame.second_field) {
454 if (ctx->prev_pts == INT64_MIN) {
455 ctx->prev_pts = frame->pts;
456 frame->pts += (avctx->pkt_timebase.den * avctx->framerate.den) / (avctx->pkt_timebase.num * avctx->framerate.num);
458 int pts_diff = (frame->pts - ctx->prev_pts) / 2;
459 ctx->prev_pts = frame->pts;
460 frame->pts += pts_diff;
464 /* CUVIDs opaque reordering breaks the internal pkt logic.
465 * So set pkt_pts and clear all the other pkt_ fields.
467 frame->pkt_pts = frame->pts;
468 av_frame_set_pkt_pos(frame, -1);
469 av_frame_set_pkt_duration(frame, 0);
470 av_frame_set_pkt_size(frame, -1);
472 frame->interlaced_frame = !parsed_frame.is_deinterlacing && !parsed_frame.dispinfo.progressive_frame;
474 if (frame->interlaced_frame)
475 frame->top_field_first = parsed_frame.dispinfo.top_field_first;
476 } else if (ctx->decoder_flushing) {
479 ret = AVERROR(EAGAIN);
484 eret = CHECK_CU(cuvidUnmapVideoFrame(ctx->cudecoder, mapped_frame));
486 eret = CHECK_CU(cuCtxPopCurrent(&dummy));
494 static int cuvid_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
496 CuvidContext *ctx = avctx->priv_data;
497 AVFrame *frame = data;
500 av_log(avctx, AV_LOG_TRACE, "cuvid_decode_frame\n");
502 if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave) {
503 av_log(avctx, AV_LOG_ERROR, "Deinterlacing is not supported via the old API\n");
504 return AVERROR(EINVAL);
507 if (!ctx->decoder_flushing) {
508 ret = cuvid_decode_packet(avctx, avpkt);
513 ret = cuvid_output_frame(avctx, frame);
514 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
516 } else if (ret < 0) {
525 static av_cold int cuvid_decode_end(AVCodecContext *avctx)
527 CuvidContext *ctx = avctx->priv_data;
529 av_fifo_freep(&ctx->frame_queue);
532 av_bsf_free(&ctx->bsf);
535 cuvidDestroyVideoParser(ctx->cuparser);
538 cuvidDestroyDecoder(ctx->cudecoder);
540 av_buffer_unref(&ctx->hwframe);
541 av_buffer_unref(&ctx->hwdevice);
546 static void cuvid_ctx_free(AVHWDeviceContext *ctx)
548 AVCUDADeviceContext *hwctx = ctx->hwctx;
549 cuCtxDestroy(hwctx->cuda_ctx);
552 static int cuvid_test_dummy_decoder(AVCodecContext *avctx, CUVIDPARSERPARAMS *cuparseinfo)
554 CUVIDDECODECREATEINFO cuinfo;
555 CUvideodecoder cudec = 0;
558 memset(&cuinfo, 0, sizeof(cuinfo));
560 cuinfo.CodecType = cuparseinfo->CodecType;
561 cuinfo.ChromaFormat = cudaVideoChromaFormat_420;
562 cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
564 cuinfo.ulWidth = 1280;
565 cuinfo.ulHeight = 720;
566 cuinfo.ulTargetWidth = cuinfo.ulWidth;
567 cuinfo.ulTargetHeight = cuinfo.ulHeight;
569 cuinfo.target_rect.left = 0;
570 cuinfo.target_rect.top = 0;
571 cuinfo.target_rect.right = cuinfo.ulWidth;
572 cuinfo.target_rect.bottom = cuinfo.ulHeight;
574 cuinfo.ulNumDecodeSurfaces = MAX_FRAME_COUNT;
575 cuinfo.ulNumOutputSurfaces = 1;
576 cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
577 cuinfo.bitDepthMinus8 = 0;
579 cuinfo.DeinterlaceMode = cudaVideoDeinterlaceMode_Weave;
581 ret = CHECK_CU(cuvidCreateDecoder(&cudec, &cuinfo));
585 ret = CHECK_CU(cuvidDestroyDecoder(cudec));
592 static av_cold int cuvid_decode_init(AVCodecContext *avctx)
594 CuvidContext *ctx = avctx->priv_data;
595 AVCUDADeviceContext *device_hwctx;
596 AVHWDeviceContext *device_ctx;
597 AVHWFramesContext *hwframe_ctx;
598 CUVIDSOURCEDATAPACKET seq_pkt;
600 CUcontext cuda_ctx = NULL;
602 const AVBitStreamFilter *bsf;
605 enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
609 ret = ff_get_format(avctx, pix_fmts);
611 av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", ret);
615 ctx->frame_queue = av_fifo_alloc(MAX_FRAME_COUNT * sizeof(CuvidParsedFrame));
616 if (!ctx->frame_queue) {
617 ret = AVERROR(ENOMEM);
621 avctx->pix_fmt = ret;
623 if (avctx->hw_frames_ctx) {
624 ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
626 ret = AVERROR(ENOMEM);
630 hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
632 ctx->hwdevice = av_buffer_ref(hwframe_ctx->device_ref);
633 if (!ctx->hwdevice) {
634 ret = AVERROR(ENOMEM);
638 device_ctx = hwframe_ctx->device_ctx;
639 device_hwctx = device_ctx->hwctx;
640 cuda_ctx = device_hwctx->cuda_ctx;
642 ctx->hwdevice = av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_CUDA);
643 if (!ctx->hwdevice) {
644 av_log(avctx, AV_LOG_ERROR, "Error allocating hwdevice\n");
645 ret = AVERROR(ENOMEM);
649 ret = CHECK_CU(cuInit(0));
653 ret = CHECK_CU(cuDeviceGet(&device, 0));
657 ret = CHECK_CU(cuCtxCreate(&cuda_ctx, CU_CTX_SCHED_BLOCKING_SYNC, device));
661 device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
662 device_ctx->free = cuvid_ctx_free;
664 device_hwctx = device_ctx->hwctx;
665 device_hwctx->cuda_ctx = cuda_ctx;
667 ret = CHECK_CU(cuCtxPopCurrent(&dummy));
671 ret = av_hwdevice_ctx_init(ctx->hwdevice);
673 av_log(avctx, AV_LOG_ERROR, "av_hwdevice_ctx_init failed\n");
677 ctx->hwframe = av_hwframe_ctx_alloc(ctx->hwdevice);
679 av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
680 ret = AVERROR(ENOMEM);
685 memset(&ctx->cuparseinfo, 0, sizeof(ctx->cuparseinfo));
686 memset(&ctx->cuparse_ext, 0, sizeof(ctx->cuparse_ext));
687 memset(&seq_pkt, 0, sizeof(seq_pkt));
689 ctx->cuparseinfo.pExtVideoInfo = &ctx->cuparse_ext;
691 switch (avctx->codec->id) {
692 #if CONFIG_H263_CUVID_DECODER
693 case AV_CODEC_ID_H263:
694 ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
697 #if CONFIG_H264_CUVID_DECODER
698 case AV_CODEC_ID_H264:
699 ctx->cuparseinfo.CodecType = cudaVideoCodec_H264;
702 #if CONFIG_HEVC_CUVID_DECODER
703 case AV_CODEC_ID_HEVC:
704 ctx->cuparseinfo.CodecType = cudaVideoCodec_HEVC;
707 #if CONFIG_MJPEG_CUVID_DECODER
708 case AV_CODEC_ID_MJPEG:
709 ctx->cuparseinfo.CodecType = cudaVideoCodec_JPEG;
712 #if CONFIG_MPEG1_CUVID_DECODER
713 case AV_CODEC_ID_MPEG1VIDEO:
714 ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG1;
717 #if CONFIG_MPEG2_CUVID_DECODER
718 case AV_CODEC_ID_MPEG2VIDEO:
719 ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG2;
722 #if CONFIG_MPEG4_CUVID_DECODER
723 case AV_CODEC_ID_MPEG4:
724 ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
727 #if CONFIG_VP8_CUVID_DECODER
728 case AV_CODEC_ID_VP8:
729 ctx->cuparseinfo.CodecType = cudaVideoCodec_VP8;
732 #if CONFIG_VP9_CUVID_DECODER
733 case AV_CODEC_ID_VP9:
734 ctx->cuparseinfo.CodecType = cudaVideoCodec_VP9;
737 #if CONFIG_VC1_CUVID_DECODER
738 case AV_CODEC_ID_VC1:
739 ctx->cuparseinfo.CodecType = cudaVideoCodec_VC1;
743 av_log(avctx, AV_LOG_ERROR, "Invalid CUVID codec!\n");
747 if (avctx->codec->id == AV_CODEC_ID_H264 || avctx->codec->id == AV_CODEC_ID_HEVC) {
748 if (avctx->codec->id == AV_CODEC_ID_H264)
749 bsf = av_bsf_get_by_name("h264_mp4toannexb");
751 bsf = av_bsf_get_by_name("hevc_mp4toannexb");
754 ret = AVERROR_BSF_NOT_FOUND;
757 if (ret = av_bsf_alloc(bsf, &ctx->bsf)) {
760 if (((ret = avcodec_parameters_from_context(ctx->bsf->par_in, avctx)) < 0) || ((ret = av_bsf_init(ctx->bsf)) < 0)) {
761 av_bsf_free(&ctx->bsf);
765 ctx->cuparse_ext.format.seqhdr_data_length = ctx->bsf->par_out->extradata_size;
766 memcpy(ctx->cuparse_ext.raw_seqhdr_data,
767 ctx->bsf->par_out->extradata,
768 FFMIN(sizeof(ctx->cuparse_ext.raw_seqhdr_data), ctx->bsf->par_out->extradata_size));
769 } else if (avctx->extradata_size > 0) {
770 ctx->cuparse_ext.format.seqhdr_data_length = avctx->extradata_size;
771 memcpy(ctx->cuparse_ext.raw_seqhdr_data,
773 FFMIN(sizeof(ctx->cuparse_ext.raw_seqhdr_data), avctx->extradata_size));
776 ctx->cuparseinfo.ulMaxNumDecodeSurfaces = MAX_FRAME_COUNT;
777 ctx->cuparseinfo.ulMaxDisplayDelay = 4;
778 ctx->cuparseinfo.pUserData = avctx;
779 ctx->cuparseinfo.pfnSequenceCallback = cuvid_handle_video_sequence;
780 ctx->cuparseinfo.pfnDecodePicture = cuvid_handle_picture_decode;
781 ctx->cuparseinfo.pfnDisplayPicture = cuvid_handle_picture_display;
783 ret = CHECK_CU(cuCtxPushCurrent(cuda_ctx));
787 ret = cuvid_test_dummy_decoder(avctx, &ctx->cuparseinfo);
791 ret = CHECK_CU(cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
795 seq_pkt.payload = ctx->cuparse_ext.raw_seqhdr_data;
796 seq_pkt.payload_size = ctx->cuparse_ext.format.seqhdr_data_length;
798 if (seq_pkt.payload && seq_pkt.payload_size) {
799 ret = CHECK_CU(cuvidParseVideoData(ctx->cuparser, &seq_pkt));
804 ret = CHECK_CU(cuCtxPopCurrent(&dummy));
808 ctx->ever_flushed = 0;
810 ctx->prev_pts = INT64_MIN;
812 if (!avctx->pkt_timebase.num || !avctx->pkt_timebase.den)
813 av_log(avctx, AV_LOG_WARNING, "Invalid pkt_timebase, passing timestamps as-is.\n");
818 cuvid_decode_end(avctx);
822 static void cuvid_flush(AVCodecContext *avctx)
824 CuvidContext *ctx = avctx->priv_data;
825 AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
826 AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
827 CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
828 CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
831 ctx->ever_flushed = 1;
833 ret = CHECK_CU(cuCtxPushCurrent(cuda_ctx));
837 av_fifo_freep(&ctx->frame_queue);
839 ctx->frame_queue = av_fifo_alloc(MAX_FRAME_COUNT * sizeof(CuvidParsedFrame));
840 if (!ctx->frame_queue) {
841 av_log(avctx, AV_LOG_ERROR, "Failed to recreate frame queue on flush\n");
845 if (ctx->cudecoder) {
846 cuvidDestroyDecoder(ctx->cudecoder);
847 ctx->cudecoder = NULL;
851 cuvidDestroyVideoParser(ctx->cuparser);
852 ctx->cuparser = NULL;
855 ret = CHECK_CU(cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
859 seq_pkt.payload = ctx->cuparse_ext.raw_seqhdr_data;
860 seq_pkt.payload_size = ctx->cuparse_ext.format.seqhdr_data_length;
862 if (seq_pkt.payload && seq_pkt.payload_size) {
863 ret = CHECK_CU(cuvidParseVideoData(ctx->cuparser, &seq_pkt));
868 ret = CHECK_CU(cuCtxPopCurrent(&dummy));
872 ctx->prev_pts = INT64_MIN;
873 ctx->decoder_flushing = 0;
877 av_log(avctx, AV_LOG_ERROR, "CUDA reinit on flush failed\n");
880 #define OFFSET(x) offsetof(CuvidContext, x)
881 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
882 static const AVOption options[] = {
883 { "deint", "Set deinterlacing mode", OFFSET(deint_mode), AV_OPT_TYPE_INT, { .i64 = cudaVideoDeinterlaceMode_Weave }, cudaVideoDeinterlaceMode_Weave, cudaVideoDeinterlaceMode_Adaptive, VD, "deint" },
884 { "weave", "Weave deinterlacing (do nothing)", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Weave }, 0, 0, VD, "deint" },
885 { "bob", "Bob deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob }, 0, 0, VD, "deint" },
886 { "adaptive", "Adaptive deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0, VD, "deint" },
890 #define DEFINE_CUVID_CODEC(x, X) \
891 static const AVClass x##_cuvid_class = { \
892 .class_name = #x "_cuvid", \
893 .item_name = av_default_item_name, \
895 .version = LIBAVUTIL_VERSION_INT, \
897 AVHWAccel ff_##x##_cuvid_hwaccel = { \
898 .name = #x "_cuvid", \
899 .type = AVMEDIA_TYPE_VIDEO, \
900 .id = AV_CODEC_ID_##X, \
901 .pix_fmt = AV_PIX_FMT_CUDA, \
903 AVCodec ff_##x##_cuvid_decoder = { \
904 .name = #x "_cuvid", \
905 .long_name = NULL_IF_CONFIG_SMALL("Nvidia CUVID " #X " decoder"), \
906 .type = AVMEDIA_TYPE_VIDEO, \
907 .id = AV_CODEC_ID_##X, \
908 .priv_data_size = sizeof(CuvidContext), \
909 .priv_class = &x##_cuvid_class, \
910 .init = cuvid_decode_init, \
911 .close = cuvid_decode_end, \
912 .decode = cuvid_decode_frame, \
913 .send_packet = cuvid_decode_packet, \
914 .receive_frame = cuvid_output_frame, \
915 .flush = cuvid_flush, \
916 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING, \
917 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_CUDA, \
922 #if CONFIG_HEVC_CUVID_DECODER
923 DEFINE_CUVID_CODEC(hevc, HEVC)
926 #if CONFIG_H263_CUVID_DECODER
927 DEFINE_CUVID_CODEC(h263, H263)
930 #if CONFIG_H264_CUVID_DECODER
931 DEFINE_CUVID_CODEC(h264, H264)
934 #if CONFIG_MJPEG_CUVID_DECODER
935 DEFINE_CUVID_CODEC(mjpeg, MJPEG)
938 #if CONFIG_MPEG1_CUVID_DECODER
939 DEFINE_CUVID_CODEC(mpeg1, MPEG1VIDEO)
942 #if CONFIG_MPEG2_CUVID_DECODER
943 DEFINE_CUVID_CODEC(mpeg2, MPEG2VIDEO)
946 #if CONFIG_MPEG4_CUVID_DECODER
947 DEFINE_CUVID_CODEC(mpeg4, MPEG4)
950 #if CONFIG_VP8_CUVID_DECODER
951 DEFINE_CUVID_CODEC(vp8, VP8)
954 #if CONFIG_VP9_CUVID_DECODER
955 DEFINE_CUVID_CODEC(vp9, VP9)
958 #if CONFIG_VC1_CUVID_DECODER
959 DEFINE_CUVID_CODEC(vc1, VC1)