FFmpeg: libavcodec/cuviddec.c Source File

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 
24 #include "compat/cuda/dynlink_loader.h"
25 
26 #include "libavutil/buffer.h"
27 #include "libavutil/mathematics.h"
28 #include "libavutil/hwcontext.h"
29 #include "libavutil/hwcontext_cuda_internal.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 {
56   AVClass *avclass;
57 
58   CUvideodecoder cudecoder;
59   CUvideoparser cuparser;
60 
61  /* This packet coincides with AVCodecInternal.in_pkt
62  * and is not owned by us. */
63   AVPacket *pkt;
64 
65   char *cu_gpu;
66   int nb_surfaces;
67   int drop_second_field;
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 
83   AVBufferRef *hwdevice;
84   AVBufferRef *hwframe;
85 
86   AVFifo *frame_queue;
87 
88   int deint_mode;
89   int deint_mode_current;
90   int64_t prev_pts;
91   int progressive_sequence;
92 
93   int internal_error;
94   int decoder_flushing;
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;
113   int second_field;
114   int is_deinterlacing;
115 } CuvidParsedFrame;
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 
139  enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
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) {
182  pix_fmts[1] = AV_PIX_FMT_YUV444P;
183 #ifdef NVDEC_HAVE_422_SUPPORT
184  } else if (format->chroma_format == cudaVideoChromaFormat_422) {
185  pix_fmts[1] = AV_PIX_FMT_NV16;
186 #endif
187  } else {
188  pix_fmts[1] = AV_PIX_FMT_NV12;
189  }
190  caps = &ctx->caps8;
191  break;
192  case 2: // 10-bit
193  if (chroma_444) {
194 #if FF_API_NVDEC_OLD_PIX_FMTS
195  pix_fmts[1] = AV_PIX_FMT_YUV444P16;
196 #else
197  pix_fmts[1] = AV_PIX_FMT_YUV444P10MSB;
198 #endif
199 #ifdef NVDEC_HAVE_422_SUPPORT
200  } else if (format->chroma_format == cudaVideoChromaFormat_422) {
201 #if FF_API_NVDEC_OLD_PIX_FMTS
202  pix_fmts[1] = AV_PIX_FMT_P216;
203 #else
204  pix_fmts[1] = AV_PIX_FMT_P210;
205 #endif
206 #endif
207  } else {
208  pix_fmts[1] = AV_PIX_FMT_P010;
209  }
210  caps = &ctx->caps10;
211  break;
212  case 4: // 12-bit
213  if (chroma_444) {
214 #if FF_API_NVDEC_OLD_PIX_FMTS
215  pix_fmts[1] = AV_PIX_FMT_YUV444P16;
216 #else
217  pix_fmts[1] = AV_PIX_FMT_YUV444P12MSB;
218 #endif
219 #ifdef NVDEC_HAVE_422_SUPPORT
220  } else if (format->chroma_format == cudaVideoChromaFormat_422) {
221 #if FF_API_NVDEC_OLD_PIX_FMTS
222  pix_fmts[1] = AV_PIX_FMT_P216;
223 #else
224  pix_fmts[1] = AV_PIX_FMT_P212;
225 #endif
226 #endif
227  } else {
228 #if FF_API_NVDEC_OLD_PIX_FMTS
229  pix_fmts[1] = AV_PIX_FMT_P016;
230 #else
231  pix_fmts[1] = AV_PIX_FMT_P012;
232 #endif
233  }
234  caps = &ctx->caps12;
235  break;
236  default:
237  break;
238  }
239 
240  if (!caps || !caps->bIsSupported) {
241  av_log(avctx, AV_LOG_ERROR, "unsupported bit depth: %d\n",
242  format->bit_depth_luma_minus8 + 8);
243  ctx->internal_error = AVERROR(EINVAL);
244  return 0;
245  }
246 
247  surface_fmt = ff_get_format(avctx, pix_fmts);
248  if (surface_fmt < 0) {
249  av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", surface_fmt);
250  ctx->internal_error = AVERROR(EINVAL);
251  return 0;
252  }
253 
254  av_log(avctx, AV_LOG_VERBOSE, "Formats: Original: %s | HW: %s | SW: %s\n",
255  av_get_pix_fmt_name(avctx->pix_fmt),
256  av_get_pix_fmt_name(surface_fmt),
257  av_get_pix_fmt_name(avctx->sw_pix_fmt));
258 
259  avctx->pix_fmt = surface_fmt;
260 
261  // Update our hwframe ctx, as the get_format callback might have refreshed it!
262  if (avctx->hw_frames_ctx) {
263  av_buffer_unref(&ctx->hwframe);
264 
265  ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
266  if (!ctx->hwframe) {
267  ctx->internal_error = AVERROR(ENOMEM);
268  return 0;
269  }
270 
271  hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
272  }
273 
274  ff_set_sar(avctx, av_div_q(
275  (AVRational){ format->display_aspect_ratio.x, format->display_aspect_ratio.y },
276  (AVRational){ avctx->width, avctx->height }));
277 
278  ctx->deint_mode_current = format->progressive_sequence
279  ? cudaVideoDeinterlaceMode_Weave
280  : ctx->deint_mode;
281 
282  ctx->progressive_sequence = format->progressive_sequence;
283 
284  if (!format->progressive_sequence && ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave)
285  avctx->flags |= AV_CODEC_FLAG_INTERLACED_DCT;
286  else
287  avctx->flags &= ~AV_CODEC_FLAG_INTERLACED_DCT;
288 
289  if (format->video_signal_description.video_full_range_flag)
290  avctx->color_range = AVCOL_RANGE_JPEG;
291  else
292  avctx->color_range = AVCOL_RANGE_MPEG;
293 
294  avctx->color_primaries = format->video_signal_description.color_primaries;
295  avctx->color_trc = format->video_signal_description.transfer_characteristics;
296  avctx->colorspace = format->video_signal_description.matrix_coefficients;
297 
298  if (format->bitrate)
299  avctx->bit_rate = format->bitrate;
300 
301  if (format->frame_rate.numerator && format->frame_rate.denominator) {
302  avctx->framerate.num = format->frame_rate.numerator;
303  avctx->framerate.den = format->frame_rate.denominator;
304  }
305 
306  if (ctx->cudecoder
307  && avctx->coded_width == format->coded_width
308  && avctx->coded_height == format->coded_height
309  && avctx->width == old_width
310  && avctx->height == old_height
311  && ctx->chroma_format == format->chroma_format
312  && ctx->codec_type == format->codec)
313  return 1;
314 
315  if (ctx->cudecoder) {
316  av_log(avctx, AV_LOG_TRACE, "Re-initializing decoder\n");
317  ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder));
318  if (ctx->internal_error < 0)
319  return 0;
320  ctx->cudecoder = NULL;
321  }
322 
323  if (hwframe_ctx->pool && (
324  hwframe_ctx->width < avctx->width ||
325  hwframe_ctx->height < avctx->height ||
326  hwframe_ctx->format != AV_PIX_FMT_CUDA ||
327  hwframe_ctx->sw_format != avctx->sw_pix_fmt)) {
328  av_log(avctx, AV_LOG_ERROR, "AVHWFramesContext is already initialized with incompatible parameters\n");
329  av_log(avctx, AV_LOG_DEBUG, "width: %d <-> %d\n", hwframe_ctx->width, avctx->width);
330  av_log(avctx, AV_LOG_DEBUG, "height: %d <-> %d\n", hwframe_ctx->height, avctx->height);
331  av_log(avctx, AV_LOG_DEBUG, "format: %s <-> cuda\n", av_get_pix_fmt_name(hwframe_ctx->format));
332  av_log(avctx, AV_LOG_DEBUG, "sw_format: %s <-> %s\n",
333  av_get_pix_fmt_name(hwframe_ctx->sw_format), av_get_pix_fmt_name(avctx->sw_pix_fmt));
334  ctx->internal_error = AVERROR(EINVAL);
335  return 0;
336  }
337 
338  ctx->chroma_format = format->chroma_format;
339 
340  cuinfo.CodecType = ctx->codec_type = format->codec;
341  cuinfo.ChromaFormat = format->chroma_format;
342 
343  switch (avctx->sw_pix_fmt) {
344  case AV_PIX_FMT_NV12:
345  cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
346  break;
347  case AV_PIX_FMT_P010:
348  case AV_PIX_FMT_P016:
349  cuinfo.OutputFormat = cudaVideoSurfaceFormat_P016;
350  break;
351 #ifdef NVDEC_HAVE_422_SUPPORT
352  case AV_PIX_FMT_NV16:
353  cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV16;
354  break;
355  case AV_PIX_FMT_P216:
356  cuinfo.OutputFormat = cudaVideoSurfaceFormat_P216;
357  break;
358 #endif
359  case AV_PIX_FMT_YUV444P:
360  cuinfo.OutputFormat = cudaVideoSurfaceFormat_YUV444;
361  break;
362  case AV_PIX_FMT_YUV444P16:
363  cuinfo.OutputFormat = cudaVideoSurfaceFormat_YUV444_16Bit;
364  break;
365  default:
366  av_log(avctx, AV_LOG_ERROR, "Unsupported output format: %s\n",
367  av_get_pix_fmt_name(avctx->sw_pix_fmt));
368  ctx->internal_error = AVERROR(EINVAL);
369  return 0;
370  }
371 
372  if (ctx->deint_mode_current != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field) {
373  avctx->framerate = av_mul_q(avctx->framerate, (AVRational){2, 1});
374  fifo_size_mul = 2;
375  }
376 
377  old_nb_surfaces = ctx->nb_surfaces;
378  ctx->nb_surfaces = FFMAX(ctx->nb_surfaces, format->min_num_decode_surfaces + 3);
379  if (avctx->extra_hw_frames > 0)
380  ctx->nb_surfaces += avctx->extra_hw_frames;
381 
382  fifo_size_inc = ctx->nb_surfaces * fifo_size_mul - av_fifo_can_read(ctx->frame_queue) - av_fifo_can_write(ctx->frame_queue);
383  if (fifo_size_inc > 0 && av_fifo_grow2(ctx->frame_queue, fifo_size_inc) < 0) {
384  av_log(avctx, AV_LOG_ERROR, "Failed to grow frame queue on video sequence callback\n");
385  ctx->internal_error = AVERROR(ENOMEM);
386  return 0;
387  }
388 
389  if (ctx->nb_surfaces > old_nb_surfaces && av_reallocp_array(&ctx->key_frame, ctx->nb_surfaces, sizeof(int)) < 0) {
390  av_log(avctx, AV_LOG_ERROR, "Failed to grow key frame array on video sequence callback\n");
391  ctx->internal_error = AVERROR(ENOMEM);
392  return 0;
393  }
394 
395  cuinfo.ulNumDecodeSurfaces = ctx->nb_surfaces;
396  cuinfo.ulNumOutputSurfaces = 1;
397  cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
398  cuinfo.bitDepthMinus8 = format->bit_depth_luma_minus8;
399  cuinfo.DeinterlaceMode = ctx->deint_mode_current;
400 
401  ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidCreateDecoder(&ctx->cudecoder, &cuinfo));
402  if (ctx->internal_error < 0)
403  return 0;
404 
405  if (!hwframe_ctx->pool) {
406  hwframe_ctx->format = AV_PIX_FMT_CUDA;
407  hwframe_ctx->sw_format = avctx->sw_pix_fmt;
408  hwframe_ctx->width = avctx->width;
409  hwframe_ctx->height = avctx->height;
410 
411  if ((ctx->internal_error = av_hwframe_ctx_init(ctx->hwframe)) < 0) {
412  av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_init failed\n");
413  return 0;
414  }
415  }
416 
417  if(ctx->cuparseinfo.ulMaxNumDecodeSurfaces != cuinfo.ulNumDecodeSurfaces) {
418  ctx->cuparseinfo.ulMaxNumDecodeSurfaces = cuinfo.ulNumDecodeSurfaces;
419  return cuinfo.ulNumDecodeSurfaces;
420  }
421 
422  return 1;
423 }
424 
425  static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS* picparams)
426 {
427  AVCodecContext *avctx = opaque;
428  CuvidContext *ctx = avctx->priv_data;
429 
430  av_log(avctx, AV_LOG_TRACE, "pfnDecodePicture\n");
431 
432  if(picparams->intra_pic_flag)
433  ctx->key_frame[picparams->CurrPicIdx] = picparams->intra_pic_flag;
434 
435  ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDecodePicture(ctx->cudecoder, picparams));
436  if (ctx->internal_error < 0)
437  return 0;
438 
439  return 1;
440 }
441 
442  static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO* dispinfo)
443 {
444  AVCodecContext *avctx = opaque;
445  CuvidContext *ctx = avctx->priv_data;
446  CuvidParsedFrame parsed_frame = { { 0 } };
447  int ret;
448 
449  parsed_frame.dispinfo = *dispinfo;
450  ctx->internal_error = 0;
451 
452  // For some reason, dispinfo->progressive_frame is sometimes wrong.
453  parsed_frame.dispinfo.progressive_frame = ctx->progressive_sequence;
454 
455  if (ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave) {
456  ret = av_fifo_write(ctx->frame_queue, &parsed_frame, 1);
457  if (ret < 0)
458  av_log(avctx, AV_LOG_ERROR, "Writing frame to fifo failed!\n");
459  } else {
460  parsed_frame.is_deinterlacing = 1;
461  ret = av_fifo_write(ctx->frame_queue, &parsed_frame, 1);
462  if (ret < 0)
463  av_log(avctx, AV_LOG_ERROR, "Writing first frame to fifo failed!\n");
464 
465  if (!ctx->drop_second_field) {
466  parsed_frame.second_field = 1;
467  ret = av_fifo_write(ctx->frame_queue, &parsed_frame, 1);
468  if (ret < 0)
469  av_log(avctx, AV_LOG_ERROR, "Writing second frame to fifo failed!\n");
470  }
471  }
472 
473  return 1;
474 }
475 
476  static int cuvid_is_buffer_full(AVCodecContext *avctx)
477 {
478  CuvidContext *ctx = avctx->priv_data;
479 
480  int shift = 0;
481  if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field)
482  shift = 1;
483 
484  // shift/divide frame count to ensure the buffer is still signalled full if one half-frame has already been returned when deinterlacing.
485  return ((av_fifo_can_read(ctx->frame_queue) + shift) >> shift) + ctx->cuparseinfo.ulMaxDisplayDelay >= ctx->nb_surfaces;
486 }
487 
488  static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
489 {
490  CuvidContext *ctx = avctx->priv_data;
491  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
492  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
493  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
494  CUVIDSOURCEDATAPACKET cupkt;
495  int ret = 0, eret = 0, is_flush = ctx->decoder_flushing;
496 
497  av_log(avctx, AV_LOG_TRACE, "cuvid_decode_packet\n");
498 
499  if (is_flush && avpkt && avpkt->size)
500  return AVERROR_EOF;
501 
502  if (cuvid_is_buffer_full(avctx) && avpkt && avpkt->size)
503  return AVERROR(EAGAIN);
504 
505  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
506  if (ret < 0) {
507  return ret;
508  }
509 
510  memset(&cupkt, 0, sizeof(cupkt));
511 
512  if (avpkt && avpkt->size) {
513  cupkt.payload_size = avpkt->size;
514  cupkt.payload = avpkt->data;
515 
516  if (avpkt->pts != AV_NOPTS_VALUE) {
517  cupkt.flags = CUVID_PKT_TIMESTAMP;
518  if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
519  cupkt.timestamp = av_rescale_q(avpkt->pts, avctx->pkt_timebase, (AVRational){1, 10000000});
520  else
521  cupkt.timestamp = avpkt->pts;
522  }
523  } else {
524  cupkt.flags = CUVID_PKT_ENDOFSTREAM;
525  ctx->decoder_flushing = 1;
526  }
527 
528  // When flushing, only actually flush cuvid when the output buffer has been fully emptied.
529  // CUVID happily dumps out a ton of frames with no regard for its own available surfaces.
530  if (!ctx->decoder_flushing || (ctx->decoder_flushing && !av_fifo_can_read(ctx->frame_queue)))
531  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &cupkt));
532  else
533  ret = 0;
534 
535  if (ret < 0)
536  goto error;
537 
538  // cuvidParseVideoData doesn't return an error just because stuff failed...
539  if (ctx->internal_error) {
540  av_log(avctx, AV_LOG_ERROR, "cuvid decode callback error\n");
541  ret = ctx->internal_error;
542  goto error;
543  }
544 
545 error:
546  eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
547 
548  if (eret < 0)
549  return eret;
550  else if (ret < 0)
551  return ret;
552  else if (is_flush)
553  return AVERROR_EOF;
554  else
555  return 0;
556 }
557 
558  static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
559 {
560  CuvidContext *ctx = avctx->priv_data;
561  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
562  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
563  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
564  CuvidParsedFrame parsed_frame;
565  CUdeviceptr mapped_frame = 0;
566  int ret = 0, eret = 0;
567 
568  av_log(avctx, AV_LOG_TRACE, "cuvid_output_frame\n");
569 
570  if (ctx->decoder_flushing) {
571  ret = cuvid_decode_packet(avctx, NULL);
572  if (ret < 0 && ret != AVERROR_EOF)
573  return ret;
574  }
575 
576  if (!cuvid_is_buffer_full(avctx)) {
577  AVPacket *const pkt = ctx->pkt;
578  ret = ff_decode_get_packet(avctx, pkt);
579  if (ret < 0 && ret != AVERROR_EOF)
580  return ret;
581  ret = cuvid_decode_packet(avctx, pkt);
582  av_packet_unref(pkt);
583  // cuvid_is_buffer_full() should avoid this.
584  if (ret == AVERROR(EAGAIN))
585  ret = AVERROR_EXTERNAL;
586  if (ret < 0 && ret != AVERROR_EOF)
587  return ret;
588  }
589 
590  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
591  if (ret < 0)
592  return ret;
593 
594  if (av_fifo_read(ctx->frame_queue, &parsed_frame, 1) >= 0) {
595  const AVPixFmtDescriptor *pixdesc;
596  CUVIDPROCPARAMS params;
597  unsigned int pitch = 0;
598  int offset = 0;
599  int i;
600 
601  memset(&params, 0, sizeof(params));
602  params.progressive_frame = parsed_frame.dispinfo.progressive_frame;
603  params.second_field = parsed_frame.second_field;
604  params.top_field_first = parsed_frame.dispinfo.top_field_first;
605 
606  ret = CHECK_CU(ctx->cvdl->cuvidMapVideoFrame(ctx->cudecoder, parsed_frame.dispinfo.picture_index, &mapped_frame, &pitch, &params));
607  if (ret < 0)
608  goto error;
609 
610  if (avctx->pix_fmt == AV_PIX_FMT_CUDA) {
611  ret = av_hwframe_get_buffer(ctx->hwframe, frame, 0);
612  if (ret < 0) {
613  av_log(avctx, AV_LOG_ERROR, "av_hwframe_get_buffer failed\n");
614  goto error;
615  }
616 
617  ret = ff_decode_frame_props(avctx, frame);
618  if (ret < 0) {
619  av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props failed\n");
620  goto error;
621  }
622 
623  pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
624 
625  for (i = 0; i < pixdesc->nb_components; i++) {
626  int height = avctx->height >> (i ? pixdesc->log2_chroma_h : 0);
627  CUDA_MEMCPY2D cpy = {
628  .srcMemoryType = CU_MEMORYTYPE_DEVICE,
629  .dstMemoryType = CU_MEMORYTYPE_DEVICE,
630  .srcDevice = mapped_frame,
631  .dstDevice = (CUdeviceptr)frame->data[i],
632  .srcPitch = pitch,
633  .dstPitch = frame->linesize[i],
634  .srcY = offset,
635  .WidthInBytes = FFMIN(pitch, frame->linesize[i]),
636  .Height = height,
637  };
638 
639  ret = CHECK_CU(ctx->cudl->cuMemcpy2DAsync(&cpy, device_hwctx->stream));
640  if (ret < 0)
641  goto error;
642 
643  offset += height;
644  }
645  } else if (avctx->pix_fmt == AV_PIX_FMT_NV12 ||
646  avctx->pix_fmt == AV_PIX_FMT_P010 ||
647  avctx->pix_fmt == AV_PIX_FMT_P016 ||
648 #ifdef NVDEC_HAVE_422_SUPPORT
649  avctx->pix_fmt == AV_PIX_FMT_NV16 ||
650  avctx->pix_fmt == AV_PIX_FMT_P216 ||
651 #endif
652  avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
653  avctx->pix_fmt == AV_PIX_FMT_YUV444P16) {
654  unsigned int offset = 0;
655  AVFrame *tmp_frame = av_frame_alloc();
656  if (!tmp_frame) {
657  av_log(avctx, AV_LOG_ERROR, "av_frame_alloc failed\n");
658  ret = AVERROR(ENOMEM);
659  goto error;
660  }
661 
662  pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
663 
664  tmp_frame->format = AV_PIX_FMT_CUDA;
665  tmp_frame->hw_frames_ctx = av_buffer_ref(ctx->hwframe);
666  if (!tmp_frame->hw_frames_ctx) {
667  ret = AVERROR(ENOMEM);
668  av_frame_free(&tmp_frame);
669  goto error;
670  }
671 
672  tmp_frame->width = avctx->width;
673  tmp_frame->height = avctx->height;
674 
675  /*
676  * Note that the following logic would not work for three plane
677  * YUV420 because the pitch value is different for the chroma
678  * planes.
679  */
680  for (i = 0; i < pixdesc->nb_components; i++) {
681  tmp_frame->data[i] = (uint8_t*)mapped_frame + offset;
682  tmp_frame->linesize[i] = pitch;
683  offset += pitch * (avctx->height >> (i ? pixdesc->log2_chroma_h : 0));
684  }
685 
686  ret = ff_get_buffer(avctx, frame, 0);
687  if (ret < 0) {
688  av_log(avctx, AV_LOG_ERROR, "ff_get_buffer failed\n");
689  av_frame_free(&tmp_frame);
690  goto error;
691  }
692 
693  ret = av_hwframe_transfer_data(frame, tmp_frame, 0);
694  if (ret) {
695  av_log(avctx, AV_LOG_ERROR, "av_hwframe_transfer_data failed\n");
696  av_frame_free(&tmp_frame);
697  goto error;
698  }
699  av_frame_free(&tmp_frame);
700  } else {
701  ret = AVERROR_BUG;
702  goto error;
703  }
704 
705  if (ctx->key_frame[parsed_frame.dispinfo.picture_index])
706  frame->flags |= AV_FRAME_FLAG_KEY;
707  else
708  frame->flags &= ~AV_FRAME_FLAG_KEY;
709  ctx->key_frame[parsed_frame.dispinfo.picture_index] = 0;
710 
711  frame->width = avctx->width;
712  frame->height = avctx->height;
713  if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
714  frame->pts = av_rescale_q(parsed_frame.dispinfo.timestamp, (AVRational){1, 10000000}, avctx->pkt_timebase);
715  else
716  frame->pts = parsed_frame.dispinfo.timestamp;
717 
718  if (parsed_frame.second_field) {
719  if (ctx->prev_pts == INT64_MIN) {
720  ctx->prev_pts = frame->pts;
721  frame->pts += (avctx->pkt_timebase.den * avctx->framerate.den) / (avctx->pkt_timebase.num * avctx->framerate.num);
722  } else {
723  int pts_diff = (frame->pts - ctx->prev_pts) / 2;
724  ctx->prev_pts = frame->pts;
725  frame->pts += pts_diff;
726  }
727  }
728 
729  /* CUVIDs opaque reordering breaks the internal pkt logic.
730  * So set pkt_pts and clear all the other pkt_ fields.
731  */
732  frame->duration = 0;
733 
734  if (!parsed_frame.is_deinterlacing && !parsed_frame.dispinfo.progressive_frame)
735  frame->flags |= AV_FRAME_FLAG_INTERLACED;
736 
737  if ((frame->flags & AV_FRAME_FLAG_INTERLACED) && parsed_frame.dispinfo.top_field_first)
738  frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;
739  } else if (ctx->decoder_flushing) {
740  ret = AVERROR_EOF;
741  } else {
742  ret = AVERROR(EAGAIN);
743  }
744 
745 error:
746  if (ret < 0)
747  av_frame_unref(frame);
748 
749  if (mapped_frame)
750  eret = CHECK_CU(ctx->cvdl->cuvidUnmapVideoFrame(ctx->cudecoder, mapped_frame));
751 
752  eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
753 
754  if (eret < 0)
755  return eret;
756  else
757  return ret;
758 }
759 
760  static av_cold int cuvid_decode_end(AVCodecContext *avctx)
761 {
762  CuvidContext *ctx = avctx->priv_data;
763  AVHWDeviceContext *device_ctx = ctx->hwdevice ? (AVHWDeviceContext *)ctx->hwdevice->data : NULL;
764  AVCUDADeviceContext *device_hwctx = device_ctx ? device_ctx->hwctx : NULL;
765  CUcontext dummy, cuda_ctx = device_hwctx ? device_hwctx->cuda_ctx : NULL;
766 
767  av_fifo_freep2(&ctx->frame_queue);
768 
769  if (cuda_ctx) {
770  ctx->cudl->cuCtxPushCurrent(cuda_ctx);
771 
772  if (ctx->cuparser)
773  ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
774 
775  if (ctx->cudecoder)
776  ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
777 
778  ctx->cudl->cuCtxPopCurrent(&dummy);
779  }
780 
781  ctx->cudl = NULL;
782 
783  av_buffer_unref(&ctx->hwframe);
784  av_buffer_unref(&ctx->hwdevice);
785 
786  av_freep(&ctx->key_frame);
787  av_freep(&ctx->cuparse_ext);
788 
789  cuvid_free_functions(&ctx->cvdl);
790 
791  return 0;
792 }
793 
794  static int cuvid_test_capabilities(AVCodecContext *avctx,
795  const CUVIDPARSERPARAMS *cuparseinfo,
796  int probed_width,
797  int probed_height,
798  int bit_depth, int is_yuv422, int is_yuv444)
799 {
800  CuvidContext *ctx = avctx->priv_data;
801  CUVIDDECODECAPS *caps;
802  int res8 = 0, res10 = 0, res12 = 0;
803 
804  if (!ctx->cvdl->cuvidGetDecoderCaps) {
805  av_log(avctx, AV_LOG_WARNING, "Used Nvidia driver is too old to perform a capability check.\n");
806  av_log(avctx, AV_LOG_WARNING, "The minimum required version is "
807 #if defined(_WIN32) || defined(__CYGWIN__)
808  "378.66"
809 #else
810  "378.13"
811 #endif
812  ". Continuing blind.\n");
813  ctx->caps8.bIsSupported = ctx->caps10.bIsSupported = 1;
814  // 12 bit was not supported before the capability check was introduced, so disable it.
815  ctx->caps12.bIsSupported = 0;
816  return 0;
817  }
818 
819  ctx->caps8.eCodecType = ctx->caps10.eCodecType = ctx->caps12.eCodecType
820  = cuparseinfo->CodecType;
821 
822  ctx->caps8.eChromaFormat = ctx->caps10.eChromaFormat = ctx->caps12.eChromaFormat
823  = is_yuv444 ? cudaVideoChromaFormat_444 :
824 #ifdef NVDEC_HAVE_422_SUPPORT
825  (is_yuv422 ? cudaVideoChromaFormat_422 : cudaVideoChromaFormat_420);
826 #else
827  cudaVideoChromaFormat_420;
828 #endif
829 
830  ctx->caps8.nBitDepthMinus8 = 0;
831  ctx->caps10.nBitDepthMinus8 = 2;
832  ctx->caps12.nBitDepthMinus8 = 4;
833 
834  res8 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps8));
835  res10 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps10));
836  res12 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps12));
837 
838  av_log(avctx, AV_LOG_VERBOSE, "CUVID capabilities for %s:\n", avctx->codec->name);
839  av_log(avctx, AV_LOG_VERBOSE, "8 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
840  ctx->caps8.bIsSupported, ctx->caps8.nMinWidth, ctx->caps8.nMaxWidth, ctx->caps8.nMinHeight, ctx->caps8.nMaxHeight);
841  av_log(avctx, AV_LOG_VERBOSE, "10 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
842  ctx->caps10.bIsSupported, ctx->caps10.nMinWidth, ctx->caps10.nMaxWidth, ctx->caps10.nMinHeight, ctx->caps10.nMaxHeight);
843  av_log(avctx, AV_LOG_VERBOSE, "12 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
844  ctx->caps12.bIsSupported, ctx->caps12.nMinWidth, ctx->caps12.nMaxWidth, ctx->caps12.nMinHeight, ctx->caps12.nMaxHeight);
845 
846  switch (bit_depth) {
847  case 10:
848  caps = &ctx->caps10;
849  if (res10 < 0)
850  return res10;
851  break;
852  case 12:
853  caps = &ctx->caps12;
854  if (res12 < 0)
855  return res12;
856  break;
857  default:
858  caps = &ctx->caps8;
859  if (res8 < 0)
860  return res8;
861  }
862 
863  if (!ctx->caps8.bIsSupported) {
864  av_log(avctx, AV_LOG_ERROR, "Codec %s is not supported with this chroma format.\n", avctx->codec->name);
865  return AVERROR(EINVAL);
866  }
867 
868  if (!caps->bIsSupported) {
869  av_log(avctx, AV_LOG_ERROR, "Bit depth %d with this chroma format is not supported.\n", bit_depth);
870  return AVERROR(EINVAL);
871  }
872 
873  if (probed_width > caps->nMaxWidth || probed_width < caps->nMinWidth) {
874  av_log(avctx, AV_LOG_ERROR, "Video width %d not within range from %d to %d\n",
875  probed_width, caps->nMinWidth, caps->nMaxWidth);
876  return AVERROR(EINVAL);
877  }
878 
879  if (probed_height > caps->nMaxHeight || probed_height < caps->nMinHeight) {
880  av_log(avctx, AV_LOG_ERROR, "Video height %d not within range from %d to %d\n",
881  probed_height, caps->nMinHeight, caps->nMaxHeight);
882  return AVERROR(EINVAL);
883  }
884 
885  if ((probed_width * probed_height) / 256 > caps->nMaxMBCount) {
886  av_log(avctx, AV_LOG_ERROR, "Video macroblock count %d exceeds maximum of %d\n",
887  (int)(probed_width * probed_height) / 256, caps->nMaxMBCount);
888  return AVERROR(EINVAL);
889  }
890 
891  return 0;
892 }
893 
894  static av_cold int cuvid_decode_init(AVCodecContext *avctx)
895 {
896  CuvidContext *ctx = avctx->priv_data;
897  AVCUDADeviceContext *device_hwctx;
898  AVHWDeviceContext *device_ctx;
899  AVHWFramesContext *hwframe_ctx;
900  CUVIDSOURCEDATAPACKET seq_pkt;
901  CUcontext cuda_ctx = NULL;
902  CUcontext dummy;
903  uint8_t *extradata;
904  int extradata_size;
905  int ret = 0;
906 
907  enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
908  AV_PIX_FMT_NONE,
909  AV_PIX_FMT_NONE };
910 
911  int probed_width = avctx->coded_width ? avctx->coded_width : 1280;
912  int probed_height = avctx->coded_height ? avctx->coded_height : 720;
913  int probed_bit_depth = 8, is_yuv444 = 0, is_yuv422 = 0;
914 
915  const AVPixFmtDescriptor *probe_desc = av_pix_fmt_desc_get(avctx->pix_fmt);
916  if (probe_desc && probe_desc->nb_components)
917  probed_bit_depth = probe_desc->comp[0].depth;
918 
919  if (probe_desc && !probe_desc->log2_chroma_w && !probe_desc->log2_chroma_h)
920  is_yuv444 = 1;
921 
922 #ifdef NVDEC_HAVE_422_SUPPORT
923  if (probe_desc && probe_desc->log2_chroma_w && !probe_desc->log2_chroma_h)
924  is_yuv422 = 1;
925 #endif
926 
927  // Pick pixel format based on bit depth and chroma sampling.
928  switch (probed_bit_depth) {
929  case 10:
930 #if FF_API_NVDEC_OLD_PIX_FMTS
931  pix_fmts[1] = is_yuv444 ? AV_PIX_FMT_YUV444P16 : (is_yuv422 ? AV_PIX_FMT_P216 : AV_PIX_FMT_P010);
932 #else
933  pix_fmts[1] = is_yuv444 ? AV_PIX_FMT_YUV444P10MSB : (is_yuv422 ? AV_PIX_FMT_P210 : AV_PIX_FMT_P010);
934 #endif
935  break;
936  case 12:
937 #if FF_API_NVDEC_OLD_PIX_FMTS
938  pix_fmts[1] = is_yuv444 ? AV_PIX_FMT_YUV444P16 : (is_yuv422 ? AV_PIX_FMT_P216 : AV_PIX_FMT_P016);
939 #else
940  pix_fmts[1] = is_yuv444 ? AV_PIX_FMT_YUV444P12MSB : (is_yuv422 ? AV_PIX_FMT_P212 : AV_PIX_FMT_P012);
941 #endif
942  break;
943  default:
944  pix_fmts[1] = is_yuv444 ? AV_PIX_FMT_YUV444P : (is_yuv422 ? AV_PIX_FMT_NV16 : AV_PIX_FMT_NV12);
945  break;
946  }
947 
948  ctx->pkt = avctx->internal->in_pkt;
949  // Accelerated transcoding scenarios with 'ffmpeg' require that the
950  // pix_fmt be set to AV_PIX_FMT_CUDA early. The sw_pix_fmt, and the
951  // pix_fmt for non-accelerated transcoding, do not need to be correct
952  // but need to be set to something.
953  ret = ff_get_format(avctx, pix_fmts);
954  if (ret < 0) {
955  av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", ret);
956  return ret;
957  }
958  avctx->pix_fmt = ret;
959 
960  if (ctx->resize_expr && sscanf(ctx->resize_expr, "%dx%d",
961  &ctx->resize.width, &ctx->resize.height) != 2) {
962  av_log(avctx, AV_LOG_ERROR, "Invalid resize expressions\n");
963  ret = AVERROR(EINVAL);
964  goto error;
965  }
966 
967  if (ctx->crop_expr && sscanf(ctx->crop_expr, "%dx%dx%dx%d",
968  &ctx->crop.top, &ctx->crop.bottom,
969  &ctx->crop.left, &ctx->crop.right) != 4) {
970  av_log(avctx, AV_LOG_ERROR, "Invalid cropping expressions\n");
971  ret = AVERROR(EINVAL);
972  goto error;
973  }
974 
975  ret = cuvid_load_functions(&ctx->cvdl, avctx);
976  if (ret < 0) {
977  av_log(avctx, AV_LOG_ERROR, "Failed loading nvcuvid.\n");
978  goto error;
979  }
980 
981  // respect the deprecated "surfaces" option if non-default value is given by user;
982  if(ctx->nb_surfaces < 0)
983  ctx->nb_surfaces = CUVID_DEFAULT_NUM_SURFACES;
984 
985  ctx->frame_queue = av_fifo_alloc2(ctx->nb_surfaces, sizeof(CuvidParsedFrame), 0);
986  if (!ctx->frame_queue) {
987  ret = AVERROR(ENOMEM);
988  goto error;
989  }
990 
991  if (avctx->hw_frames_ctx) {
992  ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
993  if (!ctx->hwframe) {
994  ret = AVERROR(ENOMEM);
995  goto error;
996  }
997 
998  hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
999 
1000  ctx->hwdevice = av_buffer_ref(hwframe_ctx->device_ref);
1001  if (!ctx->hwdevice) {
1002  ret = AVERROR(ENOMEM);
1003  goto error;
1004  }
1005  } else {
1006  if (avctx->hw_device_ctx) {
1007  ctx->hwdevice = av_buffer_ref(avctx->hw_device_ctx);
1008  if (!ctx->hwdevice) {
1009  ret = AVERROR(ENOMEM);
1010  goto error;
1011  }
1012  } else {
1013  ret = av_hwdevice_ctx_create(&ctx->hwdevice, AV_HWDEVICE_TYPE_CUDA, ctx->cu_gpu, NULL, 0);
1014  if (ret < 0)
1015  goto error;
1016  }
1017 
1018  ctx->hwframe = av_hwframe_ctx_alloc(ctx->hwdevice);
1019  if (!ctx->hwframe) {
1020  av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
1021  ret = AVERROR(ENOMEM);
1022  goto error;
1023  }
1024 
1025  hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
1026  }
1027 
1028  device_ctx = hwframe_ctx->device_ctx;
1029  device_hwctx = device_ctx->hwctx;
1030 
1031  cuda_ctx = device_hwctx->cuda_ctx;
1032  ctx->cudl = device_hwctx->internal->cuda_dl;
1033 
1034  memset(&ctx->cuparseinfo, 0, sizeof(ctx->cuparseinfo));
1035  memset(&seq_pkt, 0, sizeof(seq_pkt));
1036 
1037  switch (avctx->codec->id) {
1038 #if CONFIG_H264_CUVID_DECODER
1039  case AV_CODEC_ID_H264:
1040  ctx->cuparseinfo.CodecType = cudaVideoCodec_H264;
1041  break;
1042 #endif
1043 #if CONFIG_HEVC_CUVID_DECODER
1044  case AV_CODEC_ID_HEVC:
1045  ctx->cuparseinfo.CodecType = cudaVideoCodec_HEVC;
1046  break;
1047 #endif
1048 #if CONFIG_MJPEG_CUVID_DECODER
1049  case AV_CODEC_ID_MJPEG:
1050  ctx->cuparseinfo.CodecType = cudaVideoCodec_JPEG;
1051  break;
1052 #endif
1053 #if CONFIG_MPEG1_CUVID_DECODER
1054  case AV_CODEC_ID_MPEG1VIDEO:
1055  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG1;
1056  break;
1057 #endif
1058 #if CONFIG_MPEG2_CUVID_DECODER
1059  case AV_CODEC_ID_MPEG2VIDEO:
1060  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG2;
1061  break;
1062 #endif
1063 #if CONFIG_MPEG4_CUVID_DECODER
1064  case AV_CODEC_ID_MPEG4:
1065  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
1066  break;
1067 #endif
1068 #if CONFIG_VP8_CUVID_DECODER
1069  case AV_CODEC_ID_VP8:
1070  ctx->cuparseinfo.CodecType = cudaVideoCodec_VP8;
1071  break;
1072 #endif
1073 #if CONFIG_VP9_CUVID_DECODER
1074  case AV_CODEC_ID_VP9:
1075  ctx->cuparseinfo.CodecType = cudaVideoCodec_VP9;
1076  break;
1077 #endif
1078 #if CONFIG_VC1_CUVID_DECODER
1079  case AV_CODEC_ID_VC1:
1080  ctx->cuparseinfo.CodecType = cudaVideoCodec_VC1;
1081  break;
1082 #endif
1083 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
1084  case AV_CODEC_ID_AV1:
1085  ctx->cuparseinfo.CodecType = cudaVideoCodec_AV1;
1086  break;
1087 #endif
1088  default:
1089  av_log(avctx, AV_LOG_ERROR, "Invalid CUVID codec!\n");
1090  return AVERROR_BUG;
1091  }
1092 
1093  if (ffcodec(avctx->codec)->bsfs) {
1094  const AVCodecParameters *par = avctx->internal->bsf->par_out;
1095  extradata = par->extradata;
1096  extradata_size = par->extradata_size;
1097  } else {
1098  extradata = avctx->extradata;
1099  extradata_size = avctx->extradata_size;
1100  }
1101 
1102  // Check first bit to determine whether it's AV1CodecConfigurationRecord.
1103  // Skip first 4 bytes of AV1CodecConfigurationRecord to keep configOBUs
1104  // only, otherwise cuvidParseVideoData report unknown error.
1105  if (avctx->codec->id == AV_CODEC_ID_AV1 &&
1106  extradata_size > 4 &&
1107  extradata[0] & 0x80) {
1108  extradata += 4;
1109  extradata_size -= 4;
1110  }
1111 
1112  ctx->cuparse_ext = av_mallocz(sizeof(*ctx->cuparse_ext)
1113  + FFMAX(extradata_size - (int)sizeof(ctx->cuparse_ext->raw_seqhdr_data), 0));
1114  if (!ctx->cuparse_ext) {
1115  ret = AVERROR(ENOMEM);
1116  goto error;
1117  }
1118 
1119  if (extradata_size > 0)
1120  memcpy(ctx->cuparse_ext->raw_seqhdr_data, extradata, extradata_size);
1121  ctx->cuparse_ext->format.seqhdr_data_length = extradata_size;
1122 
1123  ctx->cuparseinfo.pExtVideoInfo = ctx->cuparse_ext;
1124 
1125  ctx->key_frame = av_mallocz(ctx->nb_surfaces * sizeof(int));
1126  if (!ctx->key_frame) {
1127  ret = AVERROR(ENOMEM);
1128  goto error;
1129  }
1130 
1131  ctx->cuparseinfo.ulMaxNumDecodeSurfaces = 1;
1132  ctx->cuparseinfo.ulMaxDisplayDelay = (avctx->flags & AV_CODEC_FLAG_LOW_DELAY) ? 0 : CUVID_MAX_DISPLAY_DELAY;
1133  ctx->cuparseinfo.pUserData = avctx;
1134  ctx->cuparseinfo.pfnSequenceCallback = cuvid_handle_video_sequence;
1135  ctx->cuparseinfo.pfnDecodePicture = cuvid_handle_picture_decode;
1136  ctx->cuparseinfo.pfnDisplayPicture = cuvid_handle_picture_display;
1137 
1138  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
1139  if (ret < 0)
1140  goto error;
1141 
1142  ret = cuvid_test_capabilities(avctx, &ctx->cuparseinfo,
1143  probed_width,
1144  probed_height,
1145  probed_bit_depth, is_yuv422, is_yuv444);
1146  if (ret < 0)
1147  goto error;
1148 
1149  ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
1150  if (ret < 0)
1151  goto error;
1152 
1153  seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
1154  seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
1155 
1156  if (seq_pkt.payload && seq_pkt.payload_size) {
1157  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
1158  if (ret < 0)
1159  goto error;
1160  }
1161 
1162  ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
1163  if (ret < 0)
1164  goto error;
1165 
1166  ctx->prev_pts = INT64_MIN;
1167 
1168  if (!avctx->pkt_timebase.num || !avctx->pkt_timebase.den)
1169  av_log(avctx, AV_LOG_WARNING, "Invalid pkt_timebase, passing timestamps as-is.\n");
1170 
1171  return 0;
1172 
1173 error:
1174  cuvid_decode_end(avctx);
1175  return ret;
1176 }
1177 
1178  static void cuvid_flush(AVCodecContext *avctx)
1179 {
1180  CuvidContext *ctx = avctx->priv_data;
1181  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
1182  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
1183  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
1184  CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
1185  int ret;
1186 
1187  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
1188  if (ret < 0)
1189  goto error;
1190 
1191  av_fifo_reset2(ctx->frame_queue);
1192 
1193  if (ctx->cudecoder) {
1194  ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
1195  ctx->cudecoder = NULL;
1196  }
1197 
1198  if (ctx->cuparser) {
1199  ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
1200  ctx->cuparser = NULL;
1201  }
1202 
1203  ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
1204  if (ret < 0)
1205  goto error;
1206 
1207  seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
1208  seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
1209 
1210  if (seq_pkt.payload && seq_pkt.payload_size) {
1211  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
1212  if (ret < 0)
1213  goto error;
1214  }
1215 
1216  ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
1217  if (ret < 0)
1218  goto error;
1219 
1220  ctx->prev_pts = INT64_MIN;
1221  ctx->decoder_flushing = 0;
1222 
1223  return;
1224  error:
1225  av_log(avctx, AV_LOG_ERROR, "CUDA reinit on flush failed\n");
1226 }
1227 
1228  #define OFFSET(x) offsetof(CuvidContext, x)
1229  #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1230  static const AVOption options[] = {
1231  { "deint", "Set deinterlacing mode", OFFSET(deint_mode), AV_OPT_TYPE_INT, { .i64 = cudaVideoDeinterlaceMode_Weave }, cudaVideoDeinterlaceMode_Weave, cudaVideoDeinterlaceMode_Adaptive, VD, .unit = "deint" },
1232  { "weave", "Weave deinterlacing (do nothing)", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Weave }, 0, 0, VD, .unit = "deint" },
1233  { "bob", "Bob deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob }, 0, 0, VD, .unit = "deint" },
1234  { "adaptive", "Adaptive deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0, VD, .unit = "deint" },
1235  { "gpu", "GPU to be used for decoding", OFFSET(cu_gpu), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1236  { "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 },
1237  { "drop_second_field", "Drop second field when deinterlacing", OFFSET(drop_second_field), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
1238  { "crop", "Crop (top)x(bottom)x(left)x(right)", OFFSET(crop_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1239  { "resize", "Resize (width)x(height)", OFFSET(resize_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1240  { NULL }
1241 };
1242 
1243  static const AVCodecHWConfigInternal *const cuvid_hw_configs[] = {
1244  &(const AVCodecHWConfigInternal) {
1245  .public = {
1246  .pix_fmt = AV_PIX_FMT_CUDA,
1247  .methods = AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX |
1248  AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX |
1249  AV_CODEC_HW_CONFIG_METHOD_INTERNAL,
1250  .device_type = AV_HWDEVICE_TYPE_CUDA
1251  },
1252  .hwaccel = NULL,
1253  },
1254  NULL
1255 };
1256 
1257  #define DEFINE_CUVID_CODEC(x, X, bsf_name) \
1258  static const AVClass x##_cuvid_class = { \
1259  .class_name = #x "_cuvid", \
1260  .item_name = av_default_item_name, \
1261  .option = options, \
1262  .version = LIBAVUTIL_VERSION_INT, \
1263  }; \
1264  const FFCodec ff_##x##_cuvid_decoder = { \
1265  .p.name = #x "_cuvid", \
1266  CODEC_LONG_NAME("Nvidia CUVID " #X " decoder"), \
1267  .p.type = AVMEDIA_TYPE_VIDEO, \
1268  .p.id = AV_CODEC_ID_##X, \
1269  .priv_data_size = sizeof(CuvidContext), \
1270  .p.priv_class = &x##_cuvid_class, \
1271  .init = cuvid_decode_init, \
1272  .close = cuvid_decode_end, \
1273  FF_CODEC_RECEIVE_FRAME_CB(cuvid_output_frame), \
1274  .flush = cuvid_flush, \
1275  .bsfs = bsf_name, \
1276  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
1277  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE | \
1278  FF_CODEC_CAP_SETS_FRAME_PROPS, \
1279  .hw_configs = cuvid_hw_configs, \
1280  .p.wrapper_name = "cuvid", \
1281  };
1282 
1283 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
1284 DEFINE_CUVID_CODEC(av1, AV1, NULL)
1285 #endif
1286 
1287 #if CONFIG_HEVC_CUVID_DECODER
1288 DEFINE_CUVID_CODEC(hevc, HEVC, "hevc_mp4toannexb")
1289 #endif
1290 
1291 #if CONFIG_H264_CUVID_DECODER
1292 DEFINE_CUVID_CODEC(h264, H264, "h264_mp4toannexb")
1293 #endif
1294 
1295 #if CONFIG_MJPEG_CUVID_DECODER
1296 DEFINE_CUVID_CODEC(mjpeg, MJPEG, NULL)
1297 #endif
1298 
1299 #if CONFIG_MPEG1_CUVID_DECODER
1300 DEFINE_CUVID_CODEC(mpeg1, MPEG1VIDEO, NULL)
1301 #endif
1302 
1303 #if CONFIG_MPEG2_CUVID_DECODER
1304 DEFINE_CUVID_CODEC(mpeg2, MPEG2VIDEO, NULL)
1305 #endif
1306 
1307 #if CONFIG_MPEG4_CUVID_DECODER
1308 DEFINE_CUVID_CODEC(mpeg4, MPEG4, NULL)
1309 #endif
1310 
1311 #if CONFIG_VP8_CUVID_DECODER
1312 DEFINE_CUVID_CODEC(vp8, VP8, NULL)
1313 #endif
1314 
1315 #if CONFIG_VP9_CUVID_DECODER
1316 DEFINE_CUVID_CODEC(vp9, VP9, NULL)
1317 #endif
1318 
1319 #if CONFIG_VC1_CUVID_DECODER
1320 DEFINE_CUVID_CODEC(vc1, VC1, NULL)
1321 #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:88
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:433
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
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:245
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:442
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:1203
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:3447
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
AV_PIX_FMT_YUV444P10MSB
#define AV_PIX_FMT_YUV444P10MSB
Definition: pixfmt.h:554
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:64
CuvidParsedFrame::is_deinterlacing
int is_deinterlacing
Definition: cuviddec.c:114
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:337
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
pixdesc.h
AVFrame::width
int width
Definition: frame.h:499
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:767
cuvid_output_frame
static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: cuviddec.c:558
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:263
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:558
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::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:226
mathematics.h
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
AV_PIX_FMT_P212
#define AV_PIX_FMT_P212
Definition: pixfmt.h:618
AV_PIX_FMT_YUV444P12MSB
#define AV_PIX_FMT_YUV444P12MSB
Definition: pixfmt.h:555
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:448
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:794
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:655
AV_HWDEVICE_TYPE_CUDA
@ AV_HWDEVICE_TYPE_CUDA
Definition: hwcontext.h:30
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:551
dynlink_loader.h
fifo.h
bsf.h
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:440
CuvidContext::resize
struct CuvidContext::@104 resize
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
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:311
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:488
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:314
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:607
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:310
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:63
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:52
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:236
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:210
av_cold
#define av_cold
Definition: attributes.h:106
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:642
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:515
CuvidContext::right
int right
Definition: cuviddec.c:74
cuvid_hw_configs
static const AVCodecHWConfigInternal *const cuvid_hw_configs[]
Definition: cuviddec.c:1243
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:552
cuvid_handle_picture_decode
static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS *picparams)
Definition: cuviddec.c:425
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:1257
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:298
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
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:339
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:488
CuvidContext::codec_type
cudaVideoCodec codec_type
Definition: cuviddec.c:98
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
NULL
#define NULL
Definition: coverity.c:32
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
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:1229
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:129
CuvidContext::internal_error
int internal_error
Definition: cuviddec.c:93
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:466
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:43
AV_CODEC_HW_CONFIG_METHOD_INTERNAL
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:318
CuvidContext::width
int width
Definition: cuviddec.c:79
CuvidContext::cvdl
CuvidFunctions * cvdl
Definition: cuviddec.c:107
cuvid_is_buffer_full
static int cuvid_is_buffer_full(AVCodecContext *avctx)
Definition: cuviddec.c:476
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:894
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:1720
AVPacket::size
int size
Definition: packet.h:559
AVFifo
Definition: fifo.c:35
height
#define height
Definition: dsp.h:89
codec_internal.h
AV_PIX_FMT_P012
#define AV_PIX_FMT_P012
Definition: pixfmt.h:603
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:542
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:760
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
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:289
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:514
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
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:620
CHECK_CU
#define CHECK_CU(x)
Definition: cuviddec.c:117
AV_PIX_FMT_P210
#define AV_PIX_FMT_P210
Definition: pixfmt.h:616
AVCodec::id
enum AVCodecID id
Definition: codec.h:186
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:551
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:514
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:496
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:179
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:1475
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:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
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:650
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:750
AV_PIX_FMT_P016
#define AV_PIX_FMT_P016
Definition: pixfmt.h:604
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:1453
avcodec.h
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:118
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:265
AVHWFramesContext::device_ctx
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
Definition: hwcontext.h:137
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:615
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:448
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:724
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:1566
AVCodecContext
main external API structure.
Definition: avcodec.h:431
AVFrame::height
int height
Definition: frame.h:499
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
CuvidParsedFrame::second_field
int second_field
Definition: cuviddec.c:113
OFFSET
#define OFFSET(x)
Definition: cuviddec.c:1228
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:602
FFCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec_internal.h:260
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:607
CuvidContext::hwframe
AVBufferRef * hwframe
Definition: cuviddec.c:84
cuvid_flush
static void cuvid_flush(AVCodecContext *avctx)
Definition: cuviddec.c:1178
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
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:298
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:458
AVPacket
This structure stores compressed data.
Definition: packet.h:535
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:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
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:472
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::crop
struct CuvidContext::@103 crop
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:638
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:506
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:3367
cuvid_handle_video_sequence
static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT *format)
Definition: cuviddec.c:125
Generated on Fri Oct 17 2025 19:21:49 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /