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