nvmedia_ldc.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2017-2023 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_LDC_H
#define NVMEDIA_LDC_H
 
#include "nvmedia_core.h"
#include <stdbool.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
#define NVMEDIA_LDC_VERSION_MAJOR 11
 
#define NVMEDIA_LDC_VERSION_MINOR 0
 
#define NVMEDIA_LDC_VERSION_PATCH 0
 
typedef struct NvMediaLdc NvMediaLdc;
 
typedef uint32_t NvMediaLdcParameters;
 
typedef struct
{
    uint32_t maxParameters;
 
    uint32_t maxRegisteredBuffers;
 
    uint32_t maxRegisteredSyncs;
 
    uint32_t flags;
} NvMediaLdcAttributes;
 
typedef struct
{
    uint32_t maxWarpMapWidth;
 
    uint32_t maxWarpMapHeight;
 
    bool enableTnr;
 
    bool enableMaskMap;
 
    uint32_t maxDstWidth;
 
    uint32_t maxDstHeight;
} NvMediaLdcParametersAttributes;
 
typedef struct
{
    uint64_t operationId;
} NvMediaLdcResult;
 
typedef enum
{
    NVMEDIA_LDC_FILTER_OFF,
 
    NVMEDIA_LDC_FILTER_LOW,
 
    NVMEDIA_LDC_FILTER_MEDIUM
} NvMediaLdcFilter;
 
#define NVMEDIA_LDC_MAX_REGIONS_X 4u
 
#define NVMEDIA_LDC_MAX_REGIONS_Y 4u
 
typedef struct
{
    uint32_t numRegionsX;
 
    uint32_t numRegionsY;
 
    uint32_t regionWidth[NVMEDIA_LDC_MAX_REGIONS_X];
 
    uint32_t regionHeight[NVMEDIA_LDC_MAX_REGIONS_Y];
 
    uint32_t controlPointXSpacingLog2[NVMEDIA_LDC_MAX_REGIONS_X];
 
    uint32_t controlPointYSpacingLog2[NVMEDIA_LDC_MAX_REGIONS_Y];
} NvMediaLdcRegionParameters;
 
typedef struct
{
    NvMediaLdcRegionParameters regionParams;
 
    float matrixCoeffs[3][3];
} NvMediaLdcIptParameters;
 
typedef struct
{
    float x;
 
    float y;
} NvMediaLdcControlPoint;
 
typedef struct
{
    NvMediaLdcRegionParameters regionParams;
 
    uint32_t numControlPoints;
 
    NvMediaLdcControlPoint const *controlPoints;
} NvMediaLdcWarpMapParameters;
 
typedef struct
{
    uint32_t width;
 
    uint32_t height;
 
    bool useMaskColor;
 
    float maskColorY;
 
    float maskColorU;
 
    float maskColorV;
 
    bool const *pixelMasks;
} NvMediaLdcMaskMapParameters;
 
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;
} NvMediaLdcTnrParameters;
 
#define NVMEDIA_LDC_CHECKSUM_NUM_BYTES 24u
 
typedef struct
{
    uint8_t data[NVMEDIA_LDC_CHECKSUM_NUM_BYTES];
} NvMediaLdcChecksum;
 
typedef enum
{
    NVMEDIA_LDC_CHECKSUM_MODE_DISABLED,
 
    NVMEDIA_LDC_CHECKSUM_MODE_SRC_SURFACE,
} NvMediaLdcChecksumMode;
 
NvMediaStatus
NvMediaLdcGetVersion(NvMediaVersion *const version);
 
NvMediaStatus
NvMediaLdcCreate(NvMediaLdc **const handle, NvMediaLdcAttributes const *const attr);
 
NvMediaStatus
NvMediaLdcDestroy(NvMediaLdc const * const handle);
 
NvMediaStatus
NvMediaLdcCreateParameters(NvMediaLdc const * const handle,
                           NvMediaLdcParametersAttributes const *const attr,
                           NvMediaLdcParameters *const params);
 
NvMediaStatus
NvMediaLdcDestroyParameters(NvMediaLdc const * const handle, NvMediaLdcParameters const params);
 
NvMediaStatus
NvMediaLdcSetFilter(NvMediaLdc const * const handle,
                    NvMediaLdcParameters const params,
                    NvMediaLdcFilter const filter);
 
NvMediaStatus
NvMediaLdcSetGeometry(NvMediaLdc const * const handle,
                      NvMediaLdcParameters const params,
                      NvMediaRect const *const srcRect,
                      NvMediaRect const *const dstRect);
 
