FFmpeg
nvdec.c
Go to the documentation of this file.
1 /*
2  * HW decode acceleration through NVDEC
3  *
4  * Copyright (c) 2016 Anton Khirnov
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "config.h"
24 #include "config_components.h"
25 
26 #include "libavutil/common.h"
27 #include "libavutil/error.h"
28 #include "libavutil/hwcontext.h"
30 #include "libavutil/cuda_check.h"
31 #include "libavutil/mem.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/pixfmt.h"
34 
35 #include "avcodec.h"
36 #include "decode.h"
37 #include "nvdec.h"
38 #include "internal.h"
39 #include "refstruct.h"
40 
41 #if !NVDECAPI_CHECK_VERSION(9, 0)
42 #define cudaVideoSurfaceFormat_YUV444 2
43 #define cudaVideoSurfaceFormat_YUV444_16Bit 3
44 #endif
45 
46 typedef struct NVDECDecoder {
47  CUvideodecoder decoder;
48 
51  CUcontext cuda_ctx;
52  CUstream stream;
53 
54  CudaFunctions *cudl;
55  CuvidFunctions *cvdl;
56 
58 } NVDECDecoder;
59 
60 typedef struct NVDECFramePool {
61  unsigned int dpb_size;
62  unsigned int nb_allocated;
64 
65 #define CHECK_CU(x) FF_CUDA_CHECK_DL(logctx, decoder->cudl, x)
66 
67 static int map_avcodec_id(enum AVCodecID id)
68 {
69  switch (id) {
70 #if CONFIG_AV1_NVDEC_HWACCEL
71  case AV_CODEC_ID_AV1: return cudaVideoCodec_AV1;
72 #endif
73  case AV_CODEC_ID_H264: return cudaVideoCodec_H264;
74  case AV_CODEC_ID_HEVC: return cudaVideoCodec_HEVC;
75  case AV_CODEC_ID_MJPEG: return cudaVideoCodec_JPEG;
76  case AV_CODEC_ID_MPEG1VIDEO: return cudaVideoCodec_MPEG1;
77  case AV_CODEC_ID_MPEG2VIDEO: return cudaVideoCodec_MPEG2;
78  case AV_CODEC_ID_MPEG4: return cudaVideoCodec_MPEG4;
79  case AV_CODEC_ID_VC1: return cudaVideoCodec_VC1;
80  case AV_CODEC_ID_VP8: return cudaVideoCodec_VP8;
81  case AV_CODEC_ID_VP9: return cudaVideoCodec_VP9;
82  case AV_CODEC_ID_WMV3: return cudaVideoCodec_VC1;
83  }
84  return -1;
85 }
86 
88 {
89  int shift_h = 0, shift_v = 0;
90 
92  return cudaVideoChromaFormat_Monochrome;
93 
94  av_pix_fmt_get_chroma_sub_sample(pix_fmt, &shift_h, &shift_v);
95 
96  if (shift_h == 1 && shift_v == 1)
97  return cudaVideoChromaFormat_420;
98  else if (shift_h == 1 && shift_v == 0)
99  return cudaVideoChromaFormat_422;
100  else if (shift_h == 0 && shift_v == 0)
101  return cudaVideoChromaFormat_444;
102 
103  return -1;
104 }
105 
107  CUVIDDECODECREATEINFO *params, void *logctx)
108 {
109  int ret;
110  CUVIDDECODECAPS caps = { 0 };
111 
112  caps.eCodecType = params->CodecType;
113  caps.eChromaFormat = params->ChromaFormat;
114  caps.nBitDepthMinus8 = params->bitDepthMinus8;
115 
116  if (!decoder->cvdl->cuvidGetDecoderCaps) {
117  av_log(logctx, AV_LOG_WARNING, "Used Nvidia driver is too old to perform a capability check.\n");
118  av_log(logctx, AV_LOG_WARNING, "The minimum required version is "
119 #if defined(_WIN32) || defined(__CYGWIN__)
120  "378.66"
121 #else
122  "378.13"
123 #endif
124  ". Continuing blind.\n");
125  return 0;
126  }
127 
128  ret = CHECK_CU(decoder->cvdl->cuvidGetDecoderCaps(&caps));
129  if (ret < 0)
130  return ret;
131 
132  av_log(logctx, AV_LOG_VERBOSE, "NVDEC capabilities:\n");
133  av_log(logctx, AV_LOG_VERBOSE, "format supported: %s, max_mb_count: %d\n",
134  caps.bIsSupported ? "yes" : "no", caps.nMaxMBCount);
135  av_log(logctx, AV_LOG_VERBOSE, "min_width: %d, max_width: %d\n",
136  caps.nMinWidth, caps.nMaxWidth);
137  av_log(logctx, AV_LOG_VERBOSE, "min_height: %d, max_height: %d\n",
138  caps.nMinHeight, caps.nMaxHeight);
139 
140  if (!caps.bIsSupported) {
141  av_log(logctx, AV_LOG_ERROR, "Hardware is lacking required capabilities\n");
142  return AVERROR(EINVAL);
143  }
144 
145  if (params->ulWidth > caps.nMaxWidth || params->ulWidth < caps.nMinWidth) {
146  av_log(logctx, AV_LOG_ERROR, "Video width %d not within range from %d to %d\n",
147  (int)params->ulWidth, caps.nMinWidth, caps.nMaxWidth);
148  return AVERROR(EINVAL);
149  }
150 
151  if (params->ulHeight > caps.nMaxHeight || params->ulHeight < caps.nMinHeight) {
152  av_log(logctx, AV_LOG_ERROR, "Video height %d not within range from %d to %d\n",
153  (int)params->ulHeight, caps.nMinHeight, caps.nMaxHeight);
154  return AVERROR(EINVAL);
155  }
156 
157  if ((params->ulWidth * params->ulHeight) / 256 > caps.nMaxMBCount) {
158  av_log(logctx, AV_LOG_ERROR, "Video macroblock count %d exceeds maximum of %d\n",
159  (int)(params->ulWidth * params->ulHeight) / 256, caps.nMaxMBCount);
160  return AVERROR(EINVAL);
161  }
162 
163  return 0;
164 }
165 
166 static void nvdec_decoder_free(FFRefStructOpaque unused, void *obj)
167 {
168  NVDECDecoder *decoder = obj;
169 
170  if (decoder->decoder) {
171  void *logctx = decoder->hw_device_ref->data;
172  CUcontext dummy;
173  CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));
174  CHECK_CU(decoder->cvdl->cuvidDestroyDecoder(decoder->decoder));
175  CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));
176  }
177 
178  av_buffer_unref(&decoder->real_hw_frames_ref);
179  av_buffer_unref(&decoder->hw_device_ref);
180 
181  cuvid_free_functions(&decoder->cvdl);
182 }
183 
184 static int nvdec_decoder_create(NVDECDecoder **out, AVBufferRef *hw_device_ref,
185  CUVIDDECODECREATEINFO *params, void *logctx)
186 {
188  AVCUDADeviceContext *device_hwctx = hw_device_ctx->hwctx;
189 
191 
192  CUcontext dummy;
193  int ret;
194 
195  decoder = ff_refstruct_alloc_ext(sizeof(*decoder), 0,
197  if (!decoder)
198  return AVERROR(ENOMEM);
199 
200  decoder->hw_device_ref = av_buffer_ref(hw_device_ref);
201  if (!decoder->hw_device_ref) {
202  ret = AVERROR(ENOMEM);
203  goto fail;
204  }
205  decoder->cuda_ctx = device_hwctx->cuda_ctx;
206  decoder->cudl = device_hwctx->internal->cuda_dl;
207  decoder->stream = device_hwctx->stream;
208 
209  ret = cuvid_load_functions(&decoder->cvdl, logctx);
210  if (ret < 0) {
211  av_log(logctx, AV_LOG_ERROR, "Failed loading nvcuvid.\n");
212  goto fail;
213  }
214 
215  ret = CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));
216  if (ret < 0)
217  goto fail;
218 
219  ret = nvdec_test_capabilities(decoder, params, logctx);
220  if (ret < 0) {
221  CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));
222  goto fail;
223  }
224 
225  ret = CHECK_CU(decoder->cvdl->cuvidCreateDecoder(&decoder->decoder, params));
226 
227  CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));
228 
229  if (ret < 0) {
230  goto fail;
231  }
232 
233  *out = decoder;
234 
235  return 0;
236 fail:
238  return ret;
239 }
240 
241 static int nvdec_decoder_frame_init(FFRefStructOpaque opaque, void *obj)
242 {
243  NVDECFramePool *pool = opaque.nc;
244  unsigned int *intp = obj;
245 
246  if (pool->nb_allocated >= pool->dpb_size)
247  return AVERROR(ENOMEM);
248 
249  *intp = pool->nb_allocated++;
250 
251  return 0;
252 }
253 
255 {
256  av_free(opaque.nc);
257 }
258 
260 {
262 
263  av_freep(&ctx->bitstream_internal);
264  ctx->bitstream = NULL;
265  ctx->bitstream_len = 0;
266  ctx->bitstream_allocated = 0;
267 
268  av_freep(&ctx->slice_offsets);
269  ctx->nb_slices = 0;
270  ctx->slice_offsets_allocated = 0;
271 
272  ff_refstruct_unref(&ctx->decoder);
273  ff_refstruct_pool_uninit(&ctx->decoder_pool);
274 
275  return 0;
276 }
277 
279 {
280  av_buffer_pool_uninit(&ctx->pool);
281 }
282 
284 {
285  return av_buffer_create(NULL, 0, NULL, NULL, 0);
286 }
287 
288 static int nvdec_init_hwframes(AVCodecContext *avctx, AVBufferRef **out_frames_ref, int dummy)
289 {
290  AVHWFramesContext *frames_ctx;
291  int ret;
292 
294  avctx->hw_device_ctx,
295  avctx->hwaccel->pix_fmt,
296  out_frames_ref);
297  if (ret < 0)
298  return ret;
299 
300  frames_ctx = (AVHWFramesContext*)(*out_frames_ref)->data;
301 
302  if (dummy) {
303  // Copied from ff_decode_get_hw_frames_ctx for compatibility
304  frames_ctx->initial_pool_size += 3;
305 
306  frames_ctx->free = nvdec_free_dummy;
307  frames_ctx->pool = av_buffer_pool_init(0, nvdec_alloc_dummy);
308 
309  if (!frames_ctx->pool) {
310  av_buffer_unref(out_frames_ref);
311  return AVERROR(ENOMEM);
312  }
313  } else {
314  // This is normally not used to actually allocate frames from
315  frames_ctx->initial_pool_size = 0;
316  }
317 
318  ret = av_hwframe_ctx_init(*out_frames_ref);
319  if (ret < 0) {
320  av_buffer_unref(out_frames_ref);
321  return ret;
322  }
323 
324  return 0;
325 }
326 
328 {
330 
332  AVBufferRef *real_hw_frames_ref;
333  NVDECFramePool *pool;
334  AVHWFramesContext *frames_ctx;
335  const AVPixFmtDescriptor *sw_desc;
336 
337  CUVIDDECODECREATEINFO params = { 0 };
338 
339  cudaVideoSurfaceFormat output_format;
340  int cuvid_codec_type, cuvid_chroma_format, chroma_444;
341  int ret = 0;
342 
343  int unsafe_output = !!(avctx->hwaccel_flags & AV_HWACCEL_FLAG_UNSAFE_OUTPUT);
344 
345  sw_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
346  if (!sw_desc)
347  return AVERROR_BUG;
348 
349  cuvid_codec_type = map_avcodec_id(avctx->codec_id);
350  if (cuvid_codec_type < 0) {
351  av_log(avctx, AV_LOG_ERROR, "Unsupported codec ID\n");
352  return AVERROR_BUG;
353  }
354 
355  cuvid_chroma_format = map_chroma_format(avctx->sw_pix_fmt);
356  if (cuvid_chroma_format < 0) {
357  av_log(avctx, AV_LOG_ERROR, "Unsupported chroma format\n");
358  return AVERROR(ENOSYS);
359  }
360  chroma_444 = ctx->supports_444 && cuvid_chroma_format == cudaVideoChromaFormat_444;
361 
362  if (!avctx->hw_frames_ctx) {
363  ret = nvdec_init_hwframes(avctx, &avctx->hw_frames_ctx, 1);
364  if (ret < 0)
365  return ret;
366 
367  ret = nvdec_init_hwframes(avctx, &real_hw_frames_ref, 0);
368  if (ret < 0)
369  return ret;
370  } else {
371  real_hw_frames_ref = av_buffer_ref(avctx->hw_frames_ctx);
372  if (!real_hw_frames_ref)
373  return AVERROR(ENOMEM);
374  }
375 
376  switch (sw_desc->comp[0].depth) {
377  case 8:
379  cudaVideoSurfaceFormat_NV12;
380  break;
381  case 10:
382  case 12:
384  cudaVideoSurfaceFormat_P016;
385  break;
386  default:
387  av_log(avctx, AV_LOG_ERROR, "Unsupported bit depth\n");
388  av_buffer_unref(&real_hw_frames_ref);
389  return AVERROR(ENOSYS);
390  }
391 
392  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
393 
394  params.ulWidth = avctx->coded_width;
395  params.ulHeight = avctx->coded_height;
396  params.ulTargetWidth = avctx->coded_width;
397  params.ulTargetHeight = avctx->coded_height;
398  params.bitDepthMinus8 = sw_desc->comp[0].depth - 8;
399  params.OutputFormat = output_format;
400  params.CodecType = cuvid_codec_type;
401  params.ChromaFormat = cuvid_chroma_format;
402  params.ulNumDecodeSurfaces = frames_ctx->initial_pool_size;
403  params.ulNumOutputSurfaces = unsafe_output ? frames_ctx->initial_pool_size : 1;
404 
405  ret = nvdec_decoder_create(&ctx->decoder, frames_ctx->device_ref, &params, avctx);
406  if (ret < 0) {
407  if (params.ulNumDecodeSurfaces > 32) {
408  av_log(avctx, AV_LOG_WARNING, "Using more than 32 (%d) decode surfaces might cause nvdec to fail.\n",
409  (int)params.ulNumDecodeSurfaces);
410  av_log(avctx, AV_LOG_WARNING, "Try lowering the amount of threads. Using %d right now.\n",
411  avctx->thread_count);
412  }
413  av_buffer_unref(&real_hw_frames_ref);
414  return ret;
415  }
416 
417  decoder = ctx->decoder;
418  decoder->unsafe_output = unsafe_output;
419  decoder->real_hw_frames_ref = real_hw_frames_ref;
420  real_hw_frames_ref = NULL;
421 
422  pool = av_mallocz(sizeof(*pool));
423  if (!pool) {
424  ret = AVERROR(ENOMEM);
425  goto fail;
426  }
427  pool->dpb_size = frames_ctx->initial_pool_size;
428 
429  ctx->decoder_pool = ff_refstruct_pool_alloc_ext(sizeof(unsigned int), 0, pool,
432  if (!ctx->decoder_pool) {
433  ret = AVERROR(ENOMEM);
434  goto fail;
435  }
436 
437  return 0;
438 fail:
439  ff_nvdec_decode_uninit(avctx);
440  return ret;
441 }
442 
443 static void nvdec_fdd_priv_free(void *priv)
444 {
445  NVDECFrame *cf = priv;
446 
447  if (!cf)
448  return;
449 
453 
454  av_freep(&priv);
455 }
456 
457 static void nvdec_unmap_mapped_frame(void *opaque, uint8_t *data)
458 {
459  NVDECFrame *unmap_data = (NVDECFrame*)data;
460  NVDECDecoder *decoder = unmap_data->decoder;
461  void *logctx = decoder->hw_device_ref->data;
462  CUdeviceptr devptr = (CUdeviceptr)opaque;
463  int ret;
464  CUcontext dummy;
465 
466  ret = CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));
467  if (ret < 0)
468  goto finish;
469 
470  CHECK_CU(decoder->cvdl->cuvidUnmapVideoFrame(decoder->decoder, devptr));
471 
472  CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));
473 
474 finish:
475  ff_refstruct_unref(&unmap_data->idx_ref);
476  ff_refstruct_unref(&unmap_data->ref_idx_ref);
477  ff_refstruct_unref(&unmap_data->decoder);
478  av_free(unmap_data);
479 }
480 
481 static int nvdec_retrieve_data(void *logctx, AVFrame *frame)
482 {
483  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
484  NVDECFrame *cf = (NVDECFrame*)fdd->hwaccel_priv;
485  NVDECDecoder *decoder = cf->decoder;
486 
487  AVHWFramesContext *hwctx = (AVHWFramesContext *)frame->hw_frames_ctx->data;
488 
489  CUVIDPROCPARAMS vpp = { 0 };
490  NVDECFrame *unmap_data = NULL;
491 
492  CUcontext dummy;
493  CUdeviceptr devptr;
494 
495  unsigned int pitch, i;
496  unsigned int offset = 0;
497  int shift_h = 0, shift_v = 0;
498  int ret = 0;
499 
500  vpp.progressive_frame = 1;
501  vpp.output_stream = decoder->stream;
502 
503  ret = CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));
504  if (ret < 0)
505  return ret;
506 
507  ret = CHECK_CU(decoder->cvdl->cuvidMapVideoFrame(decoder->decoder,
508  cf->idx, &devptr,
509  &pitch, &vpp));
510  if (ret < 0)
511  goto finish;
512 
513  unmap_data = av_mallocz(sizeof(*unmap_data));
514  if (!unmap_data) {
515  ret = AVERROR(ENOMEM);
516  goto copy_fail;
517  }
518 
519  frame->buf[1] = av_buffer_create((uint8_t *)unmap_data, sizeof(*unmap_data),
520  nvdec_unmap_mapped_frame, (void*)devptr,
522  if (!frame->buf[1]) {
523  ret = AVERROR(ENOMEM);
524  goto copy_fail;
525  }
526 
527  ret = av_buffer_replace(&frame->hw_frames_ctx, decoder->real_hw_frames_ref);
528  if (ret < 0)
529  goto copy_fail;
530 
531  unmap_data->idx = cf->idx;
532  unmap_data->idx_ref = ff_refstruct_ref(cf->idx_ref);
533  unmap_data->decoder = ff_refstruct_ref(cf->decoder);
534 
535  av_pix_fmt_get_chroma_sub_sample(hwctx->sw_format, &shift_h, &shift_v);
536  for (i = 0; frame->linesize[i]; i++) {
537  frame->data[i] = (uint8_t*)(devptr + offset);
538  frame->linesize[i] = pitch;
539  offset += pitch * (frame->height >> (i ? shift_v : 0));
540  }
541 
542  goto finish;
543 
544 copy_fail:
545  if (!frame->buf[1]) {
546  CHECK_CU(decoder->cvdl->cuvidUnmapVideoFrame(decoder->decoder, devptr));
547  av_freep(&unmap_data);
548  } else {
549  av_buffer_unref(&frame->buf[1]);
550  }
551 
552 finish:
553  CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));
554 
555  if (ret < 0 || decoder->unsafe_output)
556  return ret;
557 
559 }
560 
562 {
564  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
565  NVDECFrame *cf = NULL;
566  int ret;
567 
568  ctx->bitstream_len = 0;
569  ctx->nb_slices = 0;
570 
571  if (fdd->hwaccel_priv)
572  return 0;
573 
574  cf = av_mallocz(sizeof(*cf));
575  if (!cf)
576  return AVERROR(ENOMEM);
577 
578  cf->decoder = ff_refstruct_ref(ctx->decoder);
579 
580  cf->idx_ref = ff_refstruct_pool_get(ctx->decoder_pool);
581  if (!cf->idx_ref) {
582  av_log(avctx, AV_LOG_ERROR, "No decoder surfaces left\n");
583  ret = AVERROR(ENOMEM);
584  goto fail;
585  }
586  cf->ref_idx = cf->idx = *cf->idx_ref;
587 
588  fdd->hwaccel_priv = cf;
591 
592  return 0;
593 fail:
595  return ret;
596 
597 }
598 
600 {
602  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
603  NVDECFrame *cf;
604  int ret;
605 
606  ret = ff_nvdec_start_frame(avctx, frame);
607  if (ret < 0)
608  return ret;
609 
610  cf = fdd->hwaccel_priv;
611 
612  if (has_sep_ref) {
613  if (!cf->ref_idx_ref) {
614  cf->ref_idx_ref = ff_refstruct_pool_get(ctx->decoder_pool);
615  if (!cf->ref_idx_ref) {
616  av_log(avctx, AV_LOG_ERROR, "No decoder surfaces left\n");
617  ret = AVERROR(ENOMEM);
618  goto fail;
619  }
620  }
621  cf->ref_idx = *cf->ref_idx_ref;
622  } else {
623  ff_refstruct_unref(&cf->ref_idx_ref);
624  cf->ref_idx = cf->idx;
625  }
626 
627  return 0;
628 fail:
630  return ret;
631 }
632 
634 {
636  NVDECDecoder *decoder = ctx->decoder;
637  void *logctx = avctx;
638  CUVIDPICPARAMS *pp = &ctx->pic_params;
639 
640  CUcontext dummy;
641 
642  int ret = 0;
643 
644  pp->nBitstreamDataLen = ctx->bitstream_len;
645  pp->pBitstreamData = ctx->bitstream;
646  pp->nNumSlices = ctx->nb_slices;
647  pp->pSliceDataOffsets = ctx->slice_offsets;
648 
649  ret = CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));
650  if (ret < 0)
651  return ret;
652 
653  ret = CHECK_CU(decoder->cvdl->cuvidDecodePicture(decoder->decoder, &ctx->pic_params));
654  if (ret < 0)
655  goto finish;
656 
657 finish:
658  CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));
659 
660  return ret;
661 }
662 
664 {
666  int ret = ff_nvdec_end_frame(avctx);
667  ctx->bitstream = NULL;
668  ctx->bitstream_len = 0;
669  ctx->nb_slices = 0;
670  return ret;
671 }
672 
674  uint32_t size)
675 {
677  void *tmp;
678 
679  tmp = av_fast_realloc(ctx->slice_offsets, &ctx->slice_offsets_allocated,
680  (ctx->nb_slices + 1) * sizeof(*ctx->slice_offsets));
681  if (!tmp)
682  return AVERROR(ENOMEM);
683  ctx->slice_offsets = tmp;
684 
685  if (!ctx->bitstream)
686  ctx->bitstream = buffer;
687 
688  ctx->slice_offsets[ctx->nb_slices] = buffer - ctx->bitstream;
689  ctx->bitstream_len += size;
690  ctx->nb_slices++;
691 
692  return 0;
693 }
694 
696  AVBufferRef *hw_frames_ctx,
697  int dpb_size,
698  int supports_444)
699 {
700  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)hw_frames_ctx->data;
701  const AVPixFmtDescriptor *sw_desc;
702  int cuvid_codec_type, cuvid_chroma_format, chroma_444;
703 
704  sw_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
705  if (!sw_desc)
706  return AVERROR_BUG;
707 
708  cuvid_codec_type = map_avcodec_id(avctx->codec_id);
709  if (cuvid_codec_type < 0) {
710  av_log(avctx, AV_LOG_ERROR, "Unsupported codec ID\n");
711  return AVERROR_BUG;
712  }
713 
714  cuvid_chroma_format = map_chroma_format(avctx->sw_pix_fmt);
715  if (cuvid_chroma_format < 0) {
716  av_log(avctx, AV_LOG_VERBOSE, "Unsupported chroma format\n");
717  return AVERROR(EINVAL);
718  }
719  chroma_444 = supports_444 && cuvid_chroma_format == cudaVideoChromaFormat_444;
720 
721  frames_ctx->format = AV_PIX_FMT_CUDA;
722  frames_ctx->width = (avctx->coded_width + 1) & ~1;
723  frames_ctx->height = (avctx->coded_height + 1) & ~1;
724  /*
725  * We add two extra frames to the pool to account for deinterlacing filters
726  * holding onto their frames.
727  */
728  frames_ctx->initial_pool_size = dpb_size + 2;
729 
730  switch (sw_desc->comp[0].depth) {
731  case 8:
732  frames_ctx->sw_format = chroma_444 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_NV12;
733  break;
734  case 10:
735  frames_ctx->sw_format = chroma_444 ? AV_PIX_FMT_YUV444P16 : AV_PIX_FMT_P010;
736  break;
737  case 12:
738  frames_ctx->sw_format = chroma_444 ? AV_PIX_FMT_YUV444P16 : AV_PIX_FMT_P016;
739  break;
740  default:
741  return AVERROR(EINVAL);
742  }
743 
744  return 0;
745 }
746 
748 {
749  FrameDecodeData *fdd;
750  NVDECFrame *cf;
751 
752  if (!frame || !frame->private_ref)
753  return -1;
754 
755  fdd = (FrameDecodeData*)frame->private_ref->data;
756  cf = (NVDECFrame*)fdd->hwaccel_priv;
757  if (!cf)
758  return -1;
759 
760  return cf->ref_idx;
761 }
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1437
av_buffer_pool_init
AVBufferPool * av_buffer_pool_init(size_t size, AVBufferRef *(*alloc)(size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:283
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
ff_refstruct_ref
void * ff_refstruct_ref(void *obj)
Create a new reference to an object managed via this API, i.e.
Definition: refstruct.c:140
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
map_avcodec_id
static int map_avcodec_id(enum AVCodecID id)
Definition: nvdec.c:67
hwcontext_cuda_internal.h
out
FILE * out
Definition: movenc.c:55
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
map_chroma_format
static int map_chroma_format(enum AVPixelFormat pix_fmt)
Definition: nvdec.c:87
NVDECFramePool
Definition: nvdec.c:60
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:197
NVDECDecoder::stream
CUstream stream
Definition: nvdec.c:52
ff_refstruct_alloc_ext
static void * ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))
A wrapper around ff_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:94
ff_nvdec_get_ref_idx
int ff_nvdec_get_ref_idx(AVFrame *frame)
Definition: nvdec.c:747
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
FrameDecodeData
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
Definition: decode.h:33
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:322
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
av_frame_make_writable
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
Definition: frame.c:666
pixdesc.h
internal.h
AVHWFramesContext::free
void(* free)(struct AVHWFramesContext *ctx)
This field may be set by the caller before calling av_hwframe_ctx_init().
Definition: hwcontext.h:158
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
NVDECDecoder::unsafe_output
int unsafe_output
Definition: nvdec.c:57
data
const char data[16]
Definition: mxf.c:149
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
FrameDecodeData::hwaccel_priv_free
void(* hwaccel_priv_free)(void *priv)
Definition: decode.h:52
FFRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
NVDECDecoder::decoder
CUvideodecoder decoder
Definition: nvdec.c:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AVHWFramesContext::width
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:217
nvdec_decoder_frame_init
static int nvdec_decoder_frame_init(FFRefStructOpaque opaque, void *obj)
Definition: nvdec.c:241
NVDECDecoder::cvdl
CuvidFunctions * cvdl
Definition: nvdec.c:55
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3210
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:331
finish
static void finish(void)
Definition: movenc.c:373
NVDECFrame::idx_ref
unsigned int * idx_ref
RefStruct reference.
Definition: nvdec.h:47
ff_nvdec_start_frame
int ff_nvdec_start_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: nvdec.c:561
NVDECFrame::ref_idx
unsigned int ref_idx
Definition: nvdec.h:46
fail
#define fail()
Definition: checkasm.h:188
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1593
ff_refstruct_pool_uninit
static void ff_refstruct_pool_uninit(FFRefStructPool **poolp)
Mark the pool as being available for freeing.
Definition: refstruct.h:292
dummy
int dummy
Definition: motion.c:66
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:3198
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:639
refstruct.h
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
cudaVideoSurfaceFormat_YUV444
#define cudaVideoSurfaceFormat_YUV444
Definition: nvdec.c:42
AV_HWACCEL_FLAG_UNSAFE_OUTPUT
#define AV_HWACCEL_FLAG_UNSAFE_OUTPUT
Some hardware decoders (namely nvdec) can either output direct decoder surfaces, or make an on-device...
Definition: avcodec.h:2185
AVHWFramesContext::height
int height
Definition: hwcontext.h:217
AVHWFramesContext::pool
AVBufferPool * pool
A pool from which the frames are allocated by av_hwframe_get_buffer().
Definition: hwcontext.h:178
ff_nvdec_start_frame_sep_ref
int ff_nvdec_start_frame_sep_ref(AVCodecContext *avctx, AVFrame *frame, int has_sep_ref)
Definition: nvdec.c:599
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:497
nvdec_decoder_frame_pool_free
static void nvdec_decoder_frame_pool_free(FFRefStructOpaque opaque)
Definition: nvdec.c:254
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:515
AV_BUFFER_FLAG_READONLY
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition: buffer.h:114
nvdec_decoder_free
static void nvdec_decoder_free(FFRefStructOpaque unused, void *obj)
Definition: nvdec.c:166
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:222
NVDECFrame
Definition: nvdec.h:44
ctx
AVFormatContext * ctx
Definition: movenc.c:49
decode.h
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
NVDECDecoder::cudl
CudaFunctions * cudl
Definition: nvdec.c:54
dpb_size
int dpb_size
Definition: h264_levels.c:111
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_ID_WMV3
@ AV_CODEC_ID_WMV3
Definition: codec_id.h:123
ff_nvdec_simple_end_frame
int ff_nvdec_simple_end_frame(AVCodecContext *avctx)
Definition: nvdec.c:663
NULL
#define NULL
Definition: coverity.c:32
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:210
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:284
ff_nvdec_decode_init
int ff_nvdec_decode_init(AVCodecContext *avctx)
Definition: nvdec.c:327
AVHWFramesContext::device_ref
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
Definition: hwcontext.h:126
NVDECDecoder::hw_device_ref
AVBufferRef * hw_device_ref
Definition: nvdec.c:49
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:486
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:328
nvdec_decoder_create
static int nvdec_decoder_create(NVDECDecoder **out, AVBufferRef *hw_device_ref, CUVIDDECODECREATEINFO *params, void *logctx)
Definition: nvdec.c:184
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:53
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
error.h
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
cudaVideoSurfaceFormat_YUV444_16Bit
#define cudaVideoSurfaceFormat_YUV444_16Bit
Definition: nvdec.c:43
nvdec_alloc_dummy
static AVBufferRef * nvdec_alloc_dummy(size_t size)
Definition: nvdec.c:283
CHECK_CU
#define CHECK_CU(x)
Definition: nvdec.c:65
NVDECDecoder::real_hw_frames_ref
AVBufferRef * real_hw_frames_ref
Definition: nvdec.c:50
FrameDecodeData::post_process
int(* post_process)(void *logctx, AVFrame *frame)
The callback to perform some delayed processing on the frame right before it is returned to the calle...
Definition: decode.h:44
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:130
NVDECFrame::ref_idx_ref
unsigned int * ref_idx_ref
RefStruct reference.
Definition: nvdec.h:48
size
int size
Definition: twinvq_data.h:10344
FFRefStructOpaque::nc
void * nc
Definition: refstruct.h:59
nvdec_test_capabilities
static int nvdec_test_capabilities(NVDECDecoder *decoder, CUVIDDECODECREATEINFO *params, void *logctx)
Definition: nvdec.c:106
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
nvdec.h
nvdec_free_dummy
static void nvdec_free_dummy(struct AVHWFramesContext *ctx)
Definition: nvdec.c:278
ff_nvdec_decode_uninit
int ff_nvdec_decode_uninit(AVCodecContext *avctx)
Definition: nvdec.c:259
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
NVDECFrame::decoder
struct NVDECDecoder * decoder
RefStruct reference.
Definition: nvdec.h:49
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
hw_device_ctx
static AVBufferRef * hw_device_ctx
Definition: hw_decode.c:45
NVDECDecoder::cuda_ctx
CUcontext cuda_ctx
Definition: nvdec.c:51
nvdec_fdd_priv_free
static void nvdec_fdd_priv_free(void *priv)
Definition: nvdec.c:443
ff_nvdec_end_frame
int ff_nvdec_end_frame(AVCodecContext *avctx)
Definition: nvdec.c:633
common.h
AVCodecContext::hwaccel_flags
int hwaccel_flags
Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active).
Definition: avcodec.h:1516
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:228
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
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:1507
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:122
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
NVDECDecoder
Definition: nvdec.c:46
AV_PIX_FMT_P016
#define AV_PIX_FMT_P016
Definition: pixfmt.h:554
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:1485
avcodec.h
nvdec_retrieve_data
static int nvdec_retrieve_data(void *logctx, AVFrame *frame)
Definition: nvdec.c:481
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
AVCUDADeviceContext
This struct is allocated as AVHWDeviceContext.hwctx.
Definition: hwcontext_cuda.h:42
avcodec_get_hw_frames_parameters
int avcodec_get_hw_frames_parameters(AVCodecContext *avctx, AVBufferRef *device_ref, enum AVPixelFormat hw_pix_fmt, AVBufferRef **out_frames_ref)
Create and return a AVHWFramesContext with values adequate for hardware decoding.
Definition: decode.c:1168
ret
ret
Definition: filter_design.txt:187
pixfmt.h
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
cuda_check.h
NVDECFramePool::dpb_size
unsigned int dpb_size
Definition: nvdec.c:61
nvdec_init_hwframes
static int nvdec_init_hwframes(AVCodecContext *avctx, AVBufferRef **out_frames_ref, int dummy)
Definition: nvdec.c:288
NVDECFramePool::nb_allocated
unsigned int nb_allocated
Definition: nvdec.c:62
AVCodecContext
main external API structure.
Definition: avcodec.h:451
ff_nvdec_simple_decode_slice
int ff_nvdec_simple_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: nvdec.c:673
nvdec_unmap_mapped_frame
static void nvdec_unmap_mapped_frame(void *opaque, uint8_t *data)
Definition: nvdec.c:457
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
ff_nvdec_frame_params
int ff_nvdec_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx, int dpb_size, int supports_444)
Definition: nvdec.c:695
ff_refstruct_pool_alloc_ext
static FFRefStructPool * ff_refstruct_pool_alloc_ext(size_t size, unsigned flags, void *opaque, int(*init_cb)(FFRefStructOpaque opaque, void *obj), void(*reset_cb)(FFRefStructOpaque opaque, void *obj), void(*free_entry_cb)(FFRefStructOpaque opaque, void *obj), void(*free_cb)(FFRefStructOpaque opaque))
A wrapper around ff_refstruct_pool_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:258
output_format
static char * output_format
Definition: ffprobe.c:150
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AV_PIX_FMT_P010
#define AV_PIX_FMT_P010
Definition: pixfmt.h:552
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:639
AVHWFramesContext::initial_pool_size
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:187
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:51
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:670
NVDECContext
Definition: nvdec.h:52
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
AVHWAccel::pix_fmt
enum AVPixelFormat pix_fmt
Supported pixel format.
Definition: avcodec.h:2126
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
ff_refstruct_pool_get
void * ff_refstruct_pool_get(FFRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition: refstruct.c:297