38 #if !NVDECAPI_CHECK_VERSION(9, 0) 39 #define cudaVideoSurfaceFormat_YUV444 2 40 #define cudaVideoSurfaceFormat_YUV444_16Bit 3 60 #define CHECK_CU(x) FF_CUDA_CHECK_DL(logctx, decoder->cudl, x) 81 int shift_h = 0, shift_v = 0;
85 if (shift_h == 1 && shift_v == 1)
86 return cudaVideoChromaFormat_420;
87 else if (shift_h == 1 && shift_v == 0)
88 return cudaVideoChromaFormat_422;
89 else if (shift_h == 0 && shift_v == 0)
90 return cudaVideoChromaFormat_444;
96 CUVIDDECODECREATEINFO *params,
void *logctx)
99 CUVIDDECODECAPS caps = { 0 };
101 caps.eCodecType = params->CodecType;
102 caps.eChromaFormat = params->ChromaFormat;
103 caps.nBitDepthMinus8 = params->bitDepthMinus8;
105 if (!decoder->
cvdl->cuvidGetDecoderCaps) {
106 av_log(logctx,
AV_LOG_WARNING,
"Used Nvidia driver is too old to perform a capability check.\n");
108 #
if defined(_WIN32) || defined(__CYGWIN__)
113 ". Continuing blind.\n");
117 ret =
CHECK_CU(decoder->
cvdl->cuvidGetDecoderCaps(&caps));
123 caps.bIsSupported ?
"yes" :
"no", caps.nMaxMBCount);
125 caps.nMinWidth, caps.nMaxWidth);
127 caps.nMinHeight, caps.nMaxHeight);
129 if (!caps.bIsSupported) {
134 if (params->ulWidth > caps.nMaxWidth || params->ulWidth < caps.nMinWidth) {
136 (
int)params->ulWidth, caps.nMinWidth, caps.nMaxWidth);
140 if (params->ulHeight > caps.nMaxHeight || params->ulHeight < caps.nMinHeight) {
142 (
int)params->ulHeight, caps.nMinHeight, caps.nMaxHeight);
146 if ((params->ulWidth * params->ulHeight) / 256 > caps.nMaxMBCount) {
148 (
int)(params->ulWidth * params->ulHeight) / 256, caps.nMaxMBCount);
170 cuvid_free_functions(&decoder->
cvdl);
176 CUVIDDECODECREATEINFO *params,
void *logctx)
199 if (!decoder->hw_device_ref) {
203 decoder->cuda_ctx = device_hwctx->cuda_ctx;
204 decoder->cudl = device_hwctx->internal->cuda_dl;
205 decoder->stream = device_hwctx->stream;
207 ret = cuvid_load_functions(&decoder->cvdl, logctx);
213 ret =
CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));
223 ret =
CHECK_CU(decoder->cvdl->cuvidCreateDecoder(&decoder->decoder, params));
305 if (!frames_ctx->
pool) {
333 CUVIDDECODECREATEINFO params = { 0 };
335 cudaVideoSurfaceFormat output_format;
336 int cuvid_codec_type, cuvid_chroma_format, chroma_444;
344 if (cuvid_codec_type < 0) {
350 if (cuvid_chroma_format < 0) {
354 chroma_444 = ctx->
supports_444 && cuvid_chroma_format == cudaVideoChromaFormat_444;
366 if (!real_hw_frames_ref)
373 cudaVideoSurfaceFormat_NV12;
378 cudaVideoSurfaceFormat_P016;
392 params.bitDepthMinus8 = sw_desc->
comp[0].
depth - 8;
393 params.OutputFormat = output_format;
394 params.CodecType = cuvid_codec_type;
395 params.ChromaFormat = cuvid_chroma_format;
401 if (params.ulNumDecodeSurfaces > 32) {
402 av_log(avctx,
AV_LOG_WARNING,
"Using more than 32 (%d) decode surfaces might cause nvdec to fail.\n",
403 (
int)params.ulNumDecodeSurfaces);
413 real_hw_frames_ref =
NULL;
453 CUdeviceptr devptr = (CUdeviceptr)opaque;
479 CUVIDPROCPARAMS vpp = { 0 };
485 unsigned int pitch,
i;
487 int shift_h = 0, shift_v = 0;
490 vpp.progressive_frame = 1;
491 vpp.output_stream = decoder->
stream;
512 if (!frame->
buf[1]) {
524 unmap_data->idx = cf->idx;
532 offset += pitch * (frame->
height >> (i ? shift_v : 0));
538 if (!frame->
buf[1]) {
568 if (!cf->decoder_ref) {
579 cf->idx = *(
unsigned int*)cf->idx_ref->data;
596 void *logctx = avctx;
659 int cuvid_codec_type, cuvid_chroma_format, chroma_444;
666 if (cuvid_codec_type < 0) {
672 if (cuvid_chroma_format < 0) {
676 chroma_444 = supports_444 && cuvid_chroma_format == cudaVideoChromaFormat_444;
687 switch (sw_desc->comp[0].depth) {
#define cudaVideoSurfaceFormat_YUV444_16Bit
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
static enum AVPixelFormat pix_fmt
AVBufferRef * decoder_ref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
int coded_width
Bitstream width / height, may be different from width/height e.g.
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AV_LOG_WARNING
Something somehow does not look correct.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
int ff_nvdec_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx, int dpb_size, int supports_444)
enum AVPixelFormat pix_fmt
Supported pixel format.
int width
The allocated dimensions of the frames in this pool.
void(* hwaccel_priv_free)(void *priv)
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
int ff_nvdec_simple_end_frame(AVCodecContext *avctx)
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
static int nvdec_decoder_create(AVBufferRef **out, AVBufferRef *hw_device_ref, CUVIDDECODECREATEINFO *params, void *logctx)
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame...
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
CUVIDPICPARAMS pic_params
AVBufferRef * private_ref
AVBufferRef for internal use by a single libav* library.
int ff_nvdec_simple_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
static AVBufferRef * nvdec_decoder_frame_alloc(void *opaque, int size)
#define AV_LOG_VERBOSE
Detailed information.
#define AV_PIX_FMT_YUV444P16
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
AVBufferRef * decoder_ref
static int nvdec_test_capabilities(NVDECDecoder *decoder, CUVIDDECODECREATEINFO *params, void *logctx)
static void nvdec_unmap_mapped_frame(void *opaque, uint8_t *data)
static void nvdec_free_dummy(struct AVHWFramesContext *ctx)
static int map_chroma_format(enum AVPixelFormat pix_fmt)
#define i(width, name, range_min, range_max)
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static AVBufferRef * hw_device_ctx
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.
int ff_nvdec_end_frame(AVCodecContext *avctx)
int ff_nvdec_start_frame(AVCodecContext *avctx, AVFrame *frame)
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
static void nvdec_fdd_priv_free(void *priv)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
AVBufferRef * real_hw_frames_ref
static const uint8_t offset[127][2]
int ff_nvdec_decode_init(AVCodecContext *avctx)
int initial_pool_size
Initial size of the frame pool.
static int nvdec_init_hwframes(AVCodecContext *avctx, AVBufferRef **out_frames_ref, int dummy)
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
static void nvdec_decoder_free(void *opaque, uint8_t *data)
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.
FFmpeg internal API for CUDA.
HW acceleration through CUDA.
AVBufferPool * av_buffer_pool_init2(int size, void *opaque, AVBufferRef *(*alloc)(void *opaque, int size), void(*pool_free)(void *opaque))
Allocate and initialize a buffer pool with a more complex allocator.
preferred ID for MPEG-1/2 video decoding
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
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...
void(* free)(struct AVHWFramesContext *ctx)
This field may be set by the caller before calling av_hwframe_ctx_init().
Libavcodec external API header.
unsigned int bitstream_allocated
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
main external API structure.
int ff_nvdec_decode_uninit(AVCodecContext *avctx)
uint8_t * data
The data buffer.
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
This struct is allocated as AVHWDeviceContext.hwctx.
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
unsigned int slice_offsets_allocated
This struct describes a set or pool of "hardware" frames (i.e.
static AVBufferRef * nvdec_alloc_dummy(int size)
unsigned int nb_allocated
static int map_avcodec_id(enum AVCodecID id)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
A reference to a data buffer.
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
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. ...
common internal api header.
common internal and external API header
AVBufferPool * av_buffer_pool_init(int size, AVBufferRef *(*alloc)(int size))
Allocate and initialize a buffer pool.
int ff_nvdec_get_ref_idx(AVFrame *frame)
void * hwaccel_priv_data
hwaccel-specific private data
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
#define cudaVideoSurfaceFormat_YUV444
AVBufferPool * pool
A pool from which the frames are allocated by av_hwframe_get_buffer().
struct AVCodecInternal * internal
Private context used for internal data.
AVBufferPool * decoder_pool
static int nvdec_retrieve_data(void *logctx, AVFrame *frame)
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
void * hwaccel_priv
Per-frame private data for hwaccels.
int depth
Number of bits in the component.
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
AVPixelFormat
Pixel format.
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
AVBufferRef * hw_device_ref