NvMediaStatus
NvMediaLdcSetIptParameters(NvMediaLdc const * const handle,
                           NvMediaLdcParameters const params,
                           NvMediaLdcIptParameters const *const iptParams);
 
NvMediaStatus
NvMediaLdcSetWarpMapParameters(NvMediaLdc const * const handle,
                               NvMediaLdcParameters const params,
                               NvMediaLdcWarpMapParameters const *const warpMapParams);
 
NvMediaStatus
NvMediaLdcSetMaskMapParameters(NvMediaLdc const * const handle,
                               NvMediaLdcParameters const params,
                               NvMediaLdcMaskMapParameters const *const maskMapParams);
 
NvMediaStatus
NvMediaLdcSetTnrParameters(NvMediaLdc const * const handle,
                           NvMediaLdcParameters const params,
                           NvMediaLdcTnrParameters const *const tnrParams);
 
NvMediaStatus
NvMediaLdcResetTnr(NvMediaLdc const * const handle, NvMediaLdcParameters const params);
 
NvMediaStatus
NvMediaLdcSetChecksumMode(NvMediaLdc const * const handle,
                          NvMediaLdcParameters const params,
                          NvMediaLdcChecksumMode const checksumMode);
 
NvMediaStatus
NvMediaLdcGetChecksum(NvMediaLdc const * const handle,
                      NvMediaLdcResult const *const result,
                      NvMediaLdcChecksum *const checksum);
 
NvMediaStatus
NvMediaLdcProcess(NvMediaLdc const * const handle,
                  NvMediaLdcParameters const params,
                  NvMediaLdcResult *const result);
 
 
//
// Version History
//
// Version 1.0 May 1, 2017
// - Initial release.
//
// Version 1.1 March 16, 2018
// - Add support of TNR2
//
// Version 1.2 September 4, 2018
// - New member variable srcSurfaceType is added to NvMediaLDCInitParams.
//
// Version 1.3 December 26, 2018
// - Adding unsigned tag to macro constants to fix MISRA 10.4 violation.
// - Fixing MISRA 21.1 violations
//
// Version 1.4 January 2, 2019
// - Added deprecated warning message for NvMediaLDCCreate.
// - Added API NvMediaLDCCreateNew
//
// Version 1.5 March 6, 2019
// - Fixing MISRA 8.13 violations.
//
// Version 1.6 March 12, 2019
// - Added required header includes nvmedia_core.h and nvmedia_surface.h
//
// Version 2.0 March 29, 2019
// - Deprecated NvMediaLDCCreate API.
//
// Version 2.1 January 23, 2020
// - Limited destination surface rectangle's top, left corner to (0, 0).
//
// Version 3.0 December 26, 2021
// - Major rework of API, NvMediaImage support was deprecated and
//   all functionality related to NvMediaImage has been updated
//   in order to support NvSciBuf instead of NvMediaImage.
// - The workflow was changed from setting the parameters
//   at the Init stage to using a subset of API that set parameters
//   prior to NvMediaLdcProcess() call.
//
// Version 4.0.0 March 28, 2022
// - Add support for NvSciSync task statuses
// - Max pre-fence count changed from 32 to 16
//
// Version 5.0.0 May 10, 2022
// - Re-added the destination rectangle top-left (0, 0) limitation.
//
// Version 6.0.0 June 7, 2022
// - Forbid registering same buffer multiple times
// - Error codes changed for multiple APIs
//
// Version 7.0.0 July 8, 2022
// - New error NVMEDIA_STATUS_INVALID_STATE added for multiple APIs
//
// Version 7.0.1 August 25, 2022
// - Allow NULL context handle in NvMediaLdcFillNvSciBufAttrList
//
// Version 7.0.2 September 2, 2022
// - Always treat parameters handle value 0 as invalid
//
// Version 8.0.0 March 10, 2023
// - NvMediaLdcSetGeometry() and NvMediaLdcSetTnrParameters() no longer reset
//   TNR algorithm state
// - New API NvMediaLdcResetTnr() added for explicitly resetting the state
//
// Version 8.1.0 June 2, 2023
// - New checksum API added
//
// Version 9.0.0 September 8, 2023
// - Reject odd rectangle coordinates regardless of surface format
// - Reject destination rectangles smaller than 64x16 pixels
//
// Version 10.0.0 October 11, 2023
// - Add restrictions on xSobel output surfaces
//
// Version 11.0.0 December 1, 2023
// - Add restrictions on source and destination rectangles when IPT and warp map
//   processing are both disabled
//
 
#ifdef __cplusplus
}
#endif
 
#endif