////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camxispstatsmodule.h
/// @brief Stats class declarations
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CAMXISPSTATSMODULE_H
#define CAMXISPSTATSMODULE_H

#include "camxpacketbuilder.h"
#include "camxmem.h"
#include "camxdefs.h"
#include "camxispiqmodule.h"

CAMX_NAMESPACE_BEGIN


// NOWHINE FILE CP016: define constructor in Header file
// NOWHINE FILE CP007: Use template for trigger 2.0

static const UINT32 TapoutHDRBeforeReconstruct      = 0;    ///< HDR BHIST/BE stats tap out before HDR recontruct
static const UINT32 TapoutHDRAfterLSC               = 1;    ///< HDR BHIST/BE stats tap out after LSC module
static const UINT32 TapoutIHistBeforeGLUT           = 0;    ///< Image Histogram stats tap out before Gamma LUT
static const UINT32 TapoutIHistAfterGLUT            = 1;    ///< Image Histogram stats tap out after Gamma LUT

static const UINT32 MultipleFactorTwo               = 2;    ///< Region offset and dimension multiple factor for
                                                            ///  demosaic tapout
static const UINT32 MultipleFactorFour              = 4;    ///< Region offset and dimension multiple factor for
                                                            ///  HDR Recon tapout

static const UINT32 FieldSelectAllLines             = 0;    ///< Collect HDR BHist and/or HDR BE stats from all the ROI lines
static const UINT32 FieldSelectLongExposureLines    = 1;    ///< Collect HDR BHist and/or HDR BE stats from long exposure ROI lines
static const UINT32 FieldSelectShortExposureLines   = 2;    ///< Collect HDR BHist and/or HDR BE stats from short exposure ROI lines

class ISPStatsModule;

static const UINT32 OffsetOfTFEStatsModuleIndex = static_cast<UINT32>(ISPStatsModuleType::TFEAWBBG); ///< TFE Stats module Index
static const UINT32 TFEIQModuleLastIndex =
            static_cast<UINT32>(ISPIQModuleType::TFEPDAF) - OffsetOfTFEIQModuleIndex + 1;   ///< TFE IQ module End Index

/// @brief IFE Stats Module HW Version
struct IFEStatsHWVersion
{
    UINT32 hwCSStats14Version;           ///< CS Stats HW Version
    UINT32 hwHDRBEStats15Version;        ///< HDRBE Stats HW Version
    UINT32 hwHDRBHISTStats13Version;     ///< HDRBHIST Stats HW Version
    UINT32 hwIHISTStats12Version;        ///< IHIST Stats HW Version
    UINT32 hwBHISTStats14Version;        ///< BHIST Stats HW Version
    UINT32 hwAWBBGStats14Version;        ///< AWBBG Stats HW Version
    UINT32 hwRSStats14Version;           ///< RS Stats HW Version
    UINT32 hwTINTLESSBGStats15Version;   ///< TINTLESSBG Stats HW Version
    UINT32 hwBFStats23Version;           ///< BF Stats HW Version
    UINT32 hwBFStats25Version;           ///< BF Stats HW Version
};

/// @brief IFELiteStatsModuleCreateData
struct IFELiteStatsModuleCreateData
{
    ISPStatsModule*     pModule;            ///< Pointer to the Stats Module
    ISPStatsModuleType  statsModuleType;    ///< Stats Module Type
    IFELitePipelineData pipelineData;       ///< IFE pipeline data value
    const CHAR*         pNodeIdentifier;    ///< String identifier for the Node that creating this stats Module object
    UINT32              titanVersion;       ///< Titan version
};

/// @brief IFEStatsModuleCreateData
struct IFEStatsModuleCreateData
{
    ISPStatsModule*    pModule;            ///< Pointer to the Stats Module
    ISPStatsModuleType statsModuleType;    ///< Stats Module Type
    IFEPipelineData    pipelineData;       ///< IFE pipeline data value
    IFEStatsHWVersion  statsModuleVersion; ///< ISP IQ module version
    UINT32             titanVersion;       ///< Titan version
    const CHAR*        pNodeIdentifier;    ///< String identifier for the Node that creating this Stats Module object
};

