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  if(picparams->intra_pic_flag)
340  ctx->key_frame[picparams->CurrPicIdx] = picparams->intra_pic_flag;
341 
342  ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDecodePicture(ctx->cudecoder, picparams));
343  if (ctx->internal_error < 0)
344  return 0;
345 
346  return 1;
347 }
348 
349 static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO* dispinfo)
350 {
351  AVCodecContext *avctx = opaque;
352  CuvidContext *ctx = avctx->priv_data;
353  CuvidParsedFrame parsed_frame = { { 0 } };
354 
355  parsed_frame.dispinfo = *dispinfo;
356  ctx->internal_error = 0;
357 
358  // For some reason, dispinfo->progressive_frame is sometimes wrong.
359  parsed_frame.dispinfo.progressive_frame = ctx->progressive_sequence;
360 
361  if (ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave) {
362  av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
363  } else {
364  parsed_frame.is_deinterlacing = 1;
365  av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
366  if (!ctx->drop_second_field) {
367  parsed_frame.second_field = 1;
368  av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
369  }
370  }
371 
372  return 1;
373 }
374 
376 {
377  CuvidContext *ctx = avctx->priv_data;
378 
379  int delay = ctx->cuparseinfo.ulMaxDisplayDelay;
380  if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field)
381  delay *= 2;
382 
383  return (av_fifo_size(ctx->frame_queue) / sizeof(CuvidParsedFrame)) + delay >= ctx->nb_surfaces;
384 }
385 
386 static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
387 {
388  CuvidContext *ctx = avctx->priv_data;
389  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
390  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
391  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
392  CUVIDSOURCEDATAPACKET cupkt;
393  int ret = 0, eret = 0, is_flush = ctx->decoder_flushing;
394 
395  av_log(avctx, AV_LOG_TRACE, "cuvid_decode_packet\n");
396 
397  if (is_flush && avpkt && avpkt->size)
398  return AVERROR_EOF;
399 
400  if (cuvid_is_buffer_full(avctx) && avpkt && avpkt->size)
401  return AVERROR(EAGAIN);
402 
403  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
404  if (ret < 0) {
405  return ret;
406  }
407 
408  memset(&cupkt, 0, sizeof(cupkt));
409 
410  if (avpkt && avpkt->size) {
411  cupkt.payload_size = avpkt->size;
412  cupkt.payload = avpkt->data;
413 
414  if (avpkt->pts != AV_NOPTS_VALUE) {
415  cupkt.flags = CUVID_PKT_TIMESTAMP;
416  if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
417  cupkt.timestamp = av_rescale_q(avpkt->pts, avctx->pkt_timebase, (AVRational){1, 10000000});
418  else
419  cupkt.timestamp = avpkt->pts;
420  }
421  } else {
422  cupkt.flags = CUVID_PKT_ENDOFSTREAM;
423  ctx->decoder_flushing = 1;
424  }
425 
426  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &cupkt));
427 
428  if (ret < 0)
429  goto error;
430 
431  // cuvidParseVideoData doesn't return an error just because stuff failed...
432  if (ctx->internal_error) {
433  av_log(avctx, AV_LOG_ERROR, "cuvid decode callback error\n");
434  ret = ctx->internal_error;
435  goto error;
436  }
437 
438 error:
439  eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
440 
441  if (eret < 0)
442  return eret;
443  else if (ret < 0)
444  return ret;
445  else if (is_flush)
446  return AVERROR_EOF;
447  else
448  return 0;
449 }
450 
452 {
453  CuvidContext *ctx = avctx->priv_data;
454  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
455  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
456  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
457  CUdeviceptr mapped_frame = 0;
458  int ret = 0, eret = 0;
459 
460  av_log(avctx, AV_LOG_TRACE, "cuvid_output_frame\n");
461 
462  if (ctx->decoder_flushing) {
463  ret = cuvid_decode_packet(avctx, NULL);
464  if (ret < 0 && ret != AVERROR_EOF)
465  return ret;
466  }
467 
468  if (!cuvid_is_buffer_full(avctx)) {
469  AVPacket pkt = {0};
470  ret = ff_decode_get_packet(avctx, &pkt);
471  if (ret < 0 && ret != AVERROR_EOF)
472  return ret;
473  ret = cuvid_decode_packet(avctx, &pkt);
475  // cuvid_is_buffer_full() should avoid this.
476  if (ret == AVERROR(EAGAIN))
478  if (ret < 0 && ret != AVERROR_EOF)
479  return ret;
480  }
481 
482  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
483  if (ret < 0)
484  return ret;
485 
486  if (av_fifo_size(ctx->frame_queue)) {
487  const AVPixFmtDescriptor *pixdesc;
488  CuvidParsedFrame parsed_frame;
489  CUVIDPROCPARAMS params;
490  unsigned int pitch = 0;
491  int offset = 0;
492  int i;
493 
494  av_fifo_generic_read(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
495 
496  memset(&params, 0, sizeof(params));
497  params.progressive_frame = parsed_frame.dispinfo.progressive_frame;
498  params.second_field = parsed_frame.second_field;
499  params.top_field_first = parsed_frame.dispinfo.top_field_first;
500 
501  ret = CHECK_CU(ctx->cvdl->cuvidMapVideoFrame(ctx->cudecoder, parsed_frame.dispinfo.picture_index, &mapped_frame, &pitch, &params));
502  if (ret < 0)
503  goto error;
504 
505  if (avctx->pix_fmt == AV_PIX_FMT_CUDA) {
506  ret = av_hwframe_get_buffer(ctx->hwframe, frame, 0);
507  if (ret < 0) {
508  av_log(avctx, AV_LOG_ERROR, "av_hwframe_get_buffer failed\n");
509  goto error;
510  }
511 
512  ret = ff_decode_frame_props(avctx, frame);
513  if (ret < 0) {
514  av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props failed\n");
515  goto error;
516  }
517 
518  pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
519 
520  for (i = 0; i < pixdesc->nb_components; i++) {
521  int height = avctx->height >> (i ? pixdesc->log2_chroma_h : 0);
522  CUDA_MEMCPY2D cpy = {
523  .srcMemoryType = CU_MEMORYTYPE_DEVICE,
524  .dstMemoryType = CU_MEMORYTYPE_DEVICE,
525  .srcDevice = mapped_frame,
526  .dstDevice = (CUdeviceptr)frame->data[i],
527  .srcPitch = pitch,
528  .dstPitch = frame->linesize[i],
529  .srcY = offset,
530  .WidthInBytes = FFMIN(pitch, frame->linesize[i]),
531  .Height = height,
532  };
533 
534  ret = CHECK_CU(ctx->cudl->cuMemcpy2DAsync(&cpy, device_hwctx->stream));
535  if (ret < 0)
536  goto error;
537 
538  offset += height;
539  }
540  } else if (avctx->pix_fmt == AV_PIX_FMT_NV12 ||
541  avctx->pix_fmt == AV_PIX_FMT_P010 ||
542  avctx->pix_fmt == AV_PIX_FMT_P016 ||
543  avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
544  avctx->pix_fmt == AV_PIX_FMT_YUV444P16) {
545  unsigned int offset = 0;
546  AVFrame *tmp_frame = av_frame_alloc();
547  if (!tmp_frame) {
548  av_log(avctx, AV_LOG_ERROR, "av_frame_alloc failed\n");
549  ret = AVERROR(ENOMEM);
550  goto error;
551  }
552 
553  pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
554 
555  tmp_frame->format = AV_PIX_FMT_CUDA;
556  tmp_frame->hw_frames_ctx = av_buffer_ref(ctx->hwframe);
557  if (!tmp_frame->hw_frames_ctx) {
558  ret = AVERROR(ENOMEM);
559  av_frame_free(&tmp_frame);
560  goto error;
561  }
562 
563  tmp_frame->width = avctx->width;
564  tmp_frame->height = avctx->height;
565 
566  /*
567  * Note that the following logic would not work for three plane
568  * YUV420 because the pitch value is different for the chroma
569  * planes.
570  */
571  for (i = 0; i < pixdesc->nb_components; i++) {
572  tmp_frame->data[i] = (uint8_t*)mapped_frame + offset;
573  tmp_frame->linesize[i] = pitch;
574  offset += pitch * (avctx->height >> (i ? pixdesc->log2_chroma_h : 0));
575  }
576 
577  ret = ff_get_buffer(avctx, frame, 0);
578  if (ret < 0) {
579  av_log(avctx, AV_LOG_ERROR, "ff_get_buffer failed\n");
580  av_frame_free(&tmp_frame);
581  goto error;
582  }
583 
584  ret = av_hwframe_transfer_data(frame, tmp_frame, 0);
585  if (ret) {
586  av_log(avctx, AV_LOG_ERROR, "av_hwframe_transfer_data failed\n");
587  av_frame_free(&tmp_frame);
588  goto error;
589  }
590  av_frame_free(&tmp_frame);
591  } else {
592  ret = AVERROR_BUG;
593  goto error;
594  }
595 
596  frame->key_frame = ctx->key_frame[parsed_frame.dispinfo.picture_index];
597  ctx->key_frame[parsed_frame.dispinfo.picture_index] = 0;
598 
599  frame->width = avctx->width;
600  frame->height = avctx->height;
601  if (avctx->pkt_timebase.num && avctx->pkt_timebase.den)
602  frame->pts = av_rescale_q(parsed_frame.dispinfo.timestamp, (AVRational){1, 10000000}, avctx->pkt_timebase);
603  else
604  frame->pts = parsed_frame.dispinfo.timestamp;
605 
606  if (parsed_frame.second_field) {
607  if (ctx->prev_pts == INT64_MIN) {
608  ctx->prev_pts = frame->pts;
609  frame->pts += (avctx->pkt_timebase.den * avctx->framerate.den) / (avctx->pkt_timebase.num * avctx->framerate.num);
610  } else {
611  int pts_diff = (frame->pts - ctx->prev_pts) / 2;
612  ctx->prev_pts = frame->pts;
613  frame->pts += pts_diff;
614  }
615  }
616 
617  /* CUVIDs opaque reordering breaks the internal pkt logic.
618  * So set pkt_pts and clear all the other pkt_ fields.
619  */
620  frame->pkt_pos = -1;
621  frame->pkt_duration = 0;
622  frame->pkt_size = -1;
623 
624  frame->interlaced_frame = !parsed_frame.is_deinterlacing && !parsed_frame.dispinfo.progressive_frame;
625 
626  if (frame->interlaced_frame)
627  frame->top_field_first = parsed_frame.dispinfo.top_field_first;
628  } else if (ctx->decoder_flushing) {
629  ret = AVERROR_EOF;
630  } else {
631  ret = AVERROR(EAGAIN);
632  }
633 
634 error:
635  if (ret < 0)
637 
638  if (mapped_frame)
639  eret = CHECK_CU(ctx->cvdl->cuvidUnmapVideoFrame(ctx->cudecoder, mapped_frame));
640 
641  eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
642 
643  if (eret < 0)
644  return eret;
645  else
646  return ret;
647 }
648 
650 {
651  CuvidContext *ctx = avctx->priv_data;
652  AVHWDeviceContext *device_ctx = (AVHWDeviceContext *)ctx->hwdevice->data;
653  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
654  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
655 
656  av_fifo_freep(&ctx->frame_queue);
657 
658  ctx->cudl->cuCtxPushCurrent(cuda_ctx);
659 
660  if (ctx->cuparser)
661  ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
662 
663  if (ctx->cudecoder)
664  ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
665 
666  ctx->cudl->cuCtxPopCurrent(&dummy);
667 
668  ctx->cudl = NULL;
669 
670  av_buffer_unref(&ctx->hwframe);
671  av_buffer_unref(&ctx->hwdevice);
672 
673  av_freep(&ctx->key_frame);
674  av_freep(&ctx->cuparse_ext);
675 
676  cuvid_free_functions(&ctx->cvdl);
677 
678  return 0;
679 }
680 
682  const CUVIDPARSERPARAMS *cuparseinfo,
683  int probed_width,
684  int probed_height,
685  int bit_depth)
686 {
687  CuvidContext *ctx = avctx->priv_data;
688  CUVIDDECODECAPS *caps;
689  int res8 = 0, res10 = 0, res12 = 0;
690 
691  if (!ctx->cvdl->cuvidGetDecoderCaps) {
692  av_log(avctx, AV_LOG_WARNING, "Used Nvidia driver is too old to perform a capability check.\n");
693  av_log(avctx, AV_LOG_WARNING, "The minimum required version is "
694 #if defined(_WIN32) || defined(__CYGWIN__)
695  "378.66"
696 #else
697  "378.13"
698 #endif
699  ". Continuing blind.\n");
700  ctx->caps8.bIsSupported = ctx->caps10.bIsSupported = 1;
701  // 12 bit was not supported before the capability check was introduced, so disable it.
702  ctx->caps12.bIsSupported = 0;
703  return 0;
704  }
705 
706  ctx->caps8.eCodecType = ctx->caps10.eCodecType = ctx->caps12.eCodecType
707  = cuparseinfo->CodecType;
708  ctx->caps8.eChromaFormat = ctx->caps10.eChromaFormat = ctx->caps12.eChromaFormat
709  = cudaVideoChromaFormat_420;
710 
711  ctx->caps8.nBitDepthMinus8 = 0;
712  ctx->caps10.nBitDepthMinus8 = 2;
713  ctx->caps12.nBitDepthMinus8 = 4;
714 
715  res8 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps8));
716  res10 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps10));
717  res12 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps12));
718 
719  av_log(avctx, AV_LOG_VERBOSE, "CUVID capabilities for %s:\n", avctx->codec->name);
720  av_log(avctx, AV_LOG_VERBOSE, "8 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
721  ctx->caps8.bIsSupported, ctx->caps8.nMinWidth, ctx->caps8.nMaxWidth, ctx->caps8.nMinHeight, ctx->caps8.nMaxHeight);
722  av_log(avctx, AV_LOG_VERBOSE, "10 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
723  ctx->caps10.bIsSupported, ctx->caps10.nMinWidth, ctx->caps10.nMaxWidth, ctx->caps10.nMinHeight, ctx->caps10.nMaxHeight);
724  av_log(avctx, AV_LOG_VERBOSE, "12 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
725  ctx->caps12.bIsSupported, ctx->caps12.nMinWidth, ctx->caps12.nMaxWidth, ctx->caps12.nMinHeight, ctx->caps12.nMaxHeight);
726 
727  switch (bit_depth) {
728  case 10:
729  caps = &ctx->caps10;
730  if (res10 < 0)
731  return res10;
732  break;
733  case 12:
734  caps = &ctx->caps12;
735  if (res12 < 0)
736  return res12;
737  break;
738  default:
739  caps = &ctx->caps8;
740  if (res8 < 0)
741  return res8;
742  }
743 
744  if (!ctx->caps8.bIsSupported) {
745  av_log(avctx, AV_LOG_ERROR, "Codec %s is not supported.\n", avctx->codec->name);
746  return AVERROR(EINVAL);
747  }
748 
749  if (!caps->bIsSupported) {
750  av_log(avctx, AV_LOG_ERROR, "Bit depth %d is not supported.\n", bit_depth);
751  return AVERROR(EINVAL);
752  }
753 
754  if (probed_width > caps->nMaxWidth || probed_width < caps->nMinWidth) {
755  av_log(avctx, AV_LOG_ERROR, "Video width %d not within range from %d to %d\n",
756  probed_width, caps->nMinWidth, caps->nMaxWidth);
757  return AVERROR(EINVAL);
758  }
759 
760  if (probed_height > caps->nMaxHeight || probed_height < caps->nMinHeight) {
761  av_log(avctx, AV_LOG_ERROR, "Video height %d not within range from %d to %d\n",
762  probed_height, caps->nMinHeight, caps->nMaxHeight);
763  return AVERROR(EINVAL);
764  }
765 
766  if ((probed_width * probed_height) / 256 > caps->nMaxMBCount) {
767  av_log(avctx, AV_LOG_ERROR, "Video macroblock count %d exceeds maximum of %d\n",
768  (int)(probed_width * probed_height) / 256, caps->nMaxMBCount);
769  return AVERROR(EINVAL);
770  }
771 
772  return 0;
773 }
774 
776 {
777  CuvidContext *ctx = avctx->priv_data;
778  AVCUDADeviceContext *device_hwctx;
779  AVHWDeviceContext *device_ctx;
780  AVHWFramesContext *hwframe_ctx;
781  CUVIDSOURCEDATAPACKET seq_pkt;
782  CUcontext cuda_ctx = NULL;
783  CUcontext dummy;
784  uint8_t *extradata;
785  int extradata_size;
786  int ret = 0;
787 
790  AV_PIX_FMT_NONE };
791 
792  int probed_width = avctx->coded_width ? avctx->coded_width : 1280;
793  int probed_height = avctx->coded_height ? avctx->coded_height : 720;
794  int probed_bit_depth = 8;
795 
796  const AVPixFmtDescriptor *probe_desc = av_pix_fmt_desc_get(avctx->pix_fmt);
797  if (probe_desc && probe_desc->nb_components)
798  probed_bit_depth = probe_desc->comp[0].depth;
799 
800  // Accelerated transcoding scenarios with 'ffmpeg' require that the
801  // pix_fmt be set to AV_PIX_FMT_CUDA early. The sw_pix_fmt, and the
802  // pix_fmt for non-accelerated transcoding, do not need to be correct
803  // but need to be set to something. We arbitrarily pick NV12.
804  ret = ff_get_format(avctx, pix_fmts);
805  if (ret < 0) {
806  av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", ret);
807  return ret;
808  }
809  avctx->pix_fmt = ret;
810 
811  if (ctx->resize_expr && sscanf(ctx->resize_expr, "%dx%d",
812  &ctx->resize.width, &ctx->resize.height) != 2) {
813  av_log(avctx, AV_LOG_ERROR, "Invalid resize expressions\n");
814  ret = AVERROR(EINVAL);
815  goto error;
816  }
817 
818  if (ctx->crop_expr && sscanf(ctx->crop_expr, "%dx%dx%dx%d",
819  &ctx->crop.top, &ctx->crop.bottom,
820  &ctx->crop.left, &ctx->crop.right) != 4) {
821  av_log(avctx, AV_LOG_ERROR, "Invalid cropping expressions\n");
822  ret = AVERROR(EINVAL);
823  goto error;
824  }
825 
826  ret = cuvid_load_functions(&ctx->cvdl, avctx);
827  if (ret < 0) {
828  av_log(avctx, AV_LOG_ERROR, "Failed loading nvcuvid.\n");
829  goto error;
830  }
831 
832  ctx->frame_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(CuvidParsedFrame));
833  if (!ctx->frame_queue) {
834  ret = AVERROR(ENOMEM);
835  goto error;
836  }
837 
838  if (avctx->hw_frames_ctx) {
839  ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
840  if (!ctx->hwframe) {
841  ret = AVERROR(ENOMEM);
842  goto error;
843  }
844 
845  hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
846 
847  ctx->hwdevice = av_buffer_ref(hwframe_ctx->device_ref);
848  if (!ctx->hwdevice) {
849  ret = AVERROR(ENOMEM);
850  goto error;
851  }
852  } else {
853  if (avctx->hw_device_ctx) {
854  ctx->hwdevice = av_buffer_ref(avctx->hw_device_ctx);
855  if (!ctx->hwdevice) {
856  ret = AVERROR(ENOMEM);
857  goto error;
858  }
859  } else {
860  ret = av_hwdevice_ctx_create(&ctx->hwdevice, AV_HWDEVICE_TYPE_CUDA, ctx->cu_gpu, NULL, 0);
861  if (ret < 0)
862  goto error;
863  }
864 
865  ctx->hwframe = av_hwframe_ctx_alloc(ctx->hwdevice);
866  if (!ctx->hwframe) {
867  av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
868  ret = AVERROR(ENOMEM);
869  goto error;
870  }
871 
872  hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
873  }
874 
875  device_ctx = hwframe_ctx->device_ctx;
876  device_hwctx = device_ctx->hwctx;
877 
878  cuda_ctx = device_hwctx->cuda_ctx;
879  ctx->cudl = device_hwctx->internal->cuda_dl;
880 
881  memset(&ctx->cuparseinfo, 0, sizeof(ctx->cuparseinfo));
882  memset(&seq_pkt, 0, sizeof(seq_pkt));
883 
884  switch (avctx->codec->id) {
885 #if CONFIG_H264_CUVID_DECODER
886  case AV_CODEC_ID_H264:
887  ctx->cuparseinfo.CodecType = cudaVideoCodec_H264;
888  break;
889 #endif
890 #if CONFIG_HEVC_CUVID_DECODER
891  case AV_CODEC_ID_HEVC:
892  ctx->cuparseinfo.CodecType = cudaVideoCodec_HEVC;
893  break;
894 #endif
895 #if CONFIG_MJPEG_CUVID_DECODER
896  case AV_CODEC_ID_MJPEG:
897  ctx->cuparseinfo.CodecType = cudaVideoCodec_JPEG;
898  break;
899 #endif
900 #if CONFIG_MPEG1_CUVID_DECODER
902  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG1;
903  break;
904 #endif
905 #if CONFIG_MPEG2_CUVID_DECODER
907  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG2;
908  break;
909 #endif
910 #if CONFIG_MPEG4_CUVID_DECODER
911  case AV_CODEC_ID_MPEG4:
912  ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
913  break;
914 #endif
915 #if CONFIG_VP8_CUVID_DECODER
916  case AV_CODEC_ID_VP8:
917  ctx->cuparseinfo.CodecType = cudaVideoCodec_VP8;
918  break;
919 #endif
920 #if CONFIG_VP9_CUVID_DECODER
921  case AV_CODEC_ID_VP9:
922  ctx->cuparseinfo.CodecType = cudaVideoCodec_VP9;
923  break;
924 #endif
925 #if CONFIG_VC1_CUVID_DECODER
926  case AV_CODEC_ID_VC1:
927  ctx->cuparseinfo.CodecType = cudaVideoCodec_VC1;
928  break;
929 #endif
930 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
931  case AV_CODEC_ID_AV1:
932  ctx->cuparseinfo.CodecType = cudaVideoCodec_AV1;
933  break;
934 #endif
935  default:
936  av_log(avctx, AV_LOG_ERROR, "Invalid CUVID codec!\n");
937  return AVERROR_BUG;
938  }
939 
940  if (avctx->codec->bsfs) {
941  const AVCodecParameters *par = avctx->internal->bsf->par_out;
942  extradata = par->extradata;
943  extradata_size = par->extradata_size;
944  } else {
945  extradata = avctx->extradata;
946  extradata_size = avctx->extradata_size;
947  }
948 
949  ctx->cuparse_ext = av_mallocz(sizeof(*ctx->cuparse_ext)
950  + FFMAX(extradata_size - (int)sizeof(ctx->cuparse_ext->raw_seqhdr_data), 0));
951  if (!ctx->cuparse_ext) {
952  ret = AVERROR(ENOMEM);
953  goto error;
954  }
955 
956  if (extradata_size > 0)
957  memcpy(ctx->cuparse_ext->raw_seqhdr_data, extradata, extradata_size);
958  ctx->cuparse_ext->format.seqhdr_data_length = extradata_size;
959 
960  ctx->cuparseinfo.pExtVideoInfo = ctx->cuparse_ext;
961 
962  ctx->key_frame = av_mallocz(ctx->nb_surfaces * sizeof(int));
963  if (!ctx->key_frame) {
964  ret = AVERROR(ENOMEM);
965  goto error;
966  }
967 
968  ctx->cuparseinfo.ulMaxNumDecodeSurfaces = ctx->nb_surfaces;
969  ctx->cuparseinfo.ulMaxDisplayDelay = (avctx->flags & AV_CODEC_FLAG_LOW_DELAY) ? 0 : 4;
970  ctx->cuparseinfo.pUserData = avctx;
971  ctx->cuparseinfo.pfnSequenceCallback = cuvid_handle_video_sequence;
972  ctx->cuparseinfo.pfnDecodePicture = cuvid_handle_picture_decode;
973  ctx->cuparseinfo.pfnDisplayPicture = cuvid_handle_picture_display;
974 
975  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
976  if (ret < 0)
977  goto error;
978 
979  ret = cuvid_test_capabilities(avctx, &ctx->cuparseinfo,
980  probed_width,
981  probed_height,
982  probed_bit_depth);
983  if (ret < 0)
984  goto error;
985 
986  ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
987  if (ret < 0)
988  goto error;
989 
990  seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
991  seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
992 
993  if (seq_pkt.payload && seq_pkt.payload_size) {
994  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
995  if (ret < 0)
996  goto error;
997  }
998 
999  ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
1000  if (ret < 0)
1001  goto error;
1002 
1003  ctx->prev_pts = INT64_MIN;
1004 
1005  if (!avctx->pkt_timebase.num || !avctx->pkt_timebase.den)
1006  av_log(avctx, AV_LOG_WARNING, "Invalid pkt_timebase, passing timestamps as-is.\n");
1007 
1008  return 0;
1009 
1010 error:
1011  cuvid_decode_end(avctx);
1012  return ret;
1013 }
1014 
1015 static void cuvid_flush(AVCodecContext *avctx)
1016 {
1017  CuvidContext *ctx = avctx->priv_data;
1018  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)ctx->hwdevice->data;
1019  AVCUDADeviceContext *device_hwctx = device_ctx->hwctx;
1020  CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
1021  CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
1022  int ret;
1023 
1024  ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
1025  if (ret < 0)
1026  goto error;
1027 
1028  av_fifo_freep(&ctx->frame_queue);
1029 
1030  ctx->frame_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(CuvidParsedFrame));
1031  if (!ctx->frame_queue) {
1032  av_log(avctx, AV_LOG_ERROR, "Failed to recreate frame queue on flush\n");
1033  return;
1034  }
1035 
1036  if (ctx->cudecoder) {
1037  ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
1038  ctx->cudecoder = NULL;
1039  }
1040 
1041  if (ctx->cuparser) {
1042  ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
1043  ctx->cuparser = NULL;
1044  }
1045 
1046  ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
1047  if (ret < 0)
1048  goto error;
1049 
1050  seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
1051  seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
1052 
1053  if (seq_pkt.payload && seq_pkt.payload_size) {
1054  ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
1055  if (ret < 0)
1056  goto error;
1057  }
1058 
1059  ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
1060  if (ret < 0)
1061  goto error;
1062 
1063  ctx->prev_pts = INT64_MIN;
1064  ctx->decoder_flushing = 0;
1065 
1066  return;
1067  error:
1068  av_log(avctx, AV_LOG_ERROR, "CUDA reinit on flush failed\n");
1069 }
1070 
1071 #define OFFSET(x) offsetof(CuvidContext, x)
1072 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1073 static const AVOption options[] = {
1074  { "deint", "Set deinterlacing mode", OFFSET(deint_mode), AV_OPT_TYPE_INT, { .i64 = cudaVideoDeinterlaceMode_Weave }, cudaVideoDeinterlaceMode_Weave, cudaVideoDeinterlaceMode_Adaptive, VD, "deint" },
1075  { "weave", "Weave deinterlacing (do nothing)", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Weave }, 0, 0, VD, "deint" },
1076  { "bob", "Bob deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob }, 0, 0, VD, "deint" },
1077  { "adaptive", "Adaptive deinterlacing", 0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0, VD, "deint" },
1078  { "gpu", "GPU to be used for decoding", OFFSET(cu_gpu), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1079  { "surfaces", "Maximum surfaces to be used for decoding", OFFSET(nb_surfaces), AV_OPT_TYPE_INT, { .i64 = 25 }, 0, INT_MAX, VD },
1080  { "drop_second_field", "Drop second field when deinterlacing", OFFSET(drop_second_field), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
1081  { "crop", "Crop (top)x(bottom)x(left)x(right)", OFFSET(crop_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1082  { "resize", "Resize (width)x(height)", OFFSET(resize_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
1083  { NULL }
1084 };
1085 
1087  &(const AVCodecHWConfigInternal) {
1088  .public = {
1092  .device_type = AV_HWDEVICE_TYPE_CUDA
1093  },
1094  .hwaccel = NULL,
1095  },
1096  NULL
1097 };
1098 
1099 #define DEFINE_CUVID_CODEC(x, X, bsf_name) \
1100  static const AVClass x##_cuvid_class = { \
1101  .class_name = #x "_cuvid", \
1102  .item_name = av_default_item_name, \
1103  .option = options, \
1104  .version = LIBAVUTIL_VERSION_INT, \
1105  }; \
1106  const AVCodec ff_##x##_cuvid_decoder = { \
1107  .name = #x "_cuvid", \
1108  .long_name = NULL_IF_CONFIG_SMALL("Nvidia CUVID " #X " decoder"), \
1109  .type = AVMEDIA_TYPE_VIDEO, \
1110  .id = AV_CODEC_ID_##X, \
1111  .priv_data_size = sizeof(CuvidContext), \
1112  .priv_class = &x##_cuvid_class, \
1113  .init = cuvid_decode_init, \
1114  .close = cuvid_decode_end, \
1115  .receive_frame = cuvid_output_frame, \
1116  .flush = cuvid_flush, \
1117  .bsfs = bsf_name, \
1118  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
1119  .caps_internal = FF_CODEC_CAP_SETS_FRAME_PROPS, \
1120  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_CUDA, \
1121  AV_PIX_FMT_NV12, \
1122  AV_PIX_FMT_P010, \
1123  AV_PIX_FMT_P016, \
1124  AV_PIX_FMT_NONE }, \
1125  .hw_configs = cuvid_hw_configs, \
1126  .wrapper_name = "cuvid", \
1127  };
1128 
1129 #if CONFIG_AV1_CUVID_DECODER && defined(CUVID_HAS_AV1_SUPPORT)
1130 DEFINE_CUVID_CODEC(av1, AV1, NULL)
1131 #endif
1132 
1133 #if CONFIG_HEVC_CUVID_DECODER
1134 DEFINE_CUVID_CODEC(hevc, HEVC, "hevc_mp4toannexb")
1135 #endif
1136 
1137 #if CONFIG_H264_CUVID_DECODER
1138 DEFINE_CUVID_CODEC(h264, H264, "h264_mp4toannexb")
1139 #endif
1140 
1141 #if CONFIG_MJPEG_CUVID_DECODER
1142 DEFINE_CUVID_CODEC(mjpeg, MJPEG, NULL)
1143 #endif
1144 
1145 #if CONFIG_MPEG1_CUVID_DECODER
1146 DEFINE_CUVID_CODEC(mpeg1, MPEG1VIDEO, NULL)
1147 #endif
1148 
1149 #if CONFIG_MPEG2_CUVID_DECODER
1150 DEFINE_CUVID_CODEC(mpeg2, MPEG2VIDEO, NULL)
1151 #endif
1152 
1153 #if CONFIG_MPEG4_CUVID_DECODER
1154 DEFINE_CUVID_CODEC(mpeg4, MPEG4, NULL)
1155 #endif
1156 
1157 #if CONFIG_VP8_CUVID_DECODER
1158 DEFINE_CUVID_CODEC(vp8, VP8, NULL)
1159 #endif
1160 
1161 #if CONFIG_VP9_CUVID_DECODER
1162 DEFINE_CUVID_CODEC(vp9, VP9, NULL)
1163 #endif
1164 
1165 #if CONFIG_VC1_CUVID_DECODER
1166 DEFINE_CUVID_CODEC(vc1, VC1, NULL)
1167 #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:403
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:187
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:225
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:349
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: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:1081
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:2541
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:62
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
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:303
pixdesc.h
AVFrame::width
int width
Definition: frame.h:361
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:576
cuvid_output_frame
static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: cuviddec.c:451
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:365
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
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:197
options
static const AVOption options[]
Definition: cuviddec.c:1073
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:317
AV_HWDEVICE_TYPE_CUDA
@ AV_HWDEVICE_TYPE_CUDA
Definition: hwcontext.h:30
AVFifoBuffer
Definition: fifo.h:31
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1699
fifo.h
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:393
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:336
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:464
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:265
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:572
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:261
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:98
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:207
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:181
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:486
CuvidContext::right
int right
Definition: cuviddec.c:65
cuvid_hw_configs
static const AVCodecHWConfigInternal *const cuvid_hw_configs[]
Definition: cuviddec.c:1086
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:402
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:218
CuvidContext::caps10
CUVIDDECODECAPS caps10
Definition: cuviddec.c:92
DEFINE_CUVID_CODEC
#define DEFINE_CUVID_CODEC(x, X, bsf_name)
Definition: cuviddec.c:1099
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:202
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:463
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
cuvid_decode_packet
static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Definition: cuviddec.c:386
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:72
CuvidContext::crop_expr
char * crop_expr
Definition: cuviddec.c:59
VD
#define VD
Definition: cuviddec.c:1072
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:681
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:419
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:422
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:375
AVCodecInternal::bsf
AVBSFContext * bsf
Definition: internal.h:149
AV_CODEC_HW_CONFIG_METHOD_INTERNAL
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:442
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:51
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:775
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:1645
AVPacket::size
int size
Definition: packet.h:366
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:1713
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:649
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:376
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:57
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:358
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:485
CuvidParsedFrame::dispinfo
CUVIDPARSERDISPINFO dispinfo
Definition: cuviddec.c:103
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:224
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:436
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:244
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:1895
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:120
CuvidContext::resize_expr
char * resize_expr
Definition: cuviddec.c:60
AVCodecContext::height
int height
Definition: avcodec.h:557
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:594
CuvidContext::left
int left
Definition: cuviddec.c:63
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:559
AV_PIX_FMT_P016
#define AV_PIX_FMT_P016
Definition: pixfmt.h:439
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:1846
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:607
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:101
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:1483
AVCodecContext
main external API structure.
Definition: avcodec.h:384
AVFrame::height
int height
Definition: frame.h:361
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:106
CuvidParsedFrame::second_field
int second_field
Definition: cuviddec.c:104
OFFSET
#define OFFSET(x)
Definition: cuviddec.c:1071
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:438
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:572
CuvidContext::hwframe
AVBufferRef * hwframe
Definition: cuviddec.c:75
cuvid_flush
static void cuvid_flush(AVCodecContext *avctx)
Definition: cuviddec.c:1015
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:70
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:342
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:411
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:175
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:557
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:190
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:334
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:1706
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:52
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:90
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:2461
cuvid_handle_video_sequence
static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT *format)
Definition: cuviddec.c:110