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