nvmedia_2d.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2013-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
 * property and proprietary rights in and to this material, related
 * documentation and any modifications thereto. Any use, reproduction,
 * disclosure or distribution of this material and related documentation
 * without an express license agreement from NVIDIA CORPORATION or
 * its affiliates is strictly prohibited.
 */
 
 
#ifndef NVMEDIA_2D_H
#define NVMEDIA_2D_H
 
#include "nvmedia_core.h"
#include <stdint.h>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
#define NVMEDIA_2D_MAX_LDC_REGIONS_X 4U
 
#define NVMEDIA_2D_MAX_LDC_REGIONS_Y 4U
 
typedef enum
{
    NVMEDIA_2D_FILTER_OFF = 0x1,
 
    NVMEDIA_2D_FILTER_LOW,
 
    NVMEDIA_2D_FILTER_MEDIUM,
 
    NVMEDIA_2D_FILTER_HIGH
 
} NvMedia2DFilter;
 
typedef enum
{
    NVMEDIA_2D_TRANSFORM_NONE = 0x0,
 
    NVMEDIA_2D_TRANSFORM_ROTATE_90,
 
    NVMEDIA_2D_TRANSFORM_ROTATE_180,
 
    NVMEDIA_2D_TRANSFORM_ROTATE_270,
 
    NVMEDIA_2D_TRANSFORM_FLIP_HORIZONTAL,
 
    NVMEDIA_2D_TRANSFORM_INV_TRANSPOSE,
 
    NVMEDIA_2D_TRANSFORM_FLIP_VERTICAL,
 
    NVMEDIA_2D_TRANSFORM_TRANSPOSE
 
} NvMedia2DTransform;
 
typedef enum
{
    NVMEDIA_2D_BLEND_MODE_DISABLED,
 
    NVMEDIA_2D_BLEND_MODE_CONSTANT_ALPHA,
 
    NVMEDIA_2D_BLEND_MODE_STRAIGHT_ALPHA,
 
    NVMEDIA_2D_BLEND_MODE_PREMULTIPLIED_ALPHA
 
} NvMedia2DBlendMode;
 
typedef struct
{
    uint32_t numComposeParameters;
 
    uint32_t maxRegisteredBuffers;
 
    uint32_t maxRegisteredSyncs;
 
    uint32_t maxFilterBuffers;
 
    uint32_t maxLdcWarpMaps;
 
    uint32_t maxLdcMaskMaps;
 
    uint32_t maxTnrStates;
 
    uint32_t flags;
 
} NvMedia2DAttributes;
 
typedef struct
{
    uint32_t maxWarpMapWidth;
 
    uint32_t maxWarpMapHeight;
 
} NvMedia2DLdcWarpMapAttributes;
 
typedef struct
{
    uint32_t maxDstWidth;
 
    uint32_t maxDstHeight;
 
} NvMedia2DLdcMaskMapAttributes;
 
typedef struct
{
    uint32_t maxDstWidth;
 
    uint32_t maxDstHeight;
 
} NvMedia2DTnrStateAttributes;
 
typedef struct
{
    uint32_t maxComposeLayers;
 
    float minScaleFactor;
 
    float maxScaleFactor;
 
    uint32_t minSurfaceHeight;
 
    uint32_t maxSurfaceHeight;
 
    uint32_t minSurfaceWidth;
 
    uint32_t maxSurfaceWidth;
 
    uint32_t tileWidth;
 
    uint32_t tileHeight;
 
    bool supportsCompareCrc;
 
    bool supportsReadCrc;
 
    bool supportsCompose;
 
    bool supportsLdc;
 
    bool supportsComposeLdc;
 
    bool supportsComposeTnrOutput;
 
    bool supportsComposeXSobel;
 
    bool supportsLdcMaskMap;
 
    bool supports16BitYUVNatively;
 
    bool supportsNonAlignedRects;
} NvMedia2DCapabilities;
 
typedef uint32_t NvMedia2DComposeParameters;
 
typedef uint32_t NvMedia2DFilterBuffer;
 
typedef uint32_t NvMedia2DLdcWarpMap;
 
typedef uint32_t NvMedia2DLdcMaskMap;
 
typedef uint32_t NvMedia2DTnrState;
 
typedef struct
{
    uint64_t operationId;
 
} NvMedia2DComposeResult;
 
typedef struct
{
    int16_t coeffs[32][5];
 
} NvMedia2DFilterCoefficients5Tap;
 
typedef struct
{
    int16_t coeffs[32][10];
 
} NvMedia2DFilterCoefficients10Tap;
 
typedef struct
{
    uint32_t numRegionsX;
 
    uint32_t numRegionsY;
 
    uint32_t regionWidth[NVMEDIA_2D_MAX_LDC_REGIONS_X];
 
    uint32_t regionHeight[NVMEDIA_2D_MAX_LDC_REGIONS_Y];
 
    uint32_t controlPointXSpacingLog2[NVMEDIA_2D_MAX_LDC_REGIONS_X];
 
    uint32_t controlPointYSpacingLog2[NVMEDIA_2D_MAX_LDC_REGIONS_Y];
 
} NvMedia2DLdcRegionParameters;
 