/// @brief IFEStatsModuleCreateData
struct BPSStatsModuleCreateData
{
    ISPStatsModule*    pModule;       ///< Pointer to the Stats Module
    BPSPipelineData    pipelineData;  ///< BPS pipeline data value
};

struct IPEStatsModuleCreateData
{
    ISPStatsModule*    pModule;            ///< Pointer to the created IQ Module
    ISPInputData       initializationData; ///< Default values to configure the modules
    IPEPath            path;               ///< IPE path information
    const CHAR*        pNodeIdentifier;    ///< String identifier for the Node that creating this Stats Module object
    UINT32             titanVersion;       ///< Titan version
    UINT               statsPortID;        ///< Stats port ID for create
};

/// @brief IFE Stats Module Information
struct IFEStatsModuleInfo
{
    ISPStatsModuleType moduleType;                                              ///< Stats Module Name
    union
    {
        IFEPipelinePath IFEPath;                                                ///< IFE Path
        SFEPipelinePath SFEPath;                                                ///< SFE Path
    } PipelinePath;
    UINT8              installed;                                               ///< Module Available or not on chipset
    UINT64             statsModuleOutputPorts;                                  ///< IFEStatsModuleOutputPorts
    CamxResult         (*StatsCreate)(IFEStatsModuleCreateData* pInputData);    ///< Static create fuction of this Stats Module
};

struct StatsModuleCmdBufferParam
{
    CmdBufferManagerParam*  pCmdBufManagerParam;    ///< Pointer to the Cmd Buffer Manager params to be filled by Stats Modules
    UINT32                  numberOfCmdBufManagers; ///< Number Of Command Buffers created to be filled by Stats modules
};

/// @brief TFE Stats Module HW Version
struct TFEStatsHWVersion
{
    UINT32 hwTintlessBEStatsVersion;     ///< TINTLESS BE Stats HW Version
    UINT32 hwBHISTStatsVersion;          ///< BHIST Stats HW Version
    UINT32 hwAECBGStatsVersion;          ///< AECBG Stats HW Version
    UINT32 hwAWBBGStatsVersion;          ///< AWBBG Stats HW Version
    UINT32 hwBAFStatsVersion;            ///< BAF Stats HW Version
    UINT32 hwRSStatsVersion;             ///< RS Stats HW Version
};

/// @brief TFEStatsModuleCreateData
struct TFEStatsModuleCreateData
{
    ISPStatsModule*    pModule;            ///< Pointer to the Stats Module
    TFEPipelineData    pipelineData;       ///< TFE pipeline data value
    TFEStatsHWVersion  statsModuleVersion; ///< ISP IQ module version
    const CHAR*        pNodeIdentifier;    ///< String identifier for the Node that creating this IQ Module object
    UINT32             titanVersion;       ///< Titan version
};

