FFmpeg  4.4
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)
225  avctx->flags |= AV_CODEC_FLAG_INTERLACED_DCT;
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);
474  // cuvid_is_buffer_full() should avoid this.
475  if (ret == AVERROR(EAGAIN))
476  ret = AVERROR_EXTERNAL;
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)
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 {
893  ret = av_hwdevice_ctx_create(&ctx->hwdevice, AV_HWDEVICE_TYPE_CUDA, ctx->cu_gpu, NULL, 0);
894  if (ret < 0)
895  goto error;
896  }
897 
898  ctx->hwframe = av_hwframe_ctx_alloc(ctx->hwdevice);
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 = (avctx->flags & AV_CODEC_FLAG_LOW_DELAY) ? 0 : 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
static const char *const format[]
Definition: af_aiir.c:456
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:254
#define av_cold
Definition: attributes.h:88
uint8_t
Libavcodec external API header.
refcounted data buffer API
#define FFMIN(a, b)
Definition: common.h:105
#define FFMAX(a, b)
Definition: common.h:103
#define NULL
Definition: coverity.c:32
static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Definition: cuviddec.c:385
static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS *picparams)
Definition: cuviddec.c:332
static const AVCodecHWConfigInternal *const cuvid_hw_configs[]
Definition: cuviddec.c:1119
static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: cuviddec.c:450
static const AVOption options[]
Definition: cuviddec.c:1106
static av_cold int cuvid_decode_end(AVCodecContext *avctx)
Definition: cuviddec.c:682
static int cuvid_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: cuviddec.c:651
#define cudaVideoSurfaceFormat_YUV444
Definition: cuviddec.c:41
static int cuvid_test_capabilities(AVCodecContext *avctx, const CUVIDPARSERPARAMS *cuparseinfo, int probed_width, int probed_height, int bit_depth)
Definition: cuviddec.c:714
static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO *dispinfo)
Definition: cuviddec.c:348
#define VD
Definition: cuviddec.c:1105
#define CHECK_CU(x)
Definition: cuviddec.c:108
static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT *format)
Definition: cuviddec.c:110
static av_cold int cuvid_decode_init(AVCodecContext *avctx)
Definition: cuviddec.c:808
#define OFFSET(x)
Definition: cuviddec.c:1104
#define DEFINE_CUVID_CODEC(x, X, bsf_name)
Definition: cuviddec.c:1132
#define cudaVideoSurfaceFormat_YUV444_16Bit
Definition: cuviddec.c:42
static int cuvid_is_buffer_full(AVCodecContext *avctx)
Definition: cuviddec.c:374
static void cuvid_flush(AVCodecContext *avctx)
Definition: cuviddec.c:1048
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: decode.c:1722
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:222
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1317
static AVFrame * frame
a very simple circular buffer FIFO implementation
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
@ AV_OPT_TYPE_INT
Definition: opt.h:225
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:321
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:325
@ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
The codec supports this format via the hw_device_ctx interface.
Definition: codec.h:411
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:431
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
@ AV_CODEC_ID_AV1
Definition: codec_id.h:279
@ AV_CODEC_ID_VC1
Definition: codec_id.h:119
@ AV_CODEC_ID_VP8
Definition: codec_id.h:189
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:223
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:61
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
@ AV_CODEC_ID_VP9
Definition: codec_id.h:217
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:50
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
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
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
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
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
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
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
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:333
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
Definition: hwcontext.c:443
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:247
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
@ AV_HWDEVICE_TYPE_CUDA
Definition: hwcontext.h:30
FFmpeg internal API for CUDA.
int i
Definition: input.c:407
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:99
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
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 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
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:43
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
common internal API header
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
int dummy
Definition: motion.c:64
const char data[16]
Definition: mxf.c:142
AVOptions.
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
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:569
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:586
#define AV_PIX_FMT_P010
Definition: pixfmt.h:448
#define AV_PIX_FMT_P016
Definition: pixfmt.h:449
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NV12
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
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:235
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:412
AVCodecParameters * par_out
Parameters of the output stream.
Definition: bsf.h:83
A reference to a data buffer.
Definition: buffer.h:84
This struct is allocated as AVHWDeviceContext.hwctx.
AVCUDADeviceContextInternal * internal
Describe the class of an AVClass context structure.
Definition: log.h:67
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:2078
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:2085
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:2218
AVRational framerate
Definition: avcodec.h:2071
const struct AVCodec * codec
Definition: avcodec.h:545
int coded_height
Definition: avcodec.h:724
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:2270
int extradata_size
Definition: avcodec.h:638
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:724
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:571
void * priv_data
Definition: avcodec.h:563
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwconfig.h:34
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:452
AVBSFContext * bsf
Definition: internal.h:148
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
enum AVCodecID id
Definition: codec.h:211
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec.h:334
const char * name
Name of the codec implementation.
Definition: codec.h:204
int depth
Number of bits in the component.
Definition: pixdesc.h:58
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int width
Definition: frame.h:376
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame.
Definition: frame.h:657
attribute_deprecated int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
Definition: frame.h:419
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown.
Definition: frame.h:597
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:589
int pkt_size
size of the corresponding packet containing the compressed frame.
Definition: frame.h:633
int height
Definition: frame.h:376
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:470
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:465
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:391
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:61
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Definition: hwcontext.h:92
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
Definition: hwcontext.h:141
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
Definition: hwcontext.h:149
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
int drop_second_field
Definition: cuviddec.c:58
int * key_frame
Definition: cuviddec.c:87
struct CuvidContext::@43 crop
char * crop_expr
Definition: cuviddec.c:59
AVFifoBuffer * frame_queue
Definition: cuviddec.c:77
CUVIDDECODECAPS caps12
Definition: cuviddec.c:92
CUvideodecoder cudecoder
Definition: cuviddec.c:53
CUvideoparser cuparser
Definition: cuviddec.c:54
char * resize_expr
Definition: cuviddec.c:60
int deint_mode_current
Definition: cuviddec.c:80
int64_t prev_pts
Definition: cuviddec.c:81
CudaFunctions * cudl
Definition: cuviddec.c:97
CuvidFunctions * cvdl
Definition: cuviddec.c:98
int decoder_flushing
Definition: cuviddec.c:85
AVBufferRef * hwdevice
Definition: cuviddec.c:74
AVClass * avclass
Definition: cuviddec.c:51
cudaVideoCodec codec_type
Definition: cuviddec.c:89
char * cu_gpu
Definition: cuviddec.c:56
int nb_surfaces
Definition: cuviddec.c:57
int height
Definition: cuviddec.c:71
int deint_mode
Definition: cuviddec.c:79
cudaVideoChromaFormat chroma_format
Definition: cuviddec.c:90
AVBufferRef * hwframe
Definition: cuviddec.c:75
CUVIDDECODECAPS caps8
Definition: cuviddec.c:92
int internal_error
Definition: cuviddec.c:84
struct CuvidContext::@44 resize
CUVIDPARSERPARAMS cuparseinfo
Definition: cuviddec.c:94
CUVIDDECODECAPS caps10
Definition: cuviddec.c:92
int progressive_sequence
Definition: cuviddec.c:82
CUVIDEOFORMATEX * cuparse_ext
Definition: cuviddec.c:95
int bottom
Definition: cuviddec.c:66
int is_deinterlacing
Definition: cuviddec.c:105
CUVIDPARSERDISPINFO dispinfo
Definition: cuviddec.c:103
#define av_freep(p)
#define av_log(a,...)
static void error(const char *err)
AVPacket * pkt
Definition: movenc.c:59
AVFormatContext * ctx
Definition: movenc.c:48
#define height
static const uint8_t offset[127][2]
Definition: vf_spp.c:107