38 #if !NVDECAPI_CHECK_VERSION(9, 0) 39 #define cudaVideoSurfaceFormat_YUV444 2 40 #define cudaVideoSurfaceFormat_YUV444_16Bit 3 59 #define CHECK_CU(x) FF_CUDA_CHECK_DL(logctx, decoder->cudl, x) 80 int shift_h = 0, shift_v = 0;
84 if (shift_h == 1 && shift_v == 1)
85 return cudaVideoChromaFormat_420;
86 else if (shift_h == 1 && shift_v == 0)
87 return cudaVideoChromaFormat_422;
88 else if (shift_h == 0 && shift_v == 0)
89 return cudaVideoChromaFormat_444;
95 CUVIDDECODECREATEINFO *
params,
void *logctx)
98 CUVIDDECODECAPS caps = { 0 };
100 caps.eCodecType = params->CodecType;
101 caps.eChromaFormat = params->ChromaFormat;
102 caps.nBitDepthMinus8 = params->bitDepthMinus8;
104 if (!decoder->
cvdl->cuvidGetDecoderCaps) {
105 av_log(logctx,
AV_LOG_WARNING,
"Used Nvidia driver is too old to perform a capability check.\n");
107 #
if defined(_WIN32) || defined(__CYGWIN__)
112 ". Continuing blind.\n");
116 ret =
CHECK_CU(decoder->
cvdl->cuvidGetDecoderCaps(&caps));
122 caps.bIsSupported ?
"yes" :
"no", caps.nMaxMBCount);
124 caps.nMinWidth, caps.nMaxWidth);
126 caps.nMinHeight, caps.nMaxHeight);
128 if (!caps.bIsSupported) {
133 if (params->ulWidth > caps.nMaxWidth || params->ulWidth < caps.nMinWidth) {
135 (
int)params->ulWidth, caps.nMinWidth, caps.nMaxWidth);
139 if (params->ulHeight > caps.nMaxHeight || params->ulHeight < caps.nMinHeight) {
141 (
int)params->ulHeight, caps.nMinHeight, caps.nMaxHeight);
145 if ((params->ulWidth * params->ulHeight) / 256 > caps.nMaxMBCount) {
147 (
int)(params->ulWidth * params->ulHeight) / 256, caps.nMaxMBCount);
168 cuvid_free_functions(&decoder->
cvdl);
174 CUVIDDECODECREATEINFO *
params,
void *logctx)
197 if (!decoder->hw_device_ref) {
201 decoder->cuda_ctx = device_hwctx->cuda_ctx;
202 decoder->cudl = device_hwctx->internal->cuda_dl;
203 decoder->stream = device_hwctx->stream;
205 ret = cuvid_load_functions(&decoder->cvdl, logctx);
211 ret =
CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));
221 ret =
CHECK_CU(decoder->cvdl->cuvidCreateDecoder(&decoder->decoder, params));
280 CUVIDDECODECREATEINFO
params = { 0 };
282 cudaVideoSurfaceFormat output_format;
283 int cuvid_codec_type, cuvid_chroma_format, chroma_444;
291 if (cuvid_codec_type < 0) {
297 if (cuvid_chroma_format < 0) {
301 chroma_444 = ctx->
supports_444 && cuvid_chroma_format == cudaVideoChromaFormat_444;
312 cudaVideoSurfaceFormat_NV12;
317 cudaVideoSurfaceFormat_P016;
330 params.bitDepthMinus8 = sw_desc->
comp[0].
depth - 8;
331 params.OutputFormat = output_format;
332 params.CodecType = cuvid_codec_type;
333 params.ChromaFormat = cuvid_chroma_format;
339 if (params.ulNumDecodeSurfaces > 32) {
340 av_log(avctx,
AV_LOG_WARNING,
"Using more than 32 (%d) decode surfaces might cause nvdec to fail.\n",
341 (
int)params.ulNumDecodeSurfaces);
386 CUdeviceptr devptr = (CUdeviceptr)opaque;
412 CUVIDPROCPARAMS vpp = { 0 };
418 unsigned int pitch,
i;
420 int shift_h = 0, shift_v = 0;
423 vpp.progressive_frame = 1;
424 vpp.output_stream = decoder->
stream;
445 if (!frame->
buf[1]) {
450 unmap_data->idx = cf->idx;
458 offset += pitch * (frame->
height >> (i ? shift_v : 0));
464 if (!frame->
buf[1]) {
494 if (!cf->decoder_ref) {
505 cf->idx = *(
unsigned int*)cf->idx_ref->data;
522 void *logctx = avctx;
595 int cuvid_codec_type, cuvid_chroma_format, chroma_444;
602 if (cuvid_codec_type < 0) {
608 if (cuvid_chroma_format < 0) {
612 chroma_444 = supports_444 && cuvid_chroma_format == cudaVideoChromaFormat_444;
626 if (!frames_ctx->
pool)
629 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)
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)
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.
static const uint8_t offset[127][2]
int ff_nvdec_decode_init(AVCodecContext *avctx)
int initial_pool_size
Initial size of the frame pool.
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)
int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx, enum AVHWDeviceType dev_type)
Make sure avctx.hw_frames_ctx is set.
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.
const char const char * params
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
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.
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