Format.h

Go to the documentation of this file.

/*
 * Copyright 2020 NVIDIA Corporation. All rights reserved.
 *
 * NOTICE TO LICENSEE:
 *
 * This source code and/or documentation ("Licensed Deliverables") are
 * subject to NVIDIA intellectual property rights under U.S. and
 * international Copyright laws.
 *
 * These Licensed Deliverables contained herein is PROPRIETARY and
 * CONFIDENTIAL to NVIDIA and is being provided under the terms and
 * conditions of a form of NVIDIA software license agreement by and
 * between NVIDIA and Licensee ("License Agreement") or electronically
 * accepted by Licensee. Notwithstanding any terms or conditions to
 * the contrary in the License Agreement, reproduction or disclosure
 * of the Licensed Deliverables to any third party without the express
 * written consent of NVIDIA is prohibited.
 *
 * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
 * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
 * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE. IT IS
 * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
 * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
 * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
 * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
 * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
 * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
 * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
 * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THESE LICENSED DELIVERABLES.
 *
 * U.S. Government End Users. These Licensed Deliverables are a
 * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
 * 1995), consisting of "commercial computer software" and "commercial
 * computer software documentation" as such terms are used in 48
 * C.F.R. 12.212 (SEPT 1995) and is provided to the U.S. Government
 * only as a commercial end item. Consistent with 48 C.F.R.12.212 and
 * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
 * U.S. Government End Users acquire the Licensed Deliverables with
 * only those rights set forth herein.
 *
 * Any use of the Licensed Deliverables in individual and commercial
 * software must include, in the user documentation and internal
 * comments to the code, the above Disclaimer and U.S. Government End
 * Users Notice.
 */
 
#ifndef NV_VPI_FORMAT_H
#define NV_VPI_FORMAT_H
 
#include "Export.h"
#include "detail/FormatUtils.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum
{
    VPI_FORMAT_PACKING_0       = 0,                    
    VPI_FORMAT_PACKING_INVALID = VPI_FORMAT_PACKING_0, 
    VPI_FORMAT_PACKING_X1 = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(1, 1), 
    VPI_FORMAT_PACKING_X2 = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(2, 1), 
    VPI_FORMAT_PACKING_X4 = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(4, 1), 
    VPI_FORMAT_PACKING_X8   = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(8, 1), 
    VPI_FORMAT_PACKING_X4Y4 = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(8, 2), 
    VPI_FORMAT_PACKING_X3Y3Z2 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(8, 3), 
    VPI_FORMAT_PACKING_X16   = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(16, 1), 
    VPI_FORMAT_PACKING_X8_Y8 = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(16, 2), 
    VPI_FORMAT_PACKING_X8Y8,                                             
    VPI_FORMAT_PACKING_X6Y10,        
    VPI_FORMAT_PACKING_X10Y6,        
    VPI_FORMAT_PACKING_X2Y14,        
    VPI_FORMAT_PACKING_X12Y4,        
    VPI_FORMAT_PACKING_X4Y12,        
    VPI_FORMAT_PACKING_X8_Y8__X8_Z8, 
    VPI_FORMAT_PACKING_Y8_X8__Z8_X8, 
    VPI_FORMAT_PACKING_X5Y5Z6 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(16, 3), 
    VPI_FORMAT_PACKING_X5Y6Z5,                    
    VPI_FORMAT_PACKING_X6Y5Z5,                    
    VPI_FORMAT_PACKING_X1Y5Z5W5 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(16, 4), 
    VPI_FORMAT_PACKING_X4Y4Z4W4,                  
    VPI_FORMAT_PACKING_X5Y1Z5W5,                  
    VPI_FORMAT_PACKING_X5Y5Z1W5,                  
    VPI_FORMAT_PACKING_X5Y5Z5W1,                  
    VPI_FORMAT_PACKING_X24 = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(24, 1), 
    VPI_FORMAT_PACKING_X8_Y8_Z8 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(24, 3), 
    VPI_FORMAT_PACKING_X32 = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(32, 1), 
    VPI_FORMAT_PACKING_X16_Y16 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(32, 2), 
    VPI_FORMAT_PACKING_X16Y16,                    
    VPI_FORMAT_PACKING_X12Y20,                    
    VPI_FORMAT_PACKING_X10Y11Z11 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(32, 3), 
    VPI_FORMAT_PACKING_X11Y11Z10,                 
    VPI_FORMAT_PACKING_X2Y10Z10W10 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(32, 4), 
    VPI_FORMAT_PACKING_X8Y8Z8W8,                  
    VPI_FORMAT_PACKING_X8_Y8_Z8_W8,               
    VPI_FORMAT_PACKING_X10Y6Z10W6,                
    VPI_FORMAT_PACKING_X10Y10Z10W2,               
    VPI_FORMAT_PACKING_X12Y4Z12W4,                
    VPI_FORMAT_PACKING_X48 = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(48, 1), 
    VPI_FORMAT_PACKING_X16_Y16_Z16 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(48, 3), 
    VPI_FORMAT_PACKING_X64 = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(64, 1), 
    VPI_FORMAT_PACKING_X32_Y32 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(64, 2), 
    VPI_FORMAT_PACKING_X16_Y16_Z16_W16 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(64, 4), 
    VPI_FORMAT_PACKING_X16Y16Z16W16,              
    VPI_FORMAT_PACKING_X96 = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(96, 1), 
    VPI_FORMAT_PACKING_X32_Y32_Z32 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(96, 3), 
    VPI_FORMAT_PACKING_X128 = VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(128, 1), 
    VPI_FORMAT_PACKING_X32_Y32_Z32_W32 =
        VPI_DETAIL_FORMAT_SET_BPP_CHCOUNT(128, 4), 
    VPI_FORMAT_PACKING_X32Y32Z32W32,               
} VPIFormatPacking;
 
