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