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