1 /* 2 * This copyright notice applies to this header file only: 3 * 4 * Copyright (c) 2010-2019 NVIDIA Corporation 5 * 6 * Permission is hereby granted, free of charge, to any person 7 * obtaining a copy of this software and associated documentation 8 * files (the "Software"), to deal in the Software without 9 * restriction, including without limitation the rights to use, 10 * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 * copies of the software, and to permit persons to whom the 12 * software is furnished to do so, subject to the following 13 * conditions: 14 * 15 * The above copyright notice and this permission notice shall be 16 * included in all copies or substantial portions of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 * OTHER DEALINGS IN THE SOFTWARE. 26 */ 27 28 /** 29 * \file nvEncodeAPI.h 30 * NVIDIA GPUs - beginning with the Kepler generation - contain a hardware-based encoder 31 * (referred to as NVENC) which provides fully-accelerated hardware-based video encoding. 32 * NvEncodeAPI provides the interface for NVIDIA video encoder (NVENC). 33 * \date 2011-2019 34 * This file contains the interface constants, structure definitions and function prototypes. 35 */ 36 37 #ifndef _NV_ENCODEAPI_H_ 38 #define _NV_ENCODEAPI_H_ 39 40 #include <stdlib.h> 41 42 #ifdef _WIN32 43 #include <windows.h> 44 #endif 45 46 #ifdef _MSC_VER 47 #ifndef _STDINT 48 typedef __int32 int32_t; 49 typedef unsigned __int32 uint32_t; 50 typedef __int64 int64_t; 51 typedef unsigned __int64 uint64_t; 52 typedef signed char int8_t; 53 typedef unsigned char uint8_t; 54 typedef short int16_t; 55 typedef unsigned short uint16_t; 56 #endif 57 #else 58 #include <stdint.h> 59 #endif 60 61 #ifdef __cplusplus 62 extern "C" { 63 #endif 64 65 /** 66 * \addtogroup ENCODER_STRUCTURE NvEncodeAPI Data structures 67 * @{ 68 */ 69 70 #ifdef _WIN32 71 #define NVENCAPI __stdcall 72 typedef RECT NVENC_RECT; 73 #else 74 #define NVENCAPI 75 // ========================================================================================= 76 #ifndef GUID 77 /*! 78 * \struct GUID 79 * Abstracts the GUID structure for non-windows platforms. 80 */ 81 // ========================================================================================= 82 typedef struct 83 { 84 uint32_t Data1; /**< [in]: Specifies the first 8 hexadecimal digits of the GUID. */ 85 uint16_t Data2; /**< [in]: Specifies the first group of 4 hexadecimal digits. */ 86 uint16_t Data3; /**< [in]: Specifies the second group of 4 hexadecimal digits. */ 87 uint8_t Data4[8]; /**< [in]: Array of 8 bytes. The first 2 bytes contain the third group of 4 hexadecimal digits. 88 The remaining 6 bytes contain the final 12 hexadecimal digits. */ 89 } GUID; 90 #endif // GUID 91 92 /** 93 * \struct _NVENC_RECT 94 * Defines a Rectangle. Used in ::NV_ENC_PREPROCESS_FRAME. 95 */ 96 typedef struct _NVENC_RECT 97 { 98 uint32_t left; /**< [in]: X coordinate of the upper left corner of rectangular area to be specified. */ 99 uint32_t top; /**< [in]: Y coordinate of the upper left corner of the rectangular area to be specified. */ 100 uint32_t right; /**< [in]: X coordinate of the bottom right corner of the rectangular area to be specified. */ 101 uint32_t bottom; /**< [in]: Y coordinate of the bottom right corner of the rectangular area to be specified. */ 102 } NVENC_RECT; 103 104 #endif // _WIN32 105 106 /** @} */ /* End of GUID and NVENC_RECT structure grouping*/ 107 108 typedef void* NV_ENC_INPUT_PTR; /**< NVENCODE API input buffer */ 109 typedef void* NV_ENC_OUTPUT_PTR; /**< NVENCODE API output buffer*/ 110 typedef void* NV_ENC_REGISTERED_PTR; /**< A Resource that has been registered with NVENCODE API*/ 111 typedef void* NV_ENC_CUSTREAM_PTR; /**< Pointer to CUstream*/ 112 113 #define NVENCAPI_MAJOR_VERSION 9 114 #define NVENCAPI_MINOR_VERSION 1 115 116 #define NVENCAPI_VERSION (NVENCAPI_MAJOR_VERSION | (NVENCAPI_MINOR_VERSION << 24)) 117 118 /** 119 * Macro to generate per-structure version for use with API. 120 */ 121 #define NVENCAPI_STRUCT_VERSION(ver) ((uint32_t)NVENCAPI_VERSION | ((ver)<<16) | (0x7 << 28)) 122 123 124 #define NVENC_INFINITE_GOPLENGTH 0xffffffff 125 126 #define NV_MAX_SEQ_HDR_LEN (512) 127 128 // ========================================================================================= 129 // Encode Codec GUIDS supported by the NvEncodeAPI interface. 130 // ========================================================================================= 131 132 // {6BC82762-4E63-4ca4-AA85-1E50F321F6BF} 133 static const GUID NV_ENC_CODEC_H264_GUID = 134 { 0x6bc82762, 0x4e63, 0x4ca4, { 0xaa, 0x85, 0x1e, 0x50, 0xf3, 0x21, 0xf6, 0xbf } }; 135 136 // {790CDC88-4522-4d7b-9425-BDA9975F7603} 137 static const GUID NV_ENC_CODEC_HEVC_GUID = 138 { 0x790cdc88, 0x4522, 0x4d7b, { 0x94, 0x25, 0xbd, 0xa9, 0x97, 0x5f, 0x76, 0x3 } }; 139 140 141 142 // ========================================================================================= 143 // * Encode Profile GUIDS supported by the NvEncodeAPI interface. 144 // ========================================================================================= 145 146 // {BFD6F8E7-233C-4341-8B3E-4818523803F4} 147 static const GUID NV_ENC_CODEC_PROFILE_AUTOSELECT_GUID = 148 { 0xbfd6f8e7, 0x233c, 0x4341, { 0x8b, 0x3e, 0x48, 0x18, 0x52, 0x38, 0x3, 0xf4 } }; 149 150 // {0727BCAA-78C4-4c83-8C2F-EF3DFF267C6A} 151 static const GUID NV_ENC_H264_PROFILE_BASELINE_GUID = 152 { 0x727bcaa, 0x78c4, 0x4c83, { 0x8c, 0x2f, 0xef, 0x3d, 0xff, 0x26, 0x7c, 0x6a } }; 153 154 // {60B5C1D4-67FE-4790-94D5-C4726D7B6E6D} 155 static const GUID NV_ENC_H264_PROFILE_MAIN_GUID = 156 { 0x60b5c1d4, 0x67fe, 0x4790, { 0x94, 0xd5, 0xc4, 0x72, 0x6d, 0x7b, 0x6e, 0x6d } }; 157 158 // {E7CBC309-4F7A-4b89-AF2A-D537C92BE310} 159 static const GUID NV_ENC_H264_PROFILE_HIGH_GUID = 160 { 0xe7cbc309, 0x4f7a, 0x4b89, { 0xaf, 0x2a, 0xd5, 0x37, 0xc9, 0x2b, 0xe3, 0x10 } }; 161 162 // {7AC663CB-A598-4960-B844-339B261A7D52} 163 static const GUID NV_ENC_H264_PROFILE_HIGH_444_GUID = 164 { 0x7ac663cb, 0xa598, 0x4960, { 0xb8, 0x44, 0x33, 0x9b, 0x26, 0x1a, 0x7d, 0x52 } }; 165 166 // {40847BF5-33F7-4601-9084-E8FE3C1DB8B7} 167 static const GUID NV_ENC_H264_PROFILE_STEREO_GUID = 168 { 0x40847bf5, 0x33f7, 0x4601, { 0x90, 0x84, 0xe8, 0xfe, 0x3c, 0x1d, 0xb8, 0xb7 } }; 169 170 // {CE788D20-AAA9-4318-92BB-AC7E858C8D36} 171 static const GUID NV_ENC_H264_PROFILE_SVC_TEMPORAL_SCALABILTY = 172 { 0xce788d20, 0xaaa9, 0x4318, { 0x92, 0xbb, 0xac, 0x7e, 0x85, 0x8c, 0x8d, 0x36 } }; 173 174 // {B405AFAC-F32B-417B-89C4-9ABEED3E5978} 175 static const GUID NV_ENC_H264_PROFILE_PROGRESSIVE_HIGH_GUID = 176 { 0xb405afac, 0xf32b, 0x417b, { 0x89, 0xc4, 0x9a, 0xbe, 0xed, 0x3e, 0x59, 0x78 } }; 177 178 // {AEC1BD87-E85B-48f2-84C3-98BCA6285072} 179 static const GUID NV_ENC_H264_PROFILE_CONSTRAINED_HIGH_GUID = 180 { 0xaec1bd87, 0xe85b, 0x48f2, { 0x84, 0xc3, 0x98, 0xbc, 0xa6, 0x28, 0x50, 0x72 } }; 181 182 // {B514C39A-B55B-40fa-878F-F1253B4DFDEC} 183 static const GUID NV_ENC_HEVC_PROFILE_MAIN_GUID = 184 { 0xb514c39a, 0xb55b, 0x40fa, { 0x87, 0x8f, 0xf1, 0x25, 0x3b, 0x4d, 0xfd, 0xec } }; 185 186 // {fa4d2b6c-3a5b-411a-8018-0a3f5e3c9be5} 187 static const GUID NV_ENC_HEVC_PROFILE_MAIN10_GUID = 188 { 0xfa4d2b6c, 0x3a5b, 0x411a, { 0x80, 0x18, 0x0a, 0x3f, 0x5e, 0x3c, 0x9b, 0xe5 } }; 189 190 // For HEVC Main 444 8 bit and HEVC Main 444 10 bit profiles only 191 // {51ec32b5-1b4c-453c-9cbd-b616bd621341} 192 static const GUID NV_ENC_HEVC_PROFILE_FREXT_GUID = 193 { 0x51ec32b5, 0x1b4c, 0x453c, { 0x9c, 0xbd, 0xb6, 0x16, 0xbd, 0x62, 0x13, 0x41 } }; 194 195 // ========================================================================================= 196 // * Preset GUIDS supported by the NvEncodeAPI interface. 197 // ========================================================================================= 198 // {B2DFB705-4EBD-4C49-9B5F-24A777D3E587} 199 static const GUID NV_ENC_PRESET_DEFAULT_GUID = 200 { 0xb2dfb705, 0x4ebd, 0x4c49, { 0x9b, 0x5f, 0x24, 0xa7, 0x77, 0xd3, 0xe5, 0x87 } }; 201 202 // {60E4C59F-E846-4484-A56D-CD45BE9FDDF6} 203 static const GUID NV_ENC_PRESET_HP_GUID = 204 { 0x60e4c59f, 0xe846, 0x4484, { 0xa5, 0x6d, 0xcd, 0x45, 0xbe, 0x9f, 0xdd, 0xf6 } }; 205 206 // {34DBA71D-A77B-4B8F-9C3E-B6D5DA24C012} 207 static const GUID NV_ENC_PRESET_HQ_GUID = 208 { 0x34dba71d, 0xa77b, 0x4b8f, { 0x9c, 0x3e, 0xb6, 0xd5, 0xda, 0x24, 0xc0, 0x12 } }; 209 210 // {82E3E450-BDBB-4e40-989C-82A90DF9EF32} 211 static const GUID NV_ENC_PRESET_BD_GUID = 212 { 0x82e3e450, 0xbdbb, 0x4e40, { 0x98, 0x9c, 0x82, 0xa9, 0xd, 0xf9, 0xef, 0x32 } }; 213 214 // {49DF21C5-6DFA-4feb-9787-6ACC9EFFB726} 215 static const GUID NV_ENC_PRESET_LOW_LATENCY_DEFAULT_GUID = 216 { 0x49df21c5, 0x6dfa, 0x4feb, { 0x97, 0x87, 0x6a, 0xcc, 0x9e, 0xff, 0xb7, 0x26 } }; 217 218 // {C5F733B9-EA97-4cf9-BEC2-BF78A74FD105} 219 static const GUID NV_ENC_PRESET_LOW_LATENCY_HQ_GUID = 220 { 0xc5f733b9, 0xea97, 0x4cf9, { 0xbe, 0xc2, 0xbf, 0x78, 0xa7, 0x4f, 0xd1, 0x5 } }; 221 222 // {67082A44-4BAD-48FA-98EA-93056D150A58} 223 static const GUID NV_ENC_PRESET_LOW_LATENCY_HP_GUID = 224 { 0x67082a44, 0x4bad, 0x48fa, { 0x98, 0xea, 0x93, 0x5, 0x6d, 0x15, 0xa, 0x58 } }; 225 226 // {D5BFB716-C604-44e7-9BB8-DEA5510FC3AC} 227 static const GUID NV_ENC_PRESET_LOSSLESS_DEFAULT_GUID = 228 { 0xd5bfb716, 0xc604, 0x44e7, { 0x9b, 0xb8, 0xde, 0xa5, 0x51, 0xf, 0xc3, 0xac } }; 229 230 // {149998E7-2364-411d-82EF-179888093409} 231 static const GUID NV_ENC_PRESET_LOSSLESS_HP_GUID = 232 { 0x149998e7, 0x2364, 0x411d, { 0x82, 0xef, 0x17, 0x98, 0x88, 0x9, 0x34, 0x9 } }; 233 234 /** 235 * \addtogroup ENCODER_STRUCTURE NvEncodeAPI Data structures 236 * @{ 237 */ 238 239 /** 240 * Input frame encode modes 241 */ 242 typedef enum _NV_ENC_PARAMS_FRAME_FIELD_MODE 243 { 244 NV_ENC_PARAMS_FRAME_FIELD_MODE_FRAME = 0x01, /**< Frame mode */ 245 NV_ENC_PARAMS_FRAME_FIELD_MODE_FIELD = 0x02, /**< Field mode */ 246 NV_ENC_PARAMS_FRAME_FIELD_MODE_MBAFF = 0x03 /**< MB adaptive frame/field */ 247 } NV_ENC_PARAMS_FRAME_FIELD_MODE; 248 249 /** 250 * Rate Control Modes 251 */ 252 typedef enum _NV_ENC_PARAMS_RC_MODE 253 { 254 NV_ENC_PARAMS_RC_CONSTQP = 0x0, /**< Constant QP mode */ 255 NV_ENC_PARAMS_RC_VBR = 0x1, /**< Variable bitrate mode */ 256 NV_ENC_PARAMS_RC_CBR = 0x2, /**< Constant bitrate mode */ 257 NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ = 0x8, /**< low-delay CBR, high quality */ 258 NV_ENC_PARAMS_RC_CBR_HQ = 0x10, /**< CBR, high quality (slower) */ 259 NV_ENC_PARAMS_RC_VBR_HQ = 0x20 /**< VBR, high quality (slower) */ 260 } NV_ENC_PARAMS_RC_MODE; 261 262 /** 263 * Emphasis Levels 264 */ 265 typedef enum _NV_ENC_EMPHASIS_MAP_LEVEL 266 { 267 NV_ENC_EMPHASIS_MAP_LEVEL_0 = 0x0, /**< Emphasis Map Level 0, for zero Delta QP value */ 268 NV_ENC_EMPHASIS_MAP_LEVEL_1 = 0x1, /**< Emphasis Map Level 1, for very low Delta QP value */ 269 NV_ENC_EMPHASIS_MAP_LEVEL_2 = 0x2, /**< Emphasis Map Level 2, for low Delta QP value */ 270 NV_ENC_EMPHASIS_MAP_LEVEL_3 = 0x3, /**< Emphasis Map Level 3, for medium Delta QP value */ 271 NV_ENC_EMPHASIS_MAP_LEVEL_4 = 0x4, /**< Emphasis Map Level 4, for high Delta QP value */ 272 NV_ENC_EMPHASIS_MAP_LEVEL_5 = 0x5 /**< Emphasis Map Level 5, for very high Delta QP value */ 273 } NV_ENC_EMPHASIS_MAP_LEVEL; 274 275 /** 276 * QP MAP MODE 277 */ 278 typedef enum _NV_ENC_QP_MAP_MODE 279 { 280 NV_ENC_QP_MAP_DISABLED = 0x0, /**< Value in NV_ENC_PIC_PARAMS::qpDeltaMap have no effect. */ 281 NV_ENC_QP_MAP_EMPHASIS = 0x1, /**< Value in NV_ENC_PIC_PARAMS::qpDeltaMap will be treated as Empasis level. Currently this is only supported for H264 */ 282 NV_ENC_QP_MAP_DELTA = 0x2, /**< Value in NV_ENC_PIC_PARAMS::qpDeltaMap will be treated as QP delta map. */ 283 NV_ENC_QP_MAP = 0x3, /**< Currently This is not supported. Value in NV_ENC_PIC_PARAMS::qpDeltaMap will be treated as QP value. */ 284 } NV_ENC_QP_MAP_MODE; 285 286 #define NV_ENC_PARAMS_RC_VBR_MINQP (NV_ENC_PARAMS_RC_MODE)0x4 /**< Deprecated */ 287 #define NV_ENC_PARAMS_RC_2_PASS_QUALITY NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ /**< Deprecated */ 288 #define NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP NV_ENC_PARAMS_RC_CBR_HQ /**< Deprecated */ 289 #define NV_ENC_PARAMS_RC_2_PASS_VBR NV_ENC_PARAMS_RC_VBR_HQ /**< Deprecated */ 290 #define NV_ENC_PARAMS_RC_CBR2 NV_ENC_PARAMS_RC_CBR /**< Deprecated */ 291 292 /** 293 * Input picture structure 294 */ 295 typedef enum _NV_ENC_PIC_STRUCT 296 { 297 NV_ENC_PIC_STRUCT_FRAME = 0x01, /**< Progressive frame */ 298 NV_ENC_PIC_STRUCT_FIELD_TOP_BOTTOM = 0x02, /**< Field encoding top field first */ 299 NV_ENC_PIC_STRUCT_FIELD_BOTTOM_TOP = 0x03 /**< Field encoding bottom field first */ 300 } NV_ENC_PIC_STRUCT; 301 302 /** 303 * Input picture type 304 */ 305 typedef enum _NV_ENC_PIC_TYPE 306 { 307 NV_ENC_PIC_TYPE_P = 0x0, /**< Forward predicted */ 308 NV_ENC_PIC_TYPE_B = 0x01, /**< Bi-directionally predicted picture */ 309 NV_ENC_PIC_TYPE_I = 0x02, /**< Intra predicted picture */ 310 NV_ENC_PIC_TYPE_IDR = 0x03, /**< IDR picture */ 311 NV_ENC_PIC_TYPE_BI = 0x04, /**< Bi-directionally predicted with only Intra MBs */ 312 NV_ENC_PIC_TYPE_SKIPPED = 0x05, /**< Picture is skipped */ 313 NV_ENC_PIC_TYPE_INTRA_REFRESH = 0x06, /**< First picture in intra refresh cycle */ 314 NV_ENC_PIC_TYPE_NONREF_P = 0x07, /**< Non reference P picture */ 315 NV_ENC_PIC_TYPE_UNKNOWN = 0xFF /**< Picture type unknown */ 316 } NV_ENC_PIC_TYPE; 317 318 /** 319 * Motion vector precisions 320 */ 321 typedef enum _NV_ENC_MV_PRECISION 322 { 323 NV_ENC_MV_PRECISION_DEFAULT = 0x0, /**<Driver selects QuarterPel motion vector precision by default*/ 324 NV_ENC_MV_PRECISION_FULL_PEL = 0x01, /**< FullPel motion vector precision */ 325 NV_ENC_MV_PRECISION_HALF_PEL = 0x02, /**< HalfPel motion vector precision */ 326 NV_ENC_MV_PRECISION_QUARTER_PEL = 0x03 /**< QuarterPel motion vector precision */ 327 } NV_ENC_MV_PRECISION; 328 329 330 /** 331 * Input buffer formats 332 */ 333 typedef enum _NV_ENC_BUFFER_FORMAT 334 { 335 NV_ENC_BUFFER_FORMAT_UNDEFINED = 0x00000000, /**< Undefined buffer format */ 336 337 NV_ENC_BUFFER_FORMAT_NV12 = 0x00000001, /**< Semi-Planar YUV [Y plane followed by interleaved UV plane] */ 338 NV_ENC_BUFFER_FORMAT_YV12 = 0x00000010, /**< Planar YUV [Y plane followed by V and U planes] */ 339 NV_ENC_BUFFER_FORMAT_IYUV = 0x00000100, /**< Planar YUV [Y plane followed by U and V planes] */ 340 NV_ENC_BUFFER_FORMAT_YUV444 = 0x00001000, /**< Planar YUV [Y plane followed by U and V planes] */ 341 NV_ENC_BUFFER_FORMAT_YUV420_10BIT = 0x00010000, /**< 10 bit Semi-Planar YUV [Y plane followed by interleaved UV plane]. Each pixel of size 2 bytes. Most Significant 10 bits contain pixel data. */ 342 NV_ENC_BUFFER_FORMAT_YUV444_10BIT = 0x00100000, /**< 10 bit Planar YUV444 [Y plane followed by U and V planes]. Each pixel of size 2 bytes. Most Significant 10 bits contain pixel data. */ 343 NV_ENC_BUFFER_FORMAT_ARGB = 0x01000000, /**< 8 bit Packed A8R8G8B8. This is a word-ordered format 344 where a pixel is represented by a 32-bit word with B 345 in the lowest 8 bits, G in the next 8 bits, R in the 346 8 bits after that and A in the highest 8 bits. */ 347 NV_ENC_BUFFER_FORMAT_ARGB10 = 0x02000000, /**< 10 bit Packed A2R10G10B10. This is a word-ordered format 348 where a pixel is represented by a 32-bit word with B 349 in the lowest 10 bits, G in the next 10 bits, R in the 350 10 bits after that and A in the highest 2 bits. */ 351 NV_ENC_BUFFER_FORMAT_AYUV = 0x04000000, /**< 8 bit Packed A8Y8U8V8. This is a word-ordered format 352 where a pixel is represented by a 32-bit word with V 353 in the lowest 8 bits, U in the next 8 bits, Y in the 354 8 bits after that and A in the highest 8 bits. */ 355 NV_ENC_BUFFER_FORMAT_ABGR = 0x10000000, /**< 8 bit Packed A8B8G8R8. This is a word-ordered format 356 where a pixel is represented by a 32-bit word with R 357 in the lowest 8 bits, G in the next 8 bits, B in the 358 8 bits after that and A in the highest 8 bits. */ 359 NV_ENC_BUFFER_FORMAT_ABGR10 = 0x20000000, /**< 10 bit Packed A2B10G10R10. This is a word-ordered format 360 where a pixel is represented by a 32-bit word with R 361 in the lowest 10 bits, G in the next 10 bits, B in the 362 10 bits after that and A in the highest 2 bits. */ 363 NV_ENC_BUFFER_FORMAT_U8 = 0x40000000, /**< Buffer format representing one-dimensional buffer. 364 This format should be used only when registering the 365 resource as output buffer, which will be used to write 366 the encoded bit stream or H.264 ME only mode output. */ 367 } NV_ENC_BUFFER_FORMAT; 368 369 #define NV_ENC_BUFFER_FORMAT_NV12_PL NV_ENC_BUFFER_FORMAT_NV12 370 #define NV_ENC_BUFFER_FORMAT_YV12_PL NV_ENC_BUFFER_FORMAT_YV12 371 #define NV_ENC_BUFFER_FORMAT_IYUV_PL NV_ENC_BUFFER_FORMAT_IYUV 372 #define NV_ENC_BUFFER_FORMAT_YUV444_PL NV_ENC_BUFFER_FORMAT_YUV444 373 374 /** 375 * Encoding levels 376 */ 377 typedef enum _NV_ENC_LEVEL 378 { 379 NV_ENC_LEVEL_AUTOSELECT = 0, 380 381 NV_ENC_LEVEL_H264_1 = 10, 382 NV_ENC_LEVEL_H264_1b = 9, 383 NV_ENC_LEVEL_H264_11 = 11, 384 NV_ENC_LEVEL_H264_12 = 12, 385 NV_ENC_LEVEL_H264_13 = 13, 386 NV_ENC_LEVEL_H264_2 = 20, 387 NV_ENC_LEVEL_H264_21 = 21, 388 NV_ENC_LEVEL_H264_22 = 22, 389 NV_ENC_LEVEL_H264_3 = 30, 390 NV_ENC_LEVEL_H264_31 = 31, 391 NV_ENC_LEVEL_H264_32 = 32, 392 NV_ENC_LEVEL_H264_4 = 40, 393 NV_ENC_LEVEL_H264_41 = 41, 394 NV_ENC_LEVEL_H264_42 = 42, 395 NV_ENC_LEVEL_H264_5 = 50, 396 NV_ENC_LEVEL_H264_51 = 51, 397 NV_ENC_LEVEL_H264_52 = 52, 398 399 400 NV_ENC_LEVEL_HEVC_1 = 30, 401 NV_ENC_LEVEL_HEVC_2 = 60, 402 NV_ENC_LEVEL_HEVC_21 = 63, 403 NV_ENC_LEVEL_HEVC_3 = 90, 404 NV_ENC_LEVEL_HEVC_31 = 93, 405 NV_ENC_LEVEL_HEVC_4 = 120, 406 NV_ENC_LEVEL_HEVC_41 = 123, 407 NV_ENC_LEVEL_HEVC_5 = 150, 408 NV_ENC_LEVEL_HEVC_51 = 153, 409 NV_ENC_LEVEL_HEVC_52 = 156, 410 NV_ENC_LEVEL_HEVC_6 = 180, 411 NV_ENC_LEVEL_HEVC_61 = 183, 412 NV_ENC_LEVEL_HEVC_62 = 186, 413 414 NV_ENC_TIER_HEVC_MAIN = 0, 415 NV_ENC_TIER_HEVC_HIGH = 1 416 } NV_ENC_LEVEL; 417 418 /** 419 * Error Codes 420 */ 421 typedef enum _NVENCSTATUS 422 { 423 /** 424 * This indicates that API call returned with no errors. 425 */ 426 NV_ENC_SUCCESS, 427 428 /** 429 * This indicates that no encode capable devices were detected. 430 */ 431 NV_ENC_ERR_NO_ENCODE_DEVICE, 432 433 /** 434 * This indicates that devices pass by the client is not supported. 435 */ 436 NV_ENC_ERR_UNSUPPORTED_DEVICE, 437 438 /** 439 * This indicates that the encoder device supplied by the client is not 440 * valid. 441 */ 442 NV_ENC_ERR_INVALID_ENCODERDEVICE, 443 444 /** 445 * This indicates that device passed to the API call is invalid. 446 */ 447 NV_ENC_ERR_INVALID_DEVICE, 448 449 /** 450 * This indicates that device passed to the API call is no longer available and 451 * needs to be reinitialized. The clients need to destroy the current encoder 452 * session by freeing the allocated input output buffers and destroying the device 453 * and create a new encoding session. 454 */ 455 NV_ENC_ERR_DEVICE_NOT_EXIST, 456 457 /** 458 * This indicates that one or more of the pointers passed to the API call 459 * is invalid. 460 */ 461 NV_ENC_ERR_INVALID_PTR, 462 463 /** 464 * This indicates that completion event passed in ::NvEncEncodePicture() call 465 * is invalid. 466 */ 467 NV_ENC_ERR_INVALID_EVENT, 468 469 /** 470 * This indicates that one or more of the parameter passed to the API call 471 * is invalid. 472 */ 473 NV_ENC_ERR_INVALID_PARAM, 474 475 /** 476 * This indicates that an API call was made in wrong sequence/order. 477 */ 478 NV_ENC_ERR_INVALID_CALL, 479 480 /** 481 * This indicates that the API call failed because it was unable to allocate 482 * enough memory to perform the requested operation. 483 */ 484 NV_ENC_ERR_OUT_OF_MEMORY, 485 486 /** 487 * This indicates that the encoder has not been initialized with 488 * ::NvEncInitializeEncoder() or that initialization has failed. 489 * The client cannot allocate input or output buffers or do any encoding 490 * related operation before successfully initializing the encoder. 491 */ 492 NV_ENC_ERR_ENCODER_NOT_INITIALIZED, 493 494 /** 495 * This indicates that an unsupported parameter was passed by the client. 496 */ 497 NV_ENC_ERR_UNSUPPORTED_PARAM, 498 499 /** 500 * This indicates that the ::NvEncLockBitstream() failed to lock the output 501 * buffer. This happens when the client makes a non blocking lock call to 502 * access the output bitstream by passing NV_ENC_LOCK_BITSTREAM::doNotWait flag. 503 * This is not a fatal error and client should retry the same operation after 504 * few milliseconds. 505 */ 506 NV_ENC_ERR_LOCK_BUSY, 507 508 /** 509 * This indicates that the size of the user buffer passed by the client is 510 * insufficient for the requested operation. 511 */ 512 NV_ENC_ERR_NOT_ENOUGH_BUFFER, 513 514 /** 515 * This indicates that an invalid struct version was used by the client. 516 */ 517 NV_ENC_ERR_INVALID_VERSION, 518 519 /** 520 * This indicates that ::NvEncMapInputResource() API failed to map the client 521 * provided input resource. 522 */ 523 NV_ENC_ERR_MAP_FAILED, 524 525 /** 526 * This indicates encode driver requires more input buffers to produce an output 527 * bitstream. If this error is returned from ::NvEncEncodePicture() API, this 528 * is not a fatal error. If the client is encoding with B frames then, 529 * ::NvEncEncodePicture() API might be buffering the input frame for re-ordering. 530 * 531 * A client operating in synchronous mode cannot call ::NvEncLockBitstream() 532 * API on the output bitstream buffer if ::NvEncEncodePicture() returned the 533 * ::NV_ENC_ERR_NEED_MORE_INPUT error code. 534 * The client must continue providing input frames until encode driver returns 535 * ::NV_ENC_SUCCESS. After receiving ::NV_ENC_SUCCESS status the client can call 536 * ::NvEncLockBitstream() API on the output buffers in the same order in which 537 * it has called ::NvEncEncodePicture(). 538 */ 539 NV_ENC_ERR_NEED_MORE_INPUT, 540 541 /** 542 * This indicates that the HW encoder is busy encoding and is unable to encode 543 * the input. The client should call ::NvEncEncodePicture() again after few 544 * milliseconds. 545 */ 546 NV_ENC_ERR_ENCODER_BUSY, 547 548 /** 549 * This indicates that the completion event passed in ::NvEncEncodePicture() 550 * API has not been registered with encoder driver using ::NvEncRegisterAsyncEvent(). 551 */ 552 NV_ENC_ERR_EVENT_NOT_REGISTERD, 553 554 /** 555 * This indicates that an unknown internal error has occurred. 556 */ 557 NV_ENC_ERR_GENERIC, 558 559 /** 560 * This indicates that the client is attempting to use a feature 561 * that is not available for the license type for the current system. 562 */ 563 NV_ENC_ERR_INCOMPATIBLE_CLIENT_KEY, 564 565 /** 566 * This indicates that the client is attempting to use a feature 567 * that is not implemented for the current version. 568 */ 569 NV_ENC_ERR_UNIMPLEMENTED, 570 571 /** 572 * This indicates that the ::NvEncRegisterResource API failed to register the resource. 573 */ 574 NV_ENC_ERR_RESOURCE_REGISTER_FAILED, 575 576 /** 577 * This indicates that the client is attempting to unregister a resource 578 * that has not been successfully registered. 579 */ 580 NV_ENC_ERR_RESOURCE_NOT_REGISTERED, 581 582 /** 583 * This indicates that the client is attempting to unmap a resource 584 * that has not been successfully mapped. 585 */ 586 NV_ENC_ERR_RESOURCE_NOT_MAPPED, 587 588 } NVENCSTATUS; 589 590 /** 591 * Encode Picture encode flags. 592 */ 593 typedef enum _NV_ENC_PIC_FLAGS 594 { 595 NV_ENC_PIC_FLAG_FORCEINTRA = 0x1, /**< Encode the current picture as an Intra picture */ 596 NV_ENC_PIC_FLAG_FORCEIDR = 0x2, /**< Encode the current picture as an IDR picture. 597 This flag is only valid when Picture type decision is taken by the Encoder 598 [_NV_ENC_INITIALIZE_PARAMS::enablePTD == 1]. */ 599 NV_ENC_PIC_FLAG_OUTPUT_SPSPPS = 0x4, /**< Write the sequence and picture header in encoded bitstream of the current picture */ 600 NV_ENC_PIC_FLAG_EOS = 0x8, /**< Indicates end of the input stream */ 601 } NV_ENC_PIC_FLAGS; 602 603 /** 604 * Memory heap to allocate input and output buffers. 605 */ 606 typedef enum _NV_ENC_MEMORY_HEAP 607 { 608 NV_ENC_MEMORY_HEAP_AUTOSELECT = 0, /**< Memory heap to be decided by the encoder driver based on the usage */ 609 NV_ENC_MEMORY_HEAP_VID = 1, /**< Memory heap is in local video memory */ 610 NV_ENC_MEMORY_HEAP_SYSMEM_CACHED = 2, /**< Memory heap is in cached system memory */ 611 NV_ENC_MEMORY_HEAP_SYSMEM_UNCACHED = 3 /**< Memory heap is in uncached system memory */ 612 } NV_ENC_MEMORY_HEAP; 613 614 /** 615 * B-frame used as reference modes 616 */ 617 typedef enum _NV_ENC_BFRAME_REF_MODE 618 { 619 NV_ENC_BFRAME_REF_MODE_DISABLED = 0x0, /**< B frame is not used for reference */ 620 NV_ENC_BFRAME_REF_MODE_EACH = 0x1, /**< Each B-frame will be used for reference. currently not supported for H.264 */ 621 NV_ENC_BFRAME_REF_MODE_MIDDLE = 0x2, /**< Only(Number of B-frame)/2 th B-frame will be used for reference */ 622 } NV_ENC_BFRAME_REF_MODE; 623 624 /** 625 * H.264 entropy coding modes. 626 */ 627 typedef enum _NV_ENC_H264_ENTROPY_CODING_MODE 628 { 629 NV_ENC_H264_ENTROPY_CODING_MODE_AUTOSELECT = 0x0, /**< Entropy coding mode is auto selected by the encoder driver */ 630 NV_ENC_H264_ENTROPY_CODING_MODE_CABAC = 0x1, /**< Entropy coding mode is CABAC */ 631 NV_ENC_H264_ENTROPY_CODING_MODE_CAVLC = 0x2 /**< Entropy coding mode is CAVLC */ 632 } NV_ENC_H264_ENTROPY_CODING_MODE; 633 634 /** 635 * H.264 specific Bdirect modes 636 */ 637 typedef enum _NV_ENC_H264_BDIRECT_MODE 638 { 639 NV_ENC_H264_BDIRECT_MODE_AUTOSELECT = 0x0, /**< BDirect mode is auto selected by the encoder driver */ 640 NV_ENC_H264_BDIRECT_MODE_DISABLE = 0x1, /**< Disable BDirect mode */ 641 NV_ENC_H264_BDIRECT_MODE_TEMPORAL = 0x2, /**< Temporal BDirect mode */ 642 NV_ENC_H264_BDIRECT_MODE_SPATIAL = 0x3 /**< Spatial BDirect mode */ 643 } NV_ENC_H264_BDIRECT_MODE; 644 645 /** 646 * H.264 specific FMO usage 647 */ 648 typedef enum _NV_ENC_H264_FMO_MODE 649 { 650 NV_ENC_H264_FMO_AUTOSELECT = 0x0, /**< FMO usage is auto selected by the encoder driver */ 651 NV_ENC_H264_FMO_ENABLE = 0x1, /**< Enable FMO */ 652 NV_ENC_H264_FMO_DISABLE = 0x2, /**< Disble FMO */ 653 } NV_ENC_H264_FMO_MODE; 654 655 /** 656 * H.264 specific Adaptive Transform modes 657 */ 658 typedef enum _NV_ENC_H264_ADAPTIVE_TRANSFORM_MODE 659 { 660 NV_ENC_H264_ADAPTIVE_TRANSFORM_AUTOSELECT = 0x0, /**< Adaptive Transform 8x8 mode is auto selected by the encoder driver*/ 661 NV_ENC_H264_ADAPTIVE_TRANSFORM_DISABLE = 0x1, /**< Adaptive Transform 8x8 mode disabled */ 662 NV_ENC_H264_ADAPTIVE_TRANSFORM_ENABLE = 0x2, /**< Adaptive Transform 8x8 mode should be used */ 663 } NV_ENC_H264_ADAPTIVE_TRANSFORM_MODE; 664 665 /** 666 * Stereo frame packing modes. 667 */ 668 typedef enum _NV_ENC_STEREO_PACKING_MODE 669 { 670 NV_ENC_STEREO_PACKING_MODE_NONE = 0x0, /**< No Stereo packing required */ 671 NV_ENC_STEREO_PACKING_MODE_CHECKERBOARD = 0x1, /**< Checkerboard mode for packing stereo frames */ 672 NV_ENC_STEREO_PACKING_MODE_COLINTERLEAVE = 0x2, /**< Column Interleave mode for packing stereo frames */ 673 NV_ENC_STEREO_PACKING_MODE_ROWINTERLEAVE = 0x3, /**< Row Interleave mode for packing stereo frames */ 674 NV_ENC_STEREO_PACKING_MODE_SIDEBYSIDE = 0x4, /**< Side-by-side mode for packing stereo frames */ 675 NV_ENC_STEREO_PACKING_MODE_TOPBOTTOM = 0x5, /**< Top-Bottom mode for packing stereo frames */ 676 NV_ENC_STEREO_PACKING_MODE_FRAMESEQ = 0x6 /**< Frame Sequential mode for packing stereo frames */ 677 } NV_ENC_STEREO_PACKING_MODE; 678 679 /** 680 * Input Resource type 681 */ 682 typedef enum _NV_ENC_INPUT_RESOURCE_TYPE 683 { 684 NV_ENC_INPUT_RESOURCE_TYPE_DIRECTX = 0x0, /**< input resource type is a directx9 surface*/ 685 NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR = 0x1, /**< input resource type is a cuda device pointer surface*/ 686 NV_ENC_INPUT_RESOURCE_TYPE_CUDAARRAY = 0x2, /**< input resource type is a cuda array surface. 687 This array must be a 2D array and the CUDA_ARRAY3D_SURFACE_LDST 688 flag must have been specified when creating it. */ 689 NV_ENC_INPUT_RESOURCE_TYPE_OPENGL_TEX = 0x3 /**< input resource type is an OpenGL texture */ 690 } NV_ENC_INPUT_RESOURCE_TYPE; 691 692 /** 693 * Buffer usage 694 */ 695 typedef enum _NV_ENC_BUFFER_USAGE 696 { 697 NV_ENC_INPUT_IMAGE = 0x0, /**< Registered surface will be used for input image */ 698 NV_ENC_OUTPUT_MOTION_VECTOR = 0x1, /**< Registered surface will be used for output of H.264 ME only mode. 699 This buffer usage type is not supported for HEVC ME only mode. */ 700 NV_ENC_OUTPUT_BITSTREAM = 0x2 /**< Registered surface will be used for output bitstream in encoding */ 701 } NV_ENC_BUFFER_USAGE; 702 703 /** 704 * Encoder Device type 705 */ 706 typedef enum _NV_ENC_DEVICE_TYPE 707 { 708 NV_ENC_DEVICE_TYPE_DIRECTX = 0x0, /**< encode device type is a directx9 device */ 709 NV_ENC_DEVICE_TYPE_CUDA = 0x1, /**< encode device type is a cuda device */ 710 NV_ENC_DEVICE_TYPE_OPENGL = 0x2 /**< encode device type is an OpenGL device. 711 Use of this device type is supported only on Linux */ 712 } NV_ENC_DEVICE_TYPE; 713 714 /** 715 * Number of reference frames 716 */ 717 typedef enum _NV_ENC_NUM_REF_FRAMES 718 { 719 NV_ENC_NUM_REF_FRAMES_AUTOSELECT = 0x0, /**< Number of reference frames is auto selected by the encoder driver */ 720 NV_ENC_NUM_REF_FRAMES_1 = 0x1, /**< Number of reference frames equal to 1 */ 721 NV_ENC_NUM_REF_FRAMES_2 = 0x2, /**< Number of reference frames equal to 2 */ 722 NV_ENC_NUM_REF_FRAMES_3 = 0x3, /**< Number of reference frames equal to 3 */ 723 NV_ENC_NUM_REF_FRAMES_4 = 0x4, /**< Number of reference frames equal to 4 */ 724 NV_ENC_NUM_REF_FRAMES_5 = 0x5, /**< Number of reference frames equal to 5 */ 725 NV_ENC_NUM_REF_FRAMES_6 = 0x6, /**< Number of reference frames equal to 6 */ 726 NV_ENC_NUM_REF_FRAMES_7 = 0x7 /**< Number of reference frames equal to 7 */ 727 } NV_ENC_NUM_REF_FRAMES; 728 729 /** 730 * Encoder capabilities enumeration. 731 */ 732 typedef enum _NV_ENC_CAPS 733 { 734 /** 735 * Maximum number of B-Frames supported. 736 */ 737 NV_ENC_CAPS_NUM_MAX_BFRAMES, 738 739 /** 740 * Rate control modes supported. 741 * \n The API return value is a bitmask of the values in NV_ENC_PARAMS_RC_MODE. 742 */ 743 NV_ENC_CAPS_SUPPORTED_RATECONTROL_MODES, 744 745 /** 746 * Indicates HW support for field mode encoding. 747 * \n 0 : Interlaced mode encoding is not supported. 748 * \n 1 : Interlaced field mode encoding is supported. 749 * \n 2 : Interlaced frame encoding and field mode encoding are both supported. 750 */ 751 NV_ENC_CAPS_SUPPORT_FIELD_ENCODING, 752 753 /** 754 * Indicates HW support for monochrome mode encoding. 755 * \n 0 : Monochrome mode not supported. 756 * \n 1 : Monochrome mode supported. 757 */ 758 NV_ENC_CAPS_SUPPORT_MONOCHROME, 759 760 /** 761 * Indicates HW support for FMO. 762 * \n 0 : FMO not supported. 763 * \n 1 : FMO supported. 764 */ 765 NV_ENC_CAPS_SUPPORT_FMO, 766 767 /** 768 * Indicates HW capability for Quarter pel motion estimation. 769 * \n 0 : QuarterPel Motion Estimation not supported. 770 * \n 1 : QuarterPel Motion Estimation supported. 771 */ 772 NV_ENC_CAPS_SUPPORT_QPELMV, 773 774 /** 775 * H.264 specific. Indicates HW support for BDirect modes. 776 * \n 0 : BDirect mode encoding not supported. 777 * \n 1 : BDirect mode encoding supported. 778 */ 779 NV_ENC_CAPS_SUPPORT_BDIRECT_MODE, 780 781 /** 782 * H264 specific. Indicates HW support for CABAC entropy coding mode. 783 * \n 0 : CABAC entropy coding not supported. 784 * \n 1 : CABAC entropy coding supported. 785 */ 786 NV_ENC_CAPS_SUPPORT_CABAC, 787 788 /** 789 * Indicates HW support for Adaptive Transform. 790 * \n 0 : Adaptive Transform not supported. 791 * \n 1 : Adaptive Transform supported. 792 */ 793 NV_ENC_CAPS_SUPPORT_ADAPTIVE_TRANSFORM, 794 795 /** 796 * Indicates HW support for Multi View Coding. 797 * \n 0 : Multi View Coding not supported. 798 * \n 1 : Multi View Coding supported. 799 */ 800 NV_ENC_CAPS_SUPPORT_STEREO_MVC, 801 802 /** 803 * Indicates HW support for encoding Temporal layers. 804 * \n 0 : Encoding Temporal layers not supported. 805 * \n 1 : Encoding Temporal layers supported. 806 */ 807 NV_ENC_CAPS_NUM_MAX_TEMPORAL_LAYERS, 808 809 /** 810 * Indicates HW support for Hierarchical P frames. 811 * \n 0 : Hierarchical P frames not supported. 812 * \n 1 : Hierarchical P frames supported. 813 */ 814 NV_ENC_CAPS_SUPPORT_HIERARCHICAL_PFRAMES, 815 816 /** 817 * Indicates HW support for Hierarchical B frames. 818 * \n 0 : Hierarchical B frames not supported. 819 * \n 1 : Hierarchical B frames supported. 820 */ 821 NV_ENC_CAPS_SUPPORT_HIERARCHICAL_BFRAMES, 822 823 /** 824 * Maximum Encoding level supported (See ::NV_ENC_LEVEL for details). 825 */ 826 NV_ENC_CAPS_LEVEL_MAX, 827 828 /** 829 * Minimum Encoding level supported (See ::NV_ENC_LEVEL for details). 830 */ 831 NV_ENC_CAPS_LEVEL_MIN, 832 833 /** 834 * Indicates HW support for separate colour plane encoding. 835 * \n 0 : Separate colour plane encoding not supported. 836 * \n 1 : Separate colour plane encoding supported. 837 */ 838 NV_ENC_CAPS_SEPARATE_COLOUR_PLANE, 839 840 /** 841 * Maximum output width supported. 842 */ 843 NV_ENC_CAPS_WIDTH_MAX, 844 845 /** 846 * Maximum output height supported. 847 */ 848 NV_ENC_CAPS_HEIGHT_MAX, 849 850 /** 851 * Indicates Temporal Scalability Support. 852 * \n 0 : Temporal SVC encoding not supported. 853 * \n 1 : Temporal SVC encoding supported. 854 */ 855 NV_ENC_CAPS_SUPPORT_TEMPORAL_SVC, 856 857 /** 858 * Indicates Dynamic Encode Resolution Change Support. 859 * Support added from NvEncodeAPI version 2.0. 860 * \n 0 : Dynamic Encode Resolution Change not supported. 861 * \n 1 : Dynamic Encode Resolution Change supported. 862 */ 863 NV_ENC_CAPS_SUPPORT_DYN_RES_CHANGE, 864 865 /** 866 * Indicates Dynamic Encode Bitrate Change Support. 867 * Support added from NvEncodeAPI version 2.0. 868 * \n 0 : Dynamic Encode bitrate change not supported. 869 * \n 1 : Dynamic Encode bitrate change supported. 870 */ 871 NV_ENC_CAPS_SUPPORT_DYN_BITRATE_CHANGE, 872 873 /** 874 * Indicates Forcing Constant QP On The Fly Support. 875 * Support added from NvEncodeAPI version 2.0. 876 * \n 0 : Forcing constant QP on the fly not supported. 877 * \n 1 : Forcing constant QP on the fly supported. 878 */ 879 NV_ENC_CAPS_SUPPORT_DYN_FORCE_CONSTQP, 880 881 /** 882 * Indicates Dynamic rate control mode Change Support. 883 * \n 0 : Dynamic rate control mode change not supported. 884 * \n 1 : Dynamic rate control mode change supported. 885 */ 886 NV_ENC_CAPS_SUPPORT_DYN_RCMODE_CHANGE, 887 888 /** 889 * Indicates Subframe readback support for slice-based encoding. 890 * \n 0 : Subframe readback not supported. 891 * \n 1 : Subframe readback supported. 892 */ 893 NV_ENC_CAPS_SUPPORT_SUBFRAME_READBACK, 894 895 /** 896 * Indicates Constrained Encoding mode support. 897 * Support added from NvEncodeAPI version 2.0. 898 * \n 0 : Constrained encoding mode not supported. 899 * \n 1 : Constarined encoding mode supported. 900 * If this mode is supported client can enable this during initialisation. 901 * Client can then force a picture to be coded as constrained picture where 902 * each slice in a constrained picture will have constrained_intra_pred_flag set to 1 903 * and disable_deblocking_filter_idc will be set to 2 and prediction vectors for inter 904 * macroblocks in each slice will be restricted to the slice region. 905 */ 906 NV_ENC_CAPS_SUPPORT_CONSTRAINED_ENCODING, 907 908 /** 909 * Indicates Intra Refresh Mode Support. 910 * Support added from NvEncodeAPI version 2.0. 911 * \n 0 : Intra Refresh Mode not supported. 912 * \n 1 : Intra Refresh Mode supported. 913 */ 914 NV_ENC_CAPS_SUPPORT_INTRA_REFRESH, 915 916 /** 917 * Indicates Custom VBV Bufer Size support. It can be used for capping frame size. 918 * Support added from NvEncodeAPI version 2.0. 919 * \n 0 : Custom VBV buffer size specification from client, not supported. 920 * \n 1 : Custom VBV buffer size specification from client, supported. 921 */ 922 NV_ENC_CAPS_SUPPORT_CUSTOM_VBV_BUF_SIZE, 923 924 /** 925 * Indicates Dynamic Slice Mode Support. 926 * Support added from NvEncodeAPI version 2.0. 927 * \n 0 : Dynamic Slice Mode not supported. 928 * \n 1 : Dynamic Slice Mode supported. 929 */ 930 NV_ENC_CAPS_SUPPORT_DYNAMIC_SLICE_MODE, 931 932 /** 933 * Indicates Reference Picture Invalidation Support. 934 * Support added from NvEncodeAPI version 2.0. 935 * \n 0 : Reference Picture Invalidation not supported. 936 * \n 1 : Reference Picture Invalidation supported. 937 */ 938 NV_ENC_CAPS_SUPPORT_REF_PIC_INVALIDATION, 939 940 /** 941 * Indicates support for PreProcessing. 942 * The API return value is a bitmask of the values defined in ::NV_ENC_PREPROC_FLAGS 943 */ 944 NV_ENC_CAPS_PREPROC_SUPPORT, 945 946 /** 947 * Indicates support Async mode. 948 * \n 0 : Async Encode mode not supported. 949 * \n 1 : Async Encode mode supported. 950 */ 951 NV_ENC_CAPS_ASYNC_ENCODE_SUPPORT, 952 953 /** 954 * Maximum MBs per frame supported. 955 */ 956 NV_ENC_CAPS_MB_NUM_MAX, 957 958 /** 959 * Maximum aggregate throughput in MBs per sec. 960 */ 961 NV_ENC_CAPS_MB_PER_SEC_MAX, 962 963 /** 964 * Indicates HW support for YUV444 mode encoding. 965 * \n 0 : YUV444 mode encoding not supported. 966 * \n 1 : YUV444 mode encoding supported. 967 */ 968 NV_ENC_CAPS_SUPPORT_YUV444_ENCODE, 969 970 /** 971 * Indicates HW support for lossless encoding. 972 * \n 0 : lossless encoding not supported. 973 * \n 1 : lossless encoding supported. 974 */ 975 NV_ENC_CAPS_SUPPORT_LOSSLESS_ENCODE, 976 977 /** 978 * Indicates HW support for Sample Adaptive Offset. 979 * \n 0 : SAO not supported. 980 * \n 1 : SAO encoding supported. 981 */ 982 NV_ENC_CAPS_SUPPORT_SAO, 983 984 /** 985 * Indicates HW support for MEOnly Mode. 986 * \n 0 : MEOnly Mode not supported. 987 * \n 1 : MEOnly Mode supported for I and P frames. 988 * \n 2 : MEOnly Mode supported for I, P and B frames. 989 */ 990 NV_ENC_CAPS_SUPPORT_MEONLY_MODE, 991 992 /** 993 * Indicates HW support for lookahead encoding (enableLookahead=1). 994 * \n 0 : Lookahead not supported. 995 * \n 1 : Lookahead supported. 996 */ 997 NV_ENC_CAPS_SUPPORT_LOOKAHEAD, 998 999 /** 1000 * Indicates HW support for temporal AQ encoding (enableTemporalAQ=1). 1001 * \n 0 : Temporal AQ not supported. 1002 * \n 1 : Temporal AQ supported. 1003 */ 1004 NV_ENC_CAPS_SUPPORT_TEMPORAL_AQ, 1005 /** 1006 * Indicates HW support for 10 bit encoding. 1007 * \n 0 : 10 bit encoding not supported. 1008 * \n 1 : 10 bit encoding supported. 1009 */ 1010 NV_ENC_CAPS_SUPPORT_10BIT_ENCODE, 1011 /** 1012 * Maximum number of Long Term Reference frames supported 1013 */ 1014 NV_ENC_CAPS_NUM_MAX_LTR_FRAMES, 1015 1016 /** 1017 * Indicates HW support for Weighted Predicition. 1018 * \n 0 : Weighted Predicition not supported. 1019 * \n 1 : Weighted Predicition supported. 1020 */ 1021 NV_ENC_CAPS_SUPPORT_WEIGHTED_PREDICTION, 1022 1023 1024 /** 1025 * On managed (vGPU) platforms (Windows only), this API, in conjunction with other GRID Management APIs, can be used 1026 * to estimate the residual capacity of the hardware encoder on the GPU as a percentage of the total available encoder capacity. 1027 * This API can be called at any time; i.e. during the encode session or before opening the encode session. 1028 * If the available encoder capacity is returned as zero, applications may choose to switch to software encoding 1029 * and continue to call this API (e.g. polling once per second) until capacity becomes available. 1030 * 1031 * On baremetal (non-virtualized GPU) and linux platforms, this API always returns 100. 1032 */ 1033 NV_ENC_CAPS_DYNAMIC_QUERY_ENCODER_CAPACITY, 1034 1035 /** 1036 * Indicates B as refererence support. 1037 * \n 0 : B as reference is not supported. 1038 * \n 1 : each B-Frame as reference is supported. 1039 * \n 2 : only Middle B-frame as reference is supported. 1040 */ 1041 NV_ENC_CAPS_SUPPORT_BFRAME_REF_MODE, 1042 1043 /** 1044 * Indicates HW support for Emphasis Level Map based delta QP computation. 1045 * \n 0 : Emphasis Level Map based delta QP not supported. 1046 * \n 1 : Emphasis Level Map based delta QP is supported. 1047 */ 1048 NV_ENC_CAPS_SUPPORT_EMPHASIS_LEVEL_MAP, 1049 1050 /** 1051 * Minimum input width supported. 1052 */ 1053 NV_ENC_CAPS_WIDTH_MIN, 1054 1055 /** 1056 * Minimum input height supported. 1057 */ 1058 NV_ENC_CAPS_HEIGHT_MIN, 1059 1060 /** 1061 * Indicates HW support for multiple reference frames. 1062 */ 1063 NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES, 1064 1065 /** 1066 * Reserved - Not to be used by clients. 1067 */ 1068 NV_ENC_CAPS_EXPOSED_COUNT 1069 } NV_ENC_CAPS; 1070 1071 /** 1072 * HEVC CU SIZE 1073 */ 1074 typedef enum _NV_ENC_HEVC_CUSIZE 1075 { 1076 NV_ENC_HEVC_CUSIZE_AUTOSELECT = 0, 1077 NV_ENC_HEVC_CUSIZE_8x8 = 1, 1078 NV_ENC_HEVC_CUSIZE_16x16 = 2, 1079 NV_ENC_HEVC_CUSIZE_32x32 = 3, 1080 NV_ENC_HEVC_CUSIZE_64x64 = 4, 1081 }NV_ENC_HEVC_CUSIZE; 1082 1083 /** 1084 * Input struct for querying Encoding capabilities. 1085 */ 1086 typedef struct _NV_ENC_CAPS_PARAM 1087 { 1088 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_CAPS_PARAM_VER */ 1089 NV_ENC_CAPS capsToQuery; /**< [in]: Specifies the encode capability to be queried. Client should pass a member for ::NV_ENC_CAPS enum. */ 1090 uint32_t reserved[62]; /**< [in]: Reserved and must be set to 0 */ 1091 } NV_ENC_CAPS_PARAM; 1092 1093 /** NV_ENC_CAPS_PARAM struct version. */ 1094 #define NV_ENC_CAPS_PARAM_VER NVENCAPI_STRUCT_VERSION(1) 1095 1096 1097 /** 1098 * Encoder Output parameters 1099 */ 1100 typedef struct _NV_ENC_ENCODE_OUT_PARAMS 1101 { 1102 uint32_t version; /**< [out]: Struct version. */ 1103 uint32_t bitstreamSizeInBytes; /**< [out]: Encoded bitstream size in bytes */ 1104 uint32_t reserved[62]; /**< [out]: Reserved and must be set to 0 */ 1105 } NV_ENC_ENCODE_OUT_PARAMS; 1106 1107 /** NV_ENC_ENCODE_OUT_PARAMS struct version. */ 1108 #define NV_ENC_ENCODE_OUT_PARAMS_VER NVENCAPI_STRUCT_VERSION(1) 1109 1110 /** 1111 * Creation parameters for input buffer. 1112 */ 1113 typedef struct _NV_ENC_CREATE_INPUT_BUFFER 1114 { 1115 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_CREATE_INPUT_BUFFER_VER */ 1116 uint32_t width; /**< [in]: Input buffer width */ 1117 uint32_t height; /**< [in]: Input buffer width */ 1118 NV_ENC_MEMORY_HEAP memoryHeap; /**< [in]: Deprecated. Do not use */ 1119 NV_ENC_BUFFER_FORMAT bufferFmt; /**< [in]: Input buffer format */ 1120 uint32_t reserved; /**< [in]: Reserved and must be set to 0 */ 1121 NV_ENC_INPUT_PTR inputBuffer; /**< [out]: Pointer to input buffer */ 1122 void* pSysMemBuffer; /**< [in]: Pointer to existing sysmem buffer */ 1123 uint32_t reserved1[57]; /**< [in]: Reserved and must be set to 0 */ 1124 void* reserved2[63]; /**< [in]: Reserved and must be set to NULL */ 1125 } NV_ENC_CREATE_INPUT_BUFFER; 1126 1127 /** NV_ENC_CREATE_INPUT_BUFFER struct version. */ 1128 #define NV_ENC_CREATE_INPUT_BUFFER_VER NVENCAPI_STRUCT_VERSION(1) 1129 1130 /** 1131 * Creation parameters for output bitstream buffer. 1132 */ 1133 typedef struct _NV_ENC_CREATE_BITSTREAM_BUFFER 1134 { 1135 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_CREATE_BITSTREAM_BUFFER_VER */ 1136 uint32_t size; /**< [in]: Deprecated. Do not use */ 1137 NV_ENC_MEMORY_HEAP memoryHeap; /**< [in]: Deprecated. Do not use */ 1138 uint32_t reserved; /**< [in]: Reserved and must be set to 0 */ 1139 NV_ENC_OUTPUT_PTR bitstreamBuffer; /**< [out]: Pointer to the output bitstream buffer */ 1140 void* bitstreamBufferPtr; /**< [out]: Reserved and should not be used */ 1141 uint32_t reserved1[58]; /**< [in]: Reserved and should be set to 0 */ 1142 void* reserved2[64]; /**< [in]: Reserved and should be set to NULL */ 1143 } NV_ENC_CREATE_BITSTREAM_BUFFER; 1144 1145 /** NV_ENC_CREATE_BITSTREAM_BUFFER struct version. */ 1146 #define NV_ENC_CREATE_BITSTREAM_BUFFER_VER NVENCAPI_STRUCT_VERSION(1) 1147 1148 /** 1149 * Structs needed for ME only mode. 1150 */ 1151 typedef struct _NV_ENC_MVECTOR 1152 { 1153 int16_t mvx; /**< the x component of MV in qpel units */ 1154 int16_t mvy; /**< the y component of MV in qpel units */ 1155 } NV_ENC_MVECTOR; 1156 1157 /** 1158 * Motion vector structure per macroblock for H264 motion estimation. 1159 */ 1160 typedef struct _NV_ENC_H264_MV_DATA 1161 { 1162 NV_ENC_MVECTOR mv[4]; /**< up to 4 vectors for 8x8 partition */ 1163 uint8_t mbType; /**< 0 (I), 1 (P), 2 (IPCM), 3 (B) */ 1164 uint8_t partitionType; /**< Specifies the block partition type. 0:16x16, 1:8x8, 2:16x8, 3:8x16 */ 1165 uint16_t reserved; /**< reserved padding for alignment */ 1166 uint32_t mbCost; 1167 } NV_ENC_H264_MV_DATA; 1168 1169 /** 1170 * Motion vector structure per CU for HEVC motion estimation. 1171 */ 1172 typedef struct _NV_ENC_HEVC_MV_DATA 1173 { 1174 NV_ENC_MVECTOR mv[4]; /**< up to 4 vectors within a CU */ 1175 uint8_t cuType; /**< 0 (I), 1(P) */ 1176 uint8_t cuSize; /**< 0: 8x8, 1: 16x16, 2: 32x32, 3: 64x64 */ 1177 uint8_t partitionMode; /**< The CU partition mode 1178 0 (2Nx2N), 1 (2NxN), 2(Nx2N), 3 (NxN), 1179 4 (2NxnU), 5 (2NxnD), 6(nLx2N), 7 (nRx2N) */ 1180 uint8_t lastCUInCTB; /**< Marker to separate CUs in the current CTB from CUs in the next CTB */ 1181 } NV_ENC_HEVC_MV_DATA; 1182 1183 /** 1184 * Creation parameters for output motion vector buffer for ME only mode. 1185 */ 1186 typedef struct _NV_ENC_CREATE_MV_BUFFER 1187 { 1188 uint32_t version; /**< [in]: Struct version. Must be set to NV_ENC_CREATE_MV_BUFFER_VER */ 1189 NV_ENC_OUTPUT_PTR mvBuffer; /**< [out]: Pointer to the output motion vector buffer */ 1190 uint32_t reserved1[255]; /**< [in]: Reserved and should be set to 0 */ 1191 void* reserved2[63]; /**< [in]: Reserved and should be set to NULL */ 1192 } NV_ENC_CREATE_MV_BUFFER; 1193 1194 /** NV_ENC_CREATE_MV_BUFFER struct version*/ 1195 #define NV_ENC_CREATE_MV_BUFFER_VER NVENCAPI_STRUCT_VERSION(1) 1196 1197 /** 1198 * QP value for frames 1199 */ 1200 typedef struct _NV_ENC_QP 1201 { 1202 uint32_t qpInterP; /**< [in]: Specifies QP value for P-frame. Even though this field is uint32_t for legacy reasons, the client should treat this as a signed parameter(int32_t) for cases in which negative QP values are to be specified. */ 1203 uint32_t qpInterB; /**< [in]: Specifies QP value for B-frame. Even though this field is uint32_t for legacy reasons, the client should treat this as a signed parameter(int32_t) for cases in which negative QP values are to be specified. */ 1204 uint32_t qpIntra; /**< [in]: Specifies QP value for Intra Frame. Even though this field is uint32_t for legacy reasons, the client should treat this as a signed parameter(int32_t) for cases in which negative QP values are to be specified. */ 1205 } NV_ENC_QP; 1206 1207 /** 1208 * Rate Control Configuration Paramters 1209 */ 1210 typedef struct _NV_ENC_RC_PARAMS 1211 { 1212 uint32_t version; 1213 NV_ENC_PARAMS_RC_MODE rateControlMode; /**< [in]: Specifies the rate control mode. Check support for various rate control modes using ::NV_ENC_CAPS_SUPPORTED_RATECONTROL_MODES caps. */ 1214 NV_ENC_QP constQP; /**< [in]: Specifies the initial QP to be used for encoding, these values would be used for all frames if in Constant QP mode. */ 1215 uint32_t averageBitRate; /**< [in]: Specifies the average bitrate(in bits/sec) used for encoding. */ 1216 uint32_t maxBitRate; /**< [in]: Specifies the maximum bitrate for the encoded output. This is used for VBR and ignored for CBR mode. */ 1217 uint32_t vbvBufferSize; /**< [in]: Specifies the VBV(HRD) buffer size. in bits. Set 0 to use the default VBV buffer size. */ 1218 uint32_t vbvInitialDelay; /**< [in]: Specifies the VBV(HRD) initial delay in bits. Set 0 to use the default VBV initial delay .*/ 1219 uint32_t enableMinQP :1; /**< [in]: Set this to 1 if minimum QP used for rate control. */ 1220 uint32_t enableMaxQP :1; /**< [in]: Set this to 1 if maximum QP used for rate control. */ 1221 uint32_t enableInitialRCQP :1; /**< [in]: Set this to 1 if user suppplied initial QP is used for rate control. */ 1222 uint32_t enableAQ :1; /**< [in]: Set this to 1 to enable adaptive quantization (Spatial). */ 1223 uint32_t reservedBitField1 :1; /**< [in]: Reserved bitfields and must be set to 0. */ 1224 uint32_t enableLookahead :1; /**< [in]: Set this to 1 to enable lookahead with depth <lookaheadDepth> (if lookahead is enabled, input frames must remain available to the encoder until encode completion) */ 1225 uint32_t disableIadapt :1; /**< [in]: Set this to 1 to disable adaptive I-frame insertion at scene cuts (only has an effect when lookahead is enabled) */ 1226 uint32_t disableBadapt :1; /**< [in]: Set this to 1 to disable adaptive B-frame decision (only has an effect when lookahead is enabled) */ 1227 uint32_t enableTemporalAQ :1; /**< [in]: Set this to 1 to enable temporal AQ */ 1228 uint32_t zeroReorderDelay :1; /**< [in]: Set this to 1 to indicate zero latency operation (no reordering delay, num_reorder_frames=0) */ 1229 uint32_t enableNonRefP :1; /**< [in]: Set this to 1 to enable automatic insertion of non-reference P-frames (no effect if enablePTD=0) */ 1230 uint32_t strictGOPTarget :1; /**< [in]: Set this to 1 to minimize GOP-to-GOP rate fluctuations */ 1231 uint32_t aqStrength :4; /**< [in]: When AQ (Spatial) is enabled (i.e. NV_ENC_RC_PARAMS::enableAQ is set), this field is used to specify AQ strength. AQ strength scale is from 1 (low) - 15 (aggressive). If not set, strength is autoselected by driver. */ 1232 uint32_t reservedBitFields :16; /**< [in]: Reserved bitfields and must be set to 0 */ 1233 NV_ENC_QP minQP; /**< [in]: Specifies the minimum QP used for rate control. Client must set NV_ENC_CONFIG::enableMinQP to 1. */ 1234 NV_ENC_QP maxQP; /**< [in]: Specifies the maximum QP used for rate control. Client must set NV_ENC_CONFIG::enableMaxQP to 1. */ 1235 NV_ENC_QP initialRCQP; /**< [in]: Specifies the initial QP used for rate control. Client must set NV_ENC_CONFIG::enableInitialRCQP to 1. */ 1236 uint32_t temporallayerIdxMask; /**< [in]: Specifies the temporal layers (as a bitmask) whose QPs have changed. Valid max bitmask is [2^NV_ENC_CAPS_NUM_MAX_TEMPORAL_LAYERS - 1] */ 1237 uint8_t temporalLayerQP[8]; /**< [in]: Specifies the temporal layer QPs used for rate control. Temporal layer index is used as as the array index */ 1238 uint8_t targetQuality; /**< [in]: Target CQ (Constant Quality) level for VBR mode (range 0-51 with 0-automatic) */ 1239 uint8_t targetQualityLSB; /**< [in]: Fractional part of target quality (as 8.8 fixed point format) */ 1240 uint16_t lookaheadDepth; /**< [in]: Maximum depth of lookahead with range 0-32 (only used if enableLookahead=1) */ 1241 uint32_t reserved1; 1242 NV_ENC_QP_MAP_MODE qpMapMode; /**< [in]: This flag is used to interpret values in array specified by NV_ENC_PIC_PARAMS::qpDeltaMap. 1243 Set this to NV_ENC_QP_MAP_EMPHASIS to treat values specified by NV_ENC_PIC_PARAMS::qpDeltaMap as Emphasis Level Map. 1244 Emphasis Level can be assigned any value specified in enum NV_ENC_EMPHASIS_MAP_LEVEL. 1245 Emphasis Level Map is used to specify regions to be encoded at varying levels of quality. 1246 The hardware encoder adjusts the quantization within the image as per the provided emphasis map, 1247 by adjusting the quantization parameter (QP) assigned to each macroblock. This adjustment is commonly called “Delta QP”. 1248 The adjustment depends on the absolute QP decided by the rate control algorithm, and is applied after the rate control has decided each macroblock’s QP. 1249 Since the Delta QP overrides rate control, enabling Emphasis Level Map may violate bitrate and VBV buffer size constraints. 1250 Emphasis Level Map is useful in situations where client has a priori knowledge of the image complexity (e.g. via use of NVFBC's Classification feature) and encoding those high-complexity areas at higher quality (lower QP) is important, even at the possible cost of violating bitrate/VBV buffer size constraints 1251 This feature is not supported when AQ( Spatial/Temporal) is enabled. 1252 This feature is only supported for H264 codec currently. 1253 1254 Set this to NV_ENC_QP_MAP_DELTA to treat values specified by NV_ENC_PIC_PARAMS::qpDeltaMap as QPDelta. This specifies QP modifier to be applied on top of the QP chosen by rate control 1255 1256 Set this to NV_ENC_QP_MAP_DISABLED to ignore NV_ENC_PIC_PARAMS::qpDeltaMap values. In this case, qpDeltaMap should be set to NULL. 1257 1258 Other values are reserved for future use.*/ 1259 uint32_t reserved[7]; 1260 } NV_ENC_RC_PARAMS; 1261 1262 /** macro for constructing the version field of ::_NV_ENC_RC_PARAMS */ 1263 #define NV_ENC_RC_PARAMS_VER NVENCAPI_STRUCT_VERSION(1) 1264 1265 1266 1267 /** 1268 * \struct _NV_ENC_CONFIG_H264_VUI_PARAMETERS 1269 * H264 Video Usability Info parameters 1270 */ 1271 typedef struct _NV_ENC_CONFIG_H264_VUI_PARAMETERS 1272 { 1273 uint32_t overscanInfoPresentFlag; /**< [in]: if set to 1 , it specifies that the overscanInfo is present */ 1274 uint32_t overscanInfo; /**< [in]: Specifies the overscan info(as defined in Annex E of the ITU-T Specification). */ 1275 uint32_t videoSignalTypePresentFlag; /**< [in]: If set to 1, it specifies that the videoFormat, videoFullRangeFlag and colourDescriptionPresentFlag are present. */ 1276 uint32_t videoFormat; /**< [in]: Specifies the source video format(as defined in Annex E of the ITU-T Specification).*/ 1277 uint32_t videoFullRangeFlag; /**< [in]: Specifies the output range of the luma and chroma samples(as defined in Annex E of the ITU-T Specification). */ 1278 uint32_t colourDescriptionPresentFlag; /**< [in]: If set to 1, it specifies that the colourPrimaries, transferCharacteristics and colourMatrix are present. */ 1279 uint32_t colourPrimaries; /**< [in]: Specifies color primaries for converting to RGB(as defined in Annex E of the ITU-T Specification) */ 1280 uint32_t transferCharacteristics; /**< [in]: Specifies the opto-electronic transfer characteristics to use (as defined in Annex E of the ITU-T Specification) */ 1281 uint32_t colourMatrix; /**< [in]: Specifies the matrix coefficients used in deriving the luma and chroma from the RGB primaries (as defined in Annex E of the ITU-T Specification). */ 1282 uint32_t chromaSampleLocationFlag; /**< [in]: if set to 1 , it specifies that the chromaSampleLocationTop and chromaSampleLocationBot are present.*/ 1283 uint32_t chromaSampleLocationTop; /**< [in]: Specifies the chroma sample location for top field(as defined in Annex E of the ITU-T Specification) */ 1284 uint32_t chromaSampleLocationBot; /**< [in]: Specifies the chroma sample location for bottom field(as defined in Annex E of the ITU-T Specification) */ 1285 uint32_t bitstreamRestrictionFlag; /**< [in]: if set to 1, it specifies the bitstream restriction parameters are present in the bitstream.*/ 1286 uint32_t reserved[15]; 1287 }NV_ENC_CONFIG_H264_VUI_PARAMETERS; 1288 1289 typedef NV_ENC_CONFIG_H264_VUI_PARAMETERS NV_ENC_CONFIG_HEVC_VUI_PARAMETERS; 1290 1291 /** 1292 * \struct _NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE 1293 * External motion vector hint counts per block type. 1294 * H264 supports multiple hint while HEVC supports one hint for each valid candidate. 1295 */ 1296 typedef struct _NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE 1297 { 1298 uint32_t numCandsPerBlk16x16 : 4; /**< [in]: Supported for H264,HEVC.It Specifies the number of candidates per 16x16 block. */ 1299 uint32_t numCandsPerBlk16x8 : 4; /**< [in]: Supported for H264 only.Specifies the number of candidates per 16x8 block. */ 1300 uint32_t numCandsPerBlk8x16 : 4; /**< [in]: Supported for H264 only.Specifies the number of candidates per 8x16 block. */ 1301 uint32_t numCandsPerBlk8x8 : 4; /**< [in]: Supported for H264,HEVC.Specifies the number of candidates per 8x8 block. */ 1302 uint32_t reserved : 16; /**< [in]: Reserved for padding. */ 1303 uint32_t reserved1[3]; /**< [in]: Reserved for future use. */ 1304 } NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE; 1305 1306 1307 /** 1308 * \struct _NVENC_EXTERNAL_ME_HINT 1309 * External Motion Vector hint structure. 1310 */ 1311 typedef struct _NVENC_EXTERNAL_ME_HINT 1312 { 1313 int32_t mvx : 12; /**< [in]: Specifies the x component of integer pixel MV (relative to current MB) S12.0. */ 1314 int32_t mvy : 10; /**< [in]: Specifies the y component of integer pixel MV (relative to current MB) S10.0 .*/ 1315 int32_t refidx : 5; /**< [in]: Specifies the reference index (31=invalid). Current we support only 1 reference frame per direction for external hints, so \p refidx must be 0. */ 1316 int32_t dir : 1; /**< [in]: Specifies the direction of motion estimation . 0=L0 1=L1.*/ 1317 int32_t partType : 2; /**< [in]: Specifies the block partition type.0=16x16 1=16x8 2=8x16 3=8x8 (blocks in partition must be consecutive).*/ 1318 int32_t lastofPart : 1; /**< [in]: Set to 1 for the last MV of (sub) partition */ 1319 int32_t lastOfMB : 1; /**< [in]: Set to 1 for the last MV of macroblock. */ 1320 } NVENC_EXTERNAL_ME_HINT; 1321 1322 1323 /** 1324 * \struct _NV_ENC_CONFIG_H264 1325 * H264 encoder configuration parameters 1326 */ 1327 typedef struct _NV_ENC_CONFIG_H264 1328 { 1329 uint32_t reserved :1; /**< [in]: Reserved and must be set to 0 */ 1330 uint32_t enableStereoMVC :1; /**< [in]: Set to 1 to enable stereo MVC*/ 1331 uint32_t hierarchicalPFrames :1; /**< [in]: Set to 1 to enable hierarchical PFrames */ 1332 uint32_t hierarchicalBFrames :1; /**< [in]: Set to 1 to enable hierarchical BFrames */ 1333 uint32_t outputBufferingPeriodSEI :1; /**< [in]: Set to 1 to write SEI buffering period syntax in the bitstream */ 1334 uint32_t outputPictureTimingSEI :1; /**< [in]: Set to 1 to write SEI picture timing syntax in the bitstream. When set for following rateControlMode : NV_ENC_PARAMS_RC_CBR, NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ, 1335 NV_ENC_PARAMS_RC_CBR_HQ, filler data is inserted if needed to achieve hrd bitrate */ 1336 uint32_t outputAUD :1; /**< [in]: Set to 1 to write access unit delimiter syntax in bitstream */ 1337 uint32_t disableSPSPPS :1; /**< [in]: Set to 1 to disable writing of Sequence and Picture parameter info in bitstream */ 1338 uint32_t outputFramePackingSEI :1; /**< [in]: Set to 1 to enable writing of frame packing arrangement SEI messages to bitstream */ 1339 uint32_t outputRecoveryPointSEI :1; /**< [in]: Set to 1 to enable writing of recovery point SEI message */ 1340 uint32_t enableIntraRefresh :1; /**< [in]: Set to 1 to enable gradual decoder refresh or intra refresh. If the GOP structure uses B frames this will be ignored */ 1341 uint32_t enableConstrainedEncoding :1; /**< [in]: Set this to 1 to enable constrainedFrame encoding where each slice in the constarined picture is independent of other slices 1342 Check support for constrained encoding using ::NV_ENC_CAPS_SUPPORT_CONSTRAINED_ENCODING caps. */ 1343 uint32_t repeatSPSPPS :1; /**< [in]: Set to 1 to enable writing of Sequence and Picture parameter for every IDR frame */ 1344 uint32_t enableVFR :1; /**< [in]: Set to 1 to enable variable frame rate. */ 1345 uint32_t enableLTR :1; /**< [in]: Set to 1 to enable LTR (Long Term Reference) frame support. LTR can be used in two modes: "LTR Trust" mode and "LTR Per Picture" mode. 1346 LTR Trust mode: In this mode, ltrNumFrames pictures after IDR are automatically marked as LTR. This mode is enabled by setting ltrTrustMode = 1. 1347 Use of LTR Trust mode is strongly discouraged as this mode may be deprecated in future. 1348 LTR Per Picture mode: In this mode, client can control whether the current picture should be marked as LTR. Enable this mode by setting 1349 ltrTrustMode = 0 and ltrMarkFrame = 1 for the picture to be marked as LTR. This is the preferred mode 1350 for using LTR. 1351 Note that LTRs are not supported if encoding session is configured with B-frames */ 1352 uint32_t qpPrimeYZeroTransformBypassFlag :1; /**< [in]: To enable lossless encode set this to 1, set QP to 0 and RC_mode to NV_ENC_PARAMS_RC_CONSTQP and profile to HIGH_444_PREDICTIVE_PROFILE. 1353 Check support for lossless encoding using ::NV_ENC_CAPS_SUPPORT_LOSSLESS_ENCODE caps. */ 1354 uint32_t useConstrainedIntraPred :1; /**< [in]: Set 1 to enable constrained intra prediction. */ 1355 uint32_t enableFillerDataInsertion :1; /**< [in]: Set to 1 to enable insertion of filler data in the bitstream. 1356 This flag will take effect only when one of the CBR rate 1357 control modes (NV_ENC_PARAMS_RC_CBR, NV_ENC_PARAMS_RC_CBR_HQ, 1358 NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ) is in use and both 1359 NV_ENC_INITIALIZE_PARAMS::frameRateNum and 1360 NV_ENC_INITIALIZE_PARAMS::frameRateDen are set to non-zero 1361 values. Setting this field when 1362 NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is also set 1363 is currently not supported and will make ::NvEncInitializeEncoder() 1364 return an error. */ 1365 uint32_t reservedBitFields :14; /**< [in]: Reserved bitfields and must be set to 0 */ 1366 uint32_t level; /**< [in]: Specifies the encoding level. Client is recommended to set this to NV_ENC_LEVEL_AUTOSELECT in order to enable the NvEncodeAPI interface to select the correct level. */ 1367 uint32_t idrPeriod; /**< [in]: Specifies the IDR interval. If not set, this is made equal to gopLength in NV_ENC_CONFIG.Low latency application client can set IDR interval to NVENC_INFINITE_GOPLENGTH so that IDR frames are not inserted automatically. */ 1368 uint32_t separateColourPlaneFlag; /**< [in]: Set to 1 to enable 4:4:4 separate colour planes */ 1369 uint32_t disableDeblockingFilterIDC; /**< [in]: Specifies the deblocking filter mode. Permissible value range: [0,2] */ 1370 uint32_t numTemporalLayers; /**< [in]: Specifies max temporal layers to be used for hierarchical coding. Valid value range is [1,::NV_ENC_CAPS_NUM_MAX_TEMPORAL_LAYERS] */ 1371 uint32_t spsId; /**< [in]: Specifies the SPS id of the sequence header */ 1372 uint32_t ppsId; /**< [in]: Specifies the PPS id of the picture header */ 1373 NV_ENC_H264_ADAPTIVE_TRANSFORM_MODE adaptiveTransformMode; /**< [in]: Specifies the AdaptiveTransform Mode. Check support for AdaptiveTransform mode using ::NV_ENC_CAPS_SUPPORT_ADAPTIVE_TRANSFORM caps. */ 1374 NV_ENC_H264_FMO_MODE fmoMode; /**< [in]: Specified the FMO Mode. Check support for FMO using ::NV_ENC_CAPS_SUPPORT_FMO caps. */ 1375 NV_ENC_H264_BDIRECT_MODE bdirectMode; /**< [in]: Specifies the BDirect mode. Check support for BDirect mode using ::NV_ENC_CAPS_SUPPORT_BDIRECT_MODE caps.*/ 1376 NV_ENC_H264_ENTROPY_CODING_MODE entropyCodingMode; /**< [in]: Specifies the entropy coding mode. Check support for CABAC mode using ::NV_ENC_CAPS_SUPPORT_CABAC caps. */ 1377 NV_ENC_STEREO_PACKING_MODE stereoMode; /**< [in]: Specifies the stereo frame packing mode which is to be signalled in frame packing arrangement SEI */ 1378 uint32_t intraRefreshPeriod; /**< [in]: Specifies the interval between successive intra refresh if enableIntrarefresh is set. Requires enableIntraRefresh to be set. 1379 Will be disabled if NV_ENC_CONFIG::gopLength is not set to NVENC_INFINITE_GOPLENGTH. */ 1380 uint32_t intraRefreshCnt; /**< [in]: Specifies the length of intra refresh in number of frames for periodic intra refresh. This value should be smaller than intraRefreshPeriod */ 1381 uint32_t maxNumRefFrames; /**< [in]: Specifies the DPB size used for encoding. Setting it to 0 will let driver use the default dpb size. 1382 The low latency application which wants to invalidate reference frame as an error resilience tool 1383 is recommended to use a large DPB size so that the encoder can keep old reference frames which can be used if recent 1384 frames are invalidated. */ 1385 uint32_t sliceMode; /**< [in]: This parameter in conjunction with sliceModeData specifies the way in which the picture is divided into slices 1386 sliceMode = 0 MB based slices, sliceMode = 1 Byte based slices, sliceMode = 2 MB row based slices, sliceMode = 3 numSlices in Picture. 1387 When forceIntraRefreshWithFrameCnt is set it will have priority over sliceMode setting 1388 When sliceMode == 0 and sliceModeData == 0 whole picture will be coded with one slice */ 1389 uint32_t sliceModeData; /**< [in]: Specifies the parameter needed for sliceMode. For: 1390 sliceMode = 0, sliceModeData specifies # of MBs in each slice (except last slice) 1391 sliceMode = 1, sliceModeData specifies maximum # of bytes in each slice (except last slice) 1392 sliceMode = 2, sliceModeData specifies # of MB rows in each slice (except last slice) 1393 sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */ 1394 NV_ENC_CONFIG_H264_VUI_PARAMETERS h264VUIParameters; /**< [in]: Specifies the H264 video usability info pamameters */ 1395 uint32_t ltrNumFrames; /**< [in]: Specifies the number of LTR frames. This parameter has different meaning in two LTR modes. 1396 In "LTR Trust" mode (ltrTrustMode = 1), encoder will mark the first ltrNumFrames base layer reference frames within each IDR interval as LTR. 1397 In "LTR Per Picture" mode (ltrTrustMode = 0 and ltrMarkFrame = 1), ltrNumFrames specifies maximum number of LTR frames in DPB. */ 1398 uint32_t ltrTrustMode; /**< [in]: Specifies the LTR operating mode. See comments near NV_ENC_CONFIG_H264::enableLTR for description of the two modes. 1399 Set to 1 to use "LTR Trust" mode of LTR operation. Clients are discouraged to use "LTR Trust" mode as this mode may 1400 be deprecated in future releases. 1401 Set to 0 when using "LTR Per Picture" mode of LTR operation. */ 1402 uint32_t chromaFormatIDC; /**< [in]: Specifies the chroma format. Should be set to 1 for yuv420 input, 3 for yuv444 input. 1403 Check support for YUV444 encoding using ::NV_ENC_CAPS_SUPPORT_YUV444_ENCODE caps.*/ 1404 uint32_t maxTemporalLayers; /**< [in]: Specifies the max temporal layer used for hierarchical coding. */ 1405 NV_ENC_BFRAME_REF_MODE useBFramesAsRef; /**< [in]: Specifies the B-Frame as reference mode. Check support for useBFramesAsRef mode using ::NV_ENC_CAPS_SUPPORT_BFRAME_REF_MODE caps.*/ 1406 NV_ENC_NUM_REF_FRAMES numRefL0; /**< [in]: Specifies max number of reference frames in reference picture list L0, that can be used by hardware for prediction of a frame. 1407 Check support for numRefL0 using ::NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES caps. */ 1408 NV_ENC_NUM_REF_FRAMES numRefL1; /**< [in]: Specifies max number of reference frames in reference picture list L1, that can be used by hardware for prediction of a frame. 1409 Check support for numRefL1 using ::NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES caps. */ 1410 uint32_t reserved1[267]; /**< [in]: Reserved and must be set to 0 */ 1411 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 1412 } NV_ENC_CONFIG_H264; 1413 1414 /** 1415 * \struct _NV_ENC_CONFIG_HEVC 1416 * HEVC encoder configuration parameters to be set during initialization. 1417 */ 1418 typedef struct _NV_ENC_CONFIG_HEVC 1419 { 1420 uint32_t level; /**< [in]: Specifies the level of the encoded bitstream.*/ 1421 uint32_t tier; /**< [in]: Specifies the level tier of the encoded bitstream.*/ 1422 NV_ENC_HEVC_CUSIZE minCUSize; /**< [in]: Specifies the minimum size of luma coding unit.*/ 1423 NV_ENC_HEVC_CUSIZE maxCUSize; /**< [in]: Specifies the maximum size of luma coding unit. Currently NVENC SDK only supports maxCUSize equal to NV_ENC_HEVC_CUSIZE_32x32.*/ 1424 uint32_t useConstrainedIntraPred :1; /**< [in]: Set 1 to enable constrained intra prediction. */ 1425 uint32_t disableDeblockAcrossSliceBoundary :1; /**< [in]: Set 1 to disable in loop filtering across slice boundary.*/ 1426 uint32_t outputBufferingPeriodSEI :1; /**< [in]: Set 1 to write SEI buffering period syntax in the bitstream */ 1427 uint32_t outputPictureTimingSEI :1; /**< [in]: Set 1 to write SEI picture timing syntax in the bitstream */ 1428 uint32_t outputAUD :1; /**< [in]: Set 1 to write Access Unit Delimiter syntax. */ 1429 uint32_t enableLTR :1; /**< [in]: Set to 1 to enable LTR (Long Term Reference) frame support. LTR can be used in two modes: "LTR Trust" mode and "LTR Per Picture" mode. 1430 LTR Trust mode: In this mode, ltrNumFrames pictures after IDR are automatically marked as LTR. This mode is enabled by setting ltrTrustMode = 1. 1431 Use of LTR Trust mode is strongly discouraged as this mode may be deprecated in future releases. 1432 LTR Per Picture mode: In this mode, client can control whether the current picture should be marked as LTR. Enable this mode by setting 1433 ltrTrustMode = 0 and ltrMarkFrame = 1 for the picture to be marked as LTR. This is the preferred mode 1434 for using LTR. 1435 Note that LTRs are not supported if encoding session is configured with B-frames */ 1436 uint32_t disableSPSPPS :1; /**< [in]: Set 1 to disable VPS,SPS and PPS signalling in the bitstream. */ 1437 uint32_t repeatSPSPPS :1; /**< [in]: Set 1 to output VPS,SPS and PPS for every IDR frame.*/ 1438 uint32_t enableIntraRefresh :1; /**< [in]: Set 1 to enable gradual decoder refresh or intra refresh. If the GOP structure uses B frames this will be ignored */ 1439 uint32_t chromaFormatIDC :2; /**< [in]: Specifies the chroma format. Should be set to 1 for yuv420 input, 3 for yuv444 input.*/ 1440 uint32_t pixelBitDepthMinus8 :3; /**< [in]: Specifies pixel bit depth minus 8. Should be set to 0 for 8 bit input, 2 for 10 bit input.*/ 1441 uint32_t enableFillerDataInsertion :1; /**< [in]: Set to 1 to enable insertion of filler data in the bitstream. 1442 This flag will take effect only when one of the CBR rate 1443 control modes (NV_ENC_PARAMS_RC_CBR, NV_ENC_PARAMS_RC_CBR_HQ, 1444 NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ) is in use and both 1445 NV_ENC_INITIALIZE_PARAMS::frameRateNum and 1446 NV_ENC_INITIALIZE_PARAMS::frameRateDen are set to non-zero 1447 values. Setting this field when 1448 NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is also set 1449 is currently not supported and will make ::NvEncInitializeEncoder() 1450 return an error. */ 1451 uint32_t reserved :17; /**< [in]: Reserved bitfields.*/ 1452 uint32_t idrPeriod; /**< [in]: Specifies the IDR interval. If not set, this is made equal to gopLength in NV_ENC_CONFIG.Low latency application client can set IDR interval to NVENC_INFINITE_GOPLENGTH so that IDR frames are not inserted automatically. */ 1453 uint32_t intraRefreshPeriod; /**< [in]: Specifies the interval between successive intra refresh if enableIntrarefresh is set. Requires enableIntraRefresh to be set. 1454 Will be disabled if NV_ENC_CONFIG::gopLength is not set to NVENC_INFINITE_GOPLENGTH. */ 1455 uint32_t intraRefreshCnt; /**< [in]: Specifies the length of intra refresh in number of frames for periodic intra refresh. This value should be smaller than intraRefreshPeriod */ 1456 uint32_t maxNumRefFramesInDPB; /**< [in]: Specifies the maximum number of references frames in the DPB.*/ 1457 uint32_t ltrNumFrames; /**< [in]: This parameter has different meaning in two LTR modes. 1458 In "LTR Trust" mode (ltrTrustMode = 1), encoder will mark the first ltrNumFrames base layer reference frames within each IDR interval as LTR. 1459 In "LTR Per Picture" mode (ltrTrustMode = 0 and ltrMarkFrame = 1), ltrNumFrames specifies maximum number of LTR frames in DPB. */ 1460 uint32_t vpsId; /**< [in]: Specifies the VPS id of the video parameter set */ 1461 uint32_t spsId; /**< [in]: Specifies the SPS id of the sequence header */ 1462 uint32_t ppsId; /**< [in]: Specifies the PPS id of the picture header */ 1463 uint32_t sliceMode; /**< [in]: This parameter in conjunction with sliceModeData specifies the way in which the picture is divided into slices 1464 sliceMode = 0 CTU based slices, sliceMode = 1 Byte based slices, sliceMode = 2 CTU row based slices, sliceMode = 3, numSlices in Picture 1465 When sliceMode == 0 and sliceModeData == 0 whole picture will be coded with one slice */ 1466 uint32_t sliceModeData; /**< [in]: Specifies the parameter needed for sliceMode. For: 1467 sliceMode = 0, sliceModeData specifies # of CTUs in each slice (except last slice) 1468 sliceMode = 1, sliceModeData specifies maximum # of bytes in each slice (except last slice) 1469 sliceMode = 2, sliceModeData specifies # of CTU rows in each slice (except last slice) 1470 sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */ 1471 uint32_t maxTemporalLayersMinus1; /**< [in]: Specifies the max temporal layer used for hierarchical coding. */ 1472 NV_ENC_CONFIG_HEVC_VUI_PARAMETERS hevcVUIParameters; /**< [in]: Specifies the HEVC video usability info pamameters */ 1473 uint32_t ltrTrustMode; /**< [in]: Specifies the LTR operating mode. See comments near NV_ENC_CONFIG_HEVC::enableLTR for description of the two modes. 1474 Set to 1 to use "LTR Trust" mode of LTR operation. Clients are discouraged to use "LTR Trust" mode as this mode may 1475 be deprecated in future releases. 1476 Set to 0 when using "LTR Per Picture" mode of LTR operation. */ 1477 NV_ENC_BFRAME_REF_MODE useBFramesAsRef; /**< [in]: Specifies the B-Frame as reference mode. Check support for useBFramesAsRef mode using ::NV_ENC_CAPS_SUPPORT_BFRAME_REF_MODE caps.*/ 1478 NV_ENC_NUM_REF_FRAMES numRefL0; /**< [in]: Specifies max number of reference frames in reference picture list L0, that can be used by hardware for prediction of a frame. 1479 Check support for numRefL0 using ::NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES caps. */ 1480 NV_ENC_NUM_REF_FRAMES numRefL1; /**< [in]: Specifies max number of reference frames in reference picture list L1, that can be used by hardware for prediction of a frame. 1481 Check support for numRefL1 using ::NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES caps. */ 1482 uint32_t reserved1[214]; /**< [in]: Reserved and must be set to 0.*/ 1483 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 1484 } NV_ENC_CONFIG_HEVC; 1485 1486 /** 1487 * \struct _NV_ENC_CONFIG_H264_MEONLY 1488 * H264 encoder configuration parameters for ME only Mode 1489 * 1490 */ 1491 typedef struct _NV_ENC_CONFIG_H264_MEONLY 1492 { 1493 uint32_t disablePartition16x16 :1; /**< [in]: Disable MotionEstimation on 16x16 blocks*/ 1494 uint32_t disablePartition8x16 :1; /**< [in]: Disable MotionEstimation on 8x16 blocks*/ 1495 uint32_t disablePartition16x8 :1; /**< [in]: Disable MotionEstimation on 16x8 blocks*/ 1496 uint32_t disablePartition8x8 :1; /**< [in]: Disable MotionEstimation on 8x8 blocks*/ 1497 uint32_t disableIntraSearch :1; /**< [in]: Disable Intra search during MotionEstimation*/ 1498 uint32_t bStereoEnable :1; /**< [in]: Enable Stereo Mode for Motion Estimation where each view is independently executed*/ 1499 uint32_t reserved :26; /**< [in]: Reserved and must be set to 0 */ 1500 uint32_t reserved1 [255]; /**< [in]: Reserved and must be set to 0 */ 1501 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 1502 } NV_ENC_CONFIG_H264_MEONLY; 1503 1504 1505 /** 1506 * \struct _NV_ENC_CONFIG_HEVC_MEONLY 1507 * HEVC encoder configuration parameters for ME only Mode 1508 * 1509 */ 1510 typedef struct _NV_ENC_CONFIG_HEVC_MEONLY 1511 { 1512 uint32_t reserved [256]; /**< [in]: Reserved and must be set to 0 */ 1513 void* reserved1[64]; /**< [in]: Reserved and must be set to NULL */ 1514 } NV_ENC_CONFIG_HEVC_MEONLY; 1515 1516 /** 1517 * \struct _NV_ENC_CODEC_CONFIG 1518 * Codec-specific encoder configuration parameters to be set during initialization. 1519 */ 1520 typedef union _NV_ENC_CODEC_CONFIG 1521 { 1522 NV_ENC_CONFIG_H264 h264Config; /**< [in]: Specifies the H.264-specific encoder configuration. */ 1523 NV_ENC_CONFIG_HEVC hevcConfig; /**< [in]: Specifies the HEVC-specific encoder configuration. */ 1524 NV_ENC_CONFIG_H264_MEONLY h264MeOnlyConfig; /**< [in]: Specifies the H.264-specific ME only encoder configuration. */ 1525 NV_ENC_CONFIG_HEVC_MEONLY hevcMeOnlyConfig; /**< [in]: Specifies the HEVC-specific ME only encoder configuration. */ 1526 uint32_t reserved[320]; /**< [in]: Reserved and must be set to 0 */ 1527 } NV_ENC_CODEC_CONFIG; 1528 1529 1530 /** 1531 * \struct _NV_ENC_CONFIG 1532 * Encoder configuration parameters to be set during initialization. 1533 */ 1534 typedef struct _NV_ENC_CONFIG 1535 { 1536 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_CONFIG_VER. */ 1537 GUID profileGUID; /**< [in]: Specifies the codec profile guid. If client specifies \p NV_ENC_CODEC_PROFILE_AUTOSELECT_GUID the NvEncodeAPI interface will select the appropriate codec profile. */ 1538 uint32_t gopLength; /**< [in]: Specifies the number of pictures in one GOP. Low latency application client can set goplength to NVENC_INFINITE_GOPLENGTH so that keyframes are not inserted automatically. */ 1539 int32_t frameIntervalP; /**< [in]: Specifies the GOP pattern as follows: \p frameIntervalP = 0: I, 1: IPP, 2: IBP, 3: IBBP If goplength is set to NVENC_INFINITE_GOPLENGTH \p frameIntervalP should be set to 1. */ 1540 uint32_t monoChromeEncoding; /**< [in]: Set this to 1 to enable monochrome encoding for this session. */ 1541 NV_ENC_PARAMS_FRAME_FIELD_MODE frameFieldMode; /**< [in]: Specifies the frame/field mode. 1542 Check support for field encoding using ::NV_ENC_CAPS_SUPPORT_FIELD_ENCODING caps. 1543 Using a frameFieldMode other than NV_ENC_PARAMS_FRAME_FIELD_MODE_FRAME for RGB input is not supported. */ 1544 NV_ENC_MV_PRECISION mvPrecision; /**< [in]: Specifies the desired motion vector prediction precision. */ 1545 NV_ENC_RC_PARAMS rcParams; /**< [in]: Specifies the rate control parameters for the current encoding session. */ 1546 NV_ENC_CODEC_CONFIG encodeCodecConfig; /**< [in]: Specifies the codec specific config parameters through this union. */ 1547 uint32_t reserved [278]; /**< [in]: Reserved and must be set to 0 */ 1548 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 1549 } NV_ENC_CONFIG; 1550 1551 /** macro for constructing the version field of ::_NV_ENC_CONFIG */ 1552 #define NV_ENC_CONFIG_VER (NVENCAPI_STRUCT_VERSION(7) | ( 1<<31 )) 1553 1554 1555 /** 1556 * \struct _NV_ENC_INITIALIZE_PARAMS 1557 * Encode Session Initialization parameters. 1558 */ 1559 typedef struct _NV_ENC_INITIALIZE_PARAMS 1560 { 1561 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_INITIALIZE_PARAMS_VER. */ 1562 GUID encodeGUID; /**< [in]: Specifies the Encode GUID for which the encoder is being created. ::NvEncInitializeEncoder() API will fail if this is not set, or set to unsupported value. */ 1563 GUID presetGUID; /**< [in]: Specifies the preset for encoding. If the preset GUID is set then , the preset configuration will be applied before any other parameter. */ 1564 uint32_t encodeWidth; /**< [in]: Specifies the encode width. If not set ::NvEncInitializeEncoder() API will fail. */ 1565 uint32_t encodeHeight; /**< [in]: Specifies the encode height. If not set ::NvEncInitializeEncoder() API will fail. */ 1566 uint32_t darWidth; /**< [in]: Specifies the display aspect ratio Width. */ 1567 uint32_t darHeight; /**< [in]: Specifies the display aspect ratio height. */ 1568 uint32_t frameRateNum; /**< [in]: Specifies the numerator for frame rate used for encoding in frames per second ( Frame rate = frameRateNum / frameRateDen ). */ 1569 uint32_t frameRateDen; /**< [in]: Specifies the denominator for frame rate used for encoding in frames per second ( Frame rate = frameRateNum / frameRateDen ). */ 1570 uint32_t enableEncodeAsync; /**< [in]: Set this to 1 to enable asynchronous mode and is expected to use events to get picture completion notification. */ 1571 uint32_t enablePTD; /**< [in]: Set this to 1 to enable the Picture Type Decision is be taken by the NvEncodeAPI interface. */ 1572 uint32_t reportSliceOffsets :1; /**< [in]: Set this to 1 to enable reporting slice offsets in ::_NV_ENC_LOCK_BITSTREAM. NV_ENC_INITIALIZE_PARAMS::enableEncodeAsync must be set to 0 to use this feature. Client must set this to 0 if NV_ENC_CONFIG_H264::sliceMode is 1 on Kepler GPUs */ 1573 uint32_t enableSubFrameWrite :1; /**< [in]: Set this to 1 to write out available bitstream to memory at subframe intervals */ 1574 uint32_t enableExternalMEHints :1; /**< [in]: Set to 1 to enable external ME hints for the current frame. For NV_ENC_INITIALIZE_PARAMS::enablePTD=1 with B frames, programming L1 hints is optional for B frames since Client doesn't know internal GOP structure. 1575 NV_ENC_PIC_PARAMS::meHintRefPicDist should preferably be set with enablePTD=1. */ 1576 uint32_t enableMEOnlyMode :1; /**< [in]: Set to 1 to enable ME Only Mode .*/ 1577 uint32_t enableWeightedPrediction :1; /**< [in]: Set this to 1 to enable weighted prediction. Not supported if encode session is configured for B-Frames( 'frameIntervalP' in NV_ENC_CONFIG is greater than 1).*/ 1578 uint32_t enableOutputInVidmem :1; /**< [in]: Set this to 1 to enable output of NVENC in video memory buffer created by application. This feature is not supported for HEVC ME only mode. */ 1579 uint32_t reservedBitFields :26; /**< [in]: Reserved bitfields and must be set to 0 */ 1580 uint32_t privDataSize; /**< [in]: Reserved private data buffer size and must be set to 0 */ 1581 void* privData; /**< [in]: Reserved private data buffer and must be set to NULL */ 1582 NV_ENC_CONFIG* encodeConfig; /**< [in]: Specifies the advanced codec specific structure. If client has sent a valid codec config structure, it will override parameters set by the NV_ENC_INITIALIZE_PARAMS::presetGUID parameter. If set to NULL the NvEncodeAPI interface will use the NV_ENC_INITIALIZE_PARAMS::presetGUID to set the codec specific parameters. 1583 Client can also optionally query the NvEncodeAPI interface to get codec specific parameters for a presetGUID using ::NvEncGetEncodePresetConfig() API. It can then modify (if required) some of the codec config parameters and send down a custom config structure as part of ::_NV_ENC_INITIALIZE_PARAMS. 1584 Even in this case client is recommended to pass the same preset guid it has used in ::NvEncGetEncodePresetConfig() API to query the config structure; as NV_ENC_INITIALIZE_PARAMS::presetGUID. This will not override the custom config structure but will be used to determine other Encoder HW specific parameters not exposed in the API. */ 1585 uint32_t maxEncodeWidth; /**< [in]: Maximum encode width to be used for current Encode session. 1586 Client should allocate output buffers according to this dimension for dynamic resolution change. If set to 0, Encoder will not allow dynamic resolution change. */ 1587 uint32_t maxEncodeHeight; /**< [in]: Maximum encode height to be allowed for current Encode session. 1588 Client should allocate output buffers according to this dimension for dynamic resolution change. If set to 0, Encode will not allow dynamic resolution change. */ 1589 NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE maxMEHintCountsPerBlock[2]; /**< [in]: If Client wants to pass external motion vectors in NV_ENC_PIC_PARAMS::meExternalHints buffer it must specify the maximum number of hint candidates per block per direction for the encode session. 1590 The NV_ENC_INITIALIZE_PARAMS::maxMEHintCountsPerBlock[0] is for L0 predictors and NV_ENC_INITIALIZE_PARAMS::maxMEHintCountsPerBlock[1] is for L1 predictors. 1591 This client must also set NV_ENC_INITIALIZE_PARAMS::enableExternalMEHints to 1. */ 1592 uint32_t reserved [289]; /**< [in]: Reserved and must be set to 0 */ 1593 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 1594 } NV_ENC_INITIALIZE_PARAMS; 1595 1596 /** macro for constructing the version field of ::_NV_ENC_INITIALIZE_PARAMS */ 1597 #define NV_ENC_INITIALIZE_PARAMS_VER (NVENCAPI_STRUCT_VERSION(5) | ( 1<<31 )) 1598 1599 1600 /** 1601 * \struct _NV_ENC_RECONFIGURE_PARAMS 1602 * Encode Session Reconfigured parameters. 1603 */ 1604 typedef struct _NV_ENC_RECONFIGURE_PARAMS 1605 { 1606 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_RECONFIGURE_PARAMS_VER. */ 1607 NV_ENC_INITIALIZE_PARAMS reInitEncodeParams; /**< [in]: Encoder session re-initialization parameters. 1608 If reInitEncodeParams.encodeConfig is NULL and 1609 reInitEncodeParams.presetGUID is the same as the preset 1610 GUID specified on the call to NvEncInitializeEncoder(), 1611 EncodeAPI will continue to use the existing encode 1612 configuration. 1613 If reInitEncodeParams.encodeConfig is NULL and 1614 reInitEncodeParams.presetGUID is different from the preset 1615 GUID specified on the call to NvEncInitializeEncoder(), 1616 EncodeAPI will try to use the default configuration for 1617 the preset specified by reInitEncodeParams.presetGUID. 1618 In this case, reconfiguration may fail if the new 1619 configuration is incompatible with the existing 1620 configuration (e.g. the new configuration results in 1621 a change in the GOP structure). */ 1622 uint32_t resetEncoder :1; /**< [in]: This resets the rate control states and other internal encoder states. This should be used only with an IDR frame. 1623 If NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1, encoder will force the frame type to IDR */ 1624 uint32_t forceIDR :1; /**< [in]: Encode the current picture as an IDR picture. This flag is only valid when Picture type decision is taken by the Encoder 1625 [_NV_ENC_INITIALIZE_PARAMS::enablePTD == 1]. */ 1626 uint32_t reserved :30; 1627 1628 }NV_ENC_RECONFIGURE_PARAMS; 1629 1630 /** macro for constructing the version field of ::_NV_ENC_RECONFIGURE_PARAMS */ 1631 #define NV_ENC_RECONFIGURE_PARAMS_VER (NVENCAPI_STRUCT_VERSION(1) | ( 1<<31 )) 1632 1633 /** 1634 * \struct _NV_ENC_PRESET_CONFIG 1635 * Encoder preset config 1636 */ 1637 typedef struct _NV_ENC_PRESET_CONFIG 1638 { 1639 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_PRESET_CONFIG_VER. */ 1640 NV_ENC_CONFIG presetCfg; /**< [out]: preset config returned by the Nvidia Video Encoder interface. */ 1641 uint32_t reserved1[255]; /**< [in]: Reserved and must be set to 0 */ 1642 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 1643 }NV_ENC_PRESET_CONFIG; 1644 1645 /** macro for constructing the version field of ::_NV_ENC_PRESET_CONFIG */ 1646 #define NV_ENC_PRESET_CONFIG_VER (NVENCAPI_STRUCT_VERSION(4) | ( 1<<31 )) 1647 1648 1649 /** 1650 * \struct _NV_ENC_PIC_PARAMS_MVC 1651 * MVC-specific parameters to be sent on a per-frame basis. 1652 */ 1653 typedef struct _NV_ENC_PIC_PARAMS_MVC 1654 { 1655 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_PIC_PARAMS_MVC_VER. */ 1656 uint32_t viewID; /**< [in]: Specifies the view ID associated with the current input view. */ 1657 uint32_t temporalID; /**< [in]: Specifies the temporal ID associated with the current input view. */ 1658 uint32_t priorityID; /**< [in]: Specifies the priority ID associated with the current input view. Reserved and ignored by the NvEncodeAPI interface. */ 1659 uint32_t reserved1[12]; /**< [in]: Reserved and must be set to 0. */ 1660 void* reserved2[8]; /**< [in]: Reserved and must be set to NULL. */ 1661 }NV_ENC_PIC_PARAMS_MVC; 1662 1663 /** macro for constructing the version field of ::_NV_ENC_PIC_PARAMS_MVC */ 1664 #define NV_ENC_PIC_PARAMS_MVC_VER NVENCAPI_STRUCT_VERSION(1) 1665 1666 1667 /** 1668 * \union _NV_ENC_PIC_PARAMS_H264_EXT 1669 * H264 extension picture parameters 1670 */ 1671 typedef union _NV_ENC_PIC_PARAMS_H264_EXT 1672 { 1673 NV_ENC_PIC_PARAMS_MVC mvcPicParams; /**< [in]: Specifies the MVC picture parameters. */ 1674 uint32_t reserved1[32]; /**< [in]: Reserved and must be set to 0. */ 1675 }NV_ENC_PIC_PARAMS_H264_EXT; 1676 1677 /** 1678 * \struct _NV_ENC_SEI_PAYLOAD 1679 * User SEI message 1680 */ 1681 typedef struct _NV_ENC_SEI_PAYLOAD 1682 { 1683 uint32_t payloadSize; /**< [in] SEI payload size in bytes. SEI payload must be byte aligned, as described in Annex D */ 1684 uint32_t payloadType; /**< [in] SEI payload types and syntax can be found in Annex D of the H.264 Specification. */ 1685 uint8_t *payload; /**< [in] pointer to user data */ 1686 } NV_ENC_SEI_PAYLOAD; 1687 1688 #define NV_ENC_H264_SEI_PAYLOAD NV_ENC_SEI_PAYLOAD 1689 1690 /** 1691 * \struct _NV_ENC_PIC_PARAMS_H264 1692 * H264 specific enc pic params. sent on a per frame basis. 1693 */ 1694 typedef struct _NV_ENC_PIC_PARAMS_H264 1695 { 1696 uint32_t displayPOCSyntax; /**< [in]: Specifies the display POC syntax This is required to be set if client is handling the picture type decision. */ 1697 uint32_t reserved3; /**< [in]: Reserved and must be set to 0 */ 1698 uint32_t refPicFlag; /**< [in]: Set to 1 for a reference picture. This is ignored if NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1. */ 1699 uint32_t colourPlaneId; /**< [in]: Specifies the colour plane ID associated with the current input. */ 1700 uint32_t forceIntraRefreshWithFrameCnt; /**< [in]: Forces an intra refresh with duration equal to intraRefreshFrameCnt. 1701 When outputRecoveryPointSEI is set this is value is used for recovery_frame_cnt in recovery point SEI message 1702 forceIntraRefreshWithFrameCnt cannot be used if B frames are used in the GOP structure specified */ 1703 uint32_t constrainedFrame :1; /**< [in]: Set to 1 if client wants to encode this frame with each slice completely independent of other slices in the frame. 1704 NV_ENC_INITIALIZE_PARAMS::enableConstrainedEncoding should be set to 1 */ 1705 uint32_t sliceModeDataUpdate :1; /**< [in]: Set to 1 if client wants to change the sliceModeData field to specify new sliceSize Parameter 1706 When forceIntraRefreshWithFrameCnt is set it will have priority over sliceMode setting */ 1707 uint32_t ltrMarkFrame :1; /**< [in]: Set to 1 if client wants to mark this frame as LTR */ 1708 uint32_t ltrUseFrames :1; /**< [in]: Set to 1 if client allows encoding this frame using the LTR frames specified in ltrFrameBitmap */ 1709 uint32_t reservedBitFields :28; /**< [in]: Reserved bit fields and must be set to 0 */ 1710 uint8_t* sliceTypeData; /**< [in]: Deprecated. */ 1711 uint32_t sliceTypeArrayCnt; /**< [in]: Deprecated. */ 1712 uint32_t seiPayloadArrayCnt; /**< [in]: Specifies the number of elements allocated in seiPayloadArray array. */ 1713 NV_ENC_SEI_PAYLOAD* seiPayloadArray; /**< [in]: Array of SEI payloads which will be inserted for this frame. */ 1714 uint32_t sliceMode; /**< [in]: This parameter in conjunction with sliceModeData specifies the way in which the picture is divided into slices 1715 sliceMode = 0 MB based slices, sliceMode = 1 Byte based slices, sliceMode = 2 MB row based slices, sliceMode = 3, numSlices in Picture 1716 When forceIntraRefreshWithFrameCnt is set it will have priority over sliceMode setting 1717 When sliceMode == 0 and sliceModeData == 0 whole picture will be coded with one slice */ 1718 uint32_t sliceModeData; /**< [in]: Specifies the parameter needed for sliceMode. For: 1719 sliceMode = 0, sliceModeData specifies # of MBs in each slice (except last slice) 1720 sliceMode = 1, sliceModeData specifies maximum # of bytes in each slice (except last slice) 1721 sliceMode = 2, sliceModeData specifies # of MB rows in each slice (except last slice) 1722 sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */ 1723 uint32_t ltrMarkFrameIdx; /**< [in]: Specifies the long term referenceframe index to use for marking this frame as LTR.*/ 1724 uint32_t ltrUseFrameBitmap; /**< [in]: Specifies the the associated bitmap of LTR frame indices to use when encoding this frame. */ 1725 uint32_t ltrUsageMode; /**< [in]: Not supported. Reserved for future use and must be set to 0. */ 1726 uint32_t forceIntraSliceCount; /**< [in]: Specfies the number of slices to be forced to Intra in the current picture. 1727 This option along with forceIntraSliceIdx[] array needs to be used with sliceMode = 3 only */ 1728 uint32_t *forceIntraSliceIdx; /**< [in]: Slice indices to be forced to intra in the current picture. Each slice index should be <= num_slices_in_picture -1. Index starts from 0 for first slice. 1729 The number of entries in this array should be equal to forceIntraSliceCount */ 1730 NV_ENC_PIC_PARAMS_H264_EXT h264ExtPicParams; /**< [in]: Specifies the H264 extension config parameters using this config. */ 1731 uint32_t reserved [210]; /**< [in]: Reserved and must be set to 0. */ 1732 void* reserved2[61]; /**< [in]: Reserved and must be set to NULL. */ 1733 } NV_ENC_PIC_PARAMS_H264; 1734 1735 /** 1736 * \struct _NV_ENC_PIC_PARAMS_HEVC 1737 * HEVC specific enc pic params. sent on a per frame basis. 1738 */ 1739 typedef struct _NV_ENC_PIC_PARAMS_HEVC 1740 { 1741 uint32_t displayPOCSyntax; /**< [in]: Specifies the display POC syntax This is required to be set if client is handling the picture type decision. */ 1742 uint32_t refPicFlag; /**< [in]: Set to 1 for a reference picture. This is ignored if NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1. */ 1743 uint32_t temporalId; /**< [in]: Specifies the temporal id of the picture */ 1744 uint32_t forceIntraRefreshWithFrameCnt; /**< [in]: Forces an intra refresh with duration equal to intraRefreshFrameCnt. 1745 When outputRecoveryPointSEI is set this is value is used for recovery_frame_cnt in recovery point SEI message 1746 forceIntraRefreshWithFrameCnt cannot be used if B frames are used in the GOP structure specified */ 1747 uint32_t constrainedFrame :1; /**< [in]: Set to 1 if client wants to encode this frame with each slice completely independent of other slices in the frame. 1748 NV_ENC_INITIALIZE_PARAMS::enableConstrainedEncoding should be set to 1 */ 1749 uint32_t sliceModeDataUpdate :1; /**< [in]: Set to 1 if client wants to change the sliceModeData field to specify new sliceSize Parameter 1750 When forceIntraRefreshWithFrameCnt is set it will have priority over sliceMode setting */ 1751 uint32_t ltrMarkFrame :1; /**< [in]: Set to 1 if client wants to mark this frame as LTR */ 1752 uint32_t ltrUseFrames :1; /**< [in]: Set to 1 if client allows encoding this frame using the LTR frames specified in ltrFrameBitmap */ 1753 uint32_t reservedBitFields :28; /**< [in]: Reserved bit fields and must be set to 0 */ 1754 uint8_t* sliceTypeData; /**< [in]: Array which specifies the slice type used to force intra slice for a particular slice. Currently supported only for NV_ENC_CONFIG_H264::sliceMode == 3. 1755 Client should allocate array of size sliceModeData where sliceModeData is specified in field of ::_NV_ENC_CONFIG_H264 1756 Array element with index n corresponds to nth slice. To force a particular slice to intra client should set corresponding array element to NV_ENC_SLICE_TYPE_I 1757 all other array elements should be set to NV_ENC_SLICE_TYPE_DEFAULT */ 1758 uint32_t sliceTypeArrayCnt; /**< [in]: Client should set this to the number of elements allocated in sliceTypeData array. If sliceTypeData is NULL then this should be set to 0 */ 1759 uint32_t sliceMode; /**< [in]: This parameter in conjunction with sliceModeData specifies the way in which the picture is divided into slices 1760 sliceMode = 0 CTU based slices, sliceMode = 1 Byte based slices, sliceMode = 2 CTU row based slices, sliceMode = 3, numSlices in Picture 1761 When forceIntraRefreshWithFrameCnt is set it will have priority over sliceMode setting 1762 When sliceMode == 0 and sliceModeData == 0 whole picture will be coded with one slice */ 1763 uint32_t sliceModeData; /**< [in]: Specifies the parameter needed for sliceMode. For: 1764 sliceMode = 0, sliceModeData specifies # of CTUs in each slice (except last slice) 1765 sliceMode = 1, sliceModeData specifies maximum # of bytes in each slice (except last slice) 1766 sliceMode = 2, sliceModeData specifies # of CTU rows in each slice (except last slice) 1767 sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */ 1768 uint32_t ltrMarkFrameIdx; /**< [in]: Specifies the long term reference frame index to use for marking this frame as LTR.*/ 1769 uint32_t ltrUseFrameBitmap; /**< [in]: Specifies the associated bitmap of LTR frame indices to use when encoding this frame. */ 1770 uint32_t ltrUsageMode; /**< [in]: Not supported. Reserved for future use and must be set to 0. */ 1771 uint32_t seiPayloadArrayCnt; /**< [in]: Specifies the number of elements allocated in seiPayloadArray array. */ 1772 uint32_t reserved; /**< [in]: Reserved and must be set to 0. */ 1773 NV_ENC_SEI_PAYLOAD* seiPayloadArray; /**< [in]: Array of SEI payloads which will be inserted for this frame. */ 1774 uint32_t reserved2 [244]; /**< [in]: Reserved and must be set to 0. */ 1775 void* reserved3[61]; /**< [in]: Reserved and must be set to NULL. */ 1776 } NV_ENC_PIC_PARAMS_HEVC; 1777 1778 /** 1779 * Codec specific per-picture encoding parameters. 1780 */ 1781 typedef union _NV_ENC_CODEC_PIC_PARAMS 1782 { 1783 NV_ENC_PIC_PARAMS_H264 h264PicParams; /**< [in]: H264 encode picture params. */ 1784 NV_ENC_PIC_PARAMS_HEVC hevcPicParams; /**< [in]: HEVC encode picture params. */ 1785 uint32_t reserved[256]; /**< [in]: Reserved and must be set to 0. */ 1786 } NV_ENC_CODEC_PIC_PARAMS; 1787 1788 /** 1789 * \struct _NV_ENC_PIC_PARAMS 1790 * Encoding parameters that need to be sent on a per frame basis. 1791 */ 1792 typedef struct _NV_ENC_PIC_PARAMS 1793 { 1794 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_PIC_PARAMS_VER. */ 1795 uint32_t inputWidth; /**< [in]: Specifies the input buffer width */ 1796 uint32_t inputHeight; /**< [in]: Specifies the input buffer height */ 1797 uint32_t inputPitch; /**< [in]: Specifies the input buffer pitch. If pitch value is not known, set this to inputWidth. */ 1798 uint32_t encodePicFlags; /**< [in]: Specifies bit-wise OR`ed encode pic flags. See ::NV_ENC_PIC_FLAGS enum. */ 1799 uint32_t frameIdx; /**< [in]: Specifies the frame index associated with the input frame [optional]. */ 1800 uint64_t inputTimeStamp; /**< [in]: Specifies presentation timestamp associated with the input picture. */ 1801 uint64_t inputDuration; /**< [in]: Specifies duration of the input picture */ 1802 NV_ENC_INPUT_PTR inputBuffer; /**< [in]: Specifies the input buffer pointer. Client must use a pointer obtained from ::NvEncCreateInputBuffer() or ::NvEncMapInputResource() APIs.*/ 1803 NV_ENC_OUTPUT_PTR outputBitstream; /**< [in]: Specifies the output buffer pointer. 1804 If NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is set to 0, specifies the pointer to output buffer. Client should use a pointer obtained from ::NvEncCreateBitstreamBuffer() API. 1805 If NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is set to 1, client should allocate buffer in video memory for NV_ENC_ENCODE_OUT_PARAMS struct and encoded bitstream data. Client 1806 should use a pointer obtained from ::NvEncMapInputResource() API, when mapping this output buffer and assign it to NV_ENC_PIC_PARAMS::outputBitstream. 1807 First 256 bytes of this buffer should be interpreted as NV_ENC_ENCODE_OUT_PARAMS struct followed by encoded bitstream data. Recommended size for output buffer is sum of size of 1808 NV_ENC_ENCODE_OUT_PARAMS struct and twice the input frame size for lower resolution eg. CIF and 1.5 times the input frame size for higher resolutions. If encoded bitstream size is 1809 greater than the allocated buffer size for encoded bitstream, then the output buffer will have encoded bitstream data equal to buffer size. All CUDA operations on this buffer must use 1810 the default stream. */ 1811 void* completionEvent; /**< [in]: Specifies an event to be signalled on completion of encoding of this Frame [only if operating in Asynchronous mode]. Each output buffer should be associated with a distinct event pointer. */ 1812 NV_ENC_BUFFER_FORMAT bufferFmt; /**< [in]: Specifies the input buffer format. */ 1813 NV_ENC_PIC_STRUCT pictureStruct; /**< [in]: Specifies structure of the input picture. */ 1814 NV_ENC_PIC_TYPE pictureType; /**< [in]: Specifies input picture type. Client required to be set explicitly by the client if the client has not set NV_ENC_INITALIZE_PARAMS::enablePTD to 1 while calling NvInitializeEncoder. */ 1815 NV_ENC_CODEC_PIC_PARAMS codecPicParams; /**< [in]: Specifies the codec specific per-picture encoding parameters. */ 1816 NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE meHintCountsPerBlock[2]; /**< [in]: Specifies the number of hint candidates per block per direction for the current frame. meHintCountsPerBlock[0] is for L0 predictors and meHintCountsPerBlock[1] is for L1 predictors. 1817 The candidate count in NV_ENC_PIC_PARAMS::meHintCountsPerBlock[lx] must never exceed NV_ENC_INITIALIZE_PARAMS::maxMEHintCountsPerBlock[lx] provided during encoder intialization. */ 1818 NVENC_EXTERNAL_ME_HINT *meExternalHints; /**< [in]: Specifies the pointer to ME external hints for the current frame. The size of ME hint buffer should be equal to number of macroblocks * the total number of candidates per macroblock. 1819 The total number of candidates per MB per direction = 1*meHintCountsPerBlock[Lx].numCandsPerBlk16x16 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk16x8 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk8x8 1820 + 4*meHintCountsPerBlock[Lx].numCandsPerBlk8x8. For frames using bidirectional ME , the total number of candidates for single macroblock is sum of total number of candidates per MB for each direction (L0 and L1) */ 1821 uint32_t reserved1[6]; /**< [in]: Reserved and must be set to 0 */ 1822 void* reserved2[2]; /**< [in]: Reserved and must be set to NULL */ 1823 int8_t *qpDeltaMap; /**< [in]: Specifies the pointer to signed byte array containing value per MB in raster scan order for the current picture, which will be interpreted depending on NV_ENC_RC_PARAMS::qpMapMode. 1824 If NV_ENC_RC_PARAMS::qpMapMode is NV_ENC_QP_MAP_DELTA, qpDeltaMap specifies QP modifier per MB. This QP modifier will be applied on top of the QP chosen by rate control. 1825 If NV_ENC_RC_PARAMS::qpMapMode is NV_ENC_QP_MAP_EMPHASIS, qpDeltaMap specifies Emphasis Level Map per MB. This level value along with QP chosen by rate control is used to 1826 compute the QP modifier, which in turn is applied on top of QP chosen by rate control. 1827 If NV_ENC_RC_PARAMS::qpMapMode is NV_ENC_QP_MAP_DISABLED, value in qpDeltaMap will be ignored.*/ 1828 uint32_t qpDeltaMapSize; /**< [in]: Specifies the size in bytes of qpDeltaMap surface allocated by client and pointed to by NV_ENC_PIC_PARAMS::qpDeltaMap. Surface (array) should be picWidthInMbs * picHeightInMbs */ 1829 uint32_t reservedBitFields; /**< [in]: Reserved bitfields and must be set to 0 */ 1830 uint16_t meHintRefPicDist[2]; /**< [in]: Specifies temporal distance for reference picture (NVENC_EXTERNAL_ME_HINT::refidx = 0) used during external ME with NV_ENC_INITALIZE_PARAMS::enablePTD = 1 . meHintRefPicDist[0] is for L0 hints and meHintRefPicDist[1] is for L1 hints. 1831 If not set, will internally infer distance of 1. Ignored for NV_ENC_INITALIZE_PARAMS::enablePTD = 0 */ 1832 uint32_t reserved3[286]; /**< [in]: Reserved and must be set to 0 */ 1833 void* reserved4[60]; /**< [in]: Reserved and must be set to NULL */ 1834 } NV_ENC_PIC_PARAMS; 1835 1836 /** Macro for constructing the version field of ::_NV_ENC_PIC_PARAMS */ 1837 #define NV_ENC_PIC_PARAMS_VER (NVENCAPI_STRUCT_VERSION(4) | ( 1<<31 )) 1838 1839 1840 /** 1841 * \struct _NV_ENC_MEONLY_PARAMS 1842 * MEOnly parameters that need to be sent on a per motion estimation basis. 1843 * NV_ENC_MEONLY_PARAMS::meExternalHints is supported for H264 only. 1844 */ 1845 typedef struct _NV_ENC_MEONLY_PARAMS 1846 { 1847 uint32_t version; /**< [in]: Struct version. Must be set to NV_ENC_MEONLY_PARAMS_VER.*/ 1848 uint32_t inputWidth; /**< [in]: Specifies the input buffer width */ 1849 uint32_t inputHeight; /**< [in]: Specifies the input buffer height */ 1850 NV_ENC_INPUT_PTR inputBuffer; /**< [in]: Specifies the input buffer pointer. Client must use a pointer obtained from NvEncCreateInputBuffer() or NvEncMapInputResource() APIs. */ 1851 NV_ENC_INPUT_PTR referenceFrame; /**< [in]: Specifies the reference frame pointer */ 1852 NV_ENC_OUTPUT_PTR mvBuffer; /**< [in]: Specifies the output buffer pointer. 1853 If NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is set to 0, specifies the pointer to motion vector data buffer allocated by NvEncCreateMVBuffer. 1854 Client must lock mvBuffer using ::NvEncLockBitstream() API to get the motion vector data. 1855 If NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is set to 1, client should allocate buffer in video memory for storing the motion vector data. The size of this buffer must 1856 be equal to total number of macroblocks multiplied by size of NV_ENC_H264_MV_DATA struct. Client should use a pointer obtained from ::NvEncMapInputResource() API, when mapping this 1857 output buffer and assign it to NV_ENC_MEONLY_PARAMS::mvBuffer. All CUDA operations on this buffer must use the default stream. */ 1858 NV_ENC_BUFFER_FORMAT bufferFmt; /**< [in]: Specifies the input buffer format. */ 1859 void* completionEvent; /**< [in]: Specifies an event to be signalled on completion of motion estimation 1860 of this Frame [only if operating in Asynchronous mode]. 1861 Each output buffer should be associated with a distinct event pointer. */ 1862 uint32_t viewID; /**< [in]: Specifies left,right viewID if NV_ENC_CONFIG_H264_MEONLY::bStereoEnable is set. 1863 viewID can be 0,1 if bStereoEnable is set, 0 otherwise. */ 1864 NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE 1865 meHintCountsPerBlock[2]; /**< [in]: Specifies the number of hint candidates per block for the current frame. meHintCountsPerBlock[0] is for L0 predictors. 1866 The candidate count in NV_ENC_PIC_PARAMS::meHintCountsPerBlock[lx] must never exceed NV_ENC_INITIALIZE_PARAMS::maxMEHintCountsPerBlock[lx] provided during encoder intialization. */ 1867 NVENC_EXTERNAL_ME_HINT *meExternalHints; /**< [in]: Specifies the pointer to ME external hints for the current frame. The size of ME hint buffer should be equal to number of macroblocks * the total number of candidates per macroblock. 1868 The total number of candidates per MB per direction = 1*meHintCountsPerBlock[Lx].numCandsPerBlk16x16 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk16x8 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk8x8 1869 + 4*meHintCountsPerBlock[Lx].numCandsPerBlk8x8. For frames using bidirectional ME , the total number of candidates for single macroblock is sum of total number of candidates per MB for each direction (L0 and L1) */ 1870 uint32_t reserved1[243]; /**< [in]: Reserved and must be set to 0 */ 1871 void* reserved2[59]; /**< [in]: Reserved and must be set to NULL */ 1872 } NV_ENC_MEONLY_PARAMS; 1873 1874 /** NV_ENC_MEONLY_PARAMS struct version*/ 1875 #define NV_ENC_MEONLY_PARAMS_VER NVENCAPI_STRUCT_VERSION(3) 1876 1877 1878 /** 1879 * \struct _NV_ENC_LOCK_BITSTREAM 1880 * Bitstream buffer lock parameters. 1881 */ 1882 typedef struct _NV_ENC_LOCK_BITSTREAM 1883 { 1884 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_LOCK_BITSTREAM_VER. */ 1885 uint32_t doNotWait :1; /**< [in]: If this flag is set, the NvEncodeAPI interface will return buffer pointer even if operation is not completed. If not set, the call will block until operation completes. */ 1886 uint32_t ltrFrame :1; /**< [out]: Flag indicating this frame is marked as LTR frame */ 1887 uint32_t getRCStats :1; /**< [in]: If this flag is set then lockBitstream call will add additional intra-inter MB count and average MVX, MVY */ 1888 uint32_t reservedBitFields :29; /**< [in]: Reserved bit fields and must be set to 0 */ 1889 void* outputBitstream; /**< [in]: Pointer to the bitstream buffer being locked. */ 1890 uint32_t* sliceOffsets; /**< [in,out]: Array which receives the slice offsets. This is not supported if NV_ENC_CONFIG_H264::sliceMode is 1 on Kepler GPUs. Array size must be equal to size of frame in MBs. */ 1891 uint32_t frameIdx; /**< [out]: Frame no. for which the bitstream is being retrieved. */ 1892 uint32_t hwEncodeStatus; /**< [out]: The NvEncodeAPI interface status for the locked picture. */ 1893 uint32_t numSlices; /**< [out]: Number of slices in the encoded picture. Will be reported only if NV_ENC_INITIALIZE_PARAMS::reportSliceOffsets set to 1. */ 1894 uint32_t bitstreamSizeInBytes; /**< [out]: Actual number of bytes generated and copied to the memory pointed by bitstreamBufferPtr. */ 1895 uint64_t outputTimeStamp; /**< [out]: Presentation timestamp associated with the encoded output. */ 1896 uint64_t outputDuration; /**< [out]: Presentation duration associates with the encoded output. */ 1897 void* bitstreamBufferPtr; /**< [out]: Pointer to the generated output bitstream. 1898 For MEOnly mode _NV_ENC_LOCK_BITSTREAM::bitstreamBufferPtr should be typecast to 1899 NV_ENC_H264_MV_DATA/NV_ENC_HEVC_MV_DATA pointer respectively for H264/HEVC */ 1900 NV_ENC_PIC_TYPE pictureType; /**< [out]: Picture type of the encoded picture. */ 1901 NV_ENC_PIC_STRUCT pictureStruct; /**< [out]: Structure of the generated output picture. */ 1902 uint32_t frameAvgQP; /**< [out]: Average QP of the frame. */ 1903 uint32_t frameSatd; /**< [out]: Total SATD cost for whole frame. */ 1904 uint32_t ltrFrameIdx; /**< [out]: Frame index associated with this LTR frame. */ 1905 uint32_t ltrFrameBitmap; /**< [out]: Bitmap of LTR frames indices which were used for encoding this frame. Value of 0 if no LTR frames were used. */ 1906 uint32_t reserved[13]; /**< [in]: Reserved and must be set to 0 */ 1907 uint32_t intraMBCount; /**< [out]: For H264, Number of Intra MBs in the encoded frame. For HEVC, Number of Intra CTBs in the encoded frame. Supported only if _NV_ENC_LOCK_BITSTREAM::getRCStats set to 1. */ 1908 uint32_t interMBCount; /**< [out]: For H264, Number of Inter MBs in the encoded frame, includes skip MBs. For HEVC, Number of Inter CTBs in the encoded frame. Supported only if _NV_ENC_LOCK_BITSTREAM::getRCStats set to 1. */ 1909 int32_t averageMVX; /**< [out]: Average Motion Vector in X direction for the encoded frame. Supported only if _NV_ENC_LOCK_BITSTREAM::getRCStats set to 1. */ 1910 int32_t averageMVY; /**< [out]: Average Motion Vector in y direction for the encoded frame. Supported only if _NV_ENC_LOCK_BITSTREAM::getRCStats set to 1. */ 1911 uint32_t reserved1[219]; /**< [in]: Reserved and must be set to 0 */ 1912 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 1913 } NV_ENC_LOCK_BITSTREAM; 1914 1915 /** Macro for constructing the version field of ::_NV_ENC_LOCK_BITSTREAM */ 1916 #define NV_ENC_LOCK_BITSTREAM_VER NVENCAPI_STRUCT_VERSION(1) 1917 1918 1919 /** 1920 * \struct _NV_ENC_LOCK_INPUT_BUFFER 1921 * Uncompressed Input Buffer lock parameters. 1922 */ 1923 typedef struct _NV_ENC_LOCK_INPUT_BUFFER 1924 { 1925 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_LOCK_INPUT_BUFFER_VER. */ 1926 uint32_t doNotWait :1; /**< [in]: Set to 1 to make ::NvEncLockInputBuffer() a unblocking call. If the encoding is not completed, driver will return ::NV_ENC_ERR_ENCODER_BUSY error code. */ 1927 uint32_t reservedBitFields :31; /**< [in]: Reserved bitfields and must be set to 0 */ 1928 NV_ENC_INPUT_PTR inputBuffer; /**< [in]: Pointer to the input buffer to be locked, client should pass the pointer obtained from ::NvEncCreateInputBuffer() or ::NvEncMapInputResource API. */ 1929 void* bufferDataPtr; /**< [out]: Pointed to the locked input buffer data. Client can only access input buffer using the \p bufferDataPtr. */ 1930 uint32_t pitch; /**< [out]: Pitch of the locked input buffer. */ 1931 uint32_t reserved1[251]; /**< [in]: Reserved and must be set to 0 */ 1932 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 1933 } NV_ENC_LOCK_INPUT_BUFFER; 1934 1935 /** Macro for constructing the version field of ::_NV_ENC_LOCK_INPUT_BUFFER */ 1936 #define NV_ENC_LOCK_INPUT_BUFFER_VER NVENCAPI_STRUCT_VERSION(1) 1937 1938 1939 /** 1940 * \struct _NV_ENC_MAP_INPUT_RESOURCE 1941 * Map an input resource to a Nvidia Encoder Input Buffer 1942 */ 1943 typedef struct _NV_ENC_MAP_INPUT_RESOURCE 1944 { 1945 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_MAP_INPUT_RESOURCE_VER. */ 1946 uint32_t subResourceIndex; /**< [in]: Deprecated. Do not use. */ 1947 void* inputResource; /**< [in]: Deprecated. Do not use. */ 1948 NV_ENC_REGISTERED_PTR registeredResource; /**< [in]: The Registered resource handle obtained by calling NvEncRegisterInputResource. */ 1949 NV_ENC_INPUT_PTR mappedResource; /**< [out]: Mapped pointer corresponding to the registeredResource. This pointer must be used in NV_ENC_PIC_PARAMS::inputBuffer parameter in ::NvEncEncodePicture() API. */ 1950 NV_ENC_BUFFER_FORMAT mappedBufferFmt; /**< [out]: Buffer format of the outputResource. This buffer format must be used in NV_ENC_PIC_PARAMS::bufferFmt if client using the above mapped resource pointer. */ 1951 uint32_t reserved1[251]; /**< [in]: Reserved and must be set to 0. */ 1952 void* reserved2[63]; /**< [in]: Reserved and must be set to NULL */ 1953 } NV_ENC_MAP_INPUT_RESOURCE; 1954 1955 /** Macro for constructing the version field of ::_NV_ENC_MAP_INPUT_RESOURCE */ 1956 #define NV_ENC_MAP_INPUT_RESOURCE_VER NVENCAPI_STRUCT_VERSION(4) 1957 1958 /** 1959 * \struct _NV_ENC_INPUT_RESOURCE_OPENGL_TEX 1960 * NV_ENC_REGISTER_RESOURCE::resourceToRegister must be a pointer to a variable of this type, 1961 * when NV_ENC_REGISTER_RESOURCE::resourceType is NV_ENC_INPUT_RESOURCE_TYPE_OPENGL_TEX 1962 */ 1963 typedef struct _NV_ENC_INPUT_RESOURCE_OPENGL_TEX 1964 { 1965 uint32_t texture; /**< [in]: The name of the texture to be used. */ 1966 uint32_t target; /**< [in]: Accepted values are GL_TEXTURE_RECTANGLE and GL_TEXTURE_2D. */ 1967 } NV_ENC_INPUT_RESOURCE_OPENGL_TEX; 1968 1969 /** 1970 * \struct _NV_ENC_REGISTER_RESOURCE 1971 * Register a resource for future use with the Nvidia Video Encoder Interface. 1972 */ 1973 typedef struct _NV_ENC_REGISTER_RESOURCE 1974 { 1975 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_REGISTER_RESOURCE_VER. */ 1976 NV_ENC_INPUT_RESOURCE_TYPE resourceType; /**< [in]: Specifies the type of resource to be registered. 1977 Supported values are 1978 ::NV_ENC_INPUT_RESOURCE_TYPE_DIRECTX, 1979 ::NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR, 1980 ::NV_ENC_INPUT_RESOURCE_TYPE_OPENGL_TEX */ 1981 uint32_t width; /**< [in]: Input buffer Width. */ 1982 uint32_t height; /**< [in]: Input buffer Height. */ 1983 uint32_t pitch; /**< [in]: Input buffer Pitch. 1984 For ::NV_ENC_INPUT_RESOURCE_TYPE_DIRECTX resources, set this to 0. 1985 For ::NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR resources, set this to 1986 the pitch as obtained from cuMemAllocPitch(), or to the width in 1987 bytes (if this resource was created by using cuMemAlloc()). This 1988 value must be a multiple of 4. 1989 For ::NV_ENC_INPUT_RESOURCE_TYPE_CUDAARRAY resources, set this to the 1990 width of the allocation in bytes (i.e. 1991 CUDA_ARRAY3D_DESCRIPTOR::Width * CUDA_ARRAY3D_DESCRIPTOR::NumChannels). 1992 For ::NV_ENC_INPUT_RESOURCE_TYPE_OPENGL_TEX resources, set this to the 1993 texture width multiplied by the number of components in the texture 1994 format. */ 1995 uint32_t subResourceIndex; /**< [in]: Subresource Index of the DirectX resource to be registered. Should be set to 0 for other interfaces. */ 1996 void* resourceToRegister; /**< [in]: Handle to the resource that is being registered. */ 1997 NV_ENC_REGISTERED_PTR registeredResource; /**< [out]: Registered resource handle. This should be used in future interactions with the Nvidia Video Encoder Interface. */ 1998 NV_ENC_BUFFER_FORMAT bufferFormat; /**< [in]: Buffer format of resource to be registered. */ 1999 NV_ENC_BUFFER_USAGE bufferUsage; /**< [in]: Usage of resource to be registered. */ 2000 uint32_t reserved1[247]; /**< [in]: Reserved and must be set to 0. */ 2001 void* reserved2[62]; /**< [in]: Reserved and must be set to NULL. */ 2002 } NV_ENC_REGISTER_RESOURCE; 2003 2004 /** Macro for constructing the version field of ::_NV_ENC_REGISTER_RESOURCE */ 2005 #define NV_ENC_REGISTER_RESOURCE_VER NVENCAPI_STRUCT_VERSION(3) 2006 2007 /** 2008 * \struct _NV_ENC_STAT 2009 * Encode Stats structure. 2010 */ 2011 typedef struct _NV_ENC_STAT 2012 { 2013 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_STAT_VER. */ 2014 uint32_t reserved; /**< [in]: Reserved and must be set to 0 */ 2015 NV_ENC_OUTPUT_PTR outputBitStream; /**< [out]: Specifies the pointer to output bitstream. */ 2016 uint32_t bitStreamSize; /**< [out]: Size of generated bitstream in bytes. */ 2017 uint32_t picType; /**< [out]: Picture type of encoded picture. See ::NV_ENC_PIC_TYPE. */ 2018 uint32_t lastValidByteOffset; /**< [out]: Offset of last valid bytes of completed bitstream */ 2019 uint32_t sliceOffsets[16]; /**< [out]: Offsets of each slice */ 2020 uint32_t picIdx; /**< [out]: Picture number */ 2021 uint32_t reserved1[233]; /**< [in]: Reserved and must be set to 0 */ 2022 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 2023 } NV_ENC_STAT; 2024 2025 /** Macro for constructing the version field of ::_NV_ENC_STAT */ 2026 #define NV_ENC_STAT_VER NVENCAPI_STRUCT_VERSION(1) 2027 2028 2029 /** 2030 * \struct _NV_ENC_SEQUENCE_PARAM_PAYLOAD 2031 * Sequence and picture paramaters payload. 2032 */ 2033 typedef struct _NV_ENC_SEQUENCE_PARAM_PAYLOAD 2034 { 2035 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_INITIALIZE_PARAMS_VER. */ 2036 uint32_t inBufferSize; /**< [in]: Specifies the size of the spsppsBuffer provied by the client */ 2037 uint32_t spsId; /**< [in]: Specifies the SPS id to be used in sequence header. Default value is 0. */ 2038 uint32_t ppsId; /**< [in]: Specifies the PPS id to be used in picture header. Default value is 0. */ 2039 void* spsppsBuffer; /**< [in]: Specifies bitstream header pointer of size NV_ENC_SEQUENCE_PARAM_PAYLOAD::inBufferSize. It is the client's responsibility to manage this memory. */ 2040 uint32_t* outSPSPPSPayloadSize; /**< [out]: Size of the sequence and picture header in bytes written by the NvEncodeAPI interface to the SPSPPSBuffer. */ 2041 uint32_t reserved [250]; /**< [in]: Reserved and must be set to 0 */ 2042 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 2043 } NV_ENC_SEQUENCE_PARAM_PAYLOAD; 2044 2045 /** Macro for constructing the version field of ::_NV_ENC_SEQUENCE_PARAM_PAYLOAD */ 2046 #define NV_ENC_SEQUENCE_PARAM_PAYLOAD_VER NVENCAPI_STRUCT_VERSION(1) 2047 2048 2049 /** 2050 * Event registration/unregistration parameters. 2051 */ 2052 typedef struct _NV_ENC_EVENT_PARAMS 2053 { 2054 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_EVENT_PARAMS_VER. */ 2055 uint32_t reserved; /**< [in]: Reserved and must be set to 0 */ 2056 void* completionEvent; /**< [in]: Handle to event to be registered/unregistered with the NvEncodeAPI interface. */ 2057 uint32_t reserved1[253]; /**< [in]: Reserved and must be set to 0 */ 2058 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 2059 } NV_ENC_EVENT_PARAMS; 2060 2061 /** Macro for constructing the version field of ::_NV_ENC_EVENT_PARAMS */ 2062 #define NV_ENC_EVENT_PARAMS_VER NVENCAPI_STRUCT_VERSION(1) 2063 2064 /** 2065 * Encoder Session Creation parameters 2066 */ 2067 typedef struct _NV_ENC_OPEN_ENCODE_SESSIONEX_PARAMS 2068 { 2069 uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS_VER. */ 2070 NV_ENC_DEVICE_TYPE deviceType; /**< [in]: Specified the device Type */ 2071 void* device; /**< [in]: Pointer to client device. */ 2072 void* reserved; /**< [in]: Reserved and must be set to 0. */ 2073 uint32_t apiVersion; /**< [in]: API version. Should be set to NVENCAPI_VERSION. */ 2074 uint32_t reserved1[253]; /**< [in]: Reserved and must be set to 0 */ 2075 void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ 2076 } NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS; 2077 /** Macro for constructing the version field of ::_NV_ENC_OPEN_ENCODE_SESSIONEX_PARAMS */ 2078 #define NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS_VER NVENCAPI_STRUCT_VERSION(1) 2079 2080 /** @} */ /* END ENCODER_STRUCTURE */ 2081 2082 2083 /** 2084 * \addtogroup ENCODE_FUNC NvEncodeAPI Functions 2085 * @{ 2086 */ 2087 2088 // NvEncOpenEncodeSession 2089 /** 2090 * \brief Opens an encoding session. 2091 * 2092 * Deprecated. 2093 * 2094 * \return 2095 * ::NV_ENC_ERR_INVALID_CALL\n 2096 * 2097 */ 2098 NVENCSTATUS NVENCAPI NvEncOpenEncodeSession (void* device, uint32_t deviceType, void** encoder); 2099 2100 // NvEncGetEncodeGuidCount 2101 /** 2102 * \brief Retrieves the number of supported encode GUIDs. 2103 * 2104 * The function returns the number of codec guids supported by the NvEncodeAPI 2105 * interface. 2106 * 2107 * \param [in] encoder 2108 * Pointer to the NvEncodeAPI interface. 2109 * \param [out] encodeGUIDCount 2110 * Number of supported encode GUIDs. 2111 * 2112 * \return 2113 * ::NV_ENC_SUCCESS \n 2114 * ::NV_ENC_ERR_INVALID_PTR \n 2115 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2116 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2117 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2118 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2119 * ::NV_ENC_ERR_INVALID_PARAM \n 2120 * ::NV_ENC_ERR_GENERIC \n 2121 * 2122 */ 2123 NVENCSTATUS NVENCAPI NvEncGetEncodeGUIDCount (void* encoder, uint32_t* encodeGUIDCount); 2124 2125 2126 // NvEncGetEncodeGUIDs 2127 /** 2128 * \brief Retrieves an array of supported encoder codec GUIDs. 2129 * 2130 * The function returns an array of codec guids supported by the NvEncodeAPI interface. 2131 * The client must allocate an array where the NvEncodeAPI interface can 2132 * fill the supported guids and pass the pointer in \p *GUIDs parameter. 2133 * The size of the array can be determined by using ::NvEncGetEncodeGUIDCount() API. 2134 * The Nvidia Encoding interface returns the number of codec guids it has actually 2135 * filled in the guid array in the \p GUIDCount parameter. 2136 * 2137 * \param [in] encoder 2138 * Pointer to the NvEncodeAPI interface. 2139 * \param [in] guidArraySize 2140 * Number of GUIDs to retrieved. Should be set to the number retrieved using 2141 * ::NvEncGetEncodeGUIDCount. 2142 * \param [out] GUIDs 2143 * Array of supported Encode GUIDs. 2144 * \param [out] GUIDCount 2145 * Number of supported Encode GUIDs. 2146 * 2147 * \return 2148 * ::NV_ENC_SUCCESS \n 2149 * ::NV_ENC_ERR_INVALID_PTR \n 2150 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2151 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2152 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2153 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2154 * ::NV_ENC_ERR_INVALID_PARAM \n 2155 * ::NV_ENC_ERR_GENERIC \n 2156 * 2157 */ 2158 NVENCSTATUS NVENCAPI NvEncGetEncodeGUIDs (void* encoder, GUID* GUIDs, uint32_t guidArraySize, uint32_t* GUIDCount); 2159 2160 2161 // NvEncGetEncodeProfileGuidCount 2162 /** 2163 * \brief Retrieves the number of supported profile GUIDs. 2164 * 2165 * The function returns the number of profile GUIDs supported for a given codec. 2166 * The client must first enumerate the codec guids supported by the NvEncodeAPI 2167 * interface. After determining the codec guid, it can query the NvEncodeAPI 2168 * interface to determine the number of profile guids supported for a particular 2169 * codec guid. 2170 * 2171 * \param [in] encoder 2172 * Pointer to the NvEncodeAPI interface. 2173 * \param [in] encodeGUID 2174 * The codec guid for which the profile guids are being enumerated. 2175 * \param [out] encodeProfileGUIDCount 2176 * Number of encode profiles supported for the given encodeGUID. 2177 * 2178 * \return 2179 * ::NV_ENC_SUCCESS \n 2180 * ::NV_ENC_ERR_INVALID_PTR \n 2181 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2182 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2183 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2184 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2185 * ::NV_ENC_ERR_INVALID_PARAM \n 2186 * ::NV_ENC_ERR_GENERIC \n 2187 * 2188 */ 2189 NVENCSTATUS NVENCAPI NvEncGetEncodeProfileGUIDCount (void* encoder, GUID encodeGUID, uint32_t* encodeProfileGUIDCount); 2190 2191 2192 // NvEncGetEncodeProfileGUIDs 2193 /** 2194 * \brief Retrieves an array of supported encode profile GUIDs. 2195 * 2196 * The function returns an array of supported profile guids for a particular 2197 * codec guid. The client must allocate an array where the NvEncodeAPI interface 2198 * can populate the profile guids. The client can determine the array size using 2199 * ::NvEncGetEncodeProfileGUIDCount() API. The client must also validiate that the 2200 * NvEncodeAPI interface supports the GUID the client wants to pass as \p encodeGUID 2201 * parameter. 2202 * 2203 * \param [in] encoder 2204 * Pointer to the NvEncodeAPI interface. 2205 * \param [in] encodeGUID 2206 * The encode guid whose profile guids are being enumerated. 2207 * \param [in] guidArraySize 2208 * Number of GUIDs to be retrieved. Should be set to the number retrieved using 2209 * ::NvEncGetEncodeProfileGUIDCount. 2210 * \param [out] profileGUIDs 2211 * Array of supported Encode Profile GUIDs 2212 * \param [out] GUIDCount 2213 * Number of valid encode profile GUIDs in \p profileGUIDs array. 2214 * 2215 * \return 2216 * ::NV_ENC_SUCCESS \n 2217 * ::NV_ENC_ERR_INVALID_PTR \n 2218 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2219 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2220 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2221 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2222 * ::NV_ENC_ERR_INVALID_PARAM \n 2223 * ::NV_ENC_ERR_GENERIC \n 2224 * 2225 */ 2226 NVENCSTATUS NVENCAPI NvEncGetEncodeProfileGUIDs (void* encoder, GUID encodeGUID, GUID* profileGUIDs, uint32_t guidArraySize, uint32_t* GUIDCount); 2227 2228 // NvEncGetInputFormatCount 2229 /** 2230 * \brief Retrieve the number of supported Input formats. 2231 * 2232 * The function returns the number of supported input formats. The client must 2233 * query the NvEncodeAPI interface to determine the supported input formats 2234 * before creating the input surfaces. 2235 * 2236 * \param [in] encoder 2237 * Pointer to the NvEncodeAPI interface. 2238 * \param [in] encodeGUID 2239 * Encode GUID, corresponding to which the number of supported input formats 2240 * is to be retrieved. 2241 * \param [out] inputFmtCount 2242 * Number of input formats supported for specified Encode GUID. 2243 * 2244 * \return 2245 * ::NV_ENC_SUCCESS \n 2246 * ::NV_ENC_ERR_INVALID_PTR \n 2247 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2248 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2249 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2250 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2251 * ::NV_ENC_ERR_INVALID_PARAM \n 2252 * ::NV_ENC_ERR_GENERIC \n 2253 */ 2254 NVENCSTATUS NVENCAPI NvEncGetInputFormatCount (void* encoder, GUID encodeGUID, uint32_t* inputFmtCount); 2255 2256 2257 // NvEncGetInputFormats 2258 /** 2259 * \brief Retrieves an array of supported Input formats 2260 * 2261 * Returns an array of supported input formats The client must use the input 2262 * format to create input surface using ::NvEncCreateInputBuffer() API. 2263 * 2264 * \param [in] encoder 2265 * Pointer to the NvEncodeAPI interface. 2266 * \param [in] encodeGUID 2267 * Encode GUID, corresponding to which the number of supported input formats 2268 * is to be retrieved. 2269 *\param [in] inputFmtArraySize 2270 * Size input format count array passed in \p inputFmts. 2271 *\param [out] inputFmts 2272 * Array of input formats supported for this Encode GUID. 2273 *\param [out] inputFmtCount 2274 * The number of valid input format types returned by the NvEncodeAPI 2275 * interface in \p inputFmts array. 2276 * 2277 * \return 2278 * ::NV_ENC_SUCCESS \n 2279 * ::NV_ENC_ERR_INVALID_PTR \n 2280 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2281 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2282 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2283 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2284 * ::NV_ENC_ERR_INVALID_PARAM \n 2285 * ::NV_ENC_ERR_GENERIC \n 2286 * 2287 */ 2288 NVENCSTATUS NVENCAPI NvEncGetInputFormats (void* encoder, GUID encodeGUID, NV_ENC_BUFFER_FORMAT* inputFmts, uint32_t inputFmtArraySize, uint32_t* inputFmtCount); 2289 2290 2291 // NvEncGetEncodeCaps 2292 /** 2293 * \brief Retrieves the capability value for a specified encoder attribute. 2294 * 2295 * The function returns the capability value for a given encoder attribute. The 2296 * client must validate the encodeGUID using ::NvEncGetEncodeGUIDs() API before 2297 * calling this function. The encoder attribute being queried are enumerated in 2298 * ::NV_ENC_CAPS_PARAM enum. 2299 * 2300 * \param [in] encoder 2301 * Pointer to the NvEncodeAPI interface. 2302 * \param [in] encodeGUID 2303 * Encode GUID, corresponding to which the capability attribute is to be retrieved. 2304 * \param [in] capsParam 2305 * Used to specify attribute being queried. Refer ::NV_ENC_CAPS_PARAM for more 2306 * details. 2307 * \param [out] capsVal 2308 * The value corresponding to the capability attribute being queried. 2309 * 2310 * \return 2311 * ::NV_ENC_SUCCESS \n 2312 * ::NV_ENC_ERR_INVALID_PTR \n 2313 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2314 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2315 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2316 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2317 * ::NV_ENC_ERR_INVALID_PARAM \n 2318 * ::NV_ENC_ERR_GENERIC \n 2319 */ 2320 NVENCSTATUS NVENCAPI NvEncGetEncodeCaps (void* encoder, GUID encodeGUID, NV_ENC_CAPS_PARAM* capsParam, int* capsVal); 2321 2322 2323 // NvEncGetEncodePresetCount 2324 /** 2325 * \brief Retrieves the number of supported preset GUIDs. 2326 * 2327 * The function returns the number of preset GUIDs available for a given codec. 2328 * The client must validate the codec guid using ::NvEncGetEncodeGUIDs() API 2329 * before calling this function. 2330 * 2331 * \param [in] encoder 2332 * Pointer to the NvEncodeAPI interface. 2333 * \param [in] encodeGUID 2334 * Encode GUID, corresponding to which the number of supported presets is to 2335 * be retrieved. 2336 * \param [out] encodePresetGUIDCount 2337 * Receives the number of supported preset GUIDs. 2338 * 2339 * \return 2340 * ::NV_ENC_SUCCESS \n 2341 * ::NV_ENC_ERR_INVALID_PTR \n 2342 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2343 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2344 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2345 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2346 * ::NV_ENC_ERR_INVALID_PARAM \n 2347 * ::NV_ENC_ERR_GENERIC \n 2348 * 2349 */ 2350 NVENCSTATUS NVENCAPI NvEncGetEncodePresetCount (void* encoder, GUID encodeGUID, uint32_t* encodePresetGUIDCount); 2351 2352 2353 // NvEncGetEncodePresetGUIDs 2354 /** 2355 * \brief Receives an array of supported encoder preset GUIDs. 2356 * 2357 * The function returns an array of encode preset guids available for a given codec. 2358 * The client can directly use one of the preset guids based upon the use case 2359 * or target device. The preset guid chosen can be directly used in 2360 * NV_ENC_INITIALIZE_PARAMS::presetGUID parameter to ::NvEncEncodePicture() API. 2361 * Alternately client can also use the preset guid to retrieve the encoding config 2362 * parameters being used by NvEncodeAPI interface for that given preset, using 2363 * ::NvEncGetEncodePresetConfig() API. It can then modify preset config parameters 2364 * as per its use case and send it to NvEncodeAPI interface as part of 2365 * NV_ENC_INITIALIZE_PARAMS::encodeConfig parameter for NvEncInitializeEncoder() 2366 * API. 2367 * 2368 * 2369 * \param [in] encoder 2370 * Pointer to the NvEncodeAPI interface. 2371 * \param [in] encodeGUID 2372 * Encode GUID, corresponding to which the list of supported presets is to be 2373 * retrieved. 2374 * \param [in] guidArraySize 2375 * Size of array of preset guids passed in \p preset GUIDs 2376 * \param [out] presetGUIDs 2377 * Array of supported Encode preset GUIDs from the NvEncodeAPI interface 2378 * to client. 2379 * \param [out] encodePresetGUIDCount 2380 * Receives the number of preset GUIDs returned by the NvEncodeAPI 2381 * interface. 2382 * 2383 * \return 2384 * ::NV_ENC_SUCCESS \n 2385 * ::NV_ENC_ERR_INVALID_PTR \n 2386 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2387 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2388 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2389 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2390 * ::NV_ENC_ERR_INVALID_PARAM \n 2391 * ::NV_ENC_ERR_GENERIC \n 2392 * 2393 */ 2394 NVENCSTATUS NVENCAPI NvEncGetEncodePresetGUIDs (void* encoder, GUID encodeGUID, GUID* presetGUIDs, uint32_t guidArraySize, uint32_t* encodePresetGUIDCount); 2395 2396 2397 // NvEncGetEncodePresetConfig 2398 /** 2399 * \brief Returns a preset config structure supported for given preset GUID. 2400 * 2401 * The function returns a preset config structure for a given preset guid. Before 2402 * using this function the client must enumerate the preset guids available for 2403 * a given codec. The preset config structure can be modified by the client depending 2404 * upon its use case and can be then used to initialize the encoder using 2405 * ::NvEncInitializeEncoder() API. The client can use this function only if it 2406 * wants to modify the NvEncodeAPI preset configuration, otherwise it can 2407 * directly use the preset guid. 2408 * 2409 * \param [in] encoder 2410 * Pointer to the NvEncodeAPI interface. 2411 * \param [in] encodeGUID 2412 * Encode GUID, corresponding to which the list of supported presets is to be 2413 * retrieved. 2414 * \param [in] presetGUID 2415 * Preset GUID, corresponding to which the Encoding configurations is to be 2416 * retrieved. 2417 * \param [out] presetConfig 2418 * The requested Preset Encoder Attribute set. Refer ::_NV_ENC_CONFIG for 2419 * more details. 2420 * 2421 * \return 2422 * ::NV_ENC_SUCCESS \n 2423 * ::NV_ENC_ERR_INVALID_PTR \n 2424 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2425 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2426 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2427 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2428 * ::NV_ENC_ERR_INVALID_PARAM \n 2429 * ::NV_ENC_ERR_INVALID_VERSION \n 2430 * ::NV_ENC_ERR_GENERIC \n 2431 * 2432 */ 2433 NVENCSTATUS NVENCAPI NvEncGetEncodePresetConfig (void* encoder, GUID encodeGUID, GUID presetGUID, NV_ENC_PRESET_CONFIG* presetConfig); 2434 2435 // NvEncInitializeEncoder 2436 /** 2437 * \brief Initialize the encoder. 2438 * 2439 * This API must be used to initialize the encoder. The initialization parameter 2440 * is passed using \p *createEncodeParams The client must send the following 2441 * fields of the _NV_ENC_INITIALIZE_PARAMS structure with a valid value. 2442 * - NV_ENC_INITIALIZE_PARAMS::encodeGUID 2443 * - NV_ENC_INITIALIZE_PARAMS::encodeWidth 2444 * - NV_ENC_INITIALIZE_PARAMS::encodeHeight 2445 * 2446 * The client can pass a preset guid directly to the NvEncodeAPI interface using 2447 * NV_ENC_INITIALIZE_PARAMS::presetGUID field. If the client doesn't pass 2448 * NV_ENC_INITIALIZE_PARAMS::encodeConfig structure, the codec specific parameters 2449 * will be selected based on the preset guid. The preset guid must have been 2450 * validated by the client using ::NvEncGetEncodePresetGUIDs() API. 2451 * If the client passes a custom ::_NV_ENC_CONFIG structure through 2452 * NV_ENC_INITIALIZE_PARAMS::encodeConfig , it will override the codec specific parameters 2453 * based on the preset guid. It is recommended that even if the client passes a custom config, 2454 * it should also send a preset guid. In this case, the preset guid passed by the client 2455 * will not override any of the custom config parameters programmed by the client, 2456 * it is only used as a hint by the NvEncodeAPI interface to determine certain encoder parameters 2457 * which are not exposed to the client. 2458 * 2459 * There are two modes of operation for the encoder namely: 2460 * - Asynchronous mode 2461 * - Synchronous mode 2462 * 2463 * The client can select asynchronous or synchronous mode by setting the \p 2464 * enableEncodeAsync field in ::_NV_ENC_INITIALIZE_PARAMS to 1 or 0 respectively. 2465 *\par Asynchronous mode of operation: 2466 * The Asynchronous mode can be enabled by setting NV_ENC_INITIALIZE_PARAMS::enableEncodeAsync to 1. 2467 * The client operating in asynchronous mode must allocate completion event object 2468 * for each output buffer and pass the completion event object in the 2469 * ::NvEncEncodePicture() API. The client can create another thread and wait on 2470 * the event object to be signalled by NvEncodeAPI interface on completion of the 2471 * encoding process for the output frame. This should unblock the main thread from 2472 * submitting work to the encoder. When the event is signalled the client can call 2473 * NvEncodeAPI interfaces to copy the bitstream data using ::NvEncLockBitstream() 2474 * API. This is the preferred mode of operation. 2475 * 2476 * NOTE: Asynchronous mode is not supported on Linux. 2477 * 2478 *\par Synchronous mode of operation: 2479 * The client can select synchronous mode by setting NV_ENC_INITIALIZE_PARAMS::enableEncodeAsync to 0. 2480 * The client working in synchronous mode can work in a single threaded or multi 2481 * threaded mode. The client need not allocate any event objects. The client can 2482 * only lock the bitstream data after NvEncodeAPI interface has returned 2483 * ::NV_ENC_SUCCESS from encode picture. The NvEncodeAPI interface can return 2484 * ::NV_ENC_ERR_NEED_MORE_INPUT error code from ::NvEncEncodePicture() API. The 2485 * client must not lock the output buffer in such case but should send the next 2486 * frame for encoding. The client must keep on calling ::NvEncEncodePicture() API 2487 * until it returns ::NV_ENC_SUCCESS. \n 2488 * The client must always lock the bitstream data in order in which it has submitted. 2489 * This is true for both asynchronous and synchronous mode. 2490 * 2491 *\par Picture type decision: 2492 * If the client is taking the picture type decision and it must disable the picture 2493 * type decision module in NvEncodeAPI by setting NV_ENC_INITIALIZE_PARAMS::enablePTD 2494 * to 0. In this case the client is required to send the picture in encoding 2495 * order to NvEncodeAPI by doing the re-ordering for B frames. \n 2496 * If the client doesn't want to take the picture type decision it can enable 2497 * picture type decision module in the NvEncodeAPI interface by setting 2498 * NV_ENC_INITIALIZE_PARAMS::enablePTD to 1 and send the input pictures in display 2499 * order. 2500 * 2501 * \param [in] encoder 2502 * Pointer to the NvEncodeAPI interface. 2503 * \param [in] createEncodeParams 2504 * Refer ::_NV_ENC_INITIALIZE_PARAMS for details. 2505 * 2506 * \return 2507 * ::NV_ENC_SUCCESS \n 2508 * ::NV_ENC_ERR_INVALID_PTR \n 2509 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2510 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2511 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2512 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2513 * ::NV_ENC_ERR_INVALID_PARAM \n 2514 * ::NV_ENC_ERR_INVALID_VERSION \n 2515 * ::NV_ENC_ERR_GENERIC \n 2516 * 2517 */ 2518 NVENCSTATUS NVENCAPI NvEncInitializeEncoder (void* encoder, NV_ENC_INITIALIZE_PARAMS* createEncodeParams); 2519 2520 2521 // NvEncCreateInputBuffer 2522 /** 2523 * \brief Allocates Input buffer. 2524 * 2525 * This function is used to allocate an input buffer. The client must enumerate 2526 * the input buffer format before allocating the input buffer resources. The 2527 * NV_ENC_INPUT_PTR returned by the NvEncodeAPI interface in the 2528 * NV_ENC_CREATE_INPUT_BUFFER::inputBuffer field can be directly used in 2529 * ::NvEncEncodePicture() API. The number of input buffers to be allocated by the 2530 * client must be at least 4 more than the number of B frames being used for encoding. 2531 * 2532 * \param [in] encoder 2533 * Pointer to the NvEncodeAPI interface. 2534 * \param [in,out] createInputBufferParams 2535 * Pointer to the ::NV_ENC_CREATE_INPUT_BUFFER structure. 2536 * 2537 * \return 2538 * ::NV_ENC_SUCCESS \n 2539 * ::NV_ENC_ERR_INVALID_PTR \n 2540 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2541 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2542 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2543 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2544 * ::NV_ENC_ERR_INVALID_PARAM \n 2545 * ::NV_ENC_ERR_INVALID_VERSION \n 2546 * ::NV_ENC_ERR_GENERIC \n 2547 * 2548 */ 2549 NVENCSTATUS NVENCAPI NvEncCreateInputBuffer (void* encoder, NV_ENC_CREATE_INPUT_BUFFER* createInputBufferParams); 2550 2551 2552 // NvEncDestroyInputBuffer 2553 /** 2554 * \brief Release an input buffers. 2555 * 2556 * This function is used to free an input buffer. If the client has allocated 2557 * any input buffer using ::NvEncCreateInputBuffer() API, it must free those 2558 * input buffers by calling this function. The client must release the input 2559 * buffers before destroying the encoder using ::NvEncDestroyEncoder() API. 2560 * 2561 * \param [in] encoder 2562 * Pointer to the NvEncodeAPI interface. 2563 * \param [in] inputBuffer 2564 * Pointer to the input buffer to be released. 2565 * 2566 * \return 2567 * ::NV_ENC_SUCCESS \n 2568 * ::NV_ENC_ERR_INVALID_PTR \n 2569 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2570 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2571 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2572 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2573 * ::NV_ENC_ERR_INVALID_PARAM \n 2574 * ::NV_ENC_ERR_INVALID_VERSION \n 2575 * ::NV_ENC_ERR_GENERIC \n 2576 * 2577 */ 2578 NVENCSTATUS NVENCAPI NvEncDestroyInputBuffer (void* encoder, NV_ENC_INPUT_PTR inputBuffer); 2579 2580 // NvEncSetIOCudaStreams 2581 /** 2582 * \brief Set input and output CUDA stream for specified encoder attribute. 2583 * 2584 * Encoding may involve CUDA pre-processing on the input and post-processing on encoded output. 2585 * This function is used to set input and output CUDA streams to pipeline the CUDA pre-processing 2586 * and post-processing tasks. Clients should call this function before the call to 2587 * NvEncUnlockInputBuffer(). If this function is not called, the default CUDA stream is used for 2588 * input and output processing. After a successful call to this function, the streams specified 2589 * in that call will replace the previously-used streams. 2590 * This API is supported for NVCUVID interface only. 2591 * 2592 * \param [in] encoder 2593 * Pointer to the NvEncodeAPI interface. 2594 * \param [in] inputStream 2595 * Pointer to CUstream which is used to process ::NV_ENC_PIC_PARAMS::inputFrame for encode. 2596 * In case of ME-only mode, inputStream is used to process ::NV_ENC_MEONLY_PARAMS::inputBuffer and 2597 * ::NV_ENC_MEONLY_PARAMS::referenceFrame 2598 * \param [in] outputStream 2599 * Pointer to CUstream which is used to process ::NV_ENC_PIC_PARAMS::outputBuffer for encode. 2600 * In case of ME-only mode, outputStream is used to process ::NV_ENC_MEONLY_PARAMS::mvBuffer 2601 * 2602 * \return 2603 * ::NV_ENC_SUCCESS \n 2604 * ::NV_ENC_ERR_INVALID_PTR \n 2605 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2606 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2607 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2608 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2609 * ::NV_ENC_ERR_INVALID_PARAM \n 2610 * ::NV_ENC_ERR_INVALID_VERSION \n 2611 * ::NV_ENC_ERR_GENERIC \n 2612 */ 2613 NVENCSTATUS NVENCAPI NvEncSetIOCudaStreams (void* encoder, NV_ENC_CUSTREAM_PTR inputStream, NV_ENC_CUSTREAM_PTR outputStream); 2614 2615 2616 // NvEncCreateBitstreamBuffer 2617 /** 2618 * \brief Allocates an output bitstream buffer 2619 * 2620 * This function is used to allocate an output bitstream buffer and returns a 2621 * NV_ENC_OUTPUT_PTR to bitstream buffer to the client in the 2622 * NV_ENC_CREATE_BITSTREAM_BUFFER::bitstreamBuffer field. 2623 * The client can only call this function after the encoder session has been 2624 * initialized using ::NvEncInitializeEncoder() API. The minimum number of output 2625 * buffers allocated by the client must be at least 4 more than the number of B 2626 * B frames being used for encoding. The client can only access the output 2627 * bitsteam data by locking the \p bitstreamBuffer using the ::NvEncLockBitstream() 2628 * function. 2629 * 2630 * \param [in] encoder 2631 * Pointer to the NvEncodeAPI interface. 2632 * \param [in,out] createBitstreamBufferParams 2633 * Pointer ::NV_ENC_CREATE_BITSTREAM_BUFFER for details. 2634 * 2635 * \return 2636 * ::NV_ENC_SUCCESS \n 2637 * ::NV_ENC_ERR_INVALID_PTR \n 2638 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2639 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2640 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2641 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2642 * ::NV_ENC_ERR_INVALID_PARAM \n 2643 * ::NV_ENC_ERR_INVALID_VERSION \n 2644 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 2645 * ::NV_ENC_ERR_GENERIC \n 2646 * 2647 */ 2648 NVENCSTATUS NVENCAPI NvEncCreateBitstreamBuffer (void* encoder, NV_ENC_CREATE_BITSTREAM_BUFFER* createBitstreamBufferParams); 2649 2650 2651 // NvEncDestroyBitstreamBuffer 2652 /** 2653 * \brief Release a bitstream buffer. 2654 * 2655 * This function is used to release the output bitstream buffer allocated using 2656 * the ::NvEncCreateBitstreamBuffer() function. The client must release the output 2657 * bitstreamBuffer using this function before destroying the encoder session. 2658 * 2659 * \param [in] encoder 2660 * Pointer to the NvEncodeAPI interface. 2661 * \param [in] bitstreamBuffer 2662 * Pointer to the bitstream buffer being released. 2663 * 2664 * \return 2665 * ::NV_ENC_SUCCESS \n 2666 * ::NV_ENC_ERR_INVALID_PTR \n 2667 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2668 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2669 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2670 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2671 * ::NV_ENC_ERR_INVALID_PARAM \n 2672 * ::NV_ENC_ERR_INVALID_VERSION \n 2673 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 2674 * ::NV_ENC_ERR_GENERIC \n 2675 * 2676 */ 2677 NVENCSTATUS NVENCAPI NvEncDestroyBitstreamBuffer (void* encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); 2678 2679 // NvEncEncodePicture 2680 /** 2681 * \brief Submit an input picture for encoding. 2682 * 2683 * This function is used to submit an input picture buffer for encoding. The 2684 * encoding parameters are passed using \p *encodePicParams which is a pointer 2685 * to the ::_NV_ENC_PIC_PARAMS structure. 2686 * 2687 * If the client has set NV_ENC_INITIALIZE_PARAMS::enablePTD to 0, then it must 2688 * send a valid value for the following fields. 2689 * - NV_ENC_PIC_PARAMS::pictureType 2690 * - NV_ENC_PIC_PARAMS_H264::displayPOCSyntax (H264 only) 2691 * - NV_ENC_PIC_PARAMS_H264::frameNumSyntax(H264 only) 2692 * - NV_ENC_PIC_PARAMS_H264::refPicFlag(H264 only) 2693 * 2694 *\par MVC Encoding: 2695 * For MVC encoding the client must call encode picture api for each view separately 2696 * and must pass valid view id in NV_ENC_PIC_PARAMS_MVC::viewID field. Currently 2697 * NvEncodeAPI only support stereo MVC so client must send viewID as 0 for base 2698 * view and view ID as 1 for dependent view. 2699 * 2700 *\par Asynchronous Encoding 2701 * If the client has enabled asynchronous mode of encoding by setting 2702 * NV_ENC_INITIALIZE_PARAMS::enableEncodeAsync to 1 in the ::NvEncInitializeEncoder() 2703 * API ,then the client must send a valid NV_ENC_PIC_PARAMS::completionEvent. 2704 * Incase of asynchronous mode of operation, client can queue the ::NvEncEncodePicture() 2705 * API commands from the main thread and then queue output buffers to be processed 2706 * to a secondary worker thread. Before the locking the output buffers in the 2707 * secondary thread , the client must wait on NV_ENC_PIC_PARAMS::completionEvent 2708 * it has queued in ::NvEncEncodePicture() API call. The client must always process 2709 * completion event and the output buffer in the same order in which they have been 2710 * submitted for encoding. The NvEncodeAPI interface is responsible for any 2711 * re-ordering required for B frames and will always ensure that encoded bitstream 2712 * data is written in the same order in which output buffer is submitted. 2713 *\code 2714 The below example shows how asynchronous encoding in case of 1 B frames 2715 ------------------------------------------------------------------------ 2716 Suppose the client allocated 4 input buffers(I1,I2..), 4 output buffers(O1,O2..) 2717 and 4 completion events(E1, E2, ...). The NvEncodeAPI interface will need to 2718 keep a copy of the input buffers for re-ordering and it allocates following 2719 internal buffers (NvI1, NvI2...). These internal buffers are managed by NvEncodeAPI 2720 and the client is not responsible for the allocating or freeing the memory of 2721 the internal buffers. 2722 2723 a) The client main thread will queue the following encode frame calls. 2724 Note the picture type is unknown to the client, the decision is being taken by 2725 NvEncodeAPI interface. The client should pass ::_NV_ENC_PIC_PARAMS parameter 2726 consisting of allocated input buffer, output buffer and output events in successive 2727 ::NvEncEncodePicture() API calls along with other required encode picture params. 2728 For example: 2729 1st EncodePicture parameters - (I1, O1, E1) 2730 2nd EncodePicture parameters - (I2, O2, E2) 2731 3rd EncodePicture parameters - (I3, O3, E3) 2732 2733 b) NvEncodeAPI SW will receive the following encode Commands from the client. 2734 The left side shows input from client in the form (Input buffer, Output Buffer, 2735 Output Event). The right hand side shows a possible picture type decision take by 2736 the NvEncodeAPI interface. 2737 (I1, O1, E1) ---P1 Frame 2738 (I2, O2, E2) ---B2 Frame 2739 (I3, O3, E3) ---P3 Frame 2740 2741 c) NvEncodeAPI interface will make a copy of the input buffers to its internal 2742 buffersfor re-ordering. These copies are done as part of nvEncEncodePicture 2743 function call from the client and NvEncodeAPI interface is responsible for 2744 synchronization of copy operation with the actual encoding operation. 2745 I1 --> NvI1 2746 I2 --> NvI2 2747 I3 --> NvI3 2748 2749 d) After returning from ::NvEncEncodePicture() call , the client must queue the output 2750 bitstream processing work to the secondary thread. The output bitstream processing 2751 for asynchronous mode consist of first waiting on completion event(E1, E2..) 2752 and then locking the output bitstream buffer(O1, O2..) for reading the encoded 2753 data. The work queued to the secondary thread by the client is in the following order 2754 (I1, O1, E1) 2755 (I2, O2, E2) 2756 (I3, O3, E3) 2757 Note they are in the same order in which client calls ::NvEncEncodePicture() API 2758 in \p step a). 2759 2760 e) NvEncodeAPI interface will do the re-ordering such that Encoder HW will receive 2761 the following encode commands: 2762 (NvI1, O1, E1) ---P1 Frame 2763 (NvI3, O2, E2) ---P3 Frame 2764 (NvI2, O3, E3) ---B2 frame 2765 2766 f) After the encoding operations are completed, the events will be signalled 2767 by NvEncodeAPI interface in the following order : 2768 (O1, E1) ---P1 Frame ,output bitstream copied to O1 and event E1 signalled. 2769 (O2, E2) ---P3 Frame ,output bitstream copied to O2 and event E2 signalled. 2770 (O3, E3) ---B2 Frame ,output bitstream copied to O3 and event E3 signalled. 2771 2772 g) The client must lock the bitstream data using ::NvEncLockBitstream() API in 2773 the order O1,O2,O3 to read the encoded data, after waiting for the events 2774 to be signalled in the same order i.e E1, E2 and E3.The output processing is 2775 done in the secondary thread in the following order: 2776 Waits on E1, copies encoded bitstream from O1 2777 Waits on E2, copies encoded bitstream from O2 2778 Waits on E3, copies encoded bitstream from O3 2779 2780 -Note the client will receive the events signalling and output buffer in the 2781 same order in which they have submitted for encoding. 2782 -Note the LockBitstream will have picture type field which will notify the 2783 output picture type to the clients. 2784 -Note the input, output buffer and the output completion event are free to be 2785 reused once NvEncodeAPI interfaced has signalled the event and the client has 2786 copied the data from the output buffer. 2787 2788 * \endcode 2789 * 2790 *\par Synchronous Encoding 2791 * The client can enable synchronous mode of encoding by setting 2792 * NV_ENC_INITIALIZE_PARAMS::enableEncodeAsync to 0 in ::NvEncInitializeEncoder() API. 2793 * The NvEncodeAPI interface may return ::NV_ENC_ERR_NEED_MORE_INPUT error code for 2794 * some ::NvEncEncodePicture() API calls when NV_ENC_INITIALIZE_PARAMS::enablePTD 2795 * is set to 1, but the client must not treat it as a fatal error. The NvEncodeAPI 2796 * interface might not be able to submit an input picture buffer for encoding 2797 * immediately due to re-ordering for B frames. The NvEncodeAPI interface cannot 2798 * submit the input picture which is decided to be encoded as B frame as it waits 2799 * for backward reference from temporally subsequent frames. This input picture 2800 * is buffered internally and waits for more input picture to arrive. The client 2801 * must not call ::NvEncLockBitstream() API on the output buffers whose 2802 * ::NvEncEncodePicture() API returns ::NV_ENC_ERR_NEED_MORE_INPUT. The client must 2803 * wait for the NvEncodeAPI interface to return ::NV_ENC_SUCCESS before locking the 2804 * output bitstreams to read the encoded bitstream data. The following example 2805 * explains the scenario with synchronous encoding with 2 B frames. 2806 *\code 2807 The below example shows how synchronous encoding works in case of 1 B frames 2808 ----------------------------------------------------------------------------- 2809 Suppose the client allocated 4 input buffers(I1,I2..), 4 output buffers(O1,O2..) 2810 and 4 completion events(E1, E2, ...). The NvEncodeAPI interface will need to 2811 keep a copy of the input buffers for re-ordering and it allocates following 2812 internal buffers (NvI1, NvI2...). These internal buffers are managed by NvEncodeAPI 2813 and the client is not responsible for the allocating or freeing the memory of 2814 the internal buffers. 2815 2816 The client calls ::NvEncEncodePicture() API with input buffer I1 and output buffer O1. 2817 The NvEncodeAPI decides to encode I1 as P frame and submits it to encoder 2818 HW and returns ::NV_ENC_SUCCESS. 2819 The client can now read the encoded data by locking the output O1 by calling 2820 NvEncLockBitstream API. 2821 2822 The client calls ::NvEncEncodePicture() API with input buffer I2 and output buffer O2. 2823 The NvEncodeAPI decides to encode I2 as B frame and buffers I2 by copying it 2824 to internal buffer and returns ::NV_ENC_ERR_NEED_MORE_INPUT. 2825 The error is not fatal and it notifies client that it cannot read the encoded 2826 data by locking the output O2 by calling ::NvEncLockBitstream() API without submitting 2827 more work to the NvEncodeAPI interface. 2828 2829 The client calls ::NvEncEncodePicture() with input buffer I3 and output buffer O3. 2830 The NvEncodeAPI decides to encode I3 as P frame and it first submits I3 for 2831 encoding which will be used as backward reference frame for I2. 2832 The NvEncodeAPI then submits I2 for encoding and returns ::NV_ENC_SUCESS. Both 2833 the submission are part of the same ::NvEncEncodePicture() function call. 2834 The client can now read the encoded data for both the frames by locking the output 2835 O2 followed by O3 ,by calling ::NvEncLockBitstream() API. 2836 2837 The client must always lock the output in the same order in which it has submitted 2838 to receive the encoded bitstream in correct encoding order. 2839 2840 * \endcode 2841 * 2842 * \param [in] encoder 2843 * Pointer to the NvEncodeAPI interface. 2844 * \param [in,out] encodePicParams 2845 * Pointer to the ::_NV_ENC_PIC_PARAMS structure. 2846 * 2847 * \return 2848 * ::NV_ENC_SUCCESS \n 2849 * ::NV_ENC_ERR_INVALID_PTR \n 2850 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2851 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2852 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2853 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2854 * ::NV_ENC_ERR_INVALID_PARAM \n 2855 * ::NV_ENC_ERR_INVALID_VERSION \n 2856 * ::NV_ENC_ERR_ENCODER_BUSY \n 2857 * ::NV_ENC_ERR_NEED_MORE_INPUT \n 2858 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 2859 * ::NV_ENC_ERR_GENERIC \n 2860 * 2861 */ 2862 NVENCSTATUS NVENCAPI NvEncEncodePicture (void* encoder, NV_ENC_PIC_PARAMS* encodePicParams); 2863 2864 2865 // NvEncLockBitstream 2866 /** 2867 * \brief Lock output bitstream buffer 2868 * 2869 * This function is used to lock the bitstream buffer to read the encoded data. 2870 * The client can only access the encoded data by calling this function. 2871 * The pointer to client accessible encoded data is returned in the 2872 * NV_ENC_LOCK_BITSTREAM::bitstreamBufferPtr field. The size of the encoded data 2873 * in the output buffer is returned in the NV_ENC_LOCK_BITSTREAM::bitstreamSizeInBytes 2874 * The NvEncodeAPI interface also returns the output picture type and picture structure 2875 * of the encoded frame in NV_ENC_LOCK_BITSTREAM::pictureType and 2876 * NV_ENC_LOCK_BITSTREAM::pictureStruct fields respectively. If the client has 2877 * set NV_ENC_LOCK_BITSTREAM::doNotWait to 1, the function might return 2878 * ::NV_ENC_ERR_LOCK_BUSY if client is operating in synchronous mode. This is not 2879 * a fatal failure if NV_ENC_LOCK_BITSTREAM::doNotWait is set to 1. In the above case the client can 2880 * retry the function after few milliseconds. 2881 * 2882 * \param [in] encoder 2883 * Pointer to the NvEncodeAPI interface. 2884 * \param [in,out] lockBitstreamBufferParams 2885 * Pointer to the ::_NV_ENC_LOCK_BITSTREAM structure. 2886 * 2887 * \return 2888 * ::NV_ENC_SUCCESS \n 2889 * ::NV_ENC_ERR_INVALID_PTR \n 2890 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2891 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2892 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2893 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2894 * ::NV_ENC_ERR_INVALID_PARAM \n 2895 * ::NV_ENC_ERR_INVALID_VERSION \n 2896 * ::NV_ENC_ERR_LOCK_BUSY \n 2897 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 2898 * ::NV_ENC_ERR_GENERIC \n 2899 * 2900 */ 2901 NVENCSTATUS NVENCAPI NvEncLockBitstream (void* encoder, NV_ENC_LOCK_BITSTREAM* lockBitstreamBufferParams); 2902 2903 2904 // NvEncUnlockBitstream 2905 /** 2906 * \brief Unlock the output bitstream buffer 2907 * 2908 * This function is used to unlock the output bitstream buffer after the client 2909 * has read the encoded data from output buffer. The client must call this function 2910 * to unlock the output buffer which it has previously locked using ::NvEncLockBitstream() 2911 * function. Using a locked bitstream buffer in ::NvEncEncodePicture() API will cause 2912 * the function to fail. 2913 * 2914 * \param [in] encoder 2915 * Pointer to the NvEncodeAPI interface. 2916 * \param [in,out] bitstreamBuffer 2917 * bitstream buffer pointer being unlocked 2918 * 2919 * \return 2920 * ::NV_ENC_SUCCESS \n 2921 * ::NV_ENC_ERR_INVALID_PTR \n 2922 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2923 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2924 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2925 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2926 * ::NV_ENC_ERR_INVALID_PARAM \n 2927 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 2928 * ::NV_ENC_ERR_GENERIC \n 2929 * 2930 */ 2931 NVENCSTATUS NVENCAPI NvEncUnlockBitstream (void* encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); 2932 2933 2934 // NvLockInputBuffer 2935 /** 2936 * \brief Locks an input buffer 2937 * 2938 * This function is used to lock the input buffer to load the uncompressed YUV 2939 * pixel data into input buffer memory. The client must pass the NV_ENC_INPUT_PTR 2940 * it had previously allocated using ::NvEncCreateInputBuffer()in the 2941 * NV_ENC_LOCK_INPUT_BUFFER::inputBuffer field. 2942 * The NvEncodeAPI interface returns pointer to client accessible input buffer 2943 * memory in NV_ENC_LOCK_INPUT_BUFFER::bufferDataPtr field. 2944 * 2945 * \param [in] encoder 2946 * Pointer to the NvEncodeAPI interface. 2947 * \param [in,out] lockInputBufferParams 2948 * Pointer to the ::_NV_ENC_LOCK_INPUT_BUFFER structure 2949 * 2950 * \return 2951 * \return 2952 * ::NV_ENC_SUCCESS \n 2953 * ::NV_ENC_ERR_INVALID_PTR \n 2954 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2955 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2956 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2957 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2958 * ::NV_ENC_ERR_INVALID_PARAM \n 2959 * ::NV_ENC_ERR_INVALID_VERSION \n 2960 * ::NV_ENC_ERR_LOCK_BUSY \n 2961 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 2962 * ::NV_ENC_ERR_GENERIC \n 2963 * 2964 */ 2965 NVENCSTATUS NVENCAPI NvEncLockInputBuffer (void* encoder, NV_ENC_LOCK_INPUT_BUFFER* lockInputBufferParams); 2966 2967 2968 // NvUnlockInputBuffer 2969 /** 2970 * \brief Unlocks the input buffer 2971 * 2972 * This function is used to unlock the input buffer memory previously locked for 2973 * uploading YUV pixel data. The input buffer must be unlocked before being used 2974 * again for encoding, otherwise NvEncodeAPI will fail the ::NvEncEncodePicture() 2975 * 2976 * \param [in] encoder 2977 * Pointer to the NvEncodeAPI interface. 2978 * \param [in] inputBuffer 2979 * Pointer to the input buffer that is being unlocked. 2980 * 2981 * \return 2982 * ::NV_ENC_SUCCESS \n 2983 * ::NV_ENC_ERR_INVALID_PTR \n 2984 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 2985 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 2986 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 2987 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 2988 * ::NV_ENC_ERR_INVALID_VERSION \n 2989 * ::NV_ENC_ERR_INVALID_PARAM \n 2990 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 2991 * ::NV_ENC_ERR_GENERIC \n 2992 * 2993 * 2994 */ 2995 NVENCSTATUS NVENCAPI NvEncUnlockInputBuffer (void* encoder, NV_ENC_INPUT_PTR inputBuffer); 2996 2997 2998 // NvEncGetEncodeStats 2999 /** 3000 * \brief Get encoding statistics. 3001 * 3002 * This function is used to retrieve the encoding statistics. 3003 * This API is not supported when encode device type is CUDA. 3004 * 3005 * \param [in] encoder 3006 * Pointer to the NvEncodeAPI interface. 3007 * \param [in,out] encodeStats 3008 * Pointer to the ::_NV_ENC_STAT structure. 3009 * 3010 * \return 3011 * ::NV_ENC_SUCCESS \n 3012 * ::NV_ENC_ERR_INVALID_PTR \n 3013 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3014 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3015 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3016 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3017 * ::NV_ENC_ERR_INVALID_PARAM \n 3018 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 3019 * ::NV_ENC_ERR_GENERIC \n 3020 * 3021 */ 3022 NVENCSTATUS NVENCAPI NvEncGetEncodeStats (void* encoder, NV_ENC_STAT* encodeStats); 3023 3024 3025 // NvEncGetSequenceParams 3026 /** 3027 * \brief Get encoded sequence and picture header. 3028 * 3029 * This function can be used to retrieve the sequence and picture header out of 3030 * band. The client must call this function only after the encoder has been 3031 * initialized using ::NvEncInitializeEncoder() function. The client must 3032 * allocate the memory where the NvEncodeAPI interface can copy the bitstream 3033 * header and pass the pointer to the memory in NV_ENC_SEQUENCE_PARAM_PAYLOAD::spsppsBuffer. 3034 * The size of buffer is passed in the field NV_ENC_SEQUENCE_PARAM_PAYLOAD::inBufferSize. 3035 * The NvEncodeAPI interface will copy the bitstream header payload and returns 3036 * the actual size of the bitstream header in the field 3037 * NV_ENC_SEQUENCE_PARAM_PAYLOAD::outSPSPPSPayloadSize. 3038 * The client must call ::NvEncGetSequenceParams() function from the same thread which is 3039 * being used to call ::NvEncEncodePicture() function. 3040 * 3041 * \param [in] encoder 3042 * Pointer to the NvEncodeAPI interface. 3043 * \param [in,out] sequenceParamPayload 3044 * Pointer to the ::_NV_ENC_SEQUENCE_PARAM_PAYLOAD structure. 3045 * 3046 * \return 3047 * ::NV_ENC_SUCCESS \n 3048 * ::NV_ENC_ERR_INVALID_PTR \n 3049 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3050 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3051 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3052 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3053 * ::NV_ENC_ERR_INVALID_VERSION \n 3054 * ::NV_ENC_ERR_INVALID_PARAM \n 3055 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 3056 * ::NV_ENC_ERR_GENERIC \n 3057 * 3058 */ 3059 NVENCSTATUS NVENCAPI NvEncGetSequenceParams (void* encoder, NV_ENC_SEQUENCE_PARAM_PAYLOAD* sequenceParamPayload); 3060 3061 3062 // NvEncRegisterAsyncEvent 3063 /** 3064 * \brief Register event for notification to encoding completion. 3065 * 3066 * This function is used to register the completion event with NvEncodeAPI 3067 * interface. The event is required when the client has configured the encoder to 3068 * work in asynchronous mode. In this mode the client needs to send a completion 3069 * event with every output buffer. The NvEncodeAPI interface will signal the 3070 * completion of the encoding process using this event. Only after the event is 3071 * signalled the client can get the encoded data using ::NvEncLockBitstream() function. 3072 * 3073 * \param [in] encoder 3074 * Pointer to the NvEncodeAPI interface. 3075 * \param [in] eventParams 3076 * Pointer to the ::_NV_ENC_EVENT_PARAMS structure. 3077 * 3078 * \return 3079 * ::NV_ENC_SUCCESS \n 3080 * ::NV_ENC_ERR_INVALID_PTR \n 3081 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3082 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3083 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3084 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3085 * ::NV_ENC_ERR_INVALID_VERSION \n 3086 * ::NV_ENC_ERR_INVALID_PARAM \n 3087 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 3088 * ::NV_ENC_ERR_GENERIC \n 3089 * 3090 */ 3091 NVENCSTATUS NVENCAPI NvEncRegisterAsyncEvent (void* encoder, NV_ENC_EVENT_PARAMS* eventParams); 3092 3093 3094 // NvEncUnregisterAsyncEvent 3095 /** 3096 * \brief Unregister completion event. 3097 * 3098 * This function is used to unregister completion event which has been previously 3099 * registered using ::NvEncRegisterAsyncEvent() function. The client must unregister 3100 * all events before destroying the encoder using ::NvEncDestroyEncoder() function. 3101 * 3102 * \param [in] encoder 3103 * Pointer to the NvEncodeAPI interface. 3104 * \param [in] eventParams 3105 * Pointer to the ::_NV_ENC_EVENT_PARAMS structure. 3106 * 3107 * \return 3108 * ::NV_ENC_SUCCESS \n 3109 * ::NV_ENC_ERR_INVALID_PTR \n 3110 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3111 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3112 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3113 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3114 * ::NV_ENC_ERR_INVALID_VERSION \n 3115 * ::NV_ENC_ERR_INVALID_PARAM \n 3116 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 3117 * ::NV_ENC_ERR_GENERIC \n 3118 * 3119 */ 3120 NVENCSTATUS NVENCAPI NvEncUnregisterAsyncEvent (void* encoder, NV_ENC_EVENT_PARAMS* eventParams); 3121 3122 3123 // NvEncMapInputResource 3124 /** 3125 * \brief Map an externally created input resource pointer for encoding. 3126 * 3127 * Maps an externally allocated input resource [using and returns a NV_ENC_INPUT_PTR 3128 * which can be used for encoding in the ::NvEncEncodePicture() function. The 3129 * mapped resource is returned in the field NV_ENC_MAP_INPUT_RESOURCE::outputResourcePtr. 3130 * The NvEncodeAPI interface also returns the buffer format of the mapped resource 3131 * in the field NV_ENC_MAP_INPUT_RESOURCE::outbufferFmt. 3132 * This function provides synchronization guarantee that any graphics work submitted 3133 * on the input buffer is completed before the buffer is used for encoding. This is 3134 * also true for compute (i.e. CUDA) work, provided that the previous workload using 3135 * the input resource was submitted to the default stream. 3136 * The client should not access any input buffer while they are mapped by the encoder. 3137 * 3138 * \param [in] encoder 3139 * Pointer to the NvEncodeAPI interface. 3140 * \param [in,out] mapInputResParams 3141 * Pointer to the ::_NV_ENC_MAP_INPUT_RESOURCE structure. 3142 * 3143 * \return 3144 * ::NV_ENC_SUCCESS \n 3145 * ::NV_ENC_ERR_INVALID_PTR \n 3146 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3147 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3148 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3149 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3150 * ::NV_ENC_ERR_INVALID_VERSION \n 3151 * ::NV_ENC_ERR_INVALID_PARAM \n 3152 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 3153 * ::NV_ENC_ERR_RESOURCE_NOT_REGISTERED \n 3154 * ::NV_ENC_ERR_MAP_FAILED \n 3155 * ::NV_ENC_ERR_GENERIC \n 3156 * 3157 */ 3158 NVENCSTATUS NVENCAPI NvEncMapInputResource (void* encoder, NV_ENC_MAP_INPUT_RESOURCE* mapInputResParams); 3159 3160 3161 // NvEncUnmapInputResource 3162 /** 3163 * \brief UnMaps a NV_ENC_INPUT_PTR which was mapped for encoding 3164 * 3165 * 3166 * UnMaps an input buffer which was previously mapped using ::NvEncMapInputResource() 3167 * API. The mapping created using ::NvEncMapInputResource() should be invalidated 3168 * using this API before the external resource is destroyed by the client. The client 3169 * must unmap the buffer after ::NvEncLockBitstream() API returns succuessfully for encode 3170 * work submitted using the mapped input buffer. 3171 * 3172 * 3173 * \param [in] encoder 3174 * Pointer to the NvEncodeAPI interface. 3175 * \param [in] mappedInputBuffer 3176 * Pointer to the NV_ENC_INPUT_PTR 3177 * 3178 * \return 3179 * ::NV_ENC_SUCCESS \n 3180 * ::NV_ENC_ERR_INVALID_PTR \n 3181 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3182 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3183 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3184 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3185 * ::NV_ENC_ERR_INVALID_VERSION \n 3186 * ::NV_ENC_ERR_INVALID_PARAM \n 3187 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 3188 * ::NV_ENC_ERR_RESOURCE_NOT_REGISTERED \n 3189 * ::NV_ENC_ERR_RESOURCE_NOT_MAPPED \n 3190 * ::NV_ENC_ERR_GENERIC \n 3191 * 3192 */ 3193 NVENCSTATUS NVENCAPI NvEncUnmapInputResource (void* encoder, NV_ENC_INPUT_PTR mappedInputBuffer); 3194 3195 // NvEncDestroyEncoder 3196 /** 3197 * \brief Destroy Encoding Session 3198 * 3199 * Destroys the encoder session previously created using ::NvEncOpenEncodeSession() 3200 * function. The client must flush the encoder before freeing any resources. In order 3201 * to flush the encoder the client must pass a NULL encode picture packet and either 3202 * wait for the ::NvEncEncodePicture() function to return in synchronous mode or wait 3203 * for the flush event to be signaled by the encoder in asynchronous mode. 3204 * The client must free all the input and output resources created using the 3205 * NvEncodeAPI interface before destroying the encoder. If the client is operating 3206 * in asynchronous mode, it must also unregister the completion events previously 3207 * registered. 3208 * 3209 * \param [in] encoder 3210 * Pointer to the NvEncodeAPI interface. 3211 * 3212 * \return 3213 * ::NV_ENC_SUCCESS \n 3214 * ::NV_ENC_ERR_INVALID_PTR \n 3215 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3216 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3217 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3218 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3219 * ::NV_ENC_ERR_INVALID_PARAM \n 3220 * ::NV_ENC_ERR_GENERIC \n 3221 * 3222 */ 3223 NVENCSTATUS NVENCAPI NvEncDestroyEncoder (void* encoder); 3224 3225 // NvEncInvalidateRefFrames 3226 /** 3227 * \brief Invalidate reference frames 3228 * 3229 * Invalidates reference frame based on the time stamp provided by the client. 3230 * The encoder marks any reference frames or any frames which have been reconstructed 3231 * using the corrupt frame as invalid for motion estimation and uses older reference 3232 * frames for motion estimation. The encoded forces the current frame to be encoded 3233 * as an intra frame if no reference frames are left after invalidation process. 3234 * This is useful for low latency application for error resiliency. The client 3235 * is recommended to set NV_ENC_CONFIG_H264::maxNumRefFrames to a large value so 3236 * that encoder can keep a backup of older reference frames in the DPB and can use them 3237 * for motion estimation when the newer reference frames have been invalidated. 3238 * This API can be called multiple times. 3239 * 3240 * \param [in] encoder 3241 * Pointer to the NvEncodeAPI interface. 3242 * \param [in] invalidRefFrameTimeStamp 3243 * Timestamp of the invalid reference frames which needs to be invalidated. 3244 * 3245 * \return 3246 * ::NV_ENC_SUCCESS \n 3247 * ::NV_ENC_ERR_INVALID_PTR \n 3248 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3249 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3250 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3251 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3252 * ::NV_ENC_ERR_INVALID_PARAM \n 3253 * ::NV_ENC_ERR_GENERIC \n 3254 * 3255 */ 3256 NVENCSTATUS NVENCAPI NvEncInvalidateRefFrames(void* encoder, uint64_t invalidRefFrameTimeStamp); 3257 3258 // NvEncOpenEncodeSessionEx 3259 /** 3260 * \brief Opens an encoding session. 3261 * 3262 * Opens an encoding session and returns a pointer to the encoder interface in 3263 * the \p **encoder parameter. The client should start encoding process by calling 3264 * this API first. 3265 * The client must pass a pointer to IDirect3DDevice9 device or CUDA context in the \p *device parameter. 3266 * For the OpenGL interface, \p device must be NULL. An OpenGL context must be current when 3267 * calling all NvEncodeAPI functions. 3268 * If the creation of encoder session fails, the client must call ::NvEncDestroyEncoder API 3269 * before exiting. 3270 * 3271 * \param [in] openSessionExParams 3272 * Pointer to a ::NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS structure. 3273 * \param [out] encoder 3274 * Encode Session pointer to the NvEncodeAPI interface. 3275 * \return 3276 * ::NV_ENC_SUCCESS \n 3277 * ::NV_ENC_ERR_INVALID_PTR \n 3278 * ::NV_ENC_ERR_NO_ENCODE_DEVICE \n 3279 * ::NV_ENC_ERR_UNSUPPORTED_DEVICE \n 3280 * ::NV_ENC_ERR_INVALID_DEVICE \n 3281 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3282 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3283 * ::NV_ENC_ERR_GENERIC \n 3284 * 3285 */ 3286 NVENCSTATUS NVENCAPI NvEncOpenEncodeSessionEx (NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS *openSessionExParams, void** encoder); 3287 3288 // NvEncRegisterResource 3289 /** 3290 * \brief Registers a resource with the Nvidia Video Encoder Interface. 3291 * 3292 * Registers a resource with the Nvidia Video Encoder Interface for book keeping. 3293 * The client is expected to pass the registered resource handle as well, while calling ::NvEncMapInputResource API. 3294 * 3295 * \param [in] encoder 3296 * Pointer to the NVEncodeAPI interface. 3297 * 3298 * \param [in] registerResParams 3299 * Pointer to a ::_NV_ENC_REGISTER_RESOURCE structure 3300 * 3301 * \return 3302 * ::NV_ENC_SUCCESS \n 3303 * ::NV_ENC_ERR_INVALID_PTR \n 3304 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3305 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3306 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3307 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3308 * ::NV_ENC_ERR_INVALID_VERSION \n 3309 * ::NV_ENC_ERR_INVALID_PARAM \n 3310 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 3311 * ::NV_ENC_ERR_RESOURCE_REGISTER_FAILED \n 3312 * ::NV_ENC_ERR_GENERIC \n 3313 * ::NV_ENC_ERR_UNIMPLEMENTED \n 3314 * 3315 */ 3316 NVENCSTATUS NVENCAPI NvEncRegisterResource (void* encoder, NV_ENC_REGISTER_RESOURCE* registerResParams); 3317 3318 // NvEncUnregisterResource 3319 /** 3320 * \brief Unregisters a resource previously registered with the Nvidia Video Encoder Interface. 3321 * 3322 * Unregisters a resource previously registered with the Nvidia Video Encoder Interface. 3323 * The client is expected to unregister any resource that it has registered with the 3324 * Nvidia Video Encoder Interface before destroying the resource. 3325 * 3326 * \param [in] encoder 3327 * Pointer to the NVEncodeAPI interface. 3328 * 3329 * \param [in] registeredResource 3330 * The registered resource pointer that was returned in ::NvEncRegisterResource. 3331 * 3332 * \return 3333 * ::NV_ENC_SUCCESS \n 3334 * ::NV_ENC_ERR_INVALID_PTR \n 3335 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3336 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3337 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3338 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3339 * ::NV_ENC_ERR_INVALID_VERSION \n 3340 * ::NV_ENC_ERR_INVALID_PARAM \n 3341 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 3342 * ::NV_ENC_ERR_RESOURCE_NOT_REGISTERED \n 3343 * ::NV_ENC_ERR_GENERIC \n 3344 * ::NV_ENC_ERR_UNIMPLEMENTED \n 3345 * 3346 */ 3347 NVENCSTATUS NVENCAPI NvEncUnregisterResource (void* encoder, NV_ENC_REGISTERED_PTR registeredResource); 3348 3349 // NvEncReconfigureEncoder 3350 /** 3351 * \brief Reconfigure an existing encoding session. 3352 * 3353 * Reconfigure an existing encoding session. 3354 * The client should call this API to change/reconfigure the parameter passed during 3355 * NvEncInitializeEncoder API call. 3356 * Currently Reconfiguration of following are not supported. 3357 * Change in GOP structure. 3358 * Change in sync-Async mode. 3359 * Change in MaxWidth & MaxHeight. 3360 * Change in PTDmode. 3361 * 3362 * Resolution change is possible only if maxEncodeWidth & maxEncodeHeight of NV_ENC_INITIALIZE_PARAMS 3363 * is set while creating encoder session. 3364 * 3365 * \param [in] encoder 3366 * Pointer to the NVEncodeAPI interface. 3367 * 3368 * \param [in] reInitEncodeParams 3369 * Pointer to a ::NV_ENC_RECONFIGURE_PARAMS structure. 3370 * \return 3371 * ::NV_ENC_SUCCESS \n 3372 * ::NV_ENC_ERR_INVALID_PTR \n 3373 * ::NV_ENC_ERR_NO_ENCODE_DEVICE \n 3374 * ::NV_ENC_ERR_UNSUPPORTED_DEVICE \n 3375 * ::NV_ENC_ERR_INVALID_DEVICE \n 3376 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3377 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3378 * ::NV_ENC_ERR_GENERIC \n 3379 * 3380 */ 3381 NVENCSTATUS NVENCAPI NvEncReconfigureEncoder (void *encoder, NV_ENC_RECONFIGURE_PARAMS* reInitEncodeParams); 3382 3383 3384 3385 // NvEncCreateMVBuffer 3386 /** 3387 * \brief Allocates output MV buffer for ME only mode. 3388 * 3389 * This function is used to allocate an output MV buffer. The size of the mvBuffer is 3390 * dependent on the frame height and width of the last ::NvEncCreateInputBuffer() call. 3391 * The NV_ENC_OUTPUT_PTR returned by the NvEncodeAPI interface in the 3392 * ::NV_ENC_CREATE_MV_BUFFER::mvBuffer field should be used in 3393 * ::NvEncRunMotionEstimationOnly() API. 3394 * Client must lock ::NV_ENC_CREATE_MV_BUFFER::mvBuffer using ::NvEncLockBitstream() API to get the motion vector data. 3395 * 3396 * \param [in] encoder 3397 * Pointer to the NvEncodeAPI interface. 3398 * \param [in,out] createMVBufferParams 3399 * Pointer to the ::NV_ENC_CREATE_MV_BUFFER structure. 3400 * 3401 * \return 3402 * ::NV_ENC_SUCCESS \n 3403 * ::NV_ENC_ERR_INVALID_PTR \n 3404 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3405 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3406 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3407 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3408 * ::NV_ENC_ERR_INVALID_PARAM \n 3409 * ::NV_ENC_ERR_INVALID_VERSION \n 3410 * ::NV_ENC_ERR_GENERIC \n 3411 */ 3412 NVENCSTATUS NVENCAPI NvEncCreateMVBuffer (void* encoder, NV_ENC_CREATE_MV_BUFFER* createMVBufferParams); 3413 3414 3415 // NvEncDestroyMVBuffer 3416 /** 3417 * \brief Release an output MV buffer for ME only mode. 3418 * 3419 * This function is used to release the output MV buffer allocated using 3420 * the ::NvEncCreateMVBuffer() function. The client must release the output 3421 * mvBuffer using this function before destroying the encoder session. 3422 * 3423 * \param [in] encoder 3424 * Pointer to the NvEncodeAPI interface. 3425 * \param [in] mvBuffer 3426 * Pointer to the mvBuffer being released. 3427 * 3428 * \return 3429 * ::NV_ENC_SUCCESS \n 3430 * ::NV_ENC_ERR_INVALID_PTR \n 3431 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3432 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3433 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3434 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3435 * ::NV_ENC_ERR_INVALID_PARAM \n 3436 * ::NV_ENC_ERR_INVALID_VERSION \n 3437 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 3438 * ::NV_ENC_ERR_GENERIC \n 3439 */ 3440 NVENCSTATUS NVENCAPI NvEncDestroyMVBuffer (void* encoder, NV_ENC_OUTPUT_PTR mvBuffer); 3441 3442 3443 // NvEncRunMotionEstimationOnly 3444 /** 3445 * \brief Submit an input picture and reference frame for motion estimation in ME only mode. 3446 * 3447 * This function is used to submit the input frame and reference frame for motion 3448 * estimation. The ME parameters are passed using *meOnlyParams which is a pointer 3449 * to ::_NV_ENC_MEONLY_PARAMS structure. 3450 * Client must lock ::NV_ENC_CREATE_MV_BUFFER::mvBuffer using ::NvEncLockBitstream() API to get the motion vector data. 3451 * to get motion vector data. 3452 * 3453 * \param [in] encoder 3454 * Pointer to the NvEncodeAPI interface. 3455 * \param [in] meOnlyParams 3456 * Pointer to the ::_NV_ENC_MEONLY_PARAMS structure. 3457 * 3458 * \return 3459 * ::NV_ENC_SUCCESS \n 3460 * ::NV_ENC_ERR_INVALID_PTR \n 3461 * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n 3462 * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n 3463 * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n 3464 * ::NV_ENC_ERR_OUT_OF_MEMORY \n 3465 * ::NV_ENC_ERR_INVALID_PARAM \n 3466 * ::NV_ENC_ERR_INVALID_VERSION \n 3467 * ::NV_ENC_ERR_NEED_MORE_INPUT \n 3468 * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n 3469 * ::NV_ENC_ERR_GENERIC \n 3470 */ 3471 NVENCSTATUS NVENCAPI NvEncRunMotionEstimationOnly (void* encoder, NV_ENC_MEONLY_PARAMS* meOnlyParams); 3472 3473 // NvEncodeAPIGetMaxSupportedVersion 3474 /** 3475 * \brief Get the largest NvEncodeAPI version supported by the driver. 3476 * 3477 * This function can be used by clients to determine if the driver supports 3478 * the NvEncodeAPI header the application was compiled with. 3479 * 3480 * \param [out] version 3481 * Pointer to the requested value. The 4 least significant bits in the returned 3482 * indicate the minor version and the rest of the bits indicate the major 3483 * version of the largest supported version. 3484 * 3485 * \return 3486 * ::NV_ENC_SUCCESS \n 3487 * ::NV_ENC_ERR_INVALID_PTR \n 3488 */ 3489 NVENCSTATUS NVENCAPI NvEncodeAPIGetMaxSupportedVersion (uint32_t* version); 3490 3491 3492 // NvEncodeAPIGetLastErrorString 3493 /** 3494 * \brief Get the description of the last error reported by the API. 3495 * 3496 * This function returns a null-terminated string that can be used by clients to better understand the reason 3497 * for failure of a previous API call. 3498 * 3499 * \param [in] encoder 3500 * Pointer to the NvEncodeAPI interface. 3501 * 3502 * \return 3503 * Pointer to buffer containing the details of the last error encountered by the API. 3504 */ 3505 const char * NVENCAPI NvEncGetLastErrorString (void* encoder); 3506 3507 3508 /// \cond API PFN 3509 /* 3510 * Defines API function pointers 3511 */ 3512 typedef NVENCSTATUS (NVENCAPI* PNVENCOPENENCODESESSION) (void* device, uint32_t deviceType, void** encoder); 3513 typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEGUIDCOUNT) (void* encoder, uint32_t* encodeGUIDCount); 3514 typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEGUIDS) (void* encoder, GUID* GUIDs, uint32_t guidArraySize, uint32_t* GUIDCount); 3515 typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEPROFILEGUIDCOUNT) (void* encoder, GUID encodeGUID, uint32_t* encodeProfileGUIDCount); 3516 typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEPROFILEGUIDS) (void* encoder, GUID encodeGUID, GUID* profileGUIDs, uint32_t guidArraySize, uint32_t* GUIDCount); 3517 typedef NVENCSTATUS (NVENCAPI* PNVENCGETINPUTFORMATCOUNT) (void* encoder, GUID encodeGUID, uint32_t* inputFmtCount); 3518 typedef NVENCSTATUS (NVENCAPI* PNVENCGETINPUTFORMATS) (void* encoder, GUID encodeGUID, NV_ENC_BUFFER_FORMAT* inputFmts, uint32_t inputFmtArraySize, uint32_t* inputFmtCount); 3519 typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODECAPS) (void* encoder, GUID encodeGUID, NV_ENC_CAPS_PARAM* capsParam, int* capsVal); 3520 typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEPRESETCOUNT) (void* encoder, GUID encodeGUID, uint32_t* encodePresetGUIDCount); 3521 typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEPRESETGUIDS) (void* encoder, GUID encodeGUID, GUID* presetGUIDs, uint32_t guidArraySize, uint32_t* encodePresetGUIDCount); 3522 typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEPRESETCONFIG) (void* encoder, GUID encodeGUID, GUID presetGUID, NV_ENC_PRESET_CONFIG* presetConfig); 3523 typedef NVENCSTATUS (NVENCAPI* PNVENCINITIALIZEENCODER) (void* encoder, NV_ENC_INITIALIZE_PARAMS* createEncodeParams); 3524 typedef NVENCSTATUS (NVENCAPI* PNVENCCREATEINPUTBUFFER) (void* encoder, NV_ENC_CREATE_INPUT_BUFFER* createInputBufferParams); 3525 typedef NVENCSTATUS (NVENCAPI* PNVENCDESTROYINPUTBUFFER) (void* encoder, NV_ENC_INPUT_PTR inputBuffer); 3526 typedef NVENCSTATUS (NVENCAPI* PNVENCCREATEBITSTREAMBUFFER) (void* encoder, NV_ENC_CREATE_BITSTREAM_BUFFER* createBitstreamBufferParams); 3527 typedef NVENCSTATUS (NVENCAPI* PNVENCDESTROYBITSTREAMBUFFER) (void* encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); 3528 typedef NVENCSTATUS (NVENCAPI* PNVENCENCODEPICTURE) (void* encoder, NV_ENC_PIC_PARAMS* encodePicParams); 3529 typedef NVENCSTATUS (NVENCAPI* PNVENCLOCKBITSTREAM) (void* encoder, NV_ENC_LOCK_BITSTREAM* lockBitstreamBufferParams); 3530 typedef NVENCSTATUS (NVENCAPI* PNVENCUNLOCKBITSTREAM) (void* encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); 3531 typedef NVENCSTATUS (NVENCAPI* PNVENCLOCKINPUTBUFFER) (void* encoder, NV_ENC_LOCK_INPUT_BUFFER* lockInputBufferParams); 3532 typedef NVENCSTATUS (NVENCAPI* PNVENCUNLOCKINPUTBUFFER) (void* encoder, NV_ENC_INPUT_PTR inputBuffer); 3533 typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODESTATS) (void* encoder, NV_ENC_STAT* encodeStats); 3534 typedef NVENCSTATUS (NVENCAPI* PNVENCGETSEQUENCEPARAMS) (void* encoder, NV_ENC_SEQUENCE_PARAM_PAYLOAD* sequenceParamPayload); 3535 typedef NVENCSTATUS (NVENCAPI* PNVENCREGISTERASYNCEVENT) (void* encoder, NV_ENC_EVENT_PARAMS* eventParams); 3536 typedef NVENCSTATUS (NVENCAPI* PNVENCUNREGISTERASYNCEVENT) (void* encoder, NV_ENC_EVENT_PARAMS* eventParams); 3537 typedef NVENCSTATUS (NVENCAPI* PNVENCMAPINPUTRESOURCE) (void* encoder, NV_ENC_MAP_INPUT_RESOURCE* mapInputResParams); 3538 typedef NVENCSTATUS (NVENCAPI* PNVENCUNMAPINPUTRESOURCE) (void* encoder, NV_ENC_INPUT_PTR mappedInputBuffer); 3539 typedef NVENCSTATUS (NVENCAPI* PNVENCDESTROYENCODER) (void* encoder); 3540 typedef NVENCSTATUS (NVENCAPI* PNVENCINVALIDATEREFFRAMES) (void* encoder, uint64_t invalidRefFrameTimeStamp); 3541 typedef NVENCSTATUS (NVENCAPI* PNVENCOPENENCODESESSIONEX) (NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS *openSessionExParams, void** encoder); 3542 typedef NVENCSTATUS (NVENCAPI* PNVENCREGISTERRESOURCE) (void* encoder, NV_ENC_REGISTER_RESOURCE* registerResParams); 3543 typedef NVENCSTATUS (NVENCAPI* PNVENCUNREGISTERRESOURCE) (void* encoder, NV_ENC_REGISTERED_PTR registeredRes); 3544 typedef NVENCSTATUS (NVENCAPI* PNVENCRECONFIGUREENCODER) (void* encoder, NV_ENC_RECONFIGURE_PARAMS* reInitEncodeParams); 3545 3546 typedef NVENCSTATUS (NVENCAPI* PNVENCCREATEMVBUFFER) (void* encoder, NV_ENC_CREATE_MV_BUFFER* createMVBufferParams); 3547 typedef NVENCSTATUS (NVENCAPI* PNVENCDESTROYMVBUFFER) (void* encoder, NV_ENC_OUTPUT_PTR mvBuffer); 3548 typedef NVENCSTATUS (NVENCAPI* PNVENCRUNMOTIONESTIMATIONONLY) (void* encoder, NV_ENC_MEONLY_PARAMS* meOnlyParams); 3549 typedef const char * (NVENCAPI* PNVENCGETLASTERROR) (void* encoder); 3550 typedef NVENCSTATUS (NVENCAPI* PNVENCSETIOCUDASTREAMS) (void* encoder, NV_ENC_CUSTREAM_PTR inputStream, NV_ENC_CUSTREAM_PTR outputStream); 3551 3552 3553 /// \endcond 3554 3555 3556 /** @} */ /* END ENCODE_FUNC */ 3557 3558 /** 3559 * \ingroup ENCODER_STRUCTURE 3560 * NV_ENCODE_API_FUNCTION_LIST 3561 */ 3562 typedef struct _NV_ENCODE_API_FUNCTION_LIST 3563 { 3564 uint32_t version; /**< [in]: Client should pass NV_ENCODE_API_FUNCTION_LIST_VER. */ 3565 uint32_t reserved; /**< [in]: Reserved and should be set to 0. */ 3566 PNVENCOPENENCODESESSION nvEncOpenEncodeSession; /**< [out]: Client should access ::NvEncOpenEncodeSession() API through this pointer. */ 3567 PNVENCGETENCODEGUIDCOUNT nvEncGetEncodeGUIDCount; /**< [out]: Client should access ::NvEncGetEncodeGUIDCount() API through this pointer. */ 3568 PNVENCGETENCODEPRESETCOUNT nvEncGetEncodeProfileGUIDCount; /**< [out]: Client should access ::NvEncGetEncodeProfileGUIDCount() API through this pointer.*/ 3569 PNVENCGETENCODEPRESETGUIDS nvEncGetEncodeProfileGUIDs; /**< [out]: Client should access ::NvEncGetEncodeProfileGUIDs() API through this pointer. */ 3570 PNVENCGETENCODEGUIDS nvEncGetEncodeGUIDs; /**< [out]: Client should access ::NvEncGetEncodeGUIDs() API through this pointer. */ 3571 PNVENCGETINPUTFORMATCOUNT nvEncGetInputFormatCount; /**< [out]: Client should access ::NvEncGetInputFormatCount() API through this pointer. */ 3572 PNVENCGETINPUTFORMATS nvEncGetInputFormats; /**< [out]: Client should access ::NvEncGetInputFormats() API through this pointer. */ 3573 PNVENCGETENCODECAPS nvEncGetEncodeCaps; /**< [out]: Client should access ::NvEncGetEncodeCaps() API through this pointer. */ 3574 PNVENCGETENCODEPRESETCOUNT nvEncGetEncodePresetCount; /**< [out]: Client should access ::NvEncGetEncodePresetCount() API through this pointer. */ 3575 PNVENCGETENCODEPRESETGUIDS nvEncGetEncodePresetGUIDs; /**< [out]: Client should access ::NvEncGetEncodePresetGUIDs() API through this pointer. */ 3576 PNVENCGETENCODEPRESETCONFIG nvEncGetEncodePresetConfig; /**< [out]: Client should access ::NvEncGetEncodePresetConfig() API through this pointer. */ 3577 PNVENCINITIALIZEENCODER nvEncInitializeEncoder; /**< [out]: Client should access ::NvEncInitializeEncoder() API through this pointer. */ 3578 PNVENCCREATEINPUTBUFFER nvEncCreateInputBuffer; /**< [out]: Client should access ::NvEncCreateInputBuffer() API through this pointer. */ 3579 PNVENCDESTROYINPUTBUFFER nvEncDestroyInputBuffer; /**< [out]: Client should access ::NvEncDestroyInputBuffer() API through this pointer. */ 3580 PNVENCCREATEBITSTREAMBUFFER nvEncCreateBitstreamBuffer; /**< [out]: Client should access ::NvEncCreateBitstreamBuffer() API through this pointer. */ 3581 PNVENCDESTROYBITSTREAMBUFFER nvEncDestroyBitstreamBuffer; /**< [out]: Client should access ::NvEncDestroyBitstreamBuffer() API through this pointer. */ 3582 PNVENCENCODEPICTURE nvEncEncodePicture; /**< [out]: Client should access ::NvEncEncodePicture() API through this pointer. */ 3583 PNVENCLOCKBITSTREAM nvEncLockBitstream; /**< [out]: Client should access ::NvEncLockBitstream() API through this pointer. */ 3584 PNVENCUNLOCKBITSTREAM nvEncUnlockBitstream; /**< [out]: Client should access ::NvEncUnlockBitstream() API through this pointer. */ 3585 PNVENCLOCKINPUTBUFFER nvEncLockInputBuffer; /**< [out]: Client should access ::NvEncLockInputBuffer() API through this pointer. */ 3586 PNVENCUNLOCKINPUTBUFFER nvEncUnlockInputBuffer; /**< [out]: Client should access ::NvEncUnlockInputBuffer() API through this pointer. */ 3587 PNVENCGETENCODESTATS nvEncGetEncodeStats; /**< [out]: Client should access ::NvEncGetEncodeStats() API through this pointer. */ 3588 PNVENCGETSEQUENCEPARAMS nvEncGetSequenceParams; /**< [out]: Client should access ::NvEncGetSequenceParams() API through this pointer. */ 3589 PNVENCREGISTERASYNCEVENT nvEncRegisterAsyncEvent; /**< [out]: Client should access ::NvEncRegisterAsyncEvent() API through this pointer. */ 3590 PNVENCUNREGISTERASYNCEVENT nvEncUnregisterAsyncEvent; /**< [out]: Client should access ::NvEncUnregisterAsyncEvent() API through this pointer. */ 3591 PNVENCMAPINPUTRESOURCE nvEncMapInputResource; /**< [out]: Client should access ::NvEncMapInputResource() API through this pointer. */ 3592 PNVENCUNMAPINPUTRESOURCE nvEncUnmapInputResource; /**< [out]: Client should access ::NvEncUnmapInputResource() API through this pointer. */ 3593 PNVENCDESTROYENCODER nvEncDestroyEncoder; /**< [out]: Client should access ::NvEncDestroyEncoder() API through this pointer. */ 3594 PNVENCINVALIDATEREFFRAMES nvEncInvalidateRefFrames; /**< [out]: Client should access ::NvEncInvalidateRefFrames() API through this pointer. */ 3595 PNVENCOPENENCODESESSIONEX nvEncOpenEncodeSessionEx; /**< [out]: Client should access ::NvEncOpenEncodeSession() API through this pointer. */ 3596 PNVENCREGISTERRESOURCE nvEncRegisterResource; /**< [out]: Client should access ::NvEncRegisterResource() API through this pointer. */ 3597 PNVENCUNREGISTERRESOURCE nvEncUnregisterResource; /**< [out]: Client should access ::NvEncUnregisterResource() API through this pointer. */ 3598 PNVENCRECONFIGUREENCODER nvEncReconfigureEncoder; /**< [out]: Client should access ::NvEncReconfigureEncoder() API through this pointer. */ 3599 void* reserved1; 3600 PNVENCCREATEMVBUFFER nvEncCreateMVBuffer; /**< [out]: Client should access ::NvEncCreateMVBuffer API through this pointer. */ 3601 PNVENCDESTROYMVBUFFER nvEncDestroyMVBuffer; /**< [out]: Client should access ::NvEncDestroyMVBuffer API through this pointer. */ 3602 PNVENCRUNMOTIONESTIMATIONONLY nvEncRunMotionEstimationOnly; /**< [out]: Client should access ::NvEncRunMotionEstimationOnly API through this pointer. */ 3603 PNVENCGETLASTERROR nvEncGetLastErrorString; /**< [out]: Client should access ::nvEncGetLastErrorString API through this pointer. */ 3604 PNVENCSETIOCUDASTREAMS nvEncSetIOCudaStreams; /**< [out]: Client should access ::nvEncSetIOCudaStreams API through this pointer. */ 3605 void* reserved2[279]; /**< [in]: Reserved and must be set to NULL */ 3606 } NV_ENCODE_API_FUNCTION_LIST; 3607 3608 /** Macro for constructing the version field of ::_NV_ENCODEAPI_FUNCTION_LIST. */ 3609 #define NV_ENCODE_API_FUNCTION_LIST_VER NVENCAPI_STRUCT_VERSION(2) 3610 3611 // NvEncodeAPICreateInstance 3612 /** 3613 * \ingroup ENCODE_FUNC 3614 * Entry Point to the NvEncodeAPI interface. 3615 * 3616 * Creates an instance of the NvEncodeAPI interface, and populates the 3617 * pFunctionList with function pointers to the API routines implemented by the 3618 * NvEncodeAPI interface. 3619 * 3620 * \param [out] functionList 3621 * 3622 * \return 3623 * ::NV_ENC_SUCCESS 3624 * ::NV_ENC_ERR_INVALID_PTR 3625 */ 3626 NVENCSTATUS NVENCAPI NvEncodeAPICreateInstance(NV_ENCODE_API_FUNCTION_LIST *functionList); 3627 3628 #ifdef __cplusplus 3629 } 3630 #endif 3631 3632 3633 #endif 3634 3635