/*
* Copyright (c) 2017, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
//!
//! \file     codechal_kernel_base.h
//! \brief    Defines base class for all kernels
//! \details  Kernel base class abstracts all common functions and definitions
//!           for all kernels, each kernel class should inherit from kernel base
//!

#ifndef __CODECHAL_KERNEL_BASE_H__
#define __CODECHAL_KERNEL_BASE_H__

#include "codechal.h"
#include "codechal_hw.h"
#include "codechal_encoder_base.h"
#include <map>

//!
//! \class    CodechalKernelBase
//! \brief    Codechal kernel base
//!
class CodechalKernelBase
{
public:
    using KernelBinaryCallback = MOS_STATUS (*)(void *,
                                                EncOperation,
                                                uint32_t,
                                                void *,
                                                uint32_t *);

    //!
    //! \brief Constructor
    //!
    CodechalKernelBase(CodechalEncoderState *encoder);

    //!
    //! \brief Destructor
    //!
    virtual ~CodechalKernelBase();

    //!
    //! \brief  Intialize kernel state object
    //!
    //! \param  [in] callback
    //!         callback function which parse kernel header from kernel structure
    //! \param  [in] binaryBase
    //!         pointer to the base address of kernel binary array
    //! \param  [in] kernelUID
    //!         kernel UID 
    //!
    virtual MOS_STATUS Initialize(
        KernelBinaryCallback callback,
        uint8_t             *binaryBase,
        uint32_t             kernelUID);

    //!
    //! \brief  Allocate kernel required resources
    //!
    //! \return MOS_STATUS
    //!         MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS AllocateResources() = 0;

    //!
    //! \brief  Get binding table count
    //!
    //! \return uint32_t
    //!         Binding table count
    //!
    virtual uint32_t GetBTCount() = 0;

    //!
    //! \brief  Get input/output surfaces allocated by kernel
    //!
    //! \param  [in] surfaceId
    //!         uint32_t, surface index id
    //! \return PMOS_SURFACE
    //!         Pointer to MOS_SURFACE
    //!
    PMOS_SURFACE GetSurface(uint32_t surfaceId);

    //!
    //! \brief  Get input/output surfaces allocated for HME kernel when using MDF RT
    //!
    //! \param  [in] surfaceId
    //!         uint32_t, surface index id
    //!         Pointer to CM 2D Surface
    //!
    virtual CmSurface2D* GetCmSurface(uint32_t surfaceId) { return nullptr; };

#if USE_CODECHAL_DEBUG_TOOL
    virtual MOS_STATUS DumpKernelOutput() { return MOS_STATUS_SUCCESS; }
#endif

protected:
    //!
    //! \brief  get kernel bianry address and size
    //!
    //! \param  [in] kernelBase
    //!         base address of kernel binary
    //! \param  [in] kernelUID
    //!         kernel UID
    //! \param  [out] kernelBinary
    //!         kernel binary address for kernel UID
    //! \param  [out] size
    //!         kernel binary size
    //!
    //! \return MOS_STATUS
    //!         MOS_STATUS_SUCCESS if success
    //!
    static MOS_STATUS GetKernelBinaryAndSize(
        uint8_t * kernelBase,
        uint32_t  kernelUID,
        uint8_t **kernelBinary,
        uint32_t *size);
    //!
    //! \brief  create kernel states
    //!
    //! \param  [out] kernelState
    //!         pointer to MHW_KERNEL_STATE*
    //! \param  [in] kernelIndex
    //!         the sub kernel index in kernel state map
    //! \param  [in] operation
    //!         EncOperation,index used to get kernel header
    //! \param  [in] kernelOffset
    //!         kernel offset index
    //!
    //! \return MOS_STATUS
    //!         MOS_STATUS_SUCCESS if success
    //!
    MOS_STATUS CreateKernelState(
        MHW_KERNEL_STATE **           kernelState,
        uint32_t                      kernelIndex,
        EncOperation                  operation,
        uint32_t                      kernelOffset);

    //!
    //! \brief  Release kernel required resources
    //!
    //! \return MOS_STATUS
    //!         MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS ReleaseResources() = 0;

    //!
    //! \brief  Define common pipeline to run the kernel
    //!
    //! \return MOS_STATUS
    //!         MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS Run();

    //!
    //! \brief  Get curbe buffer size
    //!
    //! \return uint32_t
    //!         Curbe buffer size
    //!
    virtual uint32_t GetCurbeSize() = 0;

    //!
    //! \brief  Get DSH inline data length
    //!
    //! \return uint32_t
    //!         Inline data length
    //!
    virtual uint32_t GetInlineDataLength() { return 0; }

    //!
    //! \brief  Add perf tag for each kernel
    //!
    //! \return MOS_STATUS
    //!         MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS AddPerfTag() = 0;

    //!
    //! \brief  Get the pointer to current active kernel state
    //!
    //! \return MHW_KERNEL_STATE*
    //!         Pointer to MHW_KERNEL_STATE
    //!
    virtual MHW_KERNEL_STATE * GetActiveKernelState() = 0;

    //!
    //! \brief  Get media state type of each kernel
    //!
    //! \return CODECHAL_MEDIA_STATE_TYPE
    //!         media state type
    //!
    virtual CODECHAL_MEDIA_STATE_TYPE GetMediaStateType() = 0;

    //!
    //! \brief  Set curbe data for current kernel state
    //!
    //! \param  [in] kernelState
    //!         pointer to current active kernel state
    //!
    //! \return MOS_STATUS
    //!         MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS SetCurbe(MHW_KERNEL_STATE *kernelState) { return MOS_STATUS_UNIMPLEMENTED; };

    //!
    //! \brief  Send input and output surfaces for current kernel
    //!
    //! \param  [in] cmd
    //!         pointer to MOS_COMMAND_BUFFER
    //! \param  [in] kernelState
    //!         pointer to the MHW_KERNEL_STATE
    //!
    //! \return MOS_STATUS
    //!         MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS SendSurfaces(PMOS_COMMAND_BUFFER cmd, MHW_KERNEL_STATE *kernelState) = 0;

    //!
    //! \brief  Initialize media walker parameters
    //!
    //! \param  [in] walkerParam
    //!         Reference to CODECHAL_WALKEr_CODEC_PARAMS
    //!
    //! \return MOS_STATUS
    //!         MOS_STATUS_SUCCESS if success
    //!
    virtual MOS_STATUS InitWalkerCodecParams(CODECHAL_WALKER_CODEC_PARAMS &walkerParam) = 0;

    //!
    //! \brief  Utility function to clean up resource
    //!
    //! \param  [in] resource
    //!         Pointer to MOS_RESOURCE
    //! \param  [in] allocParam
    //!         Pointer to MOS_ALLOC_GFXRES_PARAMS
    //!
    //! \return MOS_STATUS
    //!         MOS_STATUS_SUCCESS if success
    //!
    MOS_STATUS CleanUpResource(PMOS_RESOURCE resource, PMOS_ALLOC_GFXRES_PARAMS allocParam);

    //!
    //! \brief  Allocate 2D surface and store surface pointer in the pool
    //!
    //! \param  [in] param
    //!         Pointer to MOS_ALLOC_GFXRES_PARAMS
    //! \param  [in] surface
    //!         Pointer to MOS_SURFACE
    //! \param  [in] surfaceId
    //!         uint32_t, index to surface
    //!
    //! \return MOS_STATUS
    //!         MOS_STATUS_SUCCESS if success
    //!
    MOS_STATUS AllocateSurface(PMOS_ALLOC_GFXRES_PARAMS param, PMOS_SURFACE surface, uint32_t surfaceId);

protected:
    CodechalEncoderState      *m_encoder            = nullptr;  //!< Pointer to ENCODER base class
    MOS_INTERFACE             *m_osInterface        = nullptr;  //!< OS interface
    CodechalHwInterface       *m_hwInterface        = nullptr;  //!< HW interface
    CodechalDebugInterface    *m_debugInterface     = nullptr;  //!< Debug interface
    MhwMiInterface            *m_miInterface        = nullptr;  //!< Common MI interface
    MhwRenderInterface        *m_renderInterface    = nullptr;  //!< Render engine interface
    XMHW_STATE_HEAP_INTERFACE *m_stateHeapInterface = nullptr;  //!< State heap class interface

    KernelBinaryCallback       m_callback           = nullptr;  //!< kernel binary structure callback
    uint8_t                   *m_kernelBinary       = nullptr;  //!< kernel bianry base address

    std::map<uint32_t, MHW_KERNEL_STATE *> m_kernelStatePool = {};  //!< pool to store kernel state with index
    std::map<uint32_t, PMOS_SURFACE>       m_surfacePool     = {};  //!< pool to store surface with index

    bool& m_firstTaskInPhase;
    bool& m_lastTaskInPhase;
    bool& m_singleTaskPhaseSupported;
    bool& m_renderContextUsesNullHw;
    bool& m_groupIdSelectSupported;
    bool& m_fieldScalingOutputInterleaved;
    bool& m_vdencEnabled;
    uint8_t&  m_groupId;
    uint32_t& m_maxBtCount;
    uint32_t& m_vmeStatesSize;
    uint32_t& m_storeData;
    uint32_t& m_verticalLineStride;
    uint32_t& m_downscaledWidthInMb4x;
    uint32_t& m_downscaledHeightInMb4x;
    uint32_t& m_downscaledWidthInMb16x;
    uint32_t& m_downscaledHeightInMb16x;
    uint32_t& m_downscaledWidthInMb32x;
    uint32_t& m_downscaledHeightInMb32x;
    uint32_t& m_mode;
    uint16_t& m_pictureCodingType;
    uint32_t& m_frameWidth;
    uint32_t& m_frameHeight;
    uint32_t& m_frameFieldHeight;
    uint32_t& m_standard;
    MHW_WALKER_MODE& m_walkerMode;

};

#endif /* __CODECHAL_KERNEL_BASE_H__ */