avcodec/cuvid: add format mismatch debug logs
[ffmpeg.git] / libavcodec / cuvid.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/fifo.h"
29 #include "libavutil/log.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32
33 #include "avcodec.h"
34 #include "internal.h"
35
36 typedef struct CuvidContext
37 {
38     AVClass *avclass;
39
40     CUvideodecoder cudecoder;
41     CUvideoparser cuparser;
42
43     char *cu_gpu;
44     int nb_surfaces;
45
46     AVBufferRef *hwdevice;
47     AVBufferRef *hwframe;
48
49     AVBSFContext *bsf;
50
51     AVFifoBuffer *frame_queue;
52
53     int deint_mode;
54     int64_t prev_pts;
55
56     int internal_error;
57     int decoder_flushing;
58
59     cudaVideoCodec codec_type;
60     cudaVideoChromaFormat chroma_format;
61
62     CUVIDPARSERPARAMS cuparseinfo;
63     CUVIDEOFORMATEX cuparse_ext;
64
65     CudaFunctions *cudl;
66     CuvidFunctions *cvdl;
67 } CuvidContext;
68
69 typedef struct CuvidParsedFrame
70 {
71     CUVIDPARSERDISPINFO dispinfo;
72     int second_field;
73     int is_deinterlacing;
74 } CuvidParsedFrame;
75
76 static int check_cu(AVCodecContext *avctx, CUresult err, const char *func)
77 {
78     CuvidContext *ctx = avctx->priv_data;
79     const char *err_name;
80     const char *err_string;
81
82     av_log(avctx, AV_LOG_TRACE, "Calling %s\n", func);
83
84     if (err == CUDA_SUCCESS)
85         return 0;
86
87     ctx->cudl->cuGetErrorName(err, &err_name);
88     ctx->cudl->cuGetErrorString(err, &err_string);
89
90     av_log(avctx, AV_LOG_ERROR, "%s failed", func);
91     if (err_name && err_string)
92         av_log(avctx, AV_LOG_ERROR, " -> %s: %s", err_name, err_string);
93     av_log(avctx, AV_LOG_ERROR, "\n");
94
95     return AVERROR_EXTERNAL;
96 }
97
98 #define CHECK_CU(x) check_cu(avctx, (x), #x)
99
100 static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT* format)
101 {
102     AVCodecContext *avctx = opaque;
103     CuvidContext *ctx = avctx->priv_data;
104     AVHWFramesContext *hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
105     CUVIDDECODECREATEINFO cuinfo;
106     int surface_fmt;
107
108     enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
109                                        AV_PIX_FMT_NONE,  // Will be updated below
110                                        AV_PIX_FMT_NONE };
111
112     av_log(avctx, AV_LOG_TRACE, "pfnSequenceCallback, progressive_sequence=%d\n", format->progressive_sequence);
113
114     ctx->internal_error = 0;
115
116     // width and height need to be set before calling ff_get_format
117     avctx->width = format->display_area.right;
118     avctx->height = format->display_area.bottom;
119
120     switch (format->bit_depth_luma_minus8) {
121     case 0: // 8-bit
122         pix_fmts[1] = AV_PIX_FMT_NV12;
123         break;
124     case 2: // 10-bit
125         pix_fmts[1] = AV_PIX_FMT_P010;
126         break;
127     case 4: // 12-bit
128         pix_fmts[1] = AV_PIX_FMT_P016;
129         break;
130     default:
131         av_log(avctx, AV_LOG_ERROR, "unsupported bit depth: %d\n",
132                format->bit_depth_luma_minus8 + 8);
133         ctx->internal_error = AVERROR(EINVAL);
134         return 0;
135     }
136     surface_fmt = ff_get_format(avctx, pix_fmts);
137     if (surface_fmt < 0) {
138         av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", surface_fmt);
139         ctx->internal_error = AVERROR(EINVAL);
140         return 0;
141     }
142
143     av_log(avctx, AV_LOG_VERBOSE, "Formats: Original: %s | HW: %s | SW: %s\n",
144            av_get_pix_fmt_name(avctx->pix_fmt),
145            av_get_pix_fmt_name(surface_fmt),
146            av_get_pix_fmt_name(avctx->sw_pix_fmt));
147
148     avctx->pix_fmt = surface_fmt;
149
150     // Update our hwframe ctx, as the get_format callback might have refreshed it!
151     if (avctx->hw_frames_ctx) {
152         av_buffer_unref(&ctx->hwframe);
153
154         ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
155         if (!ctx->hwframe) {
156             ctx->internal_error = AVERROR(ENOMEM);
157             return 0;
158         }
159
160         hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
161     }
162
163     ff_set_sar(avctx, av_div_q(
164         (AVRational){ format->display_aspect_ratio.x, format->display_aspect_ratio.y },
165         (AVRational){ avctx->width, avctx->height }));
166
167     if (!format->progressive_sequence && ctx->deint_mode == cudaVideoDeinterlaceMode_Weave)
168         avctx->flags |= AV_CODEC_FLAG_INTERLACED_DCT;
169     else
170         avctx->flags &= ~AV_CODEC_FLAG_INTERLACED_DCT;
171
172     if (format->video_signal_description.video_full_range_flag)
173         avctx->color_range = AVCOL_RANGE_JPEG;
174     else
175         avctx->color_range = AVCOL_RANGE_MPEG;
176
177     avctx->color_primaries = format->video_signal_description.color_primaries;
178     avctx->color_trc = format->video_signal_description.transfer_characteristics;
179     avctx->colorspace = format->video_signal_description.matrix_coefficients;
180
181     if (format->bitrate)
182         avctx->bit_rate = format->bitrate;
183
184     if (format->frame_rate.numerator && format->frame_rate.denominator) {
185         avctx->framerate.num = format->frame_rate.numerator;
186         avctx->framerate.den = format->frame_rate.denominator;
187     }
188
189     if (ctx->cudecoder
190             && avctx->coded_width == format->coded_width
191             && avctx->coded_height == format->coded_height
192             && ctx->chroma_format == format->chroma_format
193             && ctx->codec_type == format->codec)
194         return 1;
195
196     if (ctx->cudecoder) {
197         av_log(avctx, AV_LOG_TRACE, "Re-initializing decoder\n");
198         ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder));
199         if (ctx->internal_error < 0)
200             return 0;
201         ctx->cudecoder = NULL;
202     }
203
204     if (hwframe_ctx->pool && (
205             hwframe_ctx->width < avctx->width ||
206             hwframe_ctx->height < avctx->height ||
207             hwframe_ctx->format != AV_PIX_FMT_CUDA ||
208             hwframe_ctx->sw_format != avctx->sw_pix_fmt)) {
209         av_log(avctx, AV_LOG_ERROR, "AVHWFramesContext is already initialized with incompatible parameters\n");
210         av_log(avctx, AV_LOG_DEBUG, "width: %d <-> %d\n", hwframe_ctx->width, avctx->width);
211         av_log(avctx, AV_LOG_DEBUG, "height: %d <-> %d\n", hwframe_ctx->height, avctx->height);
212         av_log(avctx, AV_LOG_DEBUG, "format: %s <-> cuda\n", av_get_pix_fmt_name(hwframe_ctx->format));
213         av_log(avctx, AV_LOG_DEBUG, "sw_format: %s <-> %s\n",
214                av_get_pix_fmt_name(hwframe_ctx->sw_format), av_get_pix_fmt_name(avctx->sw_pix_fmt));
215         ctx->internal_error = AVERROR(EINVAL);
216         return 0;
217     }
218
219     if (format->chroma_format != cudaVideoChromaFormat_420) {
220         av_log(avctx, AV_LOG_ERROR, "Chroma formats other than 420 are not supported\n");
221         ctx->internal_error = AVERROR(EINVAL);
222         return 0;
223     }
224
225     avctx->coded_width = format->coded_width;
226     avctx->coded_height = format->coded_height;
227
228     ctx->chroma_format = format->chroma_format;
229
230     memset(&cuinfo, 0, sizeof(cuinfo));
231
232     cuinfo.CodecType = ctx->codec_type = format->codec;
233     cuinfo.ChromaFormat = format->chroma_format;
234
235     switch (avctx->sw_pix_fmt) {
236     case AV_PIX_FMT_NV12:
237         cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
238         break;
239     case AV_PIX_FMT_P010:
240     case AV_PIX_FMT_P016:
241         cuinfo.OutputFormat = cudaVideoSurfaceFormat_P016;
242         break;
243     default:
244         av_log(avctx, AV_LOG_ERROR, "Output formats other than NV12, P010 or P016 are not supported\n");
245         ctx->internal_error = AVERROR(EINVAL);
246         return 0;
247     }
248
249     cuinfo.ulWidth = avctx->coded_width;
250     cuinfo.ulHeight = avctx->coded_height;
251     cuinfo.ulTargetWidth = cuinfo.ulWidth;
252     cuinfo.ulTargetHeight = cuinfo.ulHeight;
253
254     cuinfo.target_rect.left = 0;
255     cuinfo.target_rect.top = 0;
256     cuinfo.target_rect.right = cuinfo.ulWidth;
257     cuinfo.target_rect.bottom = cuinfo.ulHeight;
258
259     cuinfo.ulNumDecodeSurfaces = ctx->nb_surfaces;
260     cuinfo.ulNumOutputSurfaces = 1;
261     cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
262     cuinfo.bitDepthMinus8 = format->bit_depth_luma_minus8;
263
264     if (format->progressive_sequence) {
265         ctx->deint_mode = cuinfo.DeinterlaceMode = cudaVideoDeinterlaceMode_Weave;
266     } else {
267         cuinfo.DeinterlaceMode = ctx->deint_mode;
268     }
269
270     if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave)
271         avctx->framerate = av_mul_q(avctx->framerate, (AVRational){2, 1});
272
273     ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidCreateDecoder(&ctx->cudecoder, &cuinfo));
274     if (ctx->internal_error < 0)
275         return 0;
276
277     if (!hwframe_ctx->pool) {
278         hwframe_ctx->format = AV_PIX_FMT_CUDA;
279         hwframe_ctx->sw_format = avctx->sw_pix_fmt;
280         hwframe_ctx->width = avctx->width;
281         hwframe_ctx->height = avctx->height;
282
283         if ((ctx->internal_error = av_hwframe_ctx_init(ctx->hwframe)) < 0) {
284             av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_init failed\n");
285             return 0;
286         }
287     }
288
289     return 1;
290 }
291
292 static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS* picparams)
293 {
294     AVCodecContext *avctx = opaque;
295     CuvidContext *ctx = avctx->priv_data;
296
297     av_log(avctx, AV_LOG_TRACE, "pfnDecodePicture\n");
298
299     ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDecodePicture(ctx->cudecoder, picparams));
300     if (ctx->internal_error < 0)
301         return 0;
302
303     return 1;
304 }
305
306 static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO* dispinfo)
307 {
308     AVCodecContext *avctx = opaque;
309     CuvidContext *ctx = avctx->priv_data;
310     CuvidParsedFrame parsed_frame = { { 0 } };
311
312     parsed_frame.dispinfo = *dispinfo;
313     ctx->internal_error = 0;
314
315     if (ctx->deint_mode == cudaVideoDeinterlaceMode_Weave) {
316         av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
317     } else {
318         parsed_frame.is_deinterlacing = 1;
319         av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
320         parsed_frame.second_field = 1;
321         av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
322     }
323
324     return 1;
325 }
326
327 static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
328 {
329     CuvidContext *ctx = avctx->priv_data;
330     AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
331     AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
332     CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
333     CUVIDSOURCEDATAPACKET cupkt;
334     AVPacket filter_packet = { 0 };
335     AVPacket filtered_packet = { 0 };
336     int ret = 0, eret = 0, is_flush = ctx->decoder_flushing;
337
338     av_log(avctx, AV_LOG_TRACE, "cuvid_decode_packet\n");
339
340     if (is_flush && avpkt && avpkt->size)
341         return AVERROR_EOF;
342
343     if ((av_fifo_size(ctx->frame_queue) / sizeof(CuvidParsedFrame)) + 2 > ctx->nb_surfaces && avpkt && avpkt->size)
344         return AVERROR(EAGAIN);
345
346     if (ctx->bsf && avpkt && avpkt->size) {
347         if ((ret = av_packet_ref(&filter_packet, avpkt)) < 0) {
348             av_log(avctx, AV_LOG_ERROR, "av_packet_ref failed\n");
349             return ret;
350         }
351
352         if ((ret = av_bsf_send_packet(ctx->bsf, &filter_packet)) < 0) {
353             av_log(avctx, AV_LOG_ERROR, "av_bsf_send_packet failed\n");
354             av_packet_unref(&filter_packet);
355             return ret;
356         }
357
358         if ((ret = av_bsf_receive_packet(ctx->bsf, &filtered_packet)) < 0) {
359             av_log(avctx, AV_LOG_ERROR, "av_bsf_receive_packet failed\n");
360             return ret;
361         }
362
363         avpkt = &filtered_packet;
364     }
365
366     ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
367     if (ret < 0) {
368         av_packet_unref(&filtered_packet);
369         return ret;
370     }
371
372     memset(&cupkt, 0, sizeof(cupkt));
373
374     if (avpkt && avpkt->size) {
375         cupkt.payload_size = avpkt->size;
376         cupkt.payload = avpkt->data;
377
378         if (avpkt->pts != AV_NOPTS_VALUE) {
379             cupkt.flags = CUVID_PKT_TIMESTAMP;
380             if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
381                 cupkt.timestamp = av_rescale_q(avpkt->pts, avctx->pkt_timebase, (AVRational){1, 10000000});
382             else
383                 cupkt.timestamp = avpkt->pts;
384         }
385     } else {
386         cupkt.flags = CUVID_PKT_ENDOFSTREAM;
387         ctx->decoder_flushing = 1;
388     }
389
390     ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &cupkt));
391
392     av_packet_unref(&filtered_packet);
393
394     if (ret < 0)
395         goto error;
396
397     // cuvidParseVideoData doesn't return an error just because stuff failed...
398     if (ctx->internal_error) {
399         av_log(avctx, AV_LOG_ERROR, "cuvid decode callback error\n");
400         ret = ctx->internal_error;
401         goto error;
402     }
403
404 error:
405     eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
406
407     if (eret < 0)
408         return eret;
409     else if (ret < 0)
410         return ret;
411     else if (is_flush)
412         return AVERROR_EOF;
413     else
414         return 0;
415 }
416
417 static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
418 {
419     CuvidContext *ctx = avctx->priv_data;
420     AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
421     AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
422     CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
423     CUdeviceptr mapped_frame = 0;
424     int ret = 0, eret = 0;
425
426     av_log(avctx, AV_LOG_TRACE, "cuvid_output_frame\n");
427
428     if (ctx->decoder_flushing) {
429         ret = cuvid_decode_packet(avctx, NULL);
430         if (ret < 0 && ret != AVERROR_EOF)
431             return ret;
432     }
433
434     ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
435     if (ret < 0)
436         return ret;
437
438     if (av_fifo_size(ctx->frame_queue)) {
439         CuvidParsedFrame parsed_frame;
440         CUVIDPROCPARAMS params;
441         unsigned int pitch = 0;
442         int offset = 0;
443         int i;
444
445         av_fifo_generic_read(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
446
447         memset(&params, 0, sizeof(params));
448         params.progressive_frame = parsed_frame.dispinfo.progressive_frame;
449         params.second_field = parsed_frame.second_field;
450         params.top_field_first = parsed_frame.dispinfo.top_field_first;
451
452         ret = CHECK_CU(ctx->cvdl->cuvidMapVideoFrame(ctx->cudecoder, parsed_frame.dispinfo.picture_index, &mapped_frame, &pitch, &params));
453         if (ret < 0)
454             goto error;
455
456         if (avctx->pix_fmt == AV_PIX_FMT_CUDA) {
457             ret = av_hwframe_get_buffer(ctx->hwframe, frame, 0);
458             if (ret < 0) {
459                 av_log(avctx, AV_LOG_ERROR, "av_hwframe_get_buffer failed\n");
460                 goto error;
461             }
462
463             ret = ff_decode_frame_props(avctx, frame);
464             if (ret < 0) {
465                 av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props failed\n");
466                 goto error;
467             }
468
469             for (i = 0; i < 2; i++) {
470                 CUDA_MEMCPY2D cpy = {
471                     .srcMemoryType = CU_MEMORYTYPE_DEVICE,
472                     .dstMemoryType = CU_MEMORYTYPE_DEVICE,
473                     .srcDevice     = mapped_frame,
474                     .dstDevice     = (CUdeviceptr)frame->data[i],
475                     .srcPitch      = pitch,
476                     .dstPitch      = frame->linesize[i],
477                     .srcY          = offset,
478                     .WidthInBytes  = FFMIN(pitch, frame->linesize[i]),
479                     .Height        = avctx->height >> (i ? 1 : 0),
480                 };
481
482                 ret = CHECK_CU(ctx->cudl->cuMemcpy2D(&cpy));
483                 if (ret < 0)
484                     goto error;
485
486                 offset += avctx->coded_height;
487             }
488         } else if (avctx->pix_fmt == AV_PIX_FMT_NV12 ||
489                    avctx->pix_fmt == AV_PIX_FMT_P010 ||
490                    avctx->pix_fmt == AV_PIX_FMT_P016) {
491             AVFrame *tmp_frame = av_frame_alloc();
492             if (!tmp_frame) {
493                 av_log(avctx, AV_LOG_ERROR, "av_frame_alloc failed\n");
494                 ret = AVERROR(ENOMEM);
495                 goto error;
496             }
497
498             tmp_frame->format        = AV_PIX_FMT_CUDA;
499             tmp_frame->hw_frames_ctx = av_buffer_ref(ctx->hwframe);
500             tmp_frame->data[0]       = (uint8_t*)mapped_frame;
501             tmp_frame->linesize[0]   = pitch;
502             tmp_frame->data[1]       = (uint8_t*)(mapped_frame + avctx->coded_height * pitch);
503             tmp_frame->linesize[1]   = pitch;
504             tmp_frame->width         = avctx->width;
505             tmp_frame->height        = avctx->height;
506
507             ret = ff_get_buffer(avctx, frame, 0);
508             if (ret < 0) {
509                 av_log(avctx, AV_LOG_ERROR, "ff_get_buffer failed\n");
510                 av_frame_free(&tmp_frame);
511                 goto error;
512             }
513
514             ret = av_hwframe_transfer_data(frame, tmp_frame, 0);
515             if (ret) {
516                 av_log(avctx, AV_LOG_ERROR, "av_hwframe_transfer_data failed\n");
517                 av_frame_free(&tmp_frame);
518                 goto error;
519             }
520             av_frame_free(&tmp_frame);
521         } else {
522             ret = AVERROR_BUG;
523             goto error;
524         }
525
526         frame->width = avctx->width;
527         frame->height = avctx->height;
528         if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
529             frame->pts = av_rescale_q(parsed_frame.dispinfo.timestamp, (AVRational){1, 10000000}, avctx->pkt_timebase);
530         else
531             frame->pts = parsed_frame.dispinfo.timestamp;
532
533         if (parsed_frame.second_field) {
534             if (ctx->prev_pts == INT64_MIN) {
535                 ctx->prev_pts = frame->pts;
536                 frame->pts += (avctx->pkt_timebase.den * avctx->framerate.den) / (avctx->pkt_timebase.num * avctx->framerate.num);
537             } else {
538                 int pts_diff = (frame->pts - ctx->prev_pts) / 2;
539                 ctx->prev_pts = frame->pts;
540                 frame->pts += pts_diff;
541             }
542         }
543
544         /* CUVIDs opaque reordering breaks the internal pkt logic.
545          * So set pkt_pts and clear all the other pkt_ fields.
546          */
547 #if FF_API_PKT_PTS
548 FF_DISABLE_DEPRECATION_WARNINGS
549         frame->pkt_pts = frame->pts;
550 FF_ENABLE_DEPRECATION_WARNINGS
551 #endif
552         av_frame_set_pkt_pos(frame, -1);
553         av_frame_set_pkt_duration(frame, 0);
554         av_frame_set_pkt_size(frame, -1);
555
556         frame->interlaced_frame = !parsed_frame.is_deinterlacing && !parsed_frame.dispinfo.progressive_frame;
557
558         if (frame->interlaced_frame)
559             frame->top_field_first = parsed_frame.dispinfo.top_field_first;
560     } else if (ctx->decoder_flushing) {
561         ret = AVERROR_EOF;
562     } else {
563         ret = AVERROR(EAGAIN);
564     }
565
566 error:
567     if (mapped_frame)
568         eret = CHECK_CU(ctx->cvdl->cuvidUnmapVideoFrame(ctx->cudecoder, mapped_frame));
569
570     eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
571
572     if (eret < 0)
573         return eret;
574     else
575         return ret;
576 }
577
578 static int cuvid_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
579 {
580     CuvidContext *ctx = avctx->priv_data;
581     AVFrame *frame = data;
582     int ret = 0;
583
584     av_log(avctx, AV_LOG_TRACE, "cuvid_decode_frame\n");
585
586     if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave) {
587         av_log(avctx, AV_LOG_ERROR, "Deinterlacing is not supported via the old API\n");
588         return AVERROR(EINVAL);
589     }
590
591     if (!ctx->decoder_flushing) {
592         ret = cuvid_decode_packet(avctx, avpkt);
593         if (ret < 0)
594             return ret;
595     }
596
597     ret = cuvid_output_frame(avctx, frame);
598     if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
599         *got_frame = 0;
600     } else if (ret < 0) {
601         return ret;
602     } else {
603         *got_frame = 1;
604     }
605
606     return 0;
607 }
608
609 static av_cold int cuvid_decode_end(AVCodecContext *avctx)
610 {
611     CuvidContext *ctx = avctx->priv_data;
612
613     av_fifo_freep(&ctx->frame_queue);
614
615     if (ctx->bsf)
616         av_bsf_free(&ctx->bsf);
617
618     if (ctx->cuparser)
619         ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
620
621     if (ctx->cudecoder)
622         ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
623
624     ctx->cudl = NULL;
625
626     av_buffer_unref(&ctx->hwframe);
627     av_buffer_unref(&ctx->hwdevice);
628
629     cuvid_free_functions(&ctx->cvdl);
630
631     return 0;
632 }
633
634 static int cuvid_test_dummy_decoder(AVCodecContext *avctx,
635                                     const CUVIDPARSERPARAMS *cuparseinfo,
636                                     int probed_width,
637                                     int probed_height)
638 {
639     CuvidContext *ctx = avctx->priv_data;
640     CUVIDDECODECREATEINFO cuinfo;
641     CUvideodecoder cudec = 0;
642     int ret = 0;
643
644     memset(&cuinfo, 0, sizeof(cuinfo));
645
646     cuinfo.CodecType = cuparseinfo->CodecType;
647     cuinfo.ChromaFormat = cudaVideoChromaFormat_420;
648     cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
649
650     cuinfo.ulWidth = probed_width;
651     cuinfo.ulHeight = probed_height;
652     cuinfo.ulTargetWidth = cuinfo.ulWidth;
653     cuinfo.ulTargetHeight = cuinfo.ulHeight;
654
655     cuinfo.target_rect.left = 0;
656     cuinfo.target_rect.top = 0;
657     cuinfo.target_rect.right = cuinfo.ulWidth;
658     cuinfo.target_rect.bottom = cuinfo.ulHeight;
659
660     cuinfo.ulNumDecodeSurfaces = ctx->nb_surfaces;
661     cuinfo.ulNumOutputSurfaces = 1;
662     cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
663     cuinfo.bitDepthMinus8 = 0;
664
665     cuinfo.DeinterlaceMode = cudaVideoDeinterlaceMode_Weave;
666
667     ret = CHECK_CU(ctx->cvdl->cuvidCreateDecoder(&cudec, &cuinfo));
668     if (ret < 0)
669         return ret;
670
671     ret = CHECK_CU(ctx->cvdl->cuvidDestroyDecoder(cudec));
672     if (ret < 0)
673         return ret;
674
675     return 0;
676 }
677
678 static av_cold int cuvid_decode_init(AVCodecContext *avctx)
679 {
680     CuvidContext *ctx = avctx->priv_data;
681     AVCUDADeviceContext *device_hwctx;
682     AVHWDeviceContext *device_ctx;
683     AVHWFramesContext *hwframe_ctx;
684     CUVIDSOURCEDATAPACKET seq_pkt;
685     CUcontext cuda_ctx = NULL;
686     CUcontext dummy;
687     const AVBitStreamFilter *bsf;
688     int ret = 0;
689
690     enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
691                                        AV_PIX_FMT_NV12,
692                                        AV_PIX_FMT_NONE };
693
694     int probed_width = avctx->coded_width ? avctx->coded_width : 1280;
695     int probed_height = avctx->coded_height ? avctx->coded_height : 720;
696
697     // Accelerated transcoding scenarios with 'ffmpeg' require that the
698     // pix_fmt be set to AV_PIX_FMT_CUDA early. The sw_pix_fmt, and the
699     // pix_fmt for non-accelerated transcoding, do not need to be correct
700     // but need to be set to something. We arbitrarily pick NV12.
701     ret = ff_get_format(avctx, pix_fmts);
702     if (ret < 0) {
703         av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", ret);
704         return ret;
705     }
706     avctx->pix_fmt = ret;
707
708     ret = cuvid_load_functions(&ctx->cvdl);
709     if (ret < 0) {
710         av_log(avctx, AV_LOG_ERROR, "Failed loading nvcuvid.\n");
711         goto error;
712     }
713
714     ctx->frame_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(CuvidParsedFrame));
715     if (!ctx->frame_queue) {
716         ret = AVERROR(ENOMEM);
717         goto error;
718     }
719
720     if (avctx->hw_frames_ctx) {
721         ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
722         if (!ctx->hwframe) {
723             ret = AVERROR(ENOMEM);
724             goto error;
725         }
726
727         hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
728
729         ctx->hwdevice = av_buffer_ref(hwframe_ctx->device_ref);
730         if (!ctx->hwdevice) {
731             ret = AVERROR(ENOMEM);
732             goto error;
733         }
734     } else {
735         ret = av_hwdevice_ctx_create(&ctx->hwdevice, AV_HWDEVICE_TYPE_CUDA, ctx->cu_gpu, NULL, 0);
736         if (ret < 0)
737             goto error;
738
739         ctx->hwframe = av_hwframe_ctx_alloc(ctx->hwdevice);
740         if (!ctx->hwframe) {
741             av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
742             ret = AVERROR(ENOMEM);
743             goto error;
744         }
745
746         hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
747     }
748
749     device_ctx = hwframe_ctx->device_ctx;
750     device_hwctx = device_ctx->hwctx;
751
752     cuda_ctx = device_hwctx->cuda_ctx;
753     ctx->cudl = device_hwctx->internal->cuda_dl;
754
755     memset(&ctx->cuparseinfo, 0, sizeof(ctx->cuparseinfo));
756     memset(&ctx->cuparse_ext, 0, sizeof(ctx->cuparse_ext));
757     memset(&seq_pkt, 0, sizeof(seq_pkt));
758
759     ctx->cuparseinfo.pExtVideoInfo = &ctx->cuparse_ext;
760
761     switch (avctx->codec->id) {
762 #if CONFIG_H264_CUVID_DECODER
763     case AV_CODEC_ID_H264:
764         ctx->cuparseinfo.CodecType = cudaVideoCodec_H264;
765         break;
766 #endif
767 #if CONFIG_HEVC_CUVID_DECODER
768     case AV_CODEC_ID_HEVC:
769         ctx->cuparseinfo.CodecType = cudaVideoCodec_HEVC;
770         break;
771 #endif
772 #if CONFIG_MJPEG_CUVID_DECODER
773     case AV_CODEC_ID_MJPEG:
774         ctx->cuparseinfo.CodecType = cudaVideoCodec_JPEG;
775         break;
776 #endif
777 #if CONFIG_MPEG1_CUVID_DECODER
778     case AV_CODEC_ID_MPEG1VIDEO:
779         ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG1;
780         break;
781 #endif
782 #if CONFIG_MPEG2_CUVID_DECODER
783     case AV_CODEC_ID_MPEG2VIDEO:
784         ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG2;
785         break;
786 #endif
787 #if CONFIG_MPEG4_CUVID_DECODER
788     case AV_CODEC_ID_MPEG4:
789         ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
790         break;
791 #endif
792 #if CONFIG_VP8_CUVID_DECODER
793     case AV_CODEC_ID_VP8:
794         ctx->cuparseinfo.CodecType = cudaVideoCodec_VP8;
795         break;
796 #endif
797 #if CONFIG_VP9_CUVID_DECODER
798     case AV_CODEC_ID_VP9:
799         ctx->cuparseinfo.CodecType = cudaVideoCodec_VP9;
800         break;
801 #endif
802 #if CONFIG_VC1_CUVID_DECODER
803     case AV_CODEC_ID_VC1:
804         ctx->cuparseinfo.CodecType = cudaVideoCodec_VC1;
805         break;
806 #endif
807     default:
808         av_log(avctx, AV_LOG_ERROR, "Invalid CUVID codec!\n");
809         return AVERROR_BUG;
810     }
811
812     if (avctx->codec->id == AV_CODEC_ID_H264 || avctx->codec->id == AV_CODEC_ID_HEVC) {
813         if (avctx->codec->id == AV_CODEC_ID_H264)
814             bsf = av_bsf_get_by_name("h264_mp4toannexb");
815         else
816             bsf = av_bsf_get_by_name("hevc_mp4toannexb");
817
818         if (!bsf) {
819             ret = AVERROR_BSF_NOT_FOUND;
820             goto error;
821         }
822         if (ret = av_bsf_alloc(bsf, &ctx->bsf)) {
823             goto error;
824         }
825         if (((ret = avcodec_parameters_from_context(ctx->bsf->par_in, avctx)) < 0) || ((ret = av_bsf_init(ctx->bsf)) < 0)) {
826             av_bsf_free(&ctx->bsf);
827             goto error;
828         }
829
830         ctx->cuparse_ext.format.seqhdr_data_length = ctx->bsf->par_out->extradata_size;
831         memcpy(ctx->cuparse_ext.raw_seqhdr_data,
832                ctx->bsf->par_out->extradata,
833                FFMIN(sizeof(ctx->cuparse_ext.raw_seqhdr_data), ctx->bsf->par_out->extradata_size));
834     } else if (avctx->extradata_size > 0) {
835         ctx->cuparse_ext.format.seqhdr_data_length = avctx->extradata_size;
836         memcpy(ctx->cuparse_ext.raw_seqhdr_data,
837                avctx->extradata,
838                FFMIN(sizeof(ctx->cuparse_ext.raw_seqhdr_data), avctx->extradata_size));
839     }
840
841     ctx->cuparseinfo.ulMaxNumDecodeSurfaces = ctx->nb_surfaces;
842     ctx->cuparseinfo.ulMaxDisplayDelay = 4;
843     ctx->cuparseinfo.pUserData = avctx;
844     ctx->cuparseinfo.pfnSequenceCallback = cuvid_handle_video_sequence;
845     ctx->cuparseinfo.pfnDecodePicture = cuvid_handle_picture_decode;
846     ctx->cuparseinfo.pfnDisplayPicture = cuvid_handle_picture_display;
847
848     ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
849     if (ret < 0)
850         goto error;
851
852     ret = cuvid_test_dummy_decoder(avctx, &ctx->cuparseinfo,
853                                    probed_width,
854                                    probed_height);
855     if (ret < 0)
856         goto error;
857
858     ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
859     if (ret < 0)
860         goto error;
861
862     seq_pkt.payload = ctx->cuparse_ext.raw_seqhdr_data;
863     seq_pkt.payload_size = ctx->cuparse_ext.format.seqhdr_data_length;
864
865     if (seq_pkt.payload && seq_pkt.payload_size) {
866         ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
867         if (ret < 0)
868             goto error;
869     }
870
871     ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
872     if (ret < 0)
873         goto error;
874
875     ctx->prev_pts = INT64_MIN;
876
877     if (!avctx->pkt_timebase.num || !avctx->pkt_timebase.den)
878         av_log(avctx, AV_LOG_WARNING, "Invalid pkt_timebase, passing timestamps as-is.\n");
879
880     return 0;
881
882 error:
883     cuvid_decode_end(avctx);
884     return ret;
885 }
886
887 static void cuvid_flush(AVCodecContext *avctx)
888 {
889     CuvidContext *ctx = avctx->priv_data;
890     AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
891     AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
892     CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
893     CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
894     int ret;
895
896     ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
897     if (ret < 0)
898         goto error;
899
900     av_fifo_freep(&ctx->frame_queue);
901
902     ctx->frame_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(CuvidParsedFrame));
903     if (!ctx->frame_queue) {
904         av_log(avctx, AV_LOG_ERROR, "Failed to recreate frame queue on flush\n");
905         return;
906     }
907
908     if (ctx->cudecoder) {
909         ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
910         ctx->cudecoder = NULL;
911     }
912
913     if (ctx->cuparser) {
914         ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
915         ctx->cuparser = NULL;
916     }
917
918     ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
919     if (ret < 0)
920         goto error;
921
922     seq_pkt.payload = ctx->cuparse_ext.raw_seqhdr_data;
923     seq_pkt.payload_size = ctx->cuparse_ext.format.seqhdr_data_length;
924
925     if (seq_pkt.payload && seq_pkt.payload_size) {
926         ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
927         if (ret < 0)
928             goto error;
929     }
930
931     ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
932     if (ret < 0)
933         goto error;
934
935     ctx->prev_pts = INT64_MIN;
936     ctx->decoder_flushing = 0;
937
938     return;
939  error:
940     av_log(avctx, AV_LOG_ERROR, "CUDA reinit on flush failed\n");
941 }
942
943 #define OFFSET(x) offsetof(CuvidContext, x)
944 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
945 static const AVOption options[] = {
946     { "deint",    "Set deinterlacing mode", OFFSET(deint_mode), AV_OPT_TYPE_INT,   { .i64 = cudaVideoDeinterlaceMode_Weave    }, cudaVideoDeinterlaceMode_Weave, cudaVideoDeinterlaceMode_Adaptive, VD, "deint" },
947     { "weave",    "Weave deinterlacing (do nothing)",        0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Weave    }, 0, 0, VD, "deint" },
948     { "bob",      "Bob deinterlacing",                       0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob      }, 0, 0, VD, "deint" },
949     { "adaptive", "Adaptive deinterlacing",                  0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0, VD, "deint" },
950     { "gpu",      "GPU to be used for decoding", OFFSET(cu_gpu), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
951     { "surfaces", "Maximum surfaces to be used for decoding", OFFSET(nb_surfaces), AV_OPT_TYPE_INT, { .i64 = 25 }, 0, INT_MAX, VD },
952     { NULL }
953 };
954
955 #define DEFINE_CUVID_CODEC(x, X) \
956     static const AVClass x##_cuvid_class = { \
957         .class_name = #x "_cuvid", \
958         .item_name = av_default_item_name, \
959         .option = options, \
960         .version = LIBAVUTIL_VERSION_INT, \
961     }; \
962     AVHWAccel ff_##x##_cuvid_hwaccel = { \
963         .name           = #x "_cuvid", \
964         .type           = AVMEDIA_TYPE_VIDEO, \
965         .id             = AV_CODEC_ID_##X, \
966         .pix_fmt        = AV_PIX_FMT_CUDA, \
967     }; \
968     AVCodec ff_##x##_cuvid_decoder = { \
969         .name           = #x "_cuvid", \
970         .long_name      = NULL_IF_CONFIG_SMALL("Nvidia CUVID " #X " decoder"), \
971         .type           = AVMEDIA_TYPE_VIDEO, \
972         .id             = AV_CODEC_ID_##X, \
973         .priv_data_size = sizeof(CuvidContext), \
974         .priv_class     = &x##_cuvid_class, \
975         .init           = cuvid_decode_init, \
976         .close          = cuvid_decode_end, \
977         .decode         = cuvid_decode_frame, \
978         .send_packet    = cuvid_decode_packet, \
979         .receive_frame  = cuvid_output_frame, \
980         .flush          = cuvid_flush, \
981         .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING, \
982         .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_CUDA, \
983                                                         AV_PIX_FMT_NV12, \
984                                                         AV_PIX_FMT_P010, \
985                                                         AV_PIX_FMT_P016, \
986                                                         AV_PIX_FMT_NONE }, \
987     };
988
989 #if CONFIG_HEVC_CUVID_DECODER
990 DEFINE_CUVID_CODEC(hevc, HEVC)
991 #endif
992
993 #if CONFIG_H264_CUVID_DECODER
994 DEFINE_CUVID_CODEC(h264, H264)
995 #endif
996
997 #if CONFIG_MJPEG_CUVID_DECODER
998 DEFINE_CUVID_CODEC(mjpeg, MJPEG)
999 #endif
1000
1001 #if CONFIG_MPEG1_CUVID_DECODER
1002 DEFINE_CUVID_CODEC(mpeg1, MPEG1VIDEO)
1003 #endif
1004
1005 #if CONFIG_MPEG2_CUVID_DECODER
1006 DEFINE_CUVID_CODEC(mpeg2, MPEG2VIDEO)
1007 #endif
1008
1009 #if CONFIG_MPEG4_CUVID_DECODER
1010 DEFINE_CUVID_CODEC(mpeg4, MPEG4)
1011 #endif
1012
1013 #if CONFIG_VP8_CUVID_DECODER
1014 DEFINE_CUVID_CODEC(vp8, VP8)
1015 #endif
1016
1017 #if CONFIG_VP9_CUVID_DECODER
1018 DEFINE_CUVID_CODEC(vp9, VP9)
1019 #endif
1020
1021 #if CONFIG_VC1_CUVID_DECODER
1022 DEFINE_CUVID_CODEC(vc1, VC1)
1023 #endif