typedef struct
{
    NvMedia2DLdcRegionParameters regionParams;
 
    float matrixCoeffs[3][3];
 
} NvMedia2DLdcTransformMatrix;
 
typedef struct
{
    float x;
 
    float y;
 
} NvMedia2DLdcControlPoint;
 
typedef struct
{
    NvMedia2DLdcRegionParameters regionParams;
 
    uint32_t numControlPoints;
 
    NvMedia2DLdcControlPoint const *controlPoints;
 
} NvMedia2DLdcWarpMapParameters;
 
typedef struct
{
    uint32_t width;
 
    uint32_t height;
 
    bool useMaskColor;
 
    float maskColorY;
 
    float maskColorU;
 
    float maskColorV;
 
    bool const *pixelMasks;
 
} NvMedia2DLdcMaskMapParameters;
 
typedef struct
{
    uint32_t spatialSigmaLuma;
 
    uint32_t spatialSigmaChroma;
 
    uint32_t rangeSigmaLuma;
 
    uint32_t rangeSigmaChroma;
 
    float sadMultiplier;
 
    float sadWeightLuma;
 
    bool alphaSmoothEnable;
 
    float alphaIncreaseCap;
 
    float alphaScaleIIR;
 
    float alphaMaxLuma;
 
    float alphaMinLuma;
 
    float alphaMaxChroma;
 
    float alphaMinChroma;
 
    float betaX1;
 
    float betaX2;
 
    float maxBeta;
 
    float minBeta;
} NvMedia2DTnrParameters;
 
#define NVMEDIA_2D_CHECKSUM_NUM_BYTES 24u
 
typedef struct
{
    uint8_t data[NVMEDIA_2D_CHECKSUM_NUM_BYTES];
} NvMedia2DChecksum;
 
typedef enum
{
    NVMEDIA_2D_CHECKSUM_MODE_DISABLED,
 
    NVMEDIA_2D_CHECKSUM_MODE_SRC_SURFACE,
} NvMedia2DChecksumMode;
 
typedef struct NvMedia2D NvMedia2D;
 
NvMedia2DAttributes
NvMedia2DGetDefaultAttributes(void);
 
NvMedia2DLdcWarpMapAttributes
NvMedia2DGetDefaultLdcWarpMapAttributes(void);
 
NvMedia2DLdcMaskMapAttributes
NvMedia2DGetDefaultLdcMaskMapAttributes(void);
 
NvMedia2DTnrStateAttributes
NvMedia2DGetDefaultTnrStateAttributes(void);
 
NvMediaStatus
NvMedia2DCreate(NvMedia2D ** const handle,
                NvMedia2DAttributes const * const attr);
 
//    completed.
NvMediaStatus
NvMedia2DDestroy(NvMedia2D const * const handle);
 
NvMedia2DCapabilities const *
NvMedia2DGetCapabilities(NvMedia2D const * const handle);
 
NvMediaStatus
NvMedia2DGetComposeParameters(NvMedia2D const * const handle,
                              NvMedia2DComposeParameters * const params);
 
NvMediaStatus
NvMedia2DReleaseComposeParameters(NvMedia2D const *const handle,
                                  NvMedia2DComposeParameters const params);
 
NvMediaStatus
NvMedia2DCompose(NvMedia2D const * const handle,
                 NvMedia2DComposeParameters const params,
                 NvMedia2DComposeResult * const result);
 
NvMediaStatus
NvMedia2DSetSrcGeometry(NvMedia2D const * const handle,
                        NvMedia2DComposeParameters const params,
                        uint32_t const index,
                        NvMediaRect const * const srcRect,
                        NvMediaRect const * const dstRect,
                        NvMedia2DTransform const transform);
 
NvMediaStatus
NvMedia2DSetSrcFilter(NvMedia2D const * const handle,
                      NvMedia2DComposeParameters const params,
                      uint32_t const index,
                      NvMedia2DFilter const filter);
 
NvMediaStatus
NvMedia2DSetSrcBlendMode(NvMedia2D const * const handle,
                         NvMedia2DComposeParameters const params,
                         uint32_t const index,
                         NvMedia2DBlendMode const blendMode,
                         float const constantAlpha);
 
NvMediaStatus
NvMedia2DSetSrcLdcTransformMatrix(NvMedia2D const * const handle,
                                  NvMedia2DComposeParameters const params,
                                  uint32_t const index,
                                  NvMedia2DLdcTransformMatrix const * const ldcIptParams);
 
NvMediaStatus
NvMedia2DSetSrcLdcWarpMap(NvMedia2D const * const handle,
                          NvMedia2DComposeParameters const params,
                          uint32_t const index,
                          NvMedia2DLdcWarpMap const ldcWarpMap);
 
