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