/* * This copyright notice applies to this header file only: * * Copyright (c) 2010-2016 NVIDIA Corporation * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the software, and to permit persons to whom the * software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /** * \file nvcuvid.h * NvCuvid API provides Video Decoding interface to NVIDIA GPU devices. * \date 2015-2015 * This file contains the interface constants, structure definitions and function prototypes. */ #if !defined(__NVCUVID_H__) #define __NVCUVID_H__ #include "compat/cuda/cuviddec.h" #if defined(__cplusplus) extern "C" { #endif /* __cplusplus */ /********************************* ** Initialization *********************************/ CUresult CUDAAPI cuvidInit(unsigned int Flags); //////////////////////////////////////////////////////////////////////////////////////////////// // // High-level helper APIs for video sources // typedef void *CUvideosource; typedef void *CUvideoparser; typedef long long CUvideotimestamp; /** * \addtogroup VIDEO_PARSER Video Parser * @{ */ /*! * \enum cudaVideoState * Video Source State */ typedef enum { cudaVideoState_Error = -1, /**< Error state (invalid source) */ cudaVideoState_Stopped = 0, /**< Source is stopped (or reached end-of-stream) */ cudaVideoState_Started = 1 /**< Source is running and delivering data */ } cudaVideoState; /*! * \enum cudaAudioCodec * Audio compression */ typedef enum { cudaAudioCodec_MPEG1=0, /**< MPEG-1 Audio */ cudaAudioCodec_MPEG2, /**< MPEG-2 Audio */ cudaAudioCodec_MP3, /**< MPEG-1 Layer III Audio */ cudaAudioCodec_AC3, /**< Dolby Digital (AC3) Audio */ cudaAudioCodec_LPCM /**< PCM Audio */ } cudaAudioCodec; /*! * \struct CUVIDEOFORMAT * Video format */ typedef struct { cudaVideoCodec codec; /**< Compression format */ /** * frame rate = numerator / denominator (for example: 30000/1001) */ struct { unsigned int numerator; /**< frame rate numerator (0 = unspecified or variable frame rate) */ unsigned int denominator; /**< frame rate denominator (0 = unspecified or variable frame rate) */ } frame_rate; unsigned char progressive_sequence; /**< 0=interlaced, 1=progressive */ unsigned char bit_depth_luma_minus8; /**< high bit depth Luma */ unsigned char bit_depth_chroma_minus8; /**< high bit depth Chroma */ unsigned char reserved1; /**< Reserved for future use */ unsigned int coded_width; /**< coded frame width */ unsigned int coded_height; /**< coded frame height */ /** * area of the frame that should be displayed * typical example: * coded_width = 1920, coded_height = 1088 * display_area = { 0,0,1920,1080 } */ struct { int left; /**< left position of display rect */ int top; /**< top position of display rect */ int right; /**< right position of display rect */ int bottom; /**< bottom position of display rect */ } display_area; cudaVideoChromaFormat chroma_format; /**< Chroma format */ unsigned int bitrate; /**< video bitrate (bps, 0=unknown) */ /** * Display Aspect Ratio = x:y (4:3, 16:9, etc) */ struct { int x; int y; } display_aspect_ratio; /** * Video Signal Description */ struct { unsigned char video_format : 3; unsigned char video_full_range_flag : 1; unsigned char reserved_zero_bits : 4; unsigned char color_primaries; unsigned char transfer_characteristics; unsigned char matrix_coefficients; } video_signal_description; unsigned int seqhdr_data_length; /**< Additional bytes following (CUVIDEOFORMATEX) */ } CUVIDEOFORMAT; /*! * \struct CUVIDEOFORMATEX * Video format including raw sequence header information */ typedef struct { CUVIDEOFORMAT format; unsigned char raw_seqhdr_data[1024]; } CUVIDEOFORMATEX; /*! * \struct CUAUDIOFORMAT * Audio Formats */ typedef struct { cudaAudioCodec codec; /**< Compression format */ unsigned int channels; /**< number of audio channels */ unsigned int samplespersec; /**< sampling frequency */ unsigned int bitrate; /**< For uncompressed, can also be used to determine bits per sample */ unsigned int reserved1; /**< Reserved for future use */ unsigned int reserved2; /**< Reserved for future use */ } CUAUDIOFORMAT; /*! * \enum CUvideopacketflags * Data packet flags */ typedef enum { CUVID_PKT_ENDOFSTREAM = 0x01, /**< Set when this is the last packet for this stream */ CUVID_PKT_TIMESTAMP = 0x02, /**< Timestamp is valid */ CUVID_PKT_DISCONTINUITY = 0x04 /**< Set when a discontinuity has to be signalled */ } CUvideopacketflags; /*! * \struct CUVIDSOURCEDATAPACKET * Data Packet */ typedef struct _CUVIDSOURCEDATAPACKET { unsigned long flags; /**< Combination of CUVID_PKT_XXX flags */ unsigned long payload_size; /**< number of bytes in the payload (may be zero if EOS flag is set) */ const unsigned char *payload; /**< Pointer to packet payload data (may be NULL if EOS flag is set) */ CUvideotimestamp timestamp; /**< Presentation timestamp (10MHz clock), only valid if CUVID_PKT_TIMESTAMP flag is set */ } CUVIDSOURCEDATAPACKET; // Callback for packet delivery typedef int (CUDAAPI *PFNVIDSOURCECALLBACK)(void *, CUVIDSOURCEDATAPACKET *); /*! * \struct CUVIDSOURCEPARAMS * Source Params */ typedef struct _CUVIDSOURCEPARAMS { unsigned int ulClockRate; /**< Timestamp units in Hz (0=default=10000000Hz) */ unsigned int uReserved1[7]; /**< Reserved for future use - set to zero */ void *pUserData; /**< Parameter passed in to the data handlers */ PFNVIDSOURCECALLBACK pfnVideoDataHandler; /**< Called to deliver audio packets */ PFNVIDSOURCECALLBACK pfnAudioDataHandler; /**< Called to deliver video packets */ void *pvReserved2[8]; /**< Reserved for future use - set to NULL */ } CUVIDSOURCEPARAMS; /*! * \enum CUvideosourceformat_flags * CUvideosourceformat_flags */ typedef enum { CUVID_FMT_EXTFORMATINFO = 0x100 /**< Return extended format structure (CUVIDEOFORMATEX) */ } CUvideosourceformat_flags; #if !defined(__APPLE__) /** * \fn CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams) * Create Video Source */ CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams); /** * \fn CUresult CUDAAPI cuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams) * Create Video Source */ CUresult CUDAAPI cuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams); /** * \fn CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj) * Destroy Video Source */ CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj); /** * \fn CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state) * Set Video Source state */ CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state); /** * \fn cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj) * Get Video Source state */ cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj); /** * \fn CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags) * Get Video Source Format */ CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags); /** * \fn CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags) * Set Video Source state */ CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags); #endif /** * \struct CUVIDPARSERDISPINFO */ typedef struct _CUVIDPARSERDISPINFO { int picture_index; /**< */ int progressive_frame; /**< */ int top_field_first; /**< */ int repeat_first_field; /**< Number of additional fields (1=ivtc, 2=frame doubling, 4=frame tripling, -1=unpaired field) */ CUvideotimestamp timestamp; /**< */ } CUVIDPARSERDISPINFO; // // Parser callbacks // The parser will call these synchronously from within cuvidParseVideoData(), whenever a picture is ready to // be decoded and/or displayed. // typedef int (CUDAAPI *PFNVIDSEQUENCECALLBACK)(void *, CUVIDEOFORMAT *); typedef int (CUDAAPI *PFNVIDDECODECALLBACK)(void *, CUVIDPICPARAMS *); typedef int (CUDAAPI *PFNVIDDISPLAYCALLBACK)(void *, CUVIDPARSERDISPINFO *); /** * \struct CUVIDPARSERPARAMS */ typedef struct _CUVIDPARSERPARAMS { cudaVideoCodec CodecType; /**< cudaVideoCodec_XXX */ unsigned int ulMaxNumDecodeSurfaces; /**< Max # of decode surfaces (parser will cycle through these) */ unsigned int ulClockRate; /**< Timestamp units in Hz (0=default=10000000Hz) */ unsigned int ulErrorThreshold; /**< % Error threshold (0-100) for calling pfnDecodePicture (100=always call pfnDecodePicture even if picture bitstream is fully corrupted) */ unsigned int ulMaxDisplayDelay; /**< Max display queue delay (improves pipelining of decode with display) - 0=no delay (recommended values: 2..4) */ unsigned int uReserved1[5]; /**< Reserved for future use - set to 0 */ void *pUserData; /**< User data for callbacks */ PFNVIDSEQUENCECALLBACK pfnSequenceCallback; /**< Called before decoding frames and/or whenever there is a format change */ PFNVIDDECODECALLBACK pfnDecodePicture; /**< Called when a picture is ready to be decoded (decode order) */ PFNVIDDISPLAYCALLBACK pfnDisplayPicture; /**< Called whenever a picture is ready to be displayed (display order) */ void *pvReserved2[7]; /**< Reserved for future use - set to NULL */ CUVIDEOFORMATEX *pExtVideoInfo; /**< [Optional] sequence header data from system layer */ } CUVIDPARSERPARAMS; /** * \fn CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams) */ CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams); /** * \fn CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket) */ CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket); /** * \fn CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj) */ CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj); /** @} */ /* END VIDEO_PARSER */ //////////////////////////////////////////////////////////////////////////////////////////////// #if defined(__cplusplus) } #endif /* __cplusplus */ #endif // __NVCUVID_H__