FFmpeg
cuviddec.c
Go to the documentation of this file.
1 /*
2  * Nvidia CUVID decoder
3  * Copyright (c) 2016 Timo Rothenpieler <timo@rothenpieler.org>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
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 old_nb_surfaces, fifo_size_inc, fifo_size_mul = 1;
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  if (ctx->deint_mode_current != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field) {
353  avctx->framerate = av_mul_q(avctx->framerate, (AVRational){2, 1});
354  fifo_size_mul = 2;
355  }
356 
357  old_nb_surfaces = ctx->nb_surfaces;
358  ctx->nb_surfaces = FFMAX(ctx->nb_surfaces, format->min_num_decode_surfaces + 3);
359  if (avctx->extra_hw_frames > 0)
360  ctx->nb_surfaces += avctx->extra_hw_frames;
361 
362  fifo_size_inc = ctx->nb_surfaces * fifo_size_mul - av_fifo_can_read(ctx->frame_queue) - av_fifo_can_write(ctx->frame_queue);
363  if (fifo_size_inc > 0 && av_fifo_grow2(ctx->frame_queue, fifo_size_inc) < 0) {
364  av_log(avctx, AV_LOG_ERROR, "Failed to grow frame queue on video sequence callback\n");
365  ctx->internal_error = AVERROR(ENOMEM);
366  return 0;
367  }
368 
369  if (ctx->nb_surfaces > old_nb_surfaces && av_reallocp_array(&ctx->key_frame, ctx->nb_surfaces, sizeof(int)) < 0) {
370  av_log(avctx, AV_LOG_ERROR, "Failed to grow key frame array on video sequence callback\n");
371  ctx->internal_error = AVERROR(ENOMEM);
372  return 0;
373  }
374 
375  cuinfo.ulNumDecodeSurfaces = ctx->nb_surfaces;
376  cuinfo.ulNumOutputSurfaces = 1;
377  cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
378  cuinfo.bitDepthMinus8 = format->bit_depth_luma_minus8;
379  cuinfo.DeinterlaceMode = ctx->deint_mode_current;
380 
381  ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidCreateDecoder(&ctx->cudecoder, &cuinfo));
382  if (ctx->internal_error < 0)
383  return 0;
384 
385  if (!hwframe_ctx->pool) {
386  hwframe_ctx->format = AV_PIX_FMT_CUDA;
387  hwframe_ctx->sw_format = avctx->sw_pix_fmt;
388  hwframe_ctx->width = avctx->width;
389  hwframe_ctx->height = avctx->height;
390 
391  if ((ctx->internal_error = av_hwframe_ctx_init(ctx->hwframe)) < 0) {
392  av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_init failed\n");
393  return 0;
394  }
395  }
396 
397  if(ctx->cuparseinfo.ulMaxNumDecodeSurfaces != cuinfo.ulNumDecodeSurfaces) {
398  ctx->cuparseinfo.ulMaxNumDecodeSurfaces = cuinfo.ulNumDecodeSurfaces;
399  return cuinfo.ulNumDecodeSurfaces;
400  }
401 
402  return 1;
403 }
404 
405 static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS* picparams)
406 {
407  AVCodecContext *avctx = opaque;
408  CuvidContext *ctx = avctx->priv_data;
409 
410  av_log(avctx, AV_LOG_TRACE, "pfnDecodePicture\n");
411 
412  if(picparams->intra_pic_flag)
413  ctx->key_frame[picparams->CurrPicIdx] = picparams->intra_pic_flag;
414 
415  ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDecodePicture(ctx->cudecoder, picparams));
416  if (ctx->internal_error < 0)
417  return 0;
418 
419  return 1;
420 }
421 
422 static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO* dispinfo)
423 {
424  AVCodecContext *avctx = opaque;
425  CuvidContext *ctx = avctx->priv_data;
426  CuvidParsedFrame parsed_frame = { { 0 } };
427 
428  parsed_frame.dispinfo = *dispinfo;
429  ctx->internal_error = 0;
430 
431  // For some reason, dispinfo->progressive_frame is sometimes wrong.
432  parsed_frame.dispinfo.progressive_frame = ctx->progressive_sequence;
433 
434  if (ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave) {
435  av_fifo_write(ctx->frame_queue, &parsed_frame, 1);
436  } else {
437  parsed_frame.is_deinterlacing = 1;
438  av_fifo_write(ctx->frame_queue, &parsed_frame, 1);
439  if (!ctx->drop_second_field) {
440  parsed_frame.second_field = 1;
441  av_fifo_write(ctx->frame_queue, &parsed_frame, 1);
442  }
443  }
444 
445  return 1;
446 }
447 
449 {
450  CuvidContext *ctx = avctx->priv_data;
451 
452  int shift = 0;
453  if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field)
454  shift = 1;
455 
456  // shift/divide frame count to ensure the buffer is still signalled full if one half-frame has already been returned when deinterlacing.
457  return ((av_fifo_can_read(ctx->frame_queue) + shift) >> shift) + ctx->cuparseinfo.ulMaxDisplayDelay >= ctx->nb_surfaces;
458 }
459 
460 static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
461 {
462  CuvidContext *ctx = avctx->priv_data;
463  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
464  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
465  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
466  CUVIDSOURCEDATAPACKET cupkt;
467  int ret = 0, eret = 0, is_flush = ctx->decoder_flushing;
468 
469  av_log(avctx, AV_LOG_TRACE, "cuvid_decode_packet\n");
470 
471  if (is_flush && avpkt && avpkt->size)
472  return AVERROR_EOF;
473 
474  if (cuvid_is_buffer_full(avctx) && avpkt && avpkt->size)
475  return AVERROR(EAGAIN);
476 
477  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
478  if (ret < 0) {
479  return ret;
480  }
481 
482  memset(&cupkt, 0, sizeof(cupkt));
483 
484  if (avpkt && avpkt->size) {
485  cupkt.payload_size = avpkt->size;
486  cupkt.payload = avpkt->data;
487 
488  if (avpkt->pts != AV_NOPTS_VALUE) {
489  cupkt.flags = CUVID_PKT_TIMESTAMP;
490  if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
491  cupkt.timestamp = av_rescale_q(avpkt->pts, avctx->pkt_timebase, (AVRational){1, 10000000});
492  else
493  cupkt.timestamp = avpkt->pts;
494  }
495  } else {
496  cupkt.flags = CUVID_PKT_ENDOFSTREAM;
497  ctx->decoder_flushing = 1;
498  }
499 
500  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &cupkt));
501 
502  if (ret < 0)
503  goto error;
504 
505  // cuvidParseVideoData doesn't return an error just because stuff failed...
506  if (ctx->internal_error) {
507  av_log(avctx, AV_LOG_ERROR, "cuvid decode callback error\n");
508  ret = ctx->internal_error;
509  goto error;
510  }
511 
512 error:
513  eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
514 
515  if (eret < 0)
516  return eret;
517  else if (ret < 0)
518  return ret;
519  else if (is_flush)
520  return AVERROR_EOF;
521  else
522  return 0;
523 }
524 
526 {
527  CuvidContext *ctx = avctx->priv_data;
528  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
529  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
530  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
531  CuvidParsedFrame parsed_frame;
532  CUdeviceptr mapped_frame = 0;
533  int ret = 0, eret = 0;
534 
535  av_log(avctx, AV_LOG_TRACE, "cuvid_output_frame\n");
536 
537  if (ctx->decoder_flushing) {
538  ret = cuvid_decode_packet(avctx, NULL);
539  if (ret < 0 && ret != AVERROR_EOF)
540  return ret;
541  }
542 
543  if (!cuvid_is_buffer_full(avctx)) {
544  AVPacket *const pkt = ctx->pkt;
545  ret = ff_decode_get_packet(avctx, pkt);
546  if (ret < 0 && ret != AVERROR_EOF)
547  return ret;
548  ret = cuvid_decode_packet(avctx, pkt);
550  // cuvid_is_buffer_full() should avoid this.
551  if (ret == AVERROR(EAGAIN))
553  if (ret < 0 && ret != AVERROR_EOF)
554  return ret;
555  }
556 
557  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
558  if (ret < 0)
559  return ret;
560 
561  if (av_fifo_read(ctx->frame_queue, &parsed_frame, 1) >= 0) {
562  const AVPixFmtDescriptor *pixdesc;
563  CUVIDPROCPARAMS params;
564  unsigned int pitch = 0;
565  int offset = 0;
566  int i;
567 
568  memset(&params, 0, sizeof(params));
569  params.progressive_frame = parsed_frame.dispinfo.progressive_frame;
570  params.second_field = parsed_frame.second_field;
571  params.top_field_first = parsed_frame.dispinfo.top_field_first;
572 
573  ret = CHECK_CU(ctx->cvdl->cuvidMapVideoFrame(ctx->cudecoder, parsed_frame.dispinfo.picture_index, &mapped_frame, &pitch, &params));
574  if (ret < 0)
575  goto error;
576 
577  if (avctx->pix_fmt == AV_PIX_FMT_CUDA) {
578  ret = av_hwframe_get_buffer(ctx->hwframe, frame, 0);
579  if (ret < 0) {
580  av_log(avctx, AV_LOG_ERROR, "av_hwframe_get_buffer failed\n");
581  goto error;
582  }
583 
584  ret = ff_decode_frame_props(avctx, frame);
585  if (ret < 0) {
586  av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props failed\n");
587  goto error;
588  }
589 
590  pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
591 
592  for (i = 0; i < pixdesc->nb_components; i++) {
593  int height = avctx->height >> (i ? pixdesc->log2_chroma_h : 0);
594  CUDA_MEMCPY2D cpy = {
595  .srcMemoryType = CU_MEMORYTYPE_DEVICE,
596  .dstMemoryType = CU_MEMORYTYPE_DEVICE,
597  .srcDevice = mapped_frame,
598  .dstDevice = (CUdeviceptr)frame->data[i],
599  .srcPitch = pitch,
600  .dstPitch = frame->linesize[i],
601  .srcY = offset,
602  .WidthInBytes = FFMIN(pitch, frame->linesize[i]),
603  .Height = height,
604  };
605 
606  ret = CHECK_CU(ctx->cudl->cuMemcpy2DAsync(&cpy, device_hwctx->stream));
607  if (ret < 0)
608  goto error;
609 
610  offset += height;
611  }
612  } else if (avctx->pix_fmt == AV_PIX_FMT_NV12 ||
613  avctx->pix_fmt == AV_PIX_FMT_P010 ||
614  avctx->pix_fmt == AV_PIX_FMT_P016 ||
615 #ifdef NVDEC_HAVE_422_SUPPORT
616  avctx->pix_fmt == AV_PIX_FMT_NV16 ||
617  avctx->pix_fmt == AV_PIX_FMT_P216 ||
618 #endif
619  avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
620  avctx->pix_fmt == AV_PIX_FMT_YUV444P16) {
621  unsigned int offset = 0;
622  AVFrame *tmp_frame = av_frame_alloc();
623  if (!tmp_frame) {
624  av_log(avctx, AV_LOG_ERROR, "av_frame_alloc failed\n");
625  ret = AVERROR(ENOMEM);
626  goto error;
627  }
628 
629  pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
630 
631  tmp_frame->format = AV_PIX_FMT_CUDA;
632  tmp_frame->hw_frames_ctx = av_buffer_ref(ctx->hwframe);
633  if (!tmp_frame->hw_frames_ctx) {
634  ret = AVERROR(ENOMEM);
635  av_frame_free(&tmp_frame);
636  goto error;
637  }
638 
639  tmp_frame->width = avctx->width;
640  tmp_frame->height = avctx->height;
641 
642  /*
643  * Note that the following logic would not work for three plane
644  * YUV420 because the pitch value is different for the chroma
645  * planes.
646  */
647  for (i = 0; i < pixdesc->nb_components; i++) {
648  tmp_frame->data[i] = (uint8_t*)mapped_frame + offset;
649  tmp_frame->linesize[i] = pitch;
650  offset += pitch * (avctx->height >> (i ? pixdesc->log2_chroma_h : 0));
651  }
652 
653  ret = ff_get_buffer(avctx, frame, 0);
654  if (ret < 0) {
655  av_log(avctx, AV_LOG_ERROR, "ff_get_buffer failed\n");
656  av_frame_free(&tmp_frame);
657  goto error;
658  }
659 
660  ret = av_hwframe_transfer_data(frame, tmp_frame, 0);
661  if (ret) {
662  av_log(avctx, AV_LOG_ERROR, "av_hwframe_transfer_data failed\n");
663  av_frame_free(&tmp_frame);
664  goto error;
665  }
666  av_frame_free(&tmp_frame);
667  } else {
668  ret = AVERROR_BUG;
669  goto error;
670  }
671 
672  if (ctx->key_frame[parsed_frame.dispinfo.picture_index])
673  frame->flags |= AV_FRAME_FLAG_KEY;
674  else
675  frame->flags &= ~AV_FRAME_FLAG_KEY;
676  ctx->key_frame[parsed_frame.dispinfo.picture_index] = 0;
677 
678  frame->width = avctx->width;
679  frame->height = avctx->height;
680  if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
681  frame->pts = av_rescale_q(parsed_frame.dispinfo.timestamp, (AVRational){1, 10000000}, avctx->pkt_timebase);
682  else
683  frame->pts = parsed_frame.dispinfo.timestamp;
684 
685  if (parsed_frame.second_field) {
686  if (ctx->prev_pts == INT64_MIN) {
687  ctx->prev_pts = frame->pts;
688  frame->pts += (avctx->pkt_timebase.den * avctx->framerate.den) / (avctx->pkt_timebase.num * avctx->framerate.num);
689  } else {
690  int pts_diff = (frame->pts - ctx->prev_pts) / 2;
691  ctx->prev_pts = frame->pts;
692  frame->pts += pts_diff;
693  }
694  }
695 
696  /* CUVIDs opaque reordering breaks the internal pkt logic.
697  * So set pkt_pts and clear all the other pkt_ fields.
698  */
699  frame->duration = 0;
700 #if FF_API_FRAME_PKT
702  frame->pkt_pos = -1;
703  frame->pkt_size = -1;
705 #endif
706 
707  if (!parsed_frame.is_deinterlacing && !parsed_frame.dispinfo.progressive_frame)
709 
710  if ((frame->flags & AV_FRAME_FLAG_INTERLACED) && parsed_frame.dispinfo.top_field_first)
712  } else if (ctx->decoder_flushing) {
713  ret = AVERROR_EOF;
714  } else {
715  ret = AVERROR(EAGAIN);
716  }
717 
718 error:
719  if (ret < 0)
721 
722  if (mapped_frame)
723  eret = CHECK_CU(ctx->cvdl->cuvidUnmapVideoFrame(ctx->cudecoder, mapped_frame));
724 
725  eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
726 
727  if (eret < 0)
728  return eret;
729  else
730  return ret;
731 }
732 
734 {
735  CuvidContext *ctx = avctx->priv_data;
736  AVHWDeviceContext *device_ctx = ctx->hwdevice ? (AVHWDeviceContext *)ctx->hwdevice->data : NULL;
737  AVCUDADeviceContext *device_hwctx = device_ctx ? device_ctx->hwctx : NULL;
738  CUcontext dummy, cuda_ctx = device_hwctx ? device_hwctx->cuda_ctx : NULL;
739 
740  av_fifo_freep2(&ctx->frame_queue);
741 
742  if (cuda_ctx) {
743  ctx->cudl->cuCtxPushCurrent(cuda_ctx);
744 
745  if (ctx->cuparser)
746  ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
747 
748  if (ctx->cudecoder)
749  ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
750 
751  ctx->cudl->cuCtxPopCurrent(&dummy);
752  }
753 
754  ctx->cudl = NULL;
755 
756  av_buffer_unref(&ctx->hwframe);
757  av_buffer_unref(&ctx->hwdevice);
758 
759  av_freep(&ctx->key_frame);
760  av_freep(&ctx->cuparse_ext);
761 
762  cuvid_free_functions(&ctx->cvdl);
763 
764  return 0;
765 }
766 
768  const CUVIDPARSERPARAMS *cuparseinfo,
769  int probed_width,
770  int probed_height,
771  int bit_depth, int is_yuv422, int is_yuv444)
772 {
773  CuvidContext *ctx = avctx->priv_data;
774  CUVIDDECODECAPS *caps;
775  int res8 = 0, res10 = 0, res12 = 0;
776 
777  if (!ctx->cvdl->cuvidGetDecoderCaps) {
778  av_log(avctx, AV_LOG_WARNING, "Used Nvidia driver is too old to perform a capability check.\n");
779  av_log(avctx, AV_LOG_WARNING, "The minimum required version is "
780 #if defined(_WIN32) || defined(__CYGWIN__)
781  "378.66"
782 #else
783  "378.13"
784 #endif
785  ". Continuing blind.\n");
786  ctx->caps8.bIsSupported = ctx->caps10.bIsSupported = 1;
787  // 12 bit was not supported before the capability check was introduced, so disable it.
788  ctx->caps12.bIsSupported = 0;
789  return 0;
790  }
791 
792  ctx->caps8.eCodecType = ctx->caps10.eCodecType = ctx->caps12.eCodecType
793  = cuparseinfo->CodecType;
794 
795  ctx->caps8.eChromaFormat = ctx->caps10.eChromaFormat = ctx->caps12.eChromaFormat
796  = is_yuv444 ? cudaVideoChromaFormat_444 :
797 #ifdef NVDEC_HAVE_422_SUPPORT
798  (is_yuv422 ? cudaVideoChromaFormat_422 : cudaVideoChromaFormat_420);
799 #else
800  cudaVideoChromaFormat_420;
801 #endif
802 
803  ctx->caps8.nBitDepthMinus8 = 0;
804  ctx->caps10.nBitDepthMinus8 = 2;
805  ctx->caps12.nBitDepthMinus8 = 4;
806 
807  res8 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps8));
808  res10 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps10));
809  res12 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps12));
810 
811  av_log(avctx, AV_LOG_VERBOSE, "CUVID capabilities for %s:\n", avctx->codec->name);
812  av_log(avctx, AV_LOG_VERBOSE, "8 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
813  ctx->caps8.bIsSupported, ctx->caps8.nMinWidth, ctx->caps8.nMaxWidth, ctx->caps8.nMinHeight, ctx->caps8.nMaxHeight);
814  av_log(avctx, AV_LOG_VERBOSE, "10 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
815  ctx->caps10.bIsSupported, ctx->caps10.nMinWidth, ctx->caps10.nMaxWidth, ctx->caps10.nMinHeight, ctx->caps10.nMaxHeight);
816  av_log(avctx, AV_LOG_VERBOSE, "12 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
817  ctx->caps12.bIsSupported, ctx->caps12.nMinWidth, ctx->caps12.nMaxWidth, ctx->caps12.nMinHeight, ctx->caps12.nMaxHeight);
818 
819  switch (bit_depth) {
820  case 10:
821  caps = &ctx->caps10;
822  if (res10 < 0)
823  return res10;
824  break;
825  case 12:
826  caps = &ctx->caps12;
827  if (res12 < 0)
828  return res12;
829  break;
830  default:
831  caps = &ctx->caps8;
832  if (res8 < 0)
833  return res8;
834  }
835 
836  if (!ctx->caps8.bIsSupported) {
837  av_log(avctx, AV_LOG_ERROR, "Codec %s is not supported with this chroma format.\n", avctx->codec->name);
838  return AVERROR(EINVAL);
839  }
840 
841  if (!caps->bIsSupported) {
842  av_log(avctx, AV_LOG_ERROR, "Bit depth %d with this chroma format is not supported.\n", bit_depth);
843  return AVERROR(EINVAL);
844  }
845 
846  if (probed_width > caps->nMaxWidth || probed_width < caps->nMinWidth) {
847  av_log(avctx, AV_LOG_ERROR, "Video width %d not within range from %d to %d\n",
848  probed_width, caps->nMinWidth, caps->nMaxWidth);
849  return AVERROR(EINVAL);
850  }
851 
852  if (probed_height > caps->nMaxHeight || probed_height < caps->nMinHeight) {
853  av_log(avctx, AV_LOG_ERROR, "Video height %d not within range from %d to %d\n",
854  probed_height, caps->nMinHeight, caps->nMaxHeight);
855  return AVERROR(EINVAL);
856  }
857 
858  if ((probed_width * probed_height) / 256 > caps->nMaxMBCount) {
859  av_log(avctx, AV_LOG_ERROR, "Video macroblock count %d exceeds maximum of %d\n",
860  (int)(probed_width * probed_height) / 256, caps->nMaxMBCount);
861  return AVERROR(EINVAL);
862  }
863 
864  return 0;
865 }
866 
868 {
869  CuvidContext *ctx = avctx->priv_data;
870  AVCUDADeviceContext *device_hwctx;
871  AVHWDeviceContext *device_ctx;
872  AVHWFramesContext *hwframe_ctx;
873  CUVIDSOURCEDATAPACKET seq_pkt;
874  CUcontext cuda_ctx = NULL;
875  CUcontext dummy;
876  uint8_t *extradata;
877  int extradata_size;
878  int ret = 0;
879 
882  AV_PIX_FMT_NONE };
883 
884  int probed_width = avctx->coded_width ? avctx->coded_width : 1280;
885  int probed_height = avctx->coded_height ? avctx->coded_height : 720;
886  int probed_bit_depth = 8, is_yuv444 = 0, is_yuv422 = 0;
887 
888  const AVPixFmtDescriptor *probe_desc = av_pix_fmt_desc_get(avctx->pix_fmt);
889  if (probe_desc && probe_desc->nb_components)
890  probed_bit_depth = probe_desc->comp[0].depth;
891 
892  if (probe_desc && !probe_desc->log2_chroma_w && !probe_desc->log2_chroma_h)
893  is_yuv444 = 1;
894 
895 #ifdef NVDEC_HAVE_422_SUPPORT
896  if (probe_desc && probe_desc->log2_chroma_w && !probe_desc->log2_chroma_h)
897  is_yuv422 = 1;
898 #endif
899 
900  // Pick pixel format based on bit depth and chroma sampling.
901  switch (probed_bit_depth) {
902  case 10:
903  pix_fmts[1] = is_yuv444 ? AV_PIX_FMT_YUV444P16 : (is_yuv422 ? AV_PIX_FMT_P216 : AV_PIX_FMT_P010);
904  break;
905  case 12:
906  pix_fmts[1] = is_yuv444 ? AV_PIX_FMT_YUV444P16 : (is_yuv422 ? AV_PIX_FMT_P216 : AV_PIX_FMT_P016);
907  break;
908  default:
909  pix_fmts[1] = is_yuv444 ? AV_PIX_FMT_YUV444P : (is_yuv422 ? AV_PIX_FMT_NV16 : AV_PIX_FMT_NV12);
910  break;
911  }
912 
913  ctx->pkt = avctx->internal->in_pkt;
914  // Accelerated transcoding scenarios with 'ffmpeg' require that the
915  // pix_fmt be set to AV_PIX_FMT_CUDA early. The sw_pix_fmt, and the
916  // pix_fmt for non-accelerated transcoding, do not need to be correct
917  // but need to be set to something.
918  ret = ff_get_format(avctx, pix_fmts);
919  if (ret < 0) {
920  av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", ret);
921  return ret;
922  }
923  avctx->pix_fmt = ret;
924 
925  if (ctx->resize_expr && sscanf(ctx->resize_expr, "%dx%d",
926  &ctx->resize.width, &ctx->resize.height) != 2) {
927  av_log(avctx, AV_LOG_ERROR, "Invalid resize expressions\n");
928  ret = AVERROR(EINVAL);
929  goto error;
930  }
931 
932  if (ctx->crop_expr && sscanf(ctx->crop_expr, "%dx%dx%dx%d",
933  &ctx->crop.top, &ctx->crop.bottom,
934  &ctx->crop.left, &ctx->crop.right) != 4) {
935  av_log(avctx, AV_LOG_ERROR, "Invalid cropping expressions\n");
936  ret = AVERROR(EINVAL);
937  goto error;
938  }
939 
940  ret = cuvid_load_functions(&ctx->cvdl, avctx);
941  if (ret < 0) {
942  av_log(avctx, AV_LOG_ERROR, "Failed loading nvcuvid.\n");
943  goto error;
944  }
945 
946  // respect the deprecated "surfaces" option if non-default value is given by user;
947  if(ctx->nb_surfaces < 0)
948  ctx->nb_surfaces = CUVID_DEFAULT_NUM_SURFACES;
949 
950  ctx->frame_queue = av_fifo_alloc2(ctx->nb_surfaces, sizeof(CuvidParsedFrame), 0);
951  if (!ctx->frame_queue) {
952  ret = AVERROR(ENOMEM);
953  goto error;
954  }
955 
956  if (avctx->hw_frames_ctx) {
957  ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
958  if (!ctx->hwframe) {
959  ret = AVERROR(ENOMEM);
960  goto error;
961  }
962 
963  hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
964 
965  ctx->hwdevice = av_buffer_ref(hwframe_ctx->device_ref);
966  if (!ctx->hwdevice) {
967  ret = AVERROR(ENOMEM);
968  goto error;
969  }
970  } else {
971  if (avctx->hw_device_ctx) {
972  ctx->hwdevice = av_buffer_ref(avctx->hw_device_ctx);
973  if (!ctx->hwdevice) {
974  ret = AVERROR(ENOMEM);
975  goto error;
976  }
977  } else {
978  ret = av_hwdevice_ctx_create(&ctx->hwdevice, AV_HWDEVICE_TYPE_CUDA, ctx->cu_gpu, NULL, 0);
979  if (ret < 0)
980  goto error;
981  }
982 
983  ctx->hwframe = av_hwframe_ctx_alloc(ctx->hwdevice);
984  if (!ctx->hwframe) {
985  av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
986  ret = AVERROR(ENOMEM);
987  goto error;
988  }
989 
990  hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
991  }
992 
993  device_ctx = hwframe_ctx->device_ctx;
994  device_hwctx = device_ctx->hwctx;
995 
996  cuda_ctx = device_hwctx->cuda_ctx;
997  ctx->cudl = device_hwctx->internal->cuda_dl;
998 
999  memset(&ctx->cuparseinfo, 0, sizeof(ctx->cuparseinfo));
1000  memset(&seq_pkt, 0, sizeof(seq_pkt));
1001 
1002  switch (avctx->codec->id) {
1003 #if CONFIG_H264_CUVID_DECODER
1004  case AV_CODEC_ID_H264:
1005  ctx->cuparseinfo.CodecType = cudaVideoCodec_H264;
1006  break;
1007 #endif
1008 #if CONFIG_HEVC_CUVID_DECODER
1009  case AV_CODEC_ID_HEVC:
1010  ctx->cuparseinfo.CodecType = cudaVideoCodec_HEVC;
1011  break;
1012 #endif
1013 #if CONFIG_MJPEG_CUVID_DECODER
1014  case AV_CODEC_ID_MJPEG:
1015  ctx->cuparseinfo.CodecType = cudaVideoCodec_JPEG;
1016  break;
1017 #endif
1018 #if CONFIG_MPEG1_CUVID_DECODER
1020  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG1;
1021  break;
1022 #endif
1023 #if CONFIG_MPEG2_CUVID_DECODER
1025  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG2;
1026  break;
1027 #endif
1028 #if CONFIG_MPEG4_CUVID_DECODER
1029  case AV_CODEC_ID_MPEG4:
1030  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
1031  break;
1032 #endif
1033 #if CONFIG_VP8_CUVID_DECODER
1034  case AV_CODEC_ID_VP8:
1035  ctx->cuparseinfo.CodecType = cudaVideoCodec_VP8;
1036  break;
1037 #endif
1038 #if CONFIG_VP9_CUVID_DECODER
1039  case AV_CODEC_ID_VP9:
1040  ctx->cuparseinfo.CodecType = cudaVideoCodec_VP9;
1041  break;
1042 #endif
1043 #if CONFIG_VC1_CUVID_DECODER
1044  case AV_CODEC_ID_VC1:
1045  ctx->cuparseinfo.CodecType = cudaVideoCodec_VC1;
1046  break;
1047 #endif
1048 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
1049  case AV_CODEC_ID_AV1:
1050  ctx->cuparseinfo.CodecType = cudaVideoCodec_AV1;
1051  break;
1052 #endif
1053  default:
1054  av_log(avctx, AV_LOG_ERROR, "Invalid CUVID codec!\n");
1055  return AVERROR_BUG;
1056  }
1057 
1058  if (ffcodec(avctx->codec)->bsfs) {
1059  const AVCodecParameters *par = avctx->internal->bsf->par_out;
1060  extradata = par->extradata;
1061  extradata_size = par->extradata_size;
1062  } else {
1063  extradata = avctx->extradata;
1064  extradata_size = avctx->extradata_size;
1065  }
1066 
1067  // Check first bit to determine whether it's AV1CodecConfigurationRecord.
1068  // Skip first 4 bytes of AV1CodecConfigurationRecord to keep configOBUs
1069  // only, otherwise cuvidParseVideoData report unknown error.
1070  if (avctx->codec->id == AV_CODEC_ID_AV1 &&
1071  extradata_size > 4 &&
1072  extradata[0] & 0x80) {
1073  extradata += 4;
1074  extradata_size -= 4;
1075  }
1076 
1077  ctx->cuparse_ext = av_mallocz(sizeof(*ctx->cuparse_ext)
1078  + FFMAX(extradata_size - (int)sizeof(ctx->cuparse_ext->raw_seqhdr_data), 0));
1079  if (!ctx->cuparse_ext) {
1080  ret = AVERROR(ENOMEM);
1081  goto error;
1082  }
1083 
1084  if (extradata_size > 0)
1085  memcpy(ctx->cuparse_ext->raw_seqhdr_data, extradata, extradata_size);
1086  ctx->cuparse_ext->format.seqhdr_data_length = extradata_size;
1087 
1088  ctx->cuparseinfo.pExtVideoInfo = ctx->cuparse_ext;
1089 
1090  ctx->key_frame = av_mallocz(ctx->nb_surfaces * sizeof(int));
1091  if (!ctx->key_frame) {
1092  ret = AVERROR(ENOMEM);
1093  goto error;
1094  }
1095 
1096  ctx->cuparseinfo.ulMaxNumDecodeSurfaces = 1;
1097  ctx->cuparseinfo.ulMaxDisplayDelay = (avctx->flags & AV_CODEC_FLAG_LOW_DELAY) ? 0 : CUVID_MAX_DISPLAY_DELAY;
1098  ctx->cuparseinfo.pUserData = avctx;
1099  ctx->cuparseinfo.pfnSequenceCallback = cuvid_handle_video_sequence;
1100  ctx->cuparseinfo.pfnDecodePicture = cuvid_handle_picture_decode;
1101  ctx->cuparseinfo.pfnDisplayPicture = cuvid_handle_picture_display;
1102 
1103  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
1104  if (ret < 0)
1105  goto error;
1106 
1107  ret = cuvid_test_capabilities(avctx, &ctx->cuparseinfo,
1108  probed_width,
1109  probed_height,
1110  probed_bit_depth, is_yuv422, is_yuv444);
1111  if (ret < 0)
1112  goto error;
1113 
1114  ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
1115  if (ret < 0)
1116  goto error;
1117 
1118  seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
1119  seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
1120 
1121  if (seq_pkt.payload && seq_pkt.payload_size) {
1122  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
1123  if (ret < 0)
1124  goto error;
1125  }
1126 
1127  ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
1128  if (ret < 0)
1129  goto error;
1130 
1131  ctx->prev_pts = INT64_MIN;
1132 
1133  if (!avctx->pkt_timebase.num || !avctx->pkt_timebase.den)
1134  av_log(avctx, AV_LOG_WARNING, "Invalid pkt_timebase, passing timestamps as-is.\n");
1135 
1136  return 0;
1137 
1138 error:
1139  cuvid_decode_end(avctx);
1140  return ret;
1141 }
1142 
1143 static void cuvid_flush(AVCodecContext *avctx)
1144 {
1145  CuvidContext *ctx = avctx->priv_data;
1146  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
1147  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
1148  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
1149  CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
1150  int ret;
1151 
1152  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
1153  if (ret < 0)
1154  goto error;
1155 
1156  av_fifo_reset2(ctx->frame_queue);
1157 
1158  if (ctx->cudecoder) {
1159  ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
1160  ctx->cudecoder = NULL;
1161  }
1162 
1163  if (ctx->cuparser) {
1164  ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
1165  ctx->cuparser = NULL;
1166  }
1167 
1168  ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
1169  if (ret < 0)
1170  goto error;
1171 
1172  seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
1173  seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
1174 
1175  if (seq_pkt.payload && seq_pkt.payload_size) {
1176  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
1177  if (ret < 0)
1178  goto error;
1179  }
1180 
1181  ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
1182  if (ret < 0)
1183  goto error;
1184 
1185  ctx->prev_pts = INT64_MIN;
1186  ctx->decoder_flushing = 0;
1187 
1188  return;
1189  error:
1190  av_log(avctx, AV_LOG_ERROR, "CUDA reinit on flush failed\n");
1191 }
1192 
1193 #define OFFSET(x) offsetof(CuvidContext, x)
1194 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1195 static const AVOption options[] = {
1196  { "deint", "Set deinterlacing mode", OFFSET(deint_mode), AV_OPT_TYPE_INT, { .i64 = cudaVideoDeinterlaceMode_Weave }, cudaVideoDeinterlaceMode_Weave, cudaVideoDeinterlaceMode_Adaptive, VD, .unit = "deint" },
1197  { "weave", "Weave deinterlacing (do nothing)", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Weave }, 0, 0, VD, .unit = "deint" },
1198  { "bob", "Bob deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob }, 0, 0, VD, .unit = "deint" },
1199  { "adaptive", "Adaptive deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0, VD, .unit = "deint" },
1200  { "gpu", "GPU to be used for decoding", OFFSET(cu_gpu), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1201  { "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 },
1202  { "drop_second_field", "Drop second field when deinterlacing", OFFSET(drop_second_field), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
1203  { "crop", "Crop (top)x(bottom)x(left)x(right)", OFFSET(crop_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1204  { "resize", "Resize (width)x(height)", OFFSET(resize_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1205  { NULL }
1206 };
1207 
1209  &(const AVCodecHWConfigInternal) {
1210  .public = {
1215  .device_type = AV_HWDEVICE_TYPE_CUDA
1216  },
1217  .hwaccel = NULL,
1218  },
1219  NULL
1220 };
1221 
1222 #define DEFINE_CUVID_CODEC(x, X, bsf_name) \
1223  static const AVClass x##_cuvid_class = { \
1224  .class_name = #x "_cuvid", \
1225  .item_name = av_default_item_name, \
1226  .option = options, \
1227  .version = LIBAVUTIL_VERSION_INT, \
1228  }; \
1229  const FFCodec ff_##x##_cuvid_decoder = { \
1230  .p.name = #x "_cuvid", \
1231  CODEC_LONG_NAME("Nvidia CUVID " #X " decoder"), \
1232  .p.type = AVMEDIA_TYPE_VIDEO, \
1233  .p.id = AV_CODEC_ID_##X, \
1234  .priv_data_size = sizeof(CuvidContext), \
1235  .p.priv_class = &x##_cuvid_class, \
1236  .init = cuvid_decode_init, \
1237  .close = cuvid_decode_end, \
1238  FF_CODEC_RECEIVE_FRAME_CB(cuvid_output_frame), \
1239  .flush = cuvid_flush, \
1240  .bsfs = bsf_name, \
1241  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
1242  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE | \
1243  FF_CODEC_CAP_SETS_FRAME_PROPS, \
1244  .hw_configs = cuvid_hw_configs, \
1245  .p.wrapper_name = "cuvid", \
1246  };
1247 
1248 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
1249 DEFINE_CUVID_CODEC(av1, AV1, NULL)
1250 #endif
1251 
1252 #if CONFIG_HEVC_CUVID_DECODER
1253 DEFINE_CUVID_CODEC(hevc, HEVC, "hevc_mp4toannexb")
1254 #endif
1255 
1256 #if CONFIG_H264_CUVID_DECODER
1257 DEFINE_CUVID_CODEC(h264, H264, "h264_mp4toannexb")
1258 #endif
1259 
1260 #if CONFIG_MJPEG_CUVID_DECODER
1261 DEFINE_CUVID_CODEC(mjpeg, MJPEG, NULL)
1262 #endif
1263 
1264 #if CONFIG_MPEG1_CUVID_DECODER
1265 DEFINE_CUVID_CODEC(mpeg1, MPEG1VIDEO, NULL)
1266 #endif
1267 
1268 #if CONFIG_MPEG2_CUVID_DECODER
1269 DEFINE_CUVID_CODEC(mpeg2, MPEG2VIDEO, NULL)
1270 #endif
1271 
1272 #if CONFIG_MPEG4_CUVID_DECODER
1273 DEFINE_CUVID_CODEC(mpeg4, MPEG4, NULL)
1274 #endif
1275 
1276 #if CONFIG_VP8_CUVID_DECODER
1277 DEFINE_CUVID_CODEC(vp8, VP8, NULL)
1278 #endif
1279 
1280 #if CONFIG_VP9_CUVID_DECODER
1281 DEFINE_CUVID_CODEC(vp9, VP9, NULL)
1282 #endif
1283 
1284 #if CONFIG_VC1_CUVID_DECODER
1285 DEFINE_CUVID_CODEC(vc1, VC1, NULL)
1286 #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
av_fifo_can_write
size_t av_fifo_can_write(const AVFifo *f)
Definition: fifo.c:94
cuvid_handle_picture_display
static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO *dispinfo)
Definition: cuviddec.c:422
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:1274
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:3313
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:70
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:746
cuvid_output_frame
static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: cuviddec.c:525
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
cuvid_test_capabilities
static int cuvid_test_capabilities(AVCodecContext *avctx, const CUVIDPARSERPARAMS *cuparseinfo, int probed_width, int probed_height, int bit_depth, int is_yuv422, int is_yuv444)
Definition: cuviddec.c:767
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:58
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:1208
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:538
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:405
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:1222
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:460
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:1194
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:106
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:448
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:867
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:1703
AVPacket::size
int size
Definition: packet.h:540
AVFifo
Definition: fifo.c:35
height
#define height
Definition: dsp.h:85
codec_internal.h
shift
static int shift(int a, int b)
Definition: bonk.c:261
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:733
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:284
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:599
CHECK_CU
#define CHECK_CU(x)
Definition: cuviddec.c:117
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:530
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:729
AV_PIX_FMT_P016
#define AV_PIX_FMT_P016
Definition: pixfmt.h:583
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:1561
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:1193
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:581
FFCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec_internal.h:255
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:1143
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:3233
cuvid_handle_video_sequence
static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT *format)
Definition: cuviddec.c:125