avcodec/mpeg4_unpack_bframes_bsf: Copy packet props
[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 "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
29 #include "avcodec.h"
30 #include "internal.h"
31
32 #include <nvcuvid.h>
33
34 #define MAX_FRAME_COUNT 20
35
36 typedef struct CuvidContext
37 {
38     CUvideodecoder cudecoder;
39     CUvideoparser cuparser;
40
41     AVBufferRef *hwdevice;
42     AVBufferRef *hwframe;
43
44     AVBSFContext *bsf;
45
46     AVFifoBuffer *frame_queue;
47
48     int internal_error;
49
50     cudaVideoCodec codec_type;
51     cudaVideoChromaFormat chroma_format;
52 } CuvidContext;
53
54 static int check_cu(AVCodecContext *avctx, CUresult err, const char *func)
55 {
56     const char *err_name;
57     const char *err_string;
58
59     av_log(avctx, AV_LOG_TRACE, "Calling %s\n", func);
60
61     if (err == CUDA_SUCCESS)
62         return 0;
63
64     cuGetErrorName(err, &err_name);
65     cuGetErrorString(err, &err_string);
66
67     av_log(avctx, AV_LOG_ERROR, "%s failed", func);
68     if (err_name && err_string)
69         av_log(avctx, AV_LOG_ERROR, " -> %s: %s", err_name, err_string);
70     av_log(avctx, AV_LOG_ERROR, "\n");
71
72     return AVERROR_EXTERNAL;
73 }
74
75 #define CHECK_CU(x) check_cu(avctx, (x), #x)
76
77 static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT* format)
78 {
79     AVCodecContext *avctx = opaque;
80     CuvidContext *ctx = avctx->priv_data;
81     AVHWFramesContext *hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
82     CUVIDDECODECREATEINFO cuinfo;
83
84     av_log(avctx, AV_LOG_TRACE, "pfnSequenceCallback\n");
85
86     ctx->internal_error = 0;
87
88     avctx->width = format->display_area.right;
89     avctx->height = format->display_area.bottom;
90
91     ff_set_sar(avctx, av_div_q(
92         (AVRational){ format->display_aspect_ratio.x, format->display_aspect_ratio.y },
93         (AVRational){ avctx->width, avctx->height }));
94
95     if (!format->progressive_sequence)
96         avctx->flags |= AV_CODEC_FLAG_INTERLACED_DCT;
97     else
98         avctx->flags &= ~AV_CODEC_FLAG_INTERLACED_DCT;
99
100     if (format->video_signal_description.video_full_range_flag)
101         avctx->color_range = AVCOL_RANGE_JPEG;
102     else
103         avctx->color_range = AVCOL_RANGE_MPEG;
104
105     avctx->color_primaries = format->video_signal_description.color_primaries;
106     avctx->color_trc = format->video_signal_description.transfer_characteristics;
107     avctx->colorspace = format->video_signal_description.matrix_coefficients;
108
109     if (format->bitrate)
110         avctx->bit_rate = format->bitrate;
111
112     if (format->frame_rate.numerator && format->frame_rate.denominator) {
113         avctx->framerate.num = format->frame_rate.numerator;
114         avctx->framerate.den = format->frame_rate.denominator;
115     }
116
117     if (ctx->cudecoder
118             && avctx->coded_width == format->coded_width
119             && avctx->coded_height == format->coded_height
120             && ctx->chroma_format == format->chroma_format
121             && ctx->codec_type == format->codec)
122         return 1;
123
124     if (ctx->cudecoder) {
125         av_log(avctx, AV_LOG_ERROR, "re-initializing decoder is not supported\n");
126         ctx->internal_error = AVERROR(EINVAL);
127         return 0;
128     }
129
130     if (hwframe_ctx->pool) {
131         av_log(avctx, AV_LOG_ERROR, "AVHWFramesContext is already initialized\n");
132         ctx->internal_error = AVERROR(EINVAL);
133         return 0;
134     }
135
136     avctx->coded_width = format->coded_width;
137     avctx->coded_height = format->coded_height;
138
139     ctx->chroma_format = format->chroma_format;
140
141     memset(&cuinfo, 0, sizeof(cuinfo));
142
143     cuinfo.CodecType = ctx->codec_type = format->codec;
144     cuinfo.ChromaFormat = format->chroma_format;
145     cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
146
147     cuinfo.ulWidth = avctx->coded_width;
148     cuinfo.ulHeight = avctx->coded_height;
149     cuinfo.ulTargetWidth = cuinfo.ulWidth;
150     cuinfo.ulTargetHeight = cuinfo.ulHeight;
151
152     cuinfo.target_rect.left = 0;
153     cuinfo.target_rect.top = 0;
154     cuinfo.target_rect.right = cuinfo.ulWidth;
155     cuinfo.target_rect.bottom = cuinfo.ulHeight;
156
157     cuinfo.ulNumDecodeSurfaces = MAX_FRAME_COUNT;
158     cuinfo.ulNumOutputSurfaces = 1;
159     cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
160
161     cuinfo.DeinterlaceMode = cudaVideoDeinterlaceMode_Weave;
162
163     ctx->internal_error = CHECK_CU(cuvidCreateDecoder(&ctx->cudecoder, &cuinfo));
164     if (ctx->internal_error < 0)
165         return 0;
166
167     hwframe_ctx->format = AV_PIX_FMT_CUDA;
168     hwframe_ctx->sw_format = AV_PIX_FMT_NV12;
169     hwframe_ctx->width = FFALIGN(avctx->coded_width, 32);
170     hwframe_ctx->height = FFALIGN(avctx->coded_height, 32);
171
172     if ((ctx->internal_error = av_hwframe_ctx_init(ctx->hwframe)) < 0) {
173         av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_init failed\n");
174         return 0;
175     }
176
177     return 1;
178 }
179
180 static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS* picparams)
181 {
182     AVCodecContext *avctx = opaque;
183     CuvidContext *ctx = avctx->priv_data;
184
185     av_log(avctx, AV_LOG_TRACE, "pfnDecodePicture\n");
186
187     ctx->internal_error = CHECK_CU(cuvidDecodePicture(ctx->cudecoder, picparams));
188     if (ctx->internal_error < 0)
189         return 0;
190
191     return 1;
192 }
193
194 static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO* dispinfo)
195 {
196     AVCodecContext *avctx = opaque;
197     CuvidContext *ctx = avctx->priv_data;
198
199     av_log(avctx, AV_LOG_TRACE, "pfnDisplayPicture\n");
200
201     ctx->internal_error = 0;
202
203     av_fifo_generic_write(ctx->frame_queue, dispinfo, sizeof(CUVIDPARSERDISPINFO), NULL);
204
205     return 1;
206 }
207
208 static int cuvid_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
209 {
210     CuvidContext *ctx = avctx->priv_data;
211     AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
212     AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
213     CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
214     AVFrame *frame = data;
215     CUVIDSOURCEDATAPACKET cupkt;
216     AVPacket filter_packet = { 0 };
217     AVPacket filtered_packet = { 0 };
218     CUdeviceptr mapped_frame = 0;
219     int ret = 0, eret = 0;
220
221     if (ctx->bsf && avpkt->size) {
222         if ((ret = av_packet_ref(&filter_packet, avpkt)) < 0) {
223             av_log(avctx, AV_LOG_ERROR, "av_packet_ref failed\n");
224             return ret;
225         }
226
227         if ((ret = av_bsf_send_packet(ctx->bsf, &filter_packet)) < 0) {
228             av_log(avctx, AV_LOG_ERROR, "av_bsf_send_packet failed\n");
229             av_packet_unref(&filter_packet);
230             return ret;
231         }
232
233         if ((ret = av_bsf_receive_packet(ctx->bsf, &filtered_packet)) < 0) {
234             av_log(avctx, AV_LOG_ERROR, "av_bsf_receive_packet failed\n");
235             return ret;
236         }
237
238         avpkt = &filtered_packet;
239     }
240
241     ret = CHECK_CU(cuCtxPushCurrent(cuda_ctx));
242     if (ret < 0) {
243         av_packet_unref(&filtered_packet);
244         return ret;
245     }
246
247     memset(&cupkt, 0, sizeof(cupkt));
248
249     if (avpkt->size) {
250         cupkt.payload_size = avpkt->size;
251         cupkt.payload = avpkt->data;
252
253         if (avpkt->pts != AV_NOPTS_VALUE) {
254             cupkt.flags = CUVID_PKT_TIMESTAMP;
255             cupkt.timestamp = av_rescale_q(avpkt->pts, avctx->time_base, (AVRational){1, 10000000});
256         }
257     } else {
258         cupkt.flags = CUVID_PKT_ENDOFSTREAM;
259     }
260
261     ret = CHECK_CU(cuvidParseVideoData(ctx->cuparser, &cupkt));
262
263     av_packet_unref(&filtered_packet);
264
265     if (ret < 0) {
266         if (ctx->internal_error)
267             ret = ctx->internal_error;
268         goto error;
269     }
270
271     if (av_fifo_size(ctx->frame_queue)) {
272         CUVIDPARSERDISPINFO dispinfo;
273         CUVIDPROCPARAMS params;
274         unsigned int pitch = 0;
275         int offset = 0;
276         int i;
277
278         av_fifo_generic_read(ctx->frame_queue, &dispinfo, sizeof(CUVIDPARSERDISPINFO), NULL);
279
280         memset(&params, 0, sizeof(params));
281         params.progressive_frame = dispinfo.progressive_frame;
282         params.second_field = 0;
283         params.top_field_first = dispinfo.top_field_first;
284
285         ret = CHECK_CU(cuvidMapVideoFrame(ctx->cudecoder, dispinfo.picture_index, &mapped_frame, &pitch, &params));
286         if (ret < 0)
287             goto error;
288
289         if (avctx->pix_fmt == AV_PIX_FMT_CUDA) {
290             ret = av_hwframe_get_buffer(ctx->hwframe, frame, 0);
291             if (ret < 0) {
292                 av_log(avctx, AV_LOG_ERROR, "av_hwframe_get_buffer failed\n");
293                 goto error;
294             }
295
296             ret = ff_decode_frame_props(avctx, frame);
297             if (ret < 0) {
298                 av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props failed\n");
299                 goto error;
300             }
301
302             for (i = 0; i < 2; i++) {
303                 CUDA_MEMCPY2D cpy = {
304                     .srcMemoryType = CU_MEMORYTYPE_DEVICE,
305                     .dstMemoryType = CU_MEMORYTYPE_DEVICE,
306                     .srcDevice     = mapped_frame,
307                     .dstDevice     = (CUdeviceptr)frame->data[i],
308                     .srcPitch      = pitch,
309                     .dstPitch      = frame->linesize[i],
310                     .srcY          = offset,
311                     .WidthInBytes  = FFMIN(pitch, frame->linesize[i]),
312                     .Height        = avctx->coded_height >> (i ? 1 : 0),
313                 };
314
315                 ret = CHECK_CU(cuMemcpy2D(&cpy));
316                 if (ret < 0)
317                     goto error;
318
319                 offset += avctx->coded_height;
320             }
321         } else if (avctx->pix_fmt == AV_PIX_FMT_NV12) {
322             AVFrame *tmp_frame = av_frame_alloc();
323             if (!tmp_frame) {
324                 av_log(avctx, AV_LOG_ERROR, "av_frame_alloc failed\n");
325                 ret = AVERROR(ENOMEM);
326                 goto error;
327             }
328
329             tmp_frame->format        = AV_PIX_FMT_CUDA;
330             tmp_frame->hw_frames_ctx = av_buffer_ref(ctx->hwframe);
331             tmp_frame->data[0]       = (uint8_t*)mapped_frame;
332             tmp_frame->linesize[0]   = pitch;
333             tmp_frame->data[1]       = (uint8_t*)(mapped_frame + avctx->coded_height * pitch);
334             tmp_frame->linesize[1]   = pitch;
335             tmp_frame->width         = avctx->width;
336             tmp_frame->height        = avctx->height;
337
338             ret = ff_get_buffer(avctx, frame, 0);
339             if (ret < 0) {
340                 av_log(avctx, AV_LOG_ERROR, "ff_get_buffer failed\n");
341                 av_frame_free(&tmp_frame);
342                 goto error;
343             }
344
345             ret = av_hwframe_transfer_data(frame, tmp_frame, 0);
346             if (ret) {
347                 av_log(avctx, AV_LOG_ERROR, "av_hwframe_transfer_data failed\n");
348                 av_frame_free(&tmp_frame);
349                 goto error;
350             }
351
352             av_frame_free(&tmp_frame);
353         } else {
354             ret = AVERROR_BUG;
355             goto error;
356         }
357
358         frame->width = avctx->width;
359         frame->height = avctx->height;
360         frame->pts = av_rescale_q(dispinfo.timestamp, (AVRational){1, 10000000}, avctx->time_base);
361
362         /* CUVIDs opaque reordering breaks the internal pkt logic.
363          * So set pkt_pts and clear all the other pkt_ fields.
364          */
365         frame->pkt_pts = frame->pts;
366         av_frame_set_pkt_pos(frame, -1);
367         av_frame_set_pkt_duration(frame, 0);
368         av_frame_set_pkt_size(frame, -1);
369
370         frame->interlaced_frame = !dispinfo.progressive_frame;
371
372         if (!dispinfo.progressive_frame)
373             frame->top_field_first = dispinfo.top_field_first;
374
375         *got_frame = 1;
376     } else {
377         *got_frame = 0;
378     }
379
380 error:
381     if (mapped_frame)
382         eret = CHECK_CU(cuvidUnmapVideoFrame(ctx->cudecoder, mapped_frame));
383
384     eret = CHECK_CU(cuCtxPopCurrent(&dummy));
385
386     if (eret < 0)
387         return eret;
388     else
389         return ret;
390 }
391
392 static av_cold int cuvid_decode_end(AVCodecContext *avctx)
393 {
394     CuvidContext *ctx = avctx->priv_data;
395
396     av_fifo_freep(&ctx->frame_queue);
397
398     if (ctx->bsf)
399         av_bsf_free(&ctx->bsf);
400
401     if (ctx->cuparser)
402         cuvidDestroyVideoParser(ctx->cuparser);
403
404     if (ctx->cudecoder)
405         cuvidDestroyDecoder(ctx->cudecoder);
406
407     av_buffer_unref(&ctx->hwframe);
408     av_buffer_unref(&ctx->hwdevice);
409
410     return 0;
411 }
412
413 static void cuvid_ctx_free(AVHWDeviceContext *ctx)
414 {
415     AVCUDADeviceContext *hwctx = ctx->hwctx;
416     cuCtxDestroy(hwctx->cuda_ctx);
417 }
418
419 static int cuvid_test_dummy_decoder(AVCodecContext *avctx, CUVIDPARSERPARAMS *cuparseinfo)
420 {
421     CUVIDDECODECREATEINFO cuinfo;
422     CUvideodecoder cudec = 0;
423     int ret = 0;
424
425     memset(&cuinfo, 0, sizeof(cuinfo));
426
427     cuinfo.CodecType = cuparseinfo->CodecType;
428     cuinfo.ChromaFormat = cudaVideoChromaFormat_420;
429     cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
430
431     cuinfo.ulWidth = 1280;
432     cuinfo.ulHeight = 720;
433     cuinfo.ulTargetWidth = cuinfo.ulWidth;
434     cuinfo.ulTargetHeight = cuinfo.ulHeight;
435
436     cuinfo.target_rect.left = 0;
437     cuinfo.target_rect.top = 0;
438     cuinfo.target_rect.right = cuinfo.ulWidth;
439     cuinfo.target_rect.bottom = cuinfo.ulHeight;
440
441     cuinfo.ulNumDecodeSurfaces = MAX_FRAME_COUNT;
442     cuinfo.ulNumOutputSurfaces = 1;
443     cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
444
445     cuinfo.DeinterlaceMode = cudaVideoDeinterlaceMode_Weave;
446
447     ret = CHECK_CU(cuvidCreateDecoder(&cudec, &cuinfo));
448     if (ret < 0)
449         return ret;
450
451     ret = CHECK_CU(cuvidDestroyDecoder(cudec));
452     if (ret < 0)
453         return ret;
454
455     return 0;
456 }
457
458 static av_cold int cuvid_decode_init(AVCodecContext *avctx)
459 {
460     CuvidContext *ctx = avctx->priv_data;
461     AVCUDADeviceContext *device_hwctx;
462     AVHWDeviceContext *device_ctx;
463     AVHWFramesContext *hwframe_ctx;
464     CUVIDPARSERPARAMS cuparseinfo;
465     CUVIDEOFORMATEX cuparse_ext;
466     CUVIDSOURCEDATAPACKET seq_pkt;
467     CUdevice device;
468     CUcontext cuda_ctx = NULL;
469     CUcontext dummy;
470     const AVBitStreamFilter *bsf;
471     int ret = 0;
472
473     enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
474                                        AV_PIX_FMT_NV12,
475                                        AV_PIX_FMT_NONE };
476
477     ret = ff_get_format(avctx, pix_fmts);
478     if (ret < 0) {
479         av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", ret);
480         return ret;
481     }
482
483     ctx->frame_queue = av_fifo_alloc(MAX_FRAME_COUNT * sizeof(CUVIDPARSERDISPINFO));
484     if (!ctx->frame_queue) {
485         ret = AVERROR(ENOMEM);
486         goto error;
487     }
488
489     avctx->pix_fmt = ret;
490
491     if (avctx->hw_frames_ctx) {
492         ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
493         if (!ctx->hwframe) {
494             ret = AVERROR(ENOMEM);
495             goto error;
496         }
497
498         hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
499
500         ctx->hwdevice = av_buffer_ref(hwframe_ctx->device_ref);
501         if (!ctx->hwdevice) {
502             ret = AVERROR(ENOMEM);
503             goto error;
504         }
505
506         device_ctx = hwframe_ctx->device_ctx;
507         device_hwctx = device_ctx->hwctx;
508         cuda_ctx = device_hwctx->cuda_ctx;
509     } else {
510         ctx->hwdevice = av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_CUDA);
511         if (!ctx->hwdevice) {
512             av_log(avctx, AV_LOG_ERROR, "Error allocating hwdevice\n");
513             ret = AVERROR(ENOMEM);
514             goto error;
515         }
516
517         ret = CHECK_CU(cuInit(0));
518         if (ret < 0)
519             goto error;
520
521         ret = CHECK_CU(cuDeviceGet(&device, 0));
522         if (ret < 0)
523             goto error;
524
525         ret = CHECK_CU(cuCtxCreate(&cuda_ctx, CU_CTX_SCHED_BLOCKING_SYNC, device));
526         if (ret < 0)
527             goto error;
528
529         device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
530         device_ctx->free = cuvid_ctx_free;
531
532         device_hwctx = device_ctx->hwctx;
533         device_hwctx->cuda_ctx = cuda_ctx;
534
535         ret = CHECK_CU(cuCtxPopCurrent(&dummy));
536         if (ret < 0)
537             goto error;
538
539         ret = av_hwdevice_ctx_init(ctx->hwdevice);
540         if (ret < 0) {
541             av_log(avctx, AV_LOG_ERROR, "av_hwdevice_ctx_init failed\n");
542             goto error;
543         }
544
545         ctx->hwframe = av_hwframe_ctx_alloc(ctx->hwdevice);
546         if (!ctx->hwframe) {
547             av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
548             ret = AVERROR(ENOMEM);
549             goto error;
550         }
551     }
552
553     memset(&cuparseinfo, 0, sizeof(cuparseinfo));
554     memset(&cuparse_ext, 0, sizeof(cuparse_ext));
555     memset(&seq_pkt, 0, sizeof(seq_pkt));
556
557     cuparseinfo.pExtVideoInfo = &cuparse_ext;
558
559     switch (avctx->codec->id) {
560 #if CONFIG_H264_CUVID_DECODER
561     case AV_CODEC_ID_H264:
562         cuparseinfo.CodecType = cudaVideoCodec_H264;
563         break;
564 #endif
565 #if CONFIG_HEVC_CUVID_DECODER
566     case AV_CODEC_ID_HEVC:
567         cuparseinfo.CodecType = cudaVideoCodec_HEVC;
568         break;
569 #endif
570 #if CONFIG_VP8_CUVID_DECODER
571     case AV_CODEC_ID_VP8:
572         cuparseinfo.CodecType = cudaVideoCodec_VP8;
573         break;
574 #endif
575 #if CONFIG_VP9_CUVID_DECODER
576     case AV_CODEC_ID_VP9:
577         cuparseinfo.CodecType = cudaVideoCodec_VP9;
578         break;
579 #endif
580 #if CONFIG_VC1_CUVID_DECODER
581     case AV_CODEC_ID_VC1:
582         cuparseinfo.CodecType = cudaVideoCodec_VC1;
583         break;
584 #endif
585     default:
586         av_log(avctx, AV_LOG_ERROR, "Invalid CUVID codec!\n");
587         return AVERROR_BUG;
588     }
589
590     if (avctx->codec->id == AV_CODEC_ID_H264 || avctx->codec->id == AV_CODEC_ID_HEVC) {
591         if (avctx->codec->id == AV_CODEC_ID_H264)
592             bsf = av_bsf_get_by_name("h264_mp4toannexb");
593         else
594             bsf = av_bsf_get_by_name("hevc_mp4toannexb");
595
596         if (!bsf) {
597             ret = AVERROR_BSF_NOT_FOUND;
598             goto error;
599         }
600         if (ret = av_bsf_alloc(bsf, &ctx->bsf)) {
601             goto error;
602         }
603         if (((ret = avcodec_parameters_from_context(ctx->bsf->par_in, avctx)) < 0) || ((ret = av_bsf_init(ctx->bsf)) < 0)) {
604             av_bsf_free(&ctx->bsf);
605             goto error;
606         }
607
608         cuparse_ext.format.seqhdr_data_length = ctx->bsf->par_out->extradata_size;
609         memcpy(cuparse_ext.raw_seqhdr_data,
610                ctx->bsf->par_out->extradata,
611                FFMIN(sizeof(cuparse_ext.raw_seqhdr_data), ctx->bsf->par_out->extradata_size));
612     } else if (avctx->extradata_size > 0) {
613         cuparse_ext.format.seqhdr_data_length = avctx->extradata_size;
614         memcpy(cuparse_ext.raw_seqhdr_data,
615                avctx->extradata,
616                FFMIN(sizeof(cuparse_ext.raw_seqhdr_data), avctx->extradata_size));
617     }
618
619     cuparseinfo.ulMaxNumDecodeSurfaces = MAX_FRAME_COUNT;
620     cuparseinfo.ulMaxDisplayDelay = 4;
621     cuparseinfo.pUserData = avctx;
622     cuparseinfo.pfnSequenceCallback = cuvid_handle_video_sequence;
623     cuparseinfo.pfnDecodePicture = cuvid_handle_picture_decode;
624     cuparseinfo.pfnDisplayPicture = cuvid_handle_picture_display;
625
626     ret = CHECK_CU(cuCtxPushCurrent(cuda_ctx));
627     if (ret < 0)
628         goto error;
629
630     ret = cuvid_test_dummy_decoder(avctx, &cuparseinfo);
631     if (ret < 0)
632         goto error;
633
634     ret = CHECK_CU(cuvidCreateVideoParser(&ctx->cuparser, &cuparseinfo));
635     if (ret < 0)
636         goto error;
637
638     seq_pkt.payload = cuparse_ext.raw_seqhdr_data;
639     seq_pkt.payload_size = cuparse_ext.format.seqhdr_data_length;
640
641     if (seq_pkt.payload && seq_pkt.payload_size) {
642         ret = CHECK_CU(cuvidParseVideoData(ctx->cuparser, &seq_pkt));
643         if (ret < 0)
644             goto error;
645     }
646
647     ret = CHECK_CU(cuCtxPopCurrent(&dummy));
648     if (ret < 0)
649         goto error;
650
651     return 0;
652
653 error:
654     cuvid_decode_end(avctx);
655     return ret;
656 }
657
658 #define DEFINE_CUVID_CODEC(x, X) \
659     AVHWAccel ff_##x##_cuvid_hwaccel = { \
660         .name           = #x "_cuvid", \
661         .type           = AVMEDIA_TYPE_VIDEO, \
662         .id             = AV_CODEC_ID_##X, \
663         .pix_fmt        = AV_PIX_FMT_CUDA, \
664     }; \
665     AVCodec ff_##x##_cuvid_decoder = { \
666         .name           = #x "_cuvid", \
667         .long_name      = NULL_IF_CONFIG_SMALL("Nvidia CUVID " #X " decoder"), \
668         .type           = AVMEDIA_TYPE_VIDEO, \
669         .id             = AV_CODEC_ID_##X, \
670         .priv_data_size = sizeof(CuvidContext), \
671         .init           = cuvid_decode_init, \
672         .close          = cuvid_decode_end, \
673         .decode         = cuvid_decode_frame, \
674         .capabilities   = AV_CODEC_CAP_DELAY, \
675         .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_CUDA, \
676                                                         AV_PIX_FMT_NV12, \
677                                                         AV_PIX_FMT_NONE }, \
678     };
679
680 #if CONFIG_HEVC_CUVID_DECODER
681 DEFINE_CUVID_CODEC(hevc, HEVC)
682 #endif
683
684 #if CONFIG_H264_CUVID_DECODER
685 DEFINE_CUVID_CODEC(h264, H264)
686 #endif
687
688 #if CONFIG_VP8_CUVID_DECODER
689 DEFINE_CUVID_CODEC(vp8, VP8)
690 #endif
691
692 #if CONFIG_VP9_CUVID_DECODER
693 DEFINE_CUVID_CODEC(vp9, VP9)
694 #endif
695
696 #if CONFIG_VC1_CUVID_DECODER
697 DEFINE_CUVID_CODEC(vc1, VC1)
698 #endif