FFmpeg
cuviddec.c
Go to the documentation of this file.
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 
23 
24 #include "libavutil/buffer.h"
25 #include "libavutil/mathematics.h"
26 #include "libavutil/hwcontext.h"
28 #include "libavutil/cuda_check.h"
29 #include "libavutil/fifo.h"
30 #include "libavutil/log.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
33 
34 #include "avcodec.h"
35 #include "decode.h"
36 #include "hwconfig.h"
37 #include "nvdec.h"
38 #include "internal.h"
39 
40 #if !NVDECAPI_CHECK_VERSION(9, 0)
41 #define cudaVideoSurfaceFormat_YUV444 2
42 #define cudaVideoSurfaceFormat_YUV444_16Bit 3
43 #endif
44 
45 #if NVDECAPI_CHECK_VERSION(11, 0)
46 #define CUVID_HAS_AV1_SUPPORT
47 #endif
48 
49 typedef struct CuvidContext
50 {
52 
53  CUvideodecoder cudecoder;
54  CUvideoparser cuparser;
55 
56  char *cu_gpu;
59  char *crop_expr;
60  char *resize_expr;
61 
62  struct {
63  int left;
64  int top;
65  int right;
66  int bottom;
67  } crop;
68 
69  struct {
70  int width;
71  int height;
72  } resize;
73 
76 
78 
81  int64_t prev_pts;
83 
86 
87  int *key_frame;
88 
89  cudaVideoCodec codec_type;
90  cudaVideoChromaFormat chroma_format;
91 
92  CUVIDDECODECAPS caps8, caps10, caps12;
93 
94  CUVIDPARSERPARAMS cuparseinfo;
95  CUVIDEOFORMATEX *cuparse_ext;
96 
97  CudaFunctions *cudl;
98  CuvidFunctions *cvdl;
99 } CuvidContext;
100 
101 typedef struct CuvidParsedFrame
102 {
103  CUVIDPARSERDISPINFO dispinfo;
107 
108 #define CHECK_CU(x) FF_CUDA_CHECK_DL(avctx, ctx->cudl, x)
109 
110 static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT* format)
111 {
112  AVCodecContext *avctx = opaque;
113  CuvidContext *ctx = avctx->priv_data;
114  AVHWFramesContext *hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
115  CUVIDDECODECAPS *caps = NULL;
116  CUVIDDECODECREATEINFO cuinfo;
117  int surface_fmt;
118  int chroma_444;
119 
120  int old_width = avctx->width;
121  int old_height = avctx->height;
122 
124  AV_PIX_FMT_NONE, // Will be updated below
125  AV_PIX_FMT_NONE };
126 
127  av_log(avctx, AV_LOG_TRACE, "pfnSequenceCallback, progressive_sequence=%d\n", format->progressive_sequence);
128 
129  memset(&cuinfo, 0, sizeof(cuinfo));
130 
131  ctx->internal_error = 0;
132 
133  avctx->coded_width = cuinfo.ulWidth = format->coded_width;
134  avctx->coded_height = cuinfo.ulHeight = format->coded_height;
135 
136  // apply cropping
137  cuinfo.display_area.left = format->display_area.left + ctx->crop.left;
138  cuinfo.display_area.top = format->display_area.top + ctx->crop.top;
139  cuinfo.display_area.right = format->display_area.right - ctx->crop.right;
140  cuinfo.display_area.bottom = format->display_area.bottom - ctx->crop.bottom;
141 
142  // width and height need to be set before calling ff_get_format
143  if (ctx->resize_expr) {
144  avctx->width = ctx->resize.width;
145  avctx->height = ctx->resize.height;
146  } else {
147  avctx->width = cuinfo.display_area.right - cuinfo.display_area.left;
148  avctx->height = cuinfo.display_area.bottom - cuinfo.display_area.top;
149  }
150 
151  // target width/height need to be multiples of two
152  cuinfo.ulTargetWidth = avctx->width = (avctx->width + 1) & ~1;
153  cuinfo.ulTargetHeight = avctx->height = (avctx->height + 1) & ~1;
154 
155  // aspect ratio conversion, 1:1, depends on scaled resolution
156  cuinfo.target_rect.left = 0;
157  cuinfo.target_rect.top = 0;
158  cuinfo.target_rect.right = cuinfo.ulTargetWidth;
159  cuinfo.target_rect.bottom = cuinfo.ulTargetHeight;
160 
161  chroma_444 = format->chroma_format == cudaVideoChromaFormat_444;
162 
163  switch (format->bit_depth_luma_minus8) {
164  case 0: // 8-bit
165  pix_fmts[1] = chroma_444 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_NV12;
166  caps = &ctx->caps8;
167  break;
168  case 2: // 10-bit
169  pix_fmts[1] = chroma_444 ? AV_PIX_FMT_YUV444P16 : AV_PIX_FMT_P010;
170  caps = &ctx->caps10;
171  break;
172  case 4: // 12-bit
173  pix_fmts[1] = chroma_444 ? AV_PIX_FMT_YUV444P16 : AV_PIX_FMT_P016;
174  caps = &ctx->caps12;
175  break;
176  default:
177  break;
178  }
179 
180  if (!caps || !caps->bIsSupported) {
181  av_log(avctx, AV_LOG_ERROR, "unsupported bit depth: %d\n",
182  format->bit_depth_luma_minus8 + 8);
183  ctx->internal_error = AVERROR(EINVAL);
184  return 0;
185  }
186 
187  surface_fmt = ff_get_format(avctx, pix_fmts);
188  if (surface_fmt < 0) {
189  av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", surface_fmt);
190  ctx->internal_error = AVERROR(EINVAL);
191  return 0;
192  }
193 
194  av_log(avctx, AV_LOG_VERBOSE, "Formats: Original: %s | HW: %s | SW: %s\n",
195  av_get_pix_fmt_name(avctx->pix_fmt),
196  av_get_pix_fmt_name(surface_fmt),
197  av_get_pix_fmt_name(avctx->sw_pix_fmt));
198 
199  avctx->pix_fmt = surface_fmt;
200 
201  // Update our hwframe ctx, as the get_format callback might have refreshed it!
202  if (avctx->hw_frames_ctx) {
203  av_buffer_unref(&ctx->hwframe);
204 
205  ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
206  if (!ctx->hwframe) {
207  ctx->internal_error = AVERROR(ENOMEM);
208  return 0;
209  }
210 
211  hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
212  }
213 
214  ff_set_sar(avctx, av_div_q(
215  (AVRational){ format->display_aspect_ratio.x, format->display_aspect_ratio.y },
216  (AVRational){ avctx->width, avctx->height }));
217 
218  ctx->deint_mode_current = format->progressive_sequence
219  ? cudaVideoDeinterlaceMode_Weave
220  : ctx->deint_mode;
221 
222  ctx->progressive_sequence = format->progressive_sequence;
223 
224  if (!format->progressive_sequence && ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave)
226  else
227  avctx->flags &= ~AV_CODEC_FLAG_INTERLACED_DCT;
228 
229  if (format->video_signal_description.video_full_range_flag)
230  avctx->color_range = AVCOL_RANGE_JPEG;
231  else
232  avctx->color_range = AVCOL_RANGE_MPEG;
233 
234  avctx->color_primaries = format->video_signal_description.color_primaries;
235  avctx->color_trc = format->video_signal_description.transfer_characteristics;
236  avctx->colorspace = format->video_signal_description.matrix_coefficients;
237 
238  if (format->bitrate)
239  avctx->bit_rate = format->bitrate;
240 
241  if (format->frame_rate.numerator && format->frame_rate.denominator) {
242  avctx->framerate.num = format->frame_rate.numerator;
243  avctx->framerate.den = format->frame_rate.denominator;
244  }
245 
246  if (ctx->cudecoder
247  && avctx->coded_width == format->coded_width
248  && avctx->coded_height == format->coded_height
249  && avctx->width == old_width
250  && avctx->height == old_height
251  && ctx->chroma_format == format->chroma_format
252  && ctx->codec_type == format->codec)
253  return 1;
254 
255  if (ctx->cudecoder) {
256  av_log(avctx, AV_LOG_TRACE, "Re-initializing decoder\n");
257  ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder));
258  if (ctx->internal_error < 0)
259  return 0;
260  ctx->cudecoder = NULL;
261  }
262 
263  if (hwframe_ctx->pool && (
264  hwframe_ctx->width < avctx->width ||
265  hwframe_ctx->height < avctx->height ||
266  hwframe_ctx->format != AV_PIX_FMT_CUDA ||
267  hwframe_ctx->sw_format != avctx->sw_pix_fmt)) {
268  av_log(avctx, AV_LOG_ERROR, "AVHWFramesContext is already initialized with incompatible parameters\n");
269  av_log(avctx, AV_LOG_DEBUG, "width: %d <-> %d\n", hwframe_ctx->width, avctx->width);
270  av_log(avctx, AV_LOG_DEBUG, "height: %d <-> %d\n", hwframe_ctx->height, avctx->height);
271  av_log(avctx, AV_LOG_DEBUG, "format: %s <-> cuda\n", av_get_pix_fmt_name(hwframe_ctx->format));
272  av_log(avctx, AV_LOG_DEBUG, "sw_format: %s <-> %s\n",
273  av_get_pix_fmt_name(hwframe_ctx->sw_format), av_get_pix_fmt_name(avctx->sw_pix_fmt));
274  ctx->internal_error = AVERROR(EINVAL);
275  return 0;
276  }
277 
278  ctx->chroma_format = format->chroma_format;
279 
280  cuinfo.CodecType = ctx->codec_type = format->codec;
281  cuinfo.ChromaFormat = format->chroma_format;
282 
283  switch (avctx->sw_pix_fmt) {
284  case AV_PIX_FMT_NV12:
285  cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
286  break;
287  case AV_PIX_FMT_P010:
288  case AV_PIX_FMT_P016:
289  cuinfo.OutputFormat = cudaVideoSurfaceFormat_P016;
290  break;
291  case AV_PIX_FMT_YUV444P:
292  cuinfo.OutputFormat = cudaVideoSurfaceFormat_YUV444;
293  break;
295  cuinfo.OutputFormat = cudaVideoSurfaceFormat_YUV444_16Bit;
296  break;
297  default:
298  av_log(avctx, AV_LOG_ERROR, "Unsupported output format: %s\n",
299  av_get_pix_fmt_name(avctx->sw_pix_fmt));
300  ctx->internal_error = AVERROR(EINVAL);
301  return 0;
302  }
303 
304  cuinfo.ulNumDecodeSurfaces = ctx->nb_surfaces;
305  cuinfo.ulNumOutputSurfaces = 1;
306  cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
307  cuinfo.bitDepthMinus8 = format->bit_depth_luma_minus8;
308  cuinfo.DeinterlaceMode = ctx->deint_mode_current;
309 
310  if (ctx->deint_mode_current != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field)
311  avctx->framerate = av_mul_q(avctx->framerate, (AVRational){2, 1});
312 
313  ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidCreateDecoder(&ctx->cudecoder, &cuinfo));
314  if (ctx->internal_error < 0)
315  return 0;
316 
317  if (!hwframe_ctx->pool) {
318  hwframe_ctx->format = AV_PIX_FMT_CUDA;
319  hwframe_ctx->sw_format = avctx->sw_pix_fmt;
320  hwframe_ctx->width = avctx->width;
321  hwframe_ctx->height = avctx->height;
322 
323  if ((ctx->internal_error = av_hwframe_ctx_init(ctx->hwframe)) < 0) {
324  av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_init failed\n");
325  return 0;
326  }
327  }
328 
329  return 1;
330 }
331 
332 static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS* picparams)
333 {
334  AVCodecContext *avctx = opaque;
335  CuvidContext *ctx = avctx->priv_data;
336 
337  av_log(avctx, AV_LOG_TRACE, "pfnDecodePicture\n");
338 
339  ctx->key_frame[picparams->CurrPicIdx] = picparams->intra_pic_flag;
340 
341  ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDecodePicture(ctx->cudecoder, picparams));
342  if (ctx->internal_error < 0)
343  return 0;
344 
345  return 1;
346 }
347 
348 static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO* dispinfo)
349 {
350  AVCodecContext *avctx = opaque;
351  CuvidContext *ctx = avctx->priv_data;
352  CuvidParsedFrame parsed_frame = { { 0 } };
353 
354  parsed_frame.dispinfo = *dispinfo;
355  ctx->internal_error = 0;
356 
357  // For some reason, dispinfo->progressive_frame is sometimes wrong.
358  parsed_frame.dispinfo.progressive_frame = ctx->progressive_sequence;
359 
360  if (ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave) {
361  av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
362  } else {
363  parsed_frame.is_deinterlacing = 1;
364  av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
365  if (!ctx->drop_second_field) {
366  parsed_frame.second_field = 1;
367  av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
368  }
369  }
370 
371  return 1;
372 }
373 
375 {
376  CuvidContext *ctx = avctx->priv_data;
377 
378  int delay = ctx->cuparseinfo.ulMaxDisplayDelay;
379  if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field)
380  delay *= 2;
381 
382  return (av_fifo_size(ctx->frame_queue) / sizeof(CuvidParsedFrame)) + delay >= ctx->nb_surfaces;
383 }
384 
385 static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
386 {
387  CuvidContext *ctx = avctx->priv_data;
388  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
389  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
390  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
391  CUVIDSOURCEDATAPACKET cupkt;
392  int ret = 0, eret = 0, is_flush = ctx->decoder_flushing;
393 
394  av_log(avctx, AV_LOG_TRACE, "cuvid_decode_packet\n");
395 
396  if (is_flush && avpkt && avpkt->size)
397  return AVERROR_EOF;
398 
399  if (cuvid_is_buffer_full(avctx) && avpkt && avpkt->size)
400  return AVERROR(EAGAIN);
401 
402  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
403  if (ret < 0) {
404  return ret;
405  }
406 
407  memset(&cupkt, 0, sizeof(cupkt));
408 
409  if (avpkt && avpkt->size) {
410  cupkt.payload_size = avpkt->size;
411  cupkt.payload = avpkt->data;
412 
413  if (avpkt->pts != AV_NOPTS_VALUE) {
414  cupkt.flags = CUVID_PKT_TIMESTAMP;
415  if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
416  cupkt.timestamp = av_rescale_q(avpkt->pts, avctx->pkt_timebase, (AVRational){1, 10000000});
417  else
418  cupkt.timestamp = avpkt->pts;
419  }
420  } else {
421  cupkt.flags = CUVID_PKT_ENDOFSTREAM;
422  ctx->decoder_flushing = 1;
423  }
424 
425  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &cupkt));
426 
427  if (ret < 0)
428  goto error;
429 
430  // cuvidParseVideoData doesn't return an error just because stuff failed...
431  if (ctx->internal_error) {
432  av_log(avctx, AV_LOG_ERROR, "cuvid decode callback error\n");
433  ret = ctx->internal_error;
434  goto error;
435  }
436 
437 error:
438  eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
439 
440  if (eret < 0)
441  return eret;
442  else if (ret < 0)
443  return ret;
444  else if (is_flush)
445  return AVERROR_EOF;
446  else
447  return 0;
448 }
449 
451 {
452  CuvidContext *ctx = avctx->priv_data;
453  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
454  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
455  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
456  CUdeviceptr mapped_frame = 0;
457  int ret = 0, eret = 0;
458 
459  av_log(avctx, AV_LOG_TRACE, "cuvid_output_frame\n");
460 
461  if (ctx->decoder_flushing) {
462  ret = cuvid_decode_packet(avctx, NULL);
463  if (ret < 0 && ret != AVERROR_EOF)
464  return ret;
465  }
466 
467  if (!cuvid_is_buffer_full(avctx)) {
468  AVPacket pkt = {0};
469  ret = ff_decode_get_packet(avctx, &pkt);
470  if (ret < 0 && ret != AVERROR_EOF)
471  return ret;
472  ret = cuvid_decode_packet(avctx, &pkt);
473  av_packet_unref(&pkt);
474  // cuvid_is_buffer_full() should avoid this.
475  if (ret == AVERROR(EAGAIN))
477  if (ret < 0 && ret != AVERROR_EOF)
478  return ret;
479  }
480 
481  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
482  if (ret < 0)
483  return ret;
484 
485  if (av_fifo_size(ctx->frame_queue)) {
486  const AVPixFmtDescriptor *pixdesc;
487  CuvidParsedFrame parsed_frame;
488  CUVIDPROCPARAMS params;
489  unsigned int pitch = 0;
490  int offset = 0;
491  int i;
492 
493  av_fifo_generic_read(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
494 
495  memset(&params, 0, sizeof(params));
496  params.progressive_frame = parsed_frame.dispinfo.progressive_frame;
497  params.second_field = parsed_frame.second_field;
498  params.top_field_first = parsed_frame.dispinfo.top_field_first;
499 
500  ret = CHECK_CU(ctx->cvdl->cuvidMapVideoFrame(ctx->cudecoder, parsed_frame.dispinfo.picture_index, &mapped_frame, &pitch, &params));
501  if (ret < 0)
502  goto error;
503 
504  if (avctx->pix_fmt == AV_PIX_FMT_CUDA) {
505  ret = av_hwframe_get_buffer(ctx->hwframe, frame, 0);
506  if (ret < 0) {
507  av_log(avctx, AV_LOG_ERROR, "av_hwframe_get_buffer failed\n");
508  goto error;
509  }
510 
511  ret = ff_decode_frame_props(avctx, frame);
512  if (ret < 0) {
513  av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props failed\n");
514  goto error;
515  }
516 
517  pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
518 
519  for (i = 0; i < pixdesc->nb_components; i++) {
520  int height = avctx->height >> (i ? pixdesc->log2_chroma_h : 0);
521  CUDA_MEMCPY2D cpy = {
522  .srcMemoryType = CU_MEMORYTYPE_DEVICE,
523  .dstMemoryType = CU_MEMORYTYPE_DEVICE,
524  .srcDevice = mapped_frame,
525  .dstDevice = (CUdeviceptr)frame->data[i],
526  .srcPitch = pitch,
527  .dstPitch = frame->linesize[i],
528  .srcY = offset,
529  .WidthInBytes = FFMIN(pitch, frame->linesize[i]),
530  .Height = height,
531  };
532 
533  ret = CHECK_CU(ctx->cudl->cuMemcpy2DAsync(&cpy, device_hwctx->stream));
534  if (ret < 0)
535  goto error;
536 
537  offset += height;
538  }
539  } else if (avctx->pix_fmt == AV_PIX_FMT_NV12 ||
540  avctx->pix_fmt == AV_PIX_FMT_P010 ||
541  avctx->pix_fmt == AV_PIX_FMT_P016 ||
542  avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
543  avctx->pix_fmt == AV_PIX_FMT_YUV444P16) {
544  unsigned int offset = 0;
545  AVFrame *tmp_frame = av_frame_alloc();
546  if (!tmp_frame) {
547  av_log(avctx, AV_LOG_ERROR, "av_frame_alloc failed\n");
548  ret = AVERROR(ENOMEM);
549  goto error;
550  }
551 
552  pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
553 
554  tmp_frame->format = AV_PIX_FMT_CUDA;
555  tmp_frame->hw_frames_ctx = av_buffer_ref(ctx->hwframe);
556  if (!tmp_frame->hw_frames_ctx) {
557  ret = AVERROR(ENOMEM);
558  av_frame_free(&tmp_frame);
559  goto error;
560  }
561 
562  tmp_frame->width = avctx->width;
563  tmp_frame->height = avctx->height;
564 
565  /*
566  * Note that the following logic would not work for three plane
567  * YUV420 because the pitch value is different for the chroma
568  * planes.
569  */
570  for (i = 0; i < pixdesc->nb_components; i++) {
571  tmp_frame->data[i] = (uint8_t*)mapped_frame + offset;
572  tmp_frame->linesize[i] = pitch;
573  offset += pitch * (avctx->height >> (i ? pixdesc->log2_chroma_h : 0));
574  }
575 
576  ret = ff_get_buffer(avctx, frame, 0);
577  if (ret < 0) {
578  av_log(avctx, AV_LOG_ERROR, "ff_get_buffer failed\n");
579  av_frame_free(&tmp_frame);
580  goto error;
581  }
582 
583  ret = av_hwframe_transfer_data(frame, tmp_frame, 0);
584  if (ret) {
585  av_log(avctx, AV_LOG_ERROR, "av_hwframe_transfer_data failed\n");
586  av_frame_free(&tmp_frame);
587  goto error;
588  }
589  av_frame_free(&tmp_frame);
590  } else {
591  ret = AVERROR_BUG;
592  goto error;
593  }
594 
595  frame->key_frame = ctx->key_frame[parsed_frame.dispinfo.picture_index];
596  frame->width = avctx->width;
597  frame->height = avctx->height;
598  if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
599  frame->pts = av_rescale_q(parsed_frame.dispinfo.timestamp, (AVRational){1, 10000000}, avctx->pkt_timebase);
600  else
601  frame->pts = parsed_frame.dispinfo.timestamp;
602 
603  if (parsed_frame.second_field) {
604  if (ctx->prev_pts == INT64_MIN) {
605  ctx->prev_pts = frame->pts;
606  frame->pts += (avctx->pkt_timebase.den * avctx->framerate.den) / (avctx->pkt_timebase.num * avctx->framerate.num);
607  } else {
608  int pts_diff = (frame->pts - ctx->prev_pts) / 2;
609  ctx->prev_pts = frame->pts;
610  frame->pts += pts_diff;
611  }
612  }
613 
614  /* CUVIDs opaque reordering breaks the internal pkt logic.
615  * So set pkt_pts and clear all the other pkt_ fields.
616  */
617 #if FF_API_PKT_PTS
619  frame->pkt_pts = frame->pts;
621 #endif
622  frame->pkt_pos = -1;
623  frame->pkt_duration = 0;
624  frame->pkt_size = -1;
625 
626  frame->interlaced_frame = !parsed_frame.is_deinterlacing && !parsed_frame.dispinfo.progressive_frame;
627 
628  if (frame->interlaced_frame)
629  frame->top_field_first = parsed_frame.dispinfo.top_field_first;
630  } else if (ctx->decoder_flushing) {
631  ret = AVERROR_EOF;
632  } else {
633  ret = AVERROR(EAGAIN);
634  }
635 
636 error:
637  if (ret < 0)
638  av_frame_unref(frame);
639 
640  if (mapped_frame)
641  eret = CHECK_CU(ctx->cvdl->cuvidUnmapVideoFrame(ctx->cudecoder, mapped_frame));
642 
643  eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
644 
645  if (eret < 0)
646  return eret;
647  else
648  return ret;
649 }
650 
651 static int cuvid_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
652 {
653  CuvidContext *ctx = avctx->priv_data;
654  AVFrame *frame = data;
655  int ret = 0;
656 
657  av_log(avctx, AV_LOG_TRACE, "cuvid_decode_frame\n");
658 
659  if (ctx->deint_mode_current != cudaVideoDeinterlaceMode_Weave) {
660  av_log(avctx, AV_LOG_ERROR, "Deinterlacing is not supported via the old API\n");
661  return AVERROR(EINVAL);
662  }
663 
664  if (!ctx->decoder_flushing) {
665  ret = cuvid_decode_packet(avctx, avpkt);
666  if (ret < 0)
667  return ret;
668  }
669 
670  ret = cuvid_output_frame(avctx, frame);
671  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
672  *got_frame = 0;
673  } else if (ret < 0) {
674  return ret;
675  } else {
676  *got_frame = 1;
677  }
678 
679  return 0;
680 }
681 
683 {
684  CuvidContext *ctx = avctx->priv_data;
685  AVHWDeviceContext *device_ctx = (AVHWDeviceContext *)ctx->hwdevice->data;
686  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
687  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
688 
689  av_fifo_freep(&ctx->frame_queue);
690 
691  ctx->cudl->cuCtxPushCurrent(cuda_ctx);
692 
693  if (ctx->cuparser)
694  ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
695 
696  if (ctx->cudecoder)
697  ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
698 
699  ctx->cudl->cuCtxPopCurrent(&dummy);
700 
701  ctx->cudl = NULL;
702 
703  av_buffer_unref(&ctx->hwframe);
704  av_buffer_unref(&ctx->hwdevice);
705 
706  av_freep(&ctx->key_frame);
707  av_freep(&ctx->cuparse_ext);
708 
709  cuvid_free_functions(&ctx->cvdl);
710 
711  return 0;
712 }
713 
715  const CUVIDPARSERPARAMS *cuparseinfo,
716  int probed_width,
717  int probed_height,
718  int bit_depth)
719 {
720  CuvidContext *ctx = avctx->priv_data;
721  CUVIDDECODECAPS *caps;
722  int res8 = 0, res10 = 0, res12 = 0;
723 
724  if (!ctx->cvdl->cuvidGetDecoderCaps) {
725  av_log(avctx, AV_LOG_WARNING, "Used Nvidia driver is too old to perform a capability check.\n");
726  av_log(avctx, AV_LOG_WARNING, "The minimum required version is "
727 #if defined(_WIN32) || defined(__CYGWIN__)
728  "378.66"
729 #else
730  "378.13"
731 #endif
732  ". Continuing blind.\n");
733  ctx->caps8.bIsSupported = ctx->caps10.bIsSupported = 1;
734  // 12 bit was not supported before the capability check was introduced, so disable it.
735  ctx->caps12.bIsSupported = 0;
736  return 0;
737  }
738 
739  ctx->caps8.eCodecType = ctx->caps10.eCodecType = ctx->caps12.eCodecType
740  = cuparseinfo->CodecType;
741  ctx->caps8.eChromaFormat = ctx->caps10.eChromaFormat = ctx->caps12.eChromaFormat
742  = cudaVideoChromaFormat_420;
743 
744  ctx->caps8.nBitDepthMinus8 = 0;
745  ctx->caps10.nBitDepthMinus8 = 2;
746  ctx->caps12.nBitDepthMinus8 = 4;
747 
748  res8 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps8));
749  res10 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps10));
750  res12 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps12));
751 
752  av_log(avctx, AV_LOG_VERBOSE, "CUVID capabilities for %s:\n", avctx->codec->name);
753  av_log(avctx, AV_LOG_VERBOSE, "8 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
754  ctx->caps8.bIsSupported, ctx->caps8.nMinWidth, ctx->caps8.nMaxWidth, ctx->caps8.nMinHeight, ctx->caps8.nMaxHeight);
755  av_log(avctx, AV_LOG_VERBOSE, "10 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
756  ctx->caps10.bIsSupported, ctx->caps10.nMinWidth, ctx->caps10.nMaxWidth, ctx->caps10.nMinHeight, ctx->caps10.nMaxHeight);
757  av_log(avctx, AV_LOG_VERBOSE, "12 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
758  ctx->caps12.bIsSupported, ctx->caps12.nMinWidth, ctx->caps12.nMaxWidth, ctx->caps12.nMinHeight, ctx->caps12.nMaxHeight);
759 
760  switch (bit_depth) {
761  case 10:
762  caps = &ctx->caps10;
763  if (res10 < 0)
764  return res10;
765  break;
766  case 12:
767  caps = &ctx->caps12;
768  if (res12 < 0)
769  return res12;
770  break;
771  default:
772  caps = &ctx->caps8;
773  if (res8 < 0)
774  return res8;
775  }
776 
777  if (!ctx->caps8.bIsSupported) {
778  av_log(avctx, AV_LOG_ERROR, "Codec %s is not supported.\n", avctx->codec->name);
779  return AVERROR(EINVAL);
780  }
781 
782  if (!caps->bIsSupported) {
783  av_log(avctx, AV_LOG_ERROR, "Bit depth %d is not supported.\n", bit_depth);
784  return AVERROR(EINVAL);
785  }
786 
787  if (probed_width > caps->nMaxWidth || probed_width < caps->nMinWidth) {
788  av_log(avctx, AV_LOG_ERROR, "Video width %d not within range from %d to %d\n",
789  probed_width, caps->nMinWidth, caps->nMaxWidth);
790  return AVERROR(EINVAL);
791  }
792 
793  if (probed_height > caps->nMaxHeight || probed_height < caps->nMinHeight) {
794  av_log(avctx, AV_LOG_ERROR, "Video height %d not within range from %d to %d\n",
795  probed_height, caps->nMinHeight, caps->nMaxHeight);
796  return AVERROR(EINVAL);
797  }
798 
799  if ((probed_width * probed_height) / 256 > caps->nMaxMBCount) {
800  av_log(avctx, AV_LOG_ERROR, "Video macroblock count %d exceeds maximum of %d\n",
801  (int)(probed_width * probed_height) / 256, caps->nMaxMBCount);
802  return AVERROR(EINVAL);
803  }
804 
805  return 0;
806 }
807 
809 {
810  CuvidContext *ctx = avctx->priv_data;
811  AVCUDADeviceContext *device_hwctx;
812  AVHWDeviceContext *device_ctx;
813  AVHWFramesContext *hwframe_ctx;
814  CUVIDSOURCEDATAPACKET seq_pkt;
815  CUcontext cuda_ctx = NULL;
816  CUcontext dummy;
817  uint8_t *extradata;
818  int extradata_size;
819  int ret = 0;
820 
823  AV_PIX_FMT_NONE };
824 
825  int probed_width = avctx->coded_width ? avctx->coded_width : 1280;
826  int probed_height = avctx->coded_height ? avctx->coded_height : 720;
827  int probed_bit_depth = 8;
828 
829  const AVPixFmtDescriptor *probe_desc = av_pix_fmt_desc_get(avctx->pix_fmt);
830  if (probe_desc && probe_desc->nb_components)
831  probed_bit_depth = probe_desc->comp[0].depth;
832 
833  // Accelerated transcoding scenarios with 'ffmpeg' require that the
834  // pix_fmt be set to AV_PIX_FMT_CUDA early. The sw_pix_fmt, and the
835  // pix_fmt for non-accelerated transcoding, do not need to be correct
836  // but need to be set to something. We arbitrarily pick NV12.
837  ret = ff_get_format(avctx, pix_fmts);
838  if (ret < 0) {
839  av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", ret);
840  return ret;
841  }
842  avctx->pix_fmt = ret;
843 
844  if (ctx->resize_expr && sscanf(ctx->resize_expr, "%dx%d",
845  &ctx->resize.width, &ctx->resize.height) != 2) {
846  av_log(avctx, AV_LOG_ERROR, "Invalid resize expressions\n");
847  ret = AVERROR(EINVAL);
848  goto error;
849  }
850 
851  if (ctx->crop_expr && sscanf(ctx->crop_expr, "%dx%dx%dx%d",
852  &ctx->crop.top, &ctx->crop.bottom,
853  &ctx->crop.left, &ctx->crop.right) != 4) {
854  av_log(avctx, AV_LOG_ERROR, "Invalid cropping expressions\n");
855  ret = AVERROR(EINVAL);
856  goto error;
857  }
858 
859  ret = cuvid_load_functions(&ctx->cvdl, avctx);
860  if (ret < 0) {
861  av_log(avctx, AV_LOG_ERROR, "Failed loading nvcuvid.\n");
862  goto error;
863  }
864 
865  ctx->frame_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(CuvidParsedFrame));
866  if (!ctx->frame_queue) {
867  ret = AVERROR(ENOMEM);
868  goto error;
869  }
870 
871  if (avctx->hw_frames_ctx) {
872  ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
873  if (!ctx->hwframe) {
874  ret = AVERROR(ENOMEM);
875  goto error;
876  }
877 
878  hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
879 
880  ctx->hwdevice = av_buffer_ref(hwframe_ctx->device_ref);
881  if (!ctx->hwdevice) {
882  ret = AVERROR(ENOMEM);
883  goto error;
884  }
885  } else {
886  if (avctx->hw_device_ctx) {
887  ctx->hwdevice = av_buffer_ref(avctx->hw_device_ctx);
888  if (!ctx->hwdevice) {
889  ret = AVERROR(ENOMEM);
890  goto error;
891  }
892  } else {
894  if (ret < 0)
895  goto error;
896  }
897 
899  if (!ctx->hwframe) {
900  av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
901  ret = AVERROR(ENOMEM);
902  goto error;
903  }
904 
905  hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
906  }
907 
908  device_ctx = hwframe_ctx->device_ctx;
909  device_hwctx = device_ctx->hwctx;
910 
911  cuda_ctx = device_hwctx->cuda_ctx;
912  ctx->cudl = device_hwctx->internal->cuda_dl;
913 
914  memset(&ctx->cuparseinfo, 0, sizeof(ctx->cuparseinfo));
915  memset(&seq_pkt, 0, sizeof(seq_pkt));
916 
917  switch (avctx->codec->id) {
918 #if CONFIG_H264_CUVID_DECODER
919  case AV_CODEC_ID_H264:
920  ctx->cuparseinfo.CodecType = cudaVideoCodec_H264;
921  break;
922 #endif
923 #if CONFIG_HEVC_CUVID_DECODER
924  case AV_CODEC_ID_HEVC:
925  ctx->cuparseinfo.CodecType = cudaVideoCodec_HEVC;
926  break;
927 #endif
928 #if CONFIG_MJPEG_CUVID_DECODER
929  case AV_CODEC_ID_MJPEG:
930  ctx->cuparseinfo.CodecType = cudaVideoCodec_JPEG;
931  break;
932 #endif
933 #if CONFIG_MPEG1_CUVID_DECODER
935  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG1;
936  break;
937 #endif
938 #if CONFIG_MPEG2_CUVID_DECODER
940  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG2;
941  break;
942 #endif
943 #if CONFIG_MPEG4_CUVID_DECODER
944  case AV_CODEC_ID_MPEG4:
945  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
946  break;
947 #endif
948 #if CONFIG_VP8_CUVID_DECODER
949  case AV_CODEC_ID_VP8:
950  ctx->cuparseinfo.CodecType = cudaVideoCodec_VP8;
951  break;
952 #endif
953 #if CONFIG_VP9_CUVID_DECODER
954  case AV_CODEC_ID_VP9:
955  ctx->cuparseinfo.CodecType = cudaVideoCodec_VP9;
956  break;
957 #endif
958 #if CONFIG_VC1_CUVID_DECODER
959  case AV_CODEC_ID_VC1:
960  ctx->cuparseinfo.CodecType = cudaVideoCodec_VC1;
961  break;
962 #endif
963 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
964  case AV_CODEC_ID_AV1:
965  ctx->cuparseinfo.CodecType = cudaVideoCodec_AV1;
966  break;
967 #endif
968  default:
969  av_log(avctx, AV_LOG_ERROR, "Invalid CUVID codec!\n");
970  return AVERROR_BUG;
971  }
972 
973  if (avctx->codec->bsfs) {
974  const AVCodecParameters *par = avctx->internal->bsf->par_out;
975  extradata = par->extradata;
976  extradata_size = par->extradata_size;
977  } else {
978  extradata = avctx->extradata;
979  extradata_size = avctx->extradata_size;
980  }
981 
982  ctx->cuparse_ext = av_mallocz(sizeof(*ctx->cuparse_ext)
983  + FFMAX(extradata_size - (int)sizeof(ctx->cuparse_ext->raw_seqhdr_data), 0));
984  if (!ctx->cuparse_ext) {
985  ret = AVERROR(ENOMEM);
986  goto error;
987  }
988 
989  if (extradata_size > 0)
990  memcpy(ctx->cuparse_ext->raw_seqhdr_data, extradata, extradata_size);
991  ctx->cuparse_ext->format.seqhdr_data_length = extradata_size;
992 
993  ctx->cuparseinfo.pExtVideoInfo = ctx->cuparse_ext;
994 
995  ctx->key_frame = av_mallocz(ctx->nb_surfaces * sizeof(int));
996  if (!ctx->key_frame) {
997  ret = AVERROR(ENOMEM);
998  goto error;
999  }
1000 
1001  ctx->cuparseinfo.ulMaxNumDecodeSurfaces = ctx->nb_surfaces;
1002  ctx->cuparseinfo.ulMaxDisplayDelay = 4;
1003  ctx->cuparseinfo.pUserData = avctx;
1004  ctx->cuparseinfo.pfnSequenceCallback = cuvid_handle_video_sequence;
1005  ctx->cuparseinfo.pfnDecodePicture = cuvid_handle_picture_decode;
1006  ctx->cuparseinfo.pfnDisplayPicture = cuvid_handle_picture_display;
1007 
1008  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
1009  if (ret < 0)
1010  goto error;
1011 
1012  ret = cuvid_test_capabilities(avctx, &ctx->cuparseinfo,
1013  probed_width,
1014  probed_height,
1015  probed_bit_depth);
1016  if (ret < 0)
1017  goto error;
1018 
1019  ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
1020  if (ret < 0)
1021  goto error;
1022 
1023  seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
1024  seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
1025 
1026  if (seq_pkt.payload && seq_pkt.payload_size) {
1027  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
1028  if (ret < 0)
1029  goto error;
1030  }
1031 
1032  ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
1033  if (ret < 0)
1034  goto error;
1035 
1036  ctx->prev_pts = INT64_MIN;
1037 
1038  if (!avctx->pkt_timebase.num || !avctx->pkt_timebase.den)
1039  av_log(avctx, AV_LOG_WARNING, "Invalid pkt_timebase, passing timestamps as-is.\n");
1040 
1041  return 0;
1042 
1043 error:
1044  cuvid_decode_end(avctx);
1045  return ret;
1046 }
1047 
1048 static void cuvid_flush(AVCodecContext *avctx)
1049 {
1050  CuvidContext *ctx = avctx->priv_data;
1051  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
1052  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
1053  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
1054  CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
1055  int ret;
1056 
1057  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
1058  if (ret < 0)
1059  goto error;
1060 
1061  av_fifo_freep(&ctx->frame_queue);
1062 
1063  ctx->frame_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(CuvidParsedFrame));
1064  if (!ctx->frame_queue) {
1065  av_log(avctx, AV_LOG_ERROR, "Failed to recreate frame queue on flush\n");
1066  return;
1067  }
1068 
1069  if (ctx->cudecoder) {
1070  ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
1071  ctx->cudecoder = NULL;
1072  }
1073 
1074  if (ctx->cuparser) {
1075  ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
1076  ctx->cuparser = NULL;
1077  }
1078 
1079  ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
1080  if (ret < 0)
1081  goto error;
1082 
1083  seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
1084  seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
1085 
1086  if (seq_pkt.payload && seq_pkt.payload_size) {
1087  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
1088  if (ret < 0)
1089  goto error;
1090  }
1091 
1092  ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
1093  if (ret < 0)
1094  goto error;
1095 
1096  ctx->prev_pts = INT64_MIN;
1097  ctx->decoder_flushing = 0;
1098 
1099  return;
1100  error:
1101  av_log(avctx, AV_LOG_ERROR, "CUDA reinit on flush failed\n");
1102 }
1103 
1104 #define OFFSET(x) offsetof(CuvidContext, x)
1105 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1106 static const AVOption options[] = {
1107  { "deint", "Set deinterlacing mode", OFFSET(deint_mode), AV_OPT_TYPE_INT, { .i64 = cudaVideoDeinterlaceMode_Weave }, cudaVideoDeinterlaceMode_Weave, cudaVideoDeinterlaceMode_Adaptive, VD, "deint" },
1108  { "weave", "Weave deinterlacing (do nothing)", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Weave }, 0, 0, VD, "deint" },
1109  { "bob", "Bob deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob }, 0, 0, VD, "deint" },
1110  { "adaptive", "Adaptive deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0, VD, "deint" },
1111  { "gpu", "GPU to be used for decoding", OFFSET(cu_gpu), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1112  { "surfaces", "Maximum surfaces to be used for decoding", OFFSET(nb_surfaces), AV_OPT_TYPE_INT, { .i64 = 25 }, 0, INT_MAX, VD },
1113  { "drop_second_field", "Drop second field when deinterlacing", OFFSET(drop_second_field), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
1114  { "crop", "Crop (top)x(bottom)x(left)x(right)", OFFSET(crop_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1115  { "resize", "Resize (width)x(height)", OFFSET(resize_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1116  { NULL }
1117 };
1118 
1120  &(const AVCodecHWConfigInternal) {
1121  .public = {
1125  .device_type = AV_HWDEVICE_TYPE_CUDA
1126  },
1127  .hwaccel = NULL,
1128  },
1129  NULL
1130 };
1131 
1132 #define DEFINE_CUVID_CODEC(x, X, bsf_name) \
1133  static const AVClass x##_cuvid_class = { \
1134  .class_name = #x "_cuvid", \
1135  .item_name = av_default_item_name, \
1136  .option = options, \
1137  .version = LIBAVUTIL_VERSION_INT, \
1138  }; \
1139  AVCodec ff_##x##_cuvid_decoder = { \
1140  .name = #x "_cuvid", \
1141  .long_name = NULL_IF_CONFIG_SMALL("Nvidia CUVID " #X " decoder"), \
1142  .type = AVMEDIA_TYPE_VIDEO, \
1143  .id = AV_CODEC_ID_##X, \
1144  .priv_data_size = sizeof(CuvidContext), \
1145  .priv_class = &x##_cuvid_class, \
1146  .init = cuvid_decode_init, \
1147  .close = cuvid_decode_end, \
1148  .decode = cuvid_decode_frame, \
1149  .receive_frame = cuvid_output_frame, \
1150  .flush = cuvid_flush, \
1151  .bsfs = bsf_name, \
1152  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
1153  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_CUDA, \
1154  AV_PIX_FMT_NV12, \
1155  AV_PIX_FMT_P010, \
1156  AV_PIX_FMT_P016, \
1157  AV_PIX_FMT_NONE }, \
1158  .hw_configs = cuvid_hw_configs, \
1159  .wrapper_name = "cuvid", \
1160  };
1161 
1162 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
1163 DEFINE_CUVID_CODEC(av1, AV1, NULL)
1164 #endif
1165 
1166 #if CONFIG_HEVC_CUVID_DECODER
1167 DEFINE_CUVID_CODEC(hevc, HEVC, "hevc_mp4toannexb")
1168 #endif
1169 
1170 #if CONFIG_H264_CUVID_DECODER
1171 DEFINE_CUVID_CODEC(h264, H264, "h264_mp4toannexb")
1172 #endif
1173 
1174 #if CONFIG_MJPEG_CUVID_DECODER
1175 DEFINE_CUVID_CODEC(mjpeg, MJPEG, NULL)
1176 #endif
1177 
1178 #if CONFIG_MPEG1_CUVID_DECODER
1179 DEFINE_CUVID_CODEC(mpeg1, MPEG1VIDEO, NULL)
1180 #endif
1181 
1182 #if CONFIG_MPEG2_CUVID_DECODER
1183 DEFINE_CUVID_CODEC(mpeg2, MPEG2VIDEO, NULL)
1184 #endif
1185 
1186 #if CONFIG_MPEG4_CUVID_DECODER
1187 DEFINE_CUVID_CODEC(mpeg4, MPEG4, NULL)
1188 #endif
1189 
1190 #if CONFIG_VP8_CUVID_DECODER
1191 DEFINE_CUVID_CODEC(vp8, VP8, NULL)
1192 #endif
1193 
1194 #if CONFIG_VP9_CUVID_DECODER
1195 DEFINE_CUVID_CODEC(vp9, VP9, NULL)
1196 #endif
1197 
1198 #if CONFIG_VC1_CUVID_DECODER
1199 DEFINE_CUVID_CODEC(vc1, VC1, NULL)
1200 #endif
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:61
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwconfig.h:34
#define NULL
Definition: coverity.c:32
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1296
const struct AVCodec * codec
Definition: avcodec.h:540
AVRational framerate
Definition: avcodec.h:2084
char * crop_expr
Definition: cuviddec.c:59
AVCodecParameters * par_out
Parameters of the output stream.
Definition: bsf.h:83
int decoder_flushing
Definition: cuviddec.c:85
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
struct CuvidContext::@49 crop
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
AVBufferRef * hwdevice
Definition: cuviddec.c:74
AVOption.
Definition: opt.h:248
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:321
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:719
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:585
static av_cold int cuvid_decode_init(AVCodecContext *avctx)
Definition: cuviddec.c:808
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
CUVIDDECODECAPS caps8
Definition: cuviddec.c:92
int bottom
Definition: cuviddec.c:66
CuvidFunctions * cvdl
Definition: cuviddec.c:98
AVCUDADeviceContextInternal * internal
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:364
int deint_mode
Definition: cuviddec.c:79
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
int nb_surfaces
Definition: cuviddec.c:57
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
CUVIDPARSERPARAMS cuparseinfo
Definition: cuviddec.c:94
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: decode.c:1701
static av_cold int cuvid_decode_end(AVCodecContext *avctx)
Definition: cuviddec.c:682
static AVPacket pkt
static void error(const char *err)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
Definition: fifo.c:122
The codec supports this format by some internal method.
Definition: codec.h:411
int deint_mode_current
Definition: cuviddec.c:80
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame...
Definition: frame.h:653
#define AV_PIX_FMT_P016
Definition: pixfmt.h:449
#define AV_PIX_FMT_P010
Definition: pixfmt.h:448
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:88
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
AVOptions.
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
int internal_error
Definition: cuviddec.c:84
CUvideoparser cuparser
Definition: cuviddec.c:54
static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Definition: cuviddec.c:385
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:248
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:407
int is_deinterlacing
Definition: cuviddec.c:105
enum AVPixelFormat pix_fmt
For decoders, a hardware pixel format which that decoder may be able to decode to if suitable hardwar...
Definition: codec.h:432
AVFifoBuffer * frame_queue
Definition: cuviddec.c:77
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:632
#define OFFSET(x)
Definition: cuviddec.c:1104
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Definition: hwcontext.h:92
int height
Definition: cuviddec.c:71
int av_hwdevice_ctx_create(AVBufferRef **pdevice_ref, enum AVHWDeviceType type, const char *device, AVDictionary *opts, int flags)
Open a device of the specified type and create an AVHWDeviceContext for it.
Definition: hwcontext.c:610
uint8_t * data
Definition: packet.h:363
int * key_frame
Definition: cuviddec.c:87
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:121
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:412
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:461
char * resize_expr
Definition: cuviddec.c:60
#define av_log(a,...)
#define cudaVideoSurfaceFormat_YUV444
Definition: cuviddec.c:41
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
CudaFunctions * cudl
Definition: cuviddec.c:97
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:2098
AVBSFContext * bsf
Definition: internal.h:141
enum AVCodecID id
Definition: codec.h:204
cudaVideoChromaFormat chroma_format
Definition: cuviddec.c:90
int width
Definition: frame.h:372
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVClass * avclass
Definition: cuviddec.c:51
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
cudaVideoCodec codec_type
Definition: cuviddec.c:89
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
CUVIDDECODECAPS caps12
Definition: cuviddec.c:92
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:213
GLenum GLint * params
Definition: opengl_enc.c:113
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:569
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:89
const char * name
Name of the codec implementation.
Definition: codec.h:197
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:333
static void cuvid_flush(AVCodecContext *avctx)
Definition: cuviddec.c:1048
#define FFMAX(a, b)
Definition: common.h:94
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
Definition: hwcontext.c:502
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
Definition: hwcontext.c:443
#define cudaVideoSurfaceFormat_YUV444_16Bit
Definition: cuviddec.c:42
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:551
#define FFMIN(a, b)
Definition: common.h:96
CUVIDDECODECAPS caps10
Definition: cuviddec.c:92
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
Definition: hwcontext.h:149
static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT *format)
Definition: cuviddec.c:110
int width
picture width / height.
Definition: avcodec.h:704
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:2241
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:254
AVBufferRef * hwframe
Definition: cuviddec.c:75
AVFormatContext * ctx
Definition: movenc.c:48
static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: cuviddec.c:450
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
FFmpeg internal API for CUDA.
int dummy
Definition: motion.c:64
static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS *picparams)
Definition: cuviddec.c:332
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding...
Definition: codec.h:314
HW acceleration through CUDA.
Definition: pixfmt.h:235
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
Full range content.
Definition: pixfmt.h:586
CUvideodecoder cudecoder
Definition: cuviddec.c:53
static int cuvid_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: cuviddec.c:651
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:387
int drop_second_field
Definition: cuviddec.c:58
Libavcodec external API header.
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown...
Definition: frame.h:593
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
The codec supports this format via the hw_device_ctx interface.
Definition: codec.h:391
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
main external API structure.
Definition: avcodec.h:531
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
uint8_t * data
The data buffer.
Definition: buffer.h:89
static int cuvid_test_capabilities(AVCodecContext *avctx, const CUVIDPARSERPARAMS *cuparseinfo, int probed_width, int probed_height, int bit_depth)
Definition: cuviddec.c:714
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1876
a very simple circular buffer FIFO implementation
static const AVOption options[]
Definition: cuviddec.c:1106
int extradata_size
Definition: avcodec.h:633
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
This struct is allocated as AVHWDeviceContext.hwctx.
int coded_height
Definition: avcodec.h:719
Describe the class of an AVClass context structure.
Definition: log.h:67
Rational number (pair of numerator and denominator).
Definition: rational.h:58
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
refcounted data buffer API
int progressive_sequence
Definition: cuviddec.c:82
char * cu_gpu
Definition: cuviddec.c:56
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
CUVIDPARSERDISPINFO dispinfo
Definition: cuviddec.c:103
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
Definition: hwcontext.h:141
attribute_deprecated int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
Definition: frame.h:415
Narrow or limited range content.
Definition: pixfmt.h:569
A reference to a data buffer.
Definition: buffer.h:81
#define DEFINE_CUVID_CODEC(x, X, bsf_name)
Definition: cuviddec.c:1132
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
common internal api header.
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:247
int64_t prev_pts
Definition: cuviddec.c:81
static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO *dispinfo)
Definition: cuviddec.c:348
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
int den
Denominator.
Definition: rational.h:60
#define CHECK_CU(x)
Definition: cuviddec.c:108
void * priv_data
Definition: avcodec.h:558
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:43
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:466
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:566
struct CuvidContext::@50 resize
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:392
enum AVColorPrimaries color_primaries
Definition: frame.h:560
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
static const AVCodecHWConfigInternal *const cuvid_hw_configs[]
Definition: cuviddec.c:1119
CUVIDEOFORMATEX * cuparse_ext
Definition: cuviddec.c:95
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
int height
Definition: frame.h:372
#define av_freep(p)
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
#define VD
Definition: cuviddec.c:1105
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2489
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
int depth
Number of bits in the component.
Definition: pixdesc.h:58
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:2293
int pkt_size
size of the corresponding packet containing the compressed frame.
Definition: frame.h:629
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:340
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:2091
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
static int cuvid_is_buffer_full(AVCodecContext *avctx)
Definition: cuviddec.c:374