NvMediaStatus
NvMedia2DSetSrcLdcMaskMap(NvMedia2D const * const handle,
                          NvMedia2DComposeParameters const params,
                          uint32_t const index,
                          NvMedia2DLdcMaskMap const ldcMaskMap);
 
NvMediaStatus
NvMedia2DSetClipRect(NvMedia2D const * const handle,
                     NvMedia2DComposeParameters const params,
                     NvMediaRect const * const clipRect);
 
NvMediaStatus
NvMedia2DSetTnrState(NvMedia2D const * const handle,
                     NvMedia2DComposeParameters const params,
                     NvMedia2DTnrState const tnrState);
 
NvMediaStatus
NvMedia2DCreateFilterBuffer(NvMedia2D const * const handle,
                            NvMedia2DFilterBuffer * const filterBuffer);
 
NvMediaStatus
NvMedia2DDestroyFilterBuffer(NvMedia2D const * const handle,
                             NvMedia2DFilterBuffer const filterBuffer);
 
NvMediaStatus
NvMedia2DSetFilterBuffer(NvMedia2D const * const handle,
                         NvMedia2DComposeParameters const params,
                         NvMedia2DFilterBuffer const filterBuffer);
 
NvMediaStatus
NvMedia2DComputeFilterCoefficients5Tap(NvMedia2D const * const handle,
                                       NvMedia2DFilterBuffer const filterBuffer,
                                       uint32_t const index,
                                       NvMedia2DFilterCoefficients5Tap const * const lumaX,
                                       NvMedia2DFilterCoefficients5Tap const * const lumaY,
                                       NvMedia2DFilterCoefficients5Tap const * const chromaX,
                                       NvMedia2DFilterCoefficients5Tap const * const chromaY);
 
NvMediaStatus
NvMedia2DComputeFilterCoefficients10Tap(NvMedia2D const * const handle,
                                        NvMedia2DFilterBuffer const filterBuffer,
                                        uint32_t const index,
                                        NvMedia2DFilterCoefficients10Tap const * const lumaX,
                                        NvMedia2DFilterCoefficients10Tap const * const lumaY,
                                        NvMedia2DFilterCoefficients10Tap const * const chromaX,
                                        NvMedia2DFilterCoefficients10Tap const * const chromaY);
 
NvMediaStatus
NvMedia2DCreateLdcWarpMap(NvMedia2D const * const handle,
                          NvMedia2DLdcWarpMapAttributes const * const ldcWarpMapAttr,
                          NvMedia2DLdcWarpMap * const ldcWarpMap);
 
NvMediaStatus
NvMedia2DDestroyLdcWarpMap(NvMedia2D const * const handle,
                           NvMedia2DLdcWarpMap const ldcWarpMap);
 
NvMediaStatus
NvMedia2DCreateLdcMaskMap(NvMedia2D const * const handle,
                          NvMedia2DLdcMaskMapAttributes const * const ldcMaskMapAttr,
                          NvMedia2DLdcMaskMap * const ldcMaskMap);
 
NvMediaStatus
NvMedia2DDestroyLdcMaskMap(NvMedia2D const * const handle,
                           NvMedia2DLdcMaskMap const ldcMaskMap);
 
NvMediaStatus
NvMedia2DFillLdcWarpMap(NvMedia2D const * const handle,
                        NvMedia2DLdcWarpMap const ldcWarpMap,
                        NvMedia2DLdcWarpMapParameters const * const lcdWarpMapParams);
 
NvMediaStatus
NvMedia2DFillLdcMaskMap(NvMedia2D const * const handle,
                        NvMedia2DLdcMaskMap const ldcMaskMap,
                        NvMedia2DLdcMaskMapParameters const * const ldcMaskMapParams);
 
NvMediaStatus
NvMedia2DCreateTnrState(NvMedia2D const * const handle,
                        NvMedia2DTnrStateAttributes const * const tnrStateAttr,
                        NvMedia2DTnrState * const tnrState);
 
NvMediaStatus
NvMedia2DDestroyTnrState(NvMedia2D const * const handle,
                         NvMedia2DTnrState const tnrState);
 
NvMediaStatus
NvMedia2DSetTnrParameters(NvMedia2D const * const handle,
                          NvMedia2DTnrState const tnrState,
                          NvMedia2DTnrParameters const *const tnrParams);
 
NvMediaStatus
NvMedia2DResetTnr(NvMedia2D const * const handle,
                  NvMedia2DTnrState const tnrState);
 
NvMediaStatus
NvMedia2DSetChecksumMode(NvMedia2D const * const handle,
                         NvMedia2DComposeParameters const params,
                         NvMedia2DChecksumMode const checksumMode);
 
NvMediaStatus
NvMedia2DGetChecksum(NvMedia2D const * const handle,
                     NvMedia2DComposeResult const *const result,
                     NvMedia2DChecksum *const checksum);
 
 
#ifdef __cplusplus
}
#endif
 
#endif // NVMEDIA_2D_H