/// @brief OPEStatsModuleCreateData
struct OPEStatsModuleCreateData
{
    ISPStatsModule*    pModule;          ///< Pointer to the Stats Module
    // OPEPipelineData    pipelineData;  /// @todo (CAMX-4909) Need to check whether this is required
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Base Class for all the Stats Module
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class ISPStatsModule
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Execute
    ///
    /// @brief  Execute process capture request to configure individual stats module
    ///
    /// @param  pInputData Pointer to the Inputdata
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult Execute(
       ISPInputData* pInputData) = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PrepareStripingParameters
    ///
    /// @brief  Prepare striping parameters for striping lib
    ///
    /// @param  pInputData Pointer to the Inputdata
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult PrepareStripingParameters(
        ISPInputData* pInputData)
    {
        CAMX_UNREFERENCED_PARAM(pInputData);
        return CamxResultSuccess;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetDualIFEData
    ///
    /// @brief  Provides information on how dual IFE mode affects the IQ module
    ///
    /// @param  pDualIFEData Pointer to dual IFE data the module will fill in
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual VOID GetDualIFEData(
        IQModuleDualIFEData* pDualIFEData)
    {
        CAMX_ASSERT(NULL != pDualIFEData);

        pDualIFEData->dualIFESensitive      = TRUE;
        pDualIFEData->dualIFEDMI32Sensitive = TRUE;
        pDualIFEData->dualIFEDMI64Sensitive = TRUE;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetDualTFEData
    ///
    /// @brief  Provides information on how dual TFE mode affects the IQ module
    ///
    /// @param  pDualTFEData Pointer to dual TFE data the module will fill in
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual VOID GetDualTFEData(
        IQModuleDualTFEData* pDualTFEData)
    {
        CAMX_ASSERT(NULL != pDualTFEData);

        pDualTFEData->dualTFESensitive      = TRUE;
        pDualTFEData->dualTFEDMI32Sensitive = TRUE;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetOPEStripeSensitiveData
    ///
    /// @brief  Provides information if OPE Stats block is stripe sensitive
    ///
    /// @param  pStripeSensitive Pointer to stripe sensitive data the module will fill in
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual VOID GetOPEStripeSensitiveData(
        BOOL* pStripeSensitive)
    {
        *pStripeSensitive = TRUE;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetDMITable
    ///
    /// @brief  Retrieve the buffer of the DMI table
    ///
    /// @return Pointer of the register buffer
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual VOID GetDMITable(UINT32** ppDMITable)
    {
        CAMX_UNREFERENCED_PARAM(ppDMITable);
        return;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetIQCmdLen
    ///
    /// @brief  Get the Command Size
    ///
    /// @return Length of the command list
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE UINT GetIQCmdLength()
    {
        return m_cmdLength;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetStatsModulePerStripeCmdLength
    ///
    /// @brief  Get the Command Size of each Stats module per stripe
    ///
    /// @return Length of the command list
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE UINT GetStatsModulePerStripeCmdLength()
    {
        return m_stripeCmdLength;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetIQCmdLen
    ///
    /// @brief  Get the DMI Size in bytes
    ///
    /// @return Length of the command list
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE UINT GetDMILen()
    {
        return m_DMITableLength;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Get32bitDMILength
    ///
    /// @brief  Get the 32 bit DMI Size
    ///
    /// @return Length of the DMI list
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE UINT32 Get32bitDMILength()
    {
        return m_32bitDMILength;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Set32bitDMIBufferOffset
    ///
    /// @brief  Set Offset in 32bit DMI buffer
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE VOID Set32bitDMIBufferOffset(UINT offset)
    {
        m_32bitDMIBufferOffsetDword = offset;

        return;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Get64bitDMILength
    ///
    /// @brief  Get the 64 bit DMI Size
    ///
    /// @return Length of the DMI list
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE UINT32 Get64bitDMILength()
    {
        return m_64bitDMILength;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Set64bitDMIBufferOffset
    ///
    /// @brief  Set Offset in 64bit DMI buffer
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE VOID Set64bitDMIBufferOffset(UINT offset)
    {
        m_64bitDMIBufferOffsetDword = offset;

        return;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// IsSFEHDRMode
    ///
    /// @brief  Returns TRUE if the SFE Usecase Mode is HDR
    ///
    /// @param  SFEMode  SFE Operating Mode
    ///
    /// @return BOOL
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE BOOL IsSFEHDRMode(
        SFEUsecaseMode SFEMode)
    {
        BOOL bIsHDRMode = FALSE;

        if ((SFEUsecaseSHDR   == SFEMode) ||
            (SFEUsecaseXCFAHDR == SFEMode))
        {
            bIsHDRMode = TRUE;
        }

        return bIsHDRMode;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetStatsType
    ///
    /// @brief  Get the Type of this Module
    ///
    /// @return module type
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ISPStatsModuleType GetStatsType()
    {
        return m_type;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetStatsName
    ///
    /// @brief  Get the Name of this Module
    ///
    /// @return module Name
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    const CHAR* GetStatsName()
    {
        const CHAR* pName;

        switch (m_type)
        {
            case ISPStatsModuleType::IFEAWBBG:
                pName = "IFEAWBBG";
                break;

            case ISPStatsModuleType::IFEBF:
                pName = "IFEBF";
                break;

            case ISPStatsModuleType::IFEBFW:
                pName = "IFEBFW";
                break;

            case ISPStatsModuleType::IFECS:
                pName = "IFECS";
                break;

            case ISPStatsModuleType::IFEBHist:
                pName = "IFEBHist";
                break;

            case ISPStatsModuleType::IFEAECBHist:
                pName = "IFEAECBHist";
                break;

            case ISPStatsModuleType::IFEAECBE:
                pName = "IFEAECBE";
                break;

            case ISPStatsModuleType::IFEGTMBHist:
                pName = "IFEGTMBHist";
                break;

            case ISPStatsModuleType::IFEHDRBE:
                pName = "IFEHDRBE";
                break;

            case ISPStatsModuleType::IFEHDRBHist:
                pName = "IFEHDRBHist";
                break;

            case ISPStatsModuleType::IFEIHist:
                pName = "IFEIHist";
                break;

            case ISPStatsModuleType::IFERS:
                pName = "IFERS";
                break;

            case ISPStatsModuleType::IFEBayerRS:
                pName = "IFEBayerRS";
                break;

            case ISPStatsModuleType::IFETintlessBG:
                pName = "IFETintlessBG";
                break;

            case ISPStatsModuleType::IFEALSCBG:
                pName = "IFEALSCBG";
                break;

            case ISPStatsModuleType::IFECAF:
                pName = "IFECAF";
                break;

            case ISPStatsModuleType::IPEHDR10P:
                pName = "IPEHDR10P";
                break;

            case ISPStatsModuleType::IPESTATSGS:
                pName = "IPESTATSGS";
                break;

            case ISPStatsModuleType::SFEAWBBG:
                pName = "SFEAWBBG";
                break;

            case ISPStatsModuleType::SFEBHist:
                pName = "SFEBHist";
                break;

            case ISPStatsModuleType::SFEBayerRS:
                pName = "SFEBayerRS";
                break;

            case ISPStatsModuleType::TFEAWBBG:
                pName = "TFEAWBBG";
                break;

            case ISPStatsModuleType::TFEBF:
                pName = "TFEBF";
                break;

            case ISPStatsModuleType::TFEBHist:
                pName = "TFEBHist";
                break;

            case ISPStatsModuleType::TFEAECBG:
                pName = "TFEAECBG";
                break;

            case ISPStatsModuleType::TFETintlessBE:
                pName = "TFETintlessBE";
                break;

            case ISPStatsModuleType::OPEIHist:
                pName = "OPEIHist";
                break;

            case ISPStatsModuleType::OPERS:
                pName = "OPERS";
                break;

            default:
                pName = "Not recognized";
        }

        return pName;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destroy
    ///
    /// @brief  Destroy the object
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE VOID Destroy()
    {
        CAMX_DELETE this;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// SetupTrigger
    ///
    /// @brief  Setup Trigger 2.0 Index Table
    ///
    /// @param  pChromatix      Pointer to the trigger types from chromatix data
    /// @param  rTriggerIndex   Trigger index vector
    /// @param  rMaxNonLeafNode Reference value to the memory that common library required
    ///
    /// @return CamxResult      CamxResultSuccess if setup trigger successfully; otherwise failed
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    template <class T>
    CamxResult SetupTrigger(
        T*                  pChromatix,
        std::vector<INT>&   rTriggerIndex,
        UINT32&             rMaxNonLeafNode)
    {
        CamxResult  result = CamxResultSuccess;

        ispglobalelements::trigger_types* pControlVariables =
            static_cast<ispglobalelements::trigger_types*>(pChromatix->control_variables.control_var_type);

        rTriggerIndex.clear();

        for (UINT32 i = 0; i < pChromatix->control_variables.control_var_typeCount; i++)
        {
            rTriggerIndex.push_back(static_cast<INT32>(*pControlVariables));
            pControlVariables++;
        }

        result = IQSettingUtils::UpdateTreeParams(rMaxNonLeafNode, rTriggerIndex);

        return result;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// IsDumpRegConfig
    ///
    /// @brief  Cheking if Stats module dump register configure is enable
    ///
    /// @param  dumpRegStatsConfigMask     dump mask
    /// @param  offsetOfStatsModuleIndex   index begin of Stats modules
    ///
    /// @return BOOL    TRUE: Dump is enable, FALSE: Otherwise
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE BOOL IsDumpRegConfig(
        UINT64 dumpRegStatsConfigMask,
        UINT32 offsetOfStatsModuleIndex) const
    {
        return (0 != (dumpRegStatsConfigMask & (1ULL << (static_cast<UINT32>(m_type) - offsetOfStatsModuleIndex))));
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FillCmdBufferManagerParams
    ///
    /// @brief  Fills the command buffer manager params needed by Stats Module
    ///
    /// @param  pInputData Pointer to the Stats Module Input data structure
    /// @param  pParam     Pointer to the structure containing the command buffer manager param to be filled by Stats Module
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult FillCmdBufferManagerParams(
       const ISPInputData*        pInputData,
       StatsModuleCmdBufferParam* pParam)
    {
        CAMX_UNREFERENCED_PARAM(pInputData);
        CAMX_UNREFERENCED_PARAM(pParam);
        return CamxResultSuccess;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FillStatsModuleDMIDumps
    ///
    /// @brief  Fill DMI reg dump info
    ///
    /// @param rDMIRegDumpVector    Reference to a vector to fill in the DMI dumps
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID FillStatsModuleDMIDumps(
        std::vector<ISPRegDumpInfo>& rDMIRegDumpVector)
    {
        if (NULL != m_pHWSetting)
        {
            m_pHWSetting->FillHWSettingDMIDumps(rDMIRegDumpVector);
        }
    }

protected:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ~ISPStatsModule
    ///
    /// @brief  Destructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~ISPStatsModule() = default;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ISPStatsModule
    ///
    /// @brief  Constructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ISPStatsModule()
    {
        m_pbIFace.RequiredWriteRegRangeSizeInDwords = PacketBuilder::RequiredWriteRegRangeSizeInDwords;
        m_pbIFace.RequiredWriteDMISizeInDwords      = PacketBuilder::RequiredWriteDMISizeInDwords;
        m_pbIFace.WriteDMI                          = PacketBuilder::WriteDMI;
        m_pbIFace.WriteRegRange                     = PacketBuilder::WriteRegRange;
        m_pbIFace.cdm_get_cmd_header_size           = cdm_get_cmd_header_size;
    }

    ISPHWSetting*       m_pHWSetting;                   ///< Pointer to the HW Setting Class
    UINT                m_cmdLength;                    ///< Length of the Command List
    ISPStatsModuleType  m_type;                         ///< Type of this module
    BOOL                m_moduleEnable;                 ///< Flag to indicated if this module is enabled
    UINT                m_DMITableLength;               ///< Length of DMI table
    UINT                m_32bitDMILength;               ///< The length of the 32 bit DMI Table, in bytes
    UINT                m_32bitDMIBufferOffsetDword;    ///< Offset to the 32bit DMI buffer, in Dword
    UINT                m_64bitDMILength;               ///< The length of the 64 bit DMI Table, in Dword
    UINT                m_64bitDMIBufferOffsetDword;    ///< Offset to the 64bit DMI buffer, in Dword
    UINT                m_stripeCmdLength;              ///< Length of the Command List per stripe
    const CHAR*         m_pNodeIdentifier;              ///< String identifier of node associated

    IFEDefaultModuleConfig* m_pDefaultConfig;           ///< Pointer to default Module Config
    std::vector<INT>        m_triggerIndex;             ///< Trigger Index Vector
    ISPHWSettingPBIface     m_pbIFace;                  ///< Packet Builder IFace

private:
    ISPStatsModule(const ISPStatsModule&) = delete;              ///< Disallow the copy constructor
    ISPStatsModule& operator=(const ISPStatsModule&) = delete;   ///< Disallow assignment operator
};

CAMX_NAMESPACE_END

#endif // CAMXISPSTATSMODULE_H