typedef enum
{
    VPI_FORMAT_DATA_TYPE_UNSIGNED, 
    VPI_FORMAT_DATA_TYPE_SIGNED,   
    VPI_FORMAT_DATA_TYPE_FLOAT     
} VPIFormatDataType;
 
typedef enum
{
    VPI_MEM_LAYOUT_PITCH_LINEAR,
 
    VPI_MEM_LAYOUT_BLOCK1_LINEAR,
 
    VPI_MEM_LAYOUT_BLOCK2_LINEAR,
 
    VPI_MEM_LAYOUT_BLOCK4_LINEAR,
 
    VPI_MEM_LAYOUT_BLOCK8_LINEAR,
 
    VPI_MEM_LAYOUT_BLOCK16_LINEAR,
 
    VPI_MEM_LAYOUT_BLOCK32_LINEAR,
 
    VPI_MEM_LAYOUT_BLOCK_LINEAR = VPI_MEM_LAYOUT_BLOCK2_LINEAR,
 
    VPI_MEM_LAYOUT_PL = VPI_MEM_LAYOUT_PITCH_LINEAR,
    VPI_MEM_LAYOUT_BL = VPI_MEM_LAYOUT_BLOCK_LINEAR
} VPIMemLayout;
 
typedef enum
{
    VPI_SWIZZLE_CHANNEL_0 = 0, 
    VPI_SWIZZLE_CHANNEL_X,     
    VPI_SWIZZLE_CHANNEL_Y,     
    VPI_SWIZZLE_CHANNEL_Z,     
    VPI_SWIZZLE_CHANNEL_W,     
    VPI_SWIZZLE_CHANNEL_1      
} VPISwizzleChannel;
 
typedef enum
{
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, 0, 0, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(1, 0, 0, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, 0, 0, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, Y, Z, W),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Z, Y, X, W),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(W, X, Y, Z),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(W, Z, Y, X),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, Z, W, X),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, Y, Z, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, Y, Z, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, Z, W, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, X, X, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, Z, Y, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Z, Y, X, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Z, Y, X, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(W, Z, Y, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, 0, 0, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, X, 0, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, 0, X, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, 0, 0, X),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, 0, 0, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, Y, 0, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, 0, Y, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, 0, 0, Y),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, X, Y, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, X, X, Y),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, Y, Y, X),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, Y, X, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, 0, 0, Y),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, 0, 0, X),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, 0, 0, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, Y, 0, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, Y, 0, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, X, Z, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, Z, X, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, Z, Y, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, Z, X, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Z, Y, W, 1)
} VPISwizzle;
 
#define VPI_MAKE_SWIZZLE(x, y, z, w) ((VPISwizzle)VPI_DETAIL_MAKE_SWIZZLE(x, y, z, w))
 
typedef enum
{
    VPI_COLOR_MODEL_OTHER,
 
    VPI_COLOR_MODEL_RGBA, 
    VPI_COLOR_MODEL_YUV,  
    VPI_COLOR_MODEL_RAW   
} VPIColorModel;
 
typedef enum
{
    VPI_COLOR_SPACE_NONCOLOR =
        VPI_DETAIL_FORMAT_SET_COLOR_MODEL(OTHER), 
    VPI_COLOR_SPACE_HSV,                          
    VPI_COLOR_SPACE_HSL,                          
    VPI_COLOR_SPACE_YIQ,                          
    VPI_COLOR_SPACE_LAB,                          
    VPI_COLOR_SPACE_LUV,                          
    VPI_COLOR_SPACE_XYZ,                          
    VPI_COLOR_SPACE_RGB = VPI_DETAIL_FORMAT_SET_COLOR_MODEL(RGBA),
 
    VPI_COLOR_SPACE_SensorRGB_LINEAR,
 
    VPI_COLOR_SPACE_sRGB,                
    VPI_COLOR_SPACE_RGB709,              
    VPI_COLOR_SPACE_RGB709_LINEAR,       
    VPI_COLOR_SPACE_DISPLAYP3_LINEAR,    
    VPI_COLOR_SPACE_DISPLAYP3_NONLINEAR, 
    VPI_COLOR_SPACE_RGB2020,             
    VPI_COLOR_SPACE_RGB2020_LINEAR,      
    VPI_COLOR_SPACE_RGB2020_PQ, 
    VPI_COLOR_SPACE_YCbCr601 =
        VPI_DETAIL_FORMAT_SET_COLOR_MODEL(YUV), 
    VPI_COLOR_SPACE_YCbCr601_ER,                
    VPI_COLOR_SPACE_YCbCr601_VC1,
 
    VPI_COLOR_SPACE_YCbCr709,        
    VPI_COLOR_SPACE_YCbCr709_ER,     
    VPI_COLOR_SPACE_YCbCr2020,       
    VPI_COLOR_SPACE_YCbCr2020_PQ_ER, 
    VPI_COLOR_SPACE_BayerRGGB = VPI_DETAIL_FORMAT_SET_COLOR_MODEL(RAW),
 
    VPI_COLOR_SPACE_BayerBGGR,
 
    VPI_COLOR_SPACE_BayerGRBG,
 
    VPI_COLOR_SPACE_BayerGBRG,
 
    VPI_COLOR_SPACE_BayerCCCC,
 
    VPI_COLOR_SPACE_BayerCRBC
} VPIColorSpace;
 
typedef enum
{
    VPI_CHROMA_SUBSAMPLING_444 = VPI_DETAIL_MAKE_CHROMA_SUBSAMPLING(1, 1, 0, 0),
 
    VPI_CHROMA_SUBSAMPLING_422_BT601 = VPI_DETAIL_MAKE_CHROMA_SUBSAMPLING(2, 1, 0, 0),
 
    VPI_CHROMA_SUBSAMPLING_422_COSITED = VPI_CHROMA_SUBSAMPLING_422_BT601,
 
    VPI_CHROMA_SUBSAMPLING_420_COSITED = VPI_DETAIL_MAKE_CHROMA_SUBSAMPLING(2, 2, 0, 0),
 
    VPI_CHROMA_SUBSAMPLING_420_MPEG1 = VPI_DETAIL_MAKE_CHROMA_SUBSAMPLING(2, 2, 1, 1),
 
    VPI_CHROMA_SUBSAMPLING_420_MPEG2 = VPI_DETAIL_MAKE_CHROMA_SUBSAMPLING(2, 2, 0, 1),
 
    VPI_CHROMA_SUBSAMPLING_NONE = VPI_CHROMA_SUBSAMPLING_444
} VPIChromaSubsampling;
 
#define vpiMakeSwizzle VPI_APINAME(vpiMakeSwizzle, 004)
#define vpiMakeChromaSubsampling VPI_APINAME(vpiMakeChromaSubsampling, 004)
#define vpiMakeFormatPacking VPI_APINAME(vpiMakeFormatPacking, 004)
#define vpiFormatPackingGetParams VPI_APINAME(vpiFormatPackingGetParams, 004)
#define vpiFormatPackingGetChannelCount VPI_APINAME(vpiFormatPackingGetChannelCount, 004)
#define vpiFormatPackingGetBitsPerPixel VPI_APINAME(vpiFormatPackingGetBitsPerPixel, 004)
 
VPI_PUBLIC VPISwizzle vpiMakeSwizzle(VPISwizzleChannel x, VPISwizzleChannel y, VPISwizzleChannel z,
                                     VPISwizzleChannel w);
VPI_PUBLIC VPIChromaSubsampling vpiMakeChromaSubsampling(int divHoriz, int divVert, int centerSampleHoriz,
                                                         int centerSampleVert);
 
VPI_PUBLIC VPIFormatPacking vpiMakeFormatPacking(int fixed, int bitsX, int bitsY, int bitsZ, int bitsW);
 
VPI_PUBLIC void vpiFormatPackingGetParams(VPIFormatPacking packing, int *fixed, int *bitsX, int *bitsY, int *bitsZ,
                                          int *bitsW);
VPI_PUBLIC int vpiFormatPackingGetChannelCount(VPIFormatPacking packing);
 
VPI_PUBLIC int vpiFormatPackingGetBitsPerPixel(VPIFormatPacking packing);
 
#ifdef __cplusplus
}
#endif
 
#endif // NV_VPI_FORMAT_H