DataLayout.h

Go to the documentation of this file.

/*
 * Copyright 2020-2021 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_DATALAYOUT_H
#define NV_VPI_DATALAYOUT_H
 
#include "Export.h"
#include "detail/FormatUtils.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum
{
    VPI_PACKING_0 = 0,
 
    VPI_PACKING_X1 = VPI_DETAIL_BPP_NCH(1, 1),
    VPI_PACKING_X2 = VPI_DETAIL_BPP_NCH(2, 1),
    VPI_PACKING_X4 = VPI_DETAIL_BPP_NCH(4, 1),
    VPI_PACKING_X8 = VPI_DETAIL_BPP_NCH(8, 1),
    VPI_PACKING_X4Y4 = VPI_DETAIL_BPP_NCH(8, 2),
    VPI_PACKING_X3Y3Z2 = VPI_DETAIL_BPP_NCH(8, 3),
 
    VPI_PACKING_X16 = VPI_DETAIL_BPP_NCH(16, 1),
    VPI_PACKING_b6X10,
    VPI_PACKING_X10b6,
    VPI_PACKING_b4X12,
    VPI_PACKING_X12b4,
    VPI_PACKING_b2X14,
 
    VPI_PACKING_X8_Y8 = VPI_DETAIL_BPP_NCH(16, 2),
 
    VPI_PACKING_X5Y5Z6 = VPI_DETAIL_BPP_NCH(16, 3),
    VPI_PACKING_X5Y6Z5,
    VPI_PACKING_X6Y5Z5,
    VPI_PACKING_b4X4Y4Z4,
    VPI_PACKING_b1X5Y5Z5,
    VPI_PACKING_X5Y5b1Z5,
 
    VPI_PACKING_X1Y5Z5W5 = VPI_DETAIL_BPP_NCH(16, 4),
    VPI_PACKING_X4Y4Z4W4,
    VPI_PACKING_X5Y1Z5W5,
    VPI_PACKING_X5Y5Z1W5,
    VPI_PACKING_X5Y5Z5W1,
 
    VPI_PACKING_X8_Y8__X8_Z8,
    VPI_PACKING_Y8_X8__Z8_X8,
 
    VPI_PACKING_X24 = VPI_DETAIL_BPP_NCH(24, 1),
 
    VPI_PACKING_X8_Y8_Z8 = VPI_DETAIL_BPP_NCH(24, 3),
 
    VPI_PACKING_X32 = VPI_DETAIL_BPP_NCH(32, 1),
    VPI_PACKING_b12X20,
 
    VPI_PACKING_X16_Y16 = VPI_DETAIL_BPP_NCH(32, 2),
    VPI_PACKING_X10b6_Y10b6,
    VPI_PACKING_X12b4_Y12b4,
 
    VPI_PACKING_X10Y11Z11 = VPI_DETAIL_BPP_NCH(32, 3),
    VPI_PACKING_X11Y11Z10,
 
    VPI_PACKING_X8_Y8_Z8_W8 = VPI_DETAIL_BPP_NCH(32, 4),
    VPI_PACKING_X2Y10Z10W10,
    VPI_PACKING_X10Y10Z10W2,
 
    VPI_PACKING_X48 = VPI_DETAIL_BPP_NCH(48, 1),
    VPI_PACKING_X16_Y16_Z16 = VPI_DETAIL_BPP_NCH(48, 3),
 
    VPI_PACKING_X64 = VPI_DETAIL_BPP_NCH(64, 1),
    VPI_PACKING_X32_Y32 = VPI_DETAIL_BPP_NCH(64, 2),
    VPI_PACKING_X16_Y16_Z16_W16 = VPI_DETAIL_BPP_NCH(64, 4),
 
    VPI_PACKING_X96 = VPI_DETAIL_BPP_NCH(96, 1),
    VPI_PACKING_X32_Y32_Z32 = VPI_DETAIL_BPP_NCH(96, 3),
 
    VPI_PACKING_X128 = VPI_DETAIL_BPP_NCH(128, 1),
    VPI_PACKING_X64_Y64 = VPI_DETAIL_BPP_NCH(128, 2),
    VPI_PACKING_X32_Y32_Z32_W32 = VPI_DETAIL_BPP_NCH(128, 4),
 
    VPI_PACKING_X192 = VPI_DETAIL_BPP_NCH(192, 1),
    VPI_PACKING_X64_Y64_Z64 = VPI_DETAIL_BPP_NCH(192, 3),
 
    VPI_PACKING_X256 = VPI_DETAIL_BPP_NCH(256, 1),
    VPI_PACKING_X64_Y64_Z64_W64 = VPI_DETAIL_BPP_NCH(256, 4),
 
    VPI_PACKING_INVALID = INT32_MAX
} VPIPacking;
 
typedef enum
{
    VPI_DATA_TYPE_INVALID = 0,
 
    VPI_DATA_TYPE_UNSIGNED, 
    VPI_DATA_TYPE_SIGNED,   
    VPI_DATA_TYPE_FLOAT,    
    VPI_DATA_TYPE_FLOATISP  
} VPIDataType;
 
typedef enum
{
    VPI_MEM_LAYOUT_INVALID = 0,
 
    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_CHANNEL_INVALID = 7, 
    VPI_CHANNEL_0 = 0, 
    VPI_CHANNEL_X,     
    VPI_CHANNEL_Y,     
    VPI_CHANNEL_Z,     
    VPI_CHANNEL_W,     
    VPI_CHANNEL_1      
} VPIChannel;
 
typedef enum
{
    VPI_SWIZZLE_INVALID = VPI_DETAIL_MAKE_SWZL(INVALID, INVALID, INVALID, INVALID),
 
    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),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, Y, X, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, Y, X, Z),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, X, Z, X),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, Z, 0, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(W, Y, X, Z),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, X, 0, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, X, 0, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, 0, Y, X),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, 0, X, Y),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, X, Y, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(0, X, 0, 1),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, Z, X, W),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, W, 0, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(X, Y, W, 0),
    VPI_DETAIL_DEF_SWIZZLE_ENUM(Y, Z, W, 0),
} VPISwizzle;
 
#ifdef VPI_DOXYGEN
#    define VPI_MAKE_SWIZZLE_ABBREV(x, y, z, w)
#else
#    define VPI_MAKE_SWIZZLE_ABBREV (VPISwizzle) VPI_DETAIL_MAKE_SWZL
#endif
 
#ifdef VPI_DOXYGEN
#    define VPI_MAKE_SWIZZLE(x, y, z, w)
#else
#    define VPI_MAKE_SWIZZLE (VPISwizzle) VPI_DETAIL_MAKE_SWIZZLE
#endif
 
VPI_PUBLIC VPISwizzle vpiMakeSwizzle(VPIChannel x, VPIChannel y, VPIChannel z, VPIChannel w);
 
VPI_PUBLIC void vpiSwizzleGetChannels(VPISwizzle swizzle, VPIChannel *channels);
 
VPI_PUBLIC int vpiSwizzleGetChannelCount(VPISwizzle swizzle);
 
typedef enum
{
    VPI_INVALID_ENDIAN, 
    VPI_HOST_ENDIAN,    
    VPI_BIG_ENDIAN      
} VPIEndianness;
 
typedef struct
{
    VPIEndianness endianness;
 
    VPISwizzle swizzle;
 
    int bits[4];
 
} VPIPackingParams;
 
VPI_PUBLIC VPIPacking vpiMakePacking(const VPIPackingParams *params);
 
VPI_PUBLIC void vpiPackingGetParams(VPIPacking packing, VPIPackingParams *params);
 
VPI_PUBLIC int vpiPackingGetComponentCount(VPIPacking packing);
 
VPI_PUBLIC void vpiPackingGetBitsPerComponent(VPIPacking packing, int32_t *bits);
 
VPI_PUBLIC int vpiPackingGetBitsPerPixel(VPIPacking packing);
 
#ifdef __cplusplus
}
#endif
 
#endif /* NV_VPI_DATALAYOUT_H */