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