/*
* Copyright (c) 2021-2025, 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     media_render_cmd_packet.h
//! \brief    Defines the interface for media render workload cmd packet
//! \details  The media cmd packet is dedicated for command buffer sequenece submit
//!
#ifndef __MEDIA_RENDER_CMD_PACKET_H__
#define __MEDIA_RENDER_CMD_PACKET_H__

#include <stdint.h>
#include <set>
#include "hal_kerneldll_next.h"
#include "media_cmd_packet.h"
#include "renderhal.h"

class MediaFeatureManager;
class MediaTask;
class MhwCpInterface;

#define RENDER_PACKET_CHK_NULL_RETURN(_ptr) \
    MOS_CHK_NULL_RETURN(MOS_COMPONENT_HW, 0, _ptr)

#define RENDER_PACKET_CHK_STATUS_RETURN(_stmt) \
    MOS_CHK_STATUS_RETURN(MOS_COMPONENT_HW, 0, _stmt)

#define RENDER_PACKET_CHK_STATUS_MESSAGE_RETURN(_stmt, _message, ...) \
    MOS_CHK_STATUS_MESSAGE_RETURN(MOS_COMPONENT_HW, 0, _stmt, _message, ##__VA_ARGS__)

#define RENDER_PACKET_ASSERTMESSAGE(_message, ...) \
    MOS_ASSERTMESSAGE(MOS_COMPONENT_HW, 0, _message, ##__VA_ARGS__)

#define RENDER_PACKET_WARNINGMESSAGE(_message, ...) \
    MOS_WARNINGMESSAGE(MOS_COMPONENT_HW, 0, _message, ##__VA_ARGS__)

#define RENDER_PACKET_NORMALMESSAGE(_message, ...) \
    MOS_NORMALMESSAGE(MOS_COMPONENT_HW, 0, _message, ##__VA_ARGS__)

#define RENDER_PACKET_VERBOSEMESSAGE(_message, ...) \
    MOS_VERBOSEMESSAGE(MOS_COMPONENT_HW, 0, _message, ##__VA_ARGS__)

#define RENDER_PACKET_ASSERT(_expr) \
    MOS_ASSERT(MOS_COMPONENT_HW, 0, _expr)

#define RENDER_PACKET_CHK_NULL_WITH_DESTROY_RETURN_VALUE(_ptr, destroyFunction) \
    MOS_CHK_COND_WITH_DESTROY_RETURN_VALUE(MOS_COMPONENT_HW, 0, (nullptr == _ptr), destroyFunction, MOS_STATUS_NULL_POINTER, "error nullptr!")

#define RENDER_PACKET_CHK_STATUS_WITH_DESTROY_RETURN_VALUE(_stmt, destroyFunction)                                                  \
{                                                                                                                                   \
    MOS_STATUS sts = (MOS_STATUS)(_stmt);                                                                                           \
    MOS_CHK_COND_WITH_DESTROY_RETURN_VALUE(MOS_COMPONENT_HW, 0, (MOS_STATUS_SUCCESS != sts), destroyFunction, sts, "error status!") \
}

//!
//! \brief Initialize MHW Kernel Param struct for loading Kernel
//!
#define INIT_MHW_KERNEL_PARAM(MhwKernelParam, _pKernelEntry)                        \
    do                                                                              \
    {                                                                               \
        MOS_ZeroMemory(&(MhwKernelParam), sizeof(MhwKernelParam));                  \
        (MhwKernelParam).pBinary  = (_pKernelEntry)->pBinary;                       \
        (MhwKernelParam).iSize    = (_pKernelEntry)->iSize;                         \
        (MhwKernelParam).iKUID    = (_pKernelEntry)->iKUID;                         \
        (MhwKernelParam).iKCID    = (_pKernelEntry)->iKCID;                         \
        (MhwKernelParam).iPaddingSize = (_pKernelEntry)->iPaddingSize;              \
    } while(0)

typedef struct _PIPECONTRL_PARAMS
{
    bool bUpdateNeeded;
    bool bEnableDataPortFlush;
    bool bUnTypedDataPortCacheFlush;
    bool bFlushRenderTargetCache;
    bool bInvalidateTextureCache;
} PIPECONTRL_PARAMS, *PPIPECONTRL_PARAMS;

typedef struct _KERNEL_WALKER_PARAMS
{
    int32_t                             iBindingTable;
    int32_t                             iMediaID;
    int32_t                             iCurbeOffset;
    int32_t                             iCurbeLength;

    int32_t                             iBlocksX;
    int32_t                             iBlocksY;
    int32_t                             iBlocksZ;
    RECT                                alignedRect;
    PIPECONTRL_PARAMS                   pipeControlParams;
    bool                                isVerticalPattern;
    bool                                bSyncFlag;
    bool                                bFlushL1;
    bool                                isGroupStartInvolvedInGroupSize;    // true if group start need be involved in the group size.
    bool                                calculateBlockXYByAlignedRect;      // true if iBlocksX/iBlocksY is calculated by alignedRect in RenderCmdPacket instead of kernel object.
    bool                                forcePreferredSLMZero;              // true if preferredSLM need force to 0.

    bool                                isEmitInlineParameter;
    uint32_t                            inlineDataLength;
    uint8_t*                            inlineData;

    uint32_t                            threadWidth;
    uint32_t                            threadHeight;
    uint32_t                            threadDepth;

    bool                                isGenerateLocalID;
    MHW_EMIT_LOCAL_MODE                 emitLocal;

    bool                                hasBarrier;
    uint32_t                            slmSize;

    uint32_t                            simdSize;

    uint32_t                            registersPerThread;

    PMHW_INDIRECT_STATE_RESOURCE_PARAMS curbeResourceList;
    uint32_t                            curbeResourceListSize;

    PMHW_INDIRECT_STATE_RESOURCE_PARAMS inlineResourceList;
    uint32_t                            inlineResourceListSize;
}KERNEL_WALKER_PARAMS, * PKERNEL_WALKER_PARAMS;

typedef struct _KERNEL_PACKET_RENDER_DATA
{
    // Kernel Information
    RENDERHAL_KERNEL_PARAM              KernelParam;
    Kdll_CacheEntry                     KernelEntry;
    int32_t                             iCurbeLength;
    int32_t                             iInlineLength;
    int32_t                             iCurbeOffset;

    MHW_SAMPLER_STATE_PARAM             SamplerStateParams;           //!< Sampler State
    PMHW_AVS_PARAMS                     pAVSParameters;               //!< AVS parameters
    MHW_SAMPLER_AVS_TABLE_PARAM         mhwSamplerAvsTableParam;      //!< params for AVS scaling 8x8 table

    // Media render state
    PRENDERHAL_MEDIA_STATE              mediaState;

    int32_t                             bindingTable;
    uint32_t                            bindingTableEntry;
    int32_t                             mediaID;

    KERNEL_WALKER_PARAMS                walkerParam;
    PMHW_VFE_SCOREBOARD                 scoreboardParams;

    int32_t                             kernelAllocationID;

    // Debug parameters
    // Kernel Used for current rendering
    char* pKernelName;
} KERNEL_PACKET_RENDER_DATA, * PKERNEL_PACKET_RENDER_DATA;

typedef enum _WALKER_TYPE
{
    WALKER_TYPE_DISABLED = 0,
    WALKER_TYPE_MEDIA,
    WALKER_TYPE_COMPUTE
}WALKER_TYPE;

//!
//! \brief VPHAL SS/EU setting
//!
struct SseuSetting
{
    uint8_t   numSlices;
    uint8_t   numSubSlices;
    uint8_t   numEUs;
    uint8_t   reserved;       // Place holder for frequency setting
};

typedef struct _RENDERHAL_SURFACE_NEXT : public _RENDERHAL_SURFACE
{
    uint32_t Index;
}RENDERHAL_SURFACE_NEXT, * PRENDERHAL_SURFACE_NEXT;

using KERNEL_RENDER_DATA = std::map<uint32_t, KERNEL_PACKET_RENDER_DATA>;

class RenderCmdPacket : virtual public CmdPacket, public mhw::mi::Itf::ParSetting
{
public:
    RenderCmdPacket(MediaTask* task, PMOS_INTERFACE pOsInterface, RENDERHAL_INTERFACE* m_renderHal);

    virtual ~RenderCmdPacket();
    virtual MOS_STATUS Init();
    virtual MOS_STATUS Destroy();
    virtual MOS_STATUS Submit(MOS_COMMAND_BUFFER* commandBuffer, uint8_t packetPhase = otherPacket);

    // Currently only support HDC read/write, for sampler enabling will be in next step
    // Step1 : render engine set up
    MOS_STATUS RenderEngineSetup();

    // Step2: Kernel State Set up
    virtual MOS_STATUS KernelStateSetup(
        void *kernel)
    {
        return MOS_STATUS_SUCCESS;
    }

    virtual uint32_t SetSurfaceForHwAccess(
        PMOS_SURFACE                           surface,
        PRENDERHAL_SURFACE_NEXT                pRenderSurface,
        PRENDERHAL_SURFACE_STATE_PARAMS        pSurfaceParams,
        bool                                   bWrite,
        std::vector<RENDERHAL_STATE_LOCATION> &stateLocations);

    // Step3: RSS Setup, return index insert in binding table
    virtual uint32_t SetSurfaceForHwAccess(
        PMOS_SURFACE                    surface,
        PRENDERHAL_SURFACE_NEXT         pRenderSurface,
        PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
        bool                            bWrite);

    // Step3: RSS Setup with fixed binding index, return index insert in binding table
    virtual MOS_STATUS SetSurfaceForHwAccess(
        PMOS_SURFACE                    surface,
        PRENDERHAL_SURFACE_NEXT         pRenderSurface,
        PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
        uint32_t                        &bindingIndex,
        bool                            bWrite,
        PRENDERHAL_SURFACE_STATE_ENTRY *surfaceEntries      = nullptr,
        uint32_t *                      numOfSurfaceEntries = nullptr);

    virtual MOS_STATUS SetSurfaceForHwAccess(
        PMOS_SURFACE                           surface,
        PRENDERHAL_SURFACE_NEXT                pRenderSurface,
        PRENDERHAL_SURFACE_STATE_PARAMS        pSurfaceParams,
        std::set<uint32_t>                    &bindingIndexes,
        bool                                   bWrite,
        std::vector<RENDERHAL_STATE_LOCATION> &stateLocations,
        uint32_t                               capcityOfSurfaceEntries = 0,
        PRENDERHAL_SURFACE_STATE_ENTRY        *surfaceEntries          = nullptr,
        uint32_t                              *numOfSurfaceEntries     = nullptr);

    virtual uint32_t SetBufferForHwAccess(
        PMOS_SURFACE                           buffer,
        PRENDERHAL_SURFACE_NEXT                pRenderSurface,
        PRENDERHAL_SURFACE_STATE_PARAMS        pSurfaceParams,
        bool                                   bWrite,
        std::vector<RENDERHAL_STATE_LOCATION> &stateLocations);

    virtual uint32_t SetBufferForHwAccess(
        PMOS_SURFACE                    buffer,
        PRENDERHAL_SURFACE_NEXT         pRenderSurface,
        PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
        uint32_t                        bindingIndex,
        bool                            bWrite);
    
    virtual MOS_STATUS SetBufferForHwAccess(
        PMOS_SURFACE                           buffer,
        PRENDERHAL_SURFACE_NEXT                pRenderSurface,
        PRENDERHAL_SURFACE_STATE_PARAMS        pSurfaceParams,
        std::set<uint32_t>                    &bindingIndexes,
        bool                                   bWrite,
        std::vector<RENDERHAL_STATE_LOCATION> &stateLocations);

    virtual uint32_t SetBufferForHwAccess(
        MOS_BUFFER                      buffer,
        PRENDERHAL_SURFACE_NEXT         pRenderSurface,
        PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
        bool                            bWrite);

    // Step4: Packet to prepare the curbe data Setup, then call packet to set it up
    // PData point to the Curbe prepared by packet
    MOS_STATUS SetupCurbe(
        void *   pData,
        uint32_t curbeLength,
        uint32_t maximumNumberofThreads = 0);

    // Step6: different kernel have different media walker settings
    virtual MOS_STATUS SetupMediaWalker()
    {
        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS PrepareMediaWalkerParams(KERNEL_WALKER_PARAMS params, MHW_WALKER_PARAMS &mediaWalker);

    MOS_STATUS PrepareComputeWalkerParams(KERNEL_WALKER_PARAMS params, MHW_GPGPU_WALKER_PARAMS &gpgpuWalker);

    bool m_isMultiBindingTables = false;

    bool m_isLargeSurfaceStateNeeded = false;

    bool m_isMultiKernelOneMediaState = false;

#if (_DEBUG || _RELEASE_INTERNAL)
    virtual MOS_STATUS StallBatchBuffer(
        PMOS_COMMAND_BUFFER cmdBuffer)
    {
        return MOS_STATUS_SUCCESS;
    }
#endif

protected:
    // Step5: Load Kernel
    virtual MOS_STATUS LoadKernel();

    // for VPP usage, there are more data need to updated, create as virtual for future inplemention in VPP
    virtual MOS_STATUS InitRenderHalSurface(
        MOS_SURFACE        surface,
        PRENDERHAL_SURFACE pRenderSurface);

    virtual MOS_STATUS InitRenderHalBuffer(
        MOS_BUFFER         surface,
        PRENDERHAL_SURFACE pRenderSurface);

    virtual void OcaDumpDbgInfo(MOS_COMMAND_BUFFER &cmdBuffer, MOS_CONTEXT &mosContext)
    {
    }

    virtual MOS_STATUS SetMediaFrameTracking(RENDERHAL_GENERIC_PROLOG_PARAMS &genericPrologParams)
    {
        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS InitKernelEntry();

    MOS_STATUS SetPowerMode(
        uint32_t KernelID);

    bool IsMiBBEndNeeded(
        PMOS_INTERFACE pOsInterface)
    {
        // need to be remodify
        bool needed = true;

        return needed;
    }

    void ResetBindingTableEntry()
    {
        m_renderData.bindingTableEntry = 0;
    }

    virtual void UpdateKernelConfigParam(RENDERHAL_KERNEL_PARAM &kernelParam);

    MOS_STATUS SendMultiKernelMediaStates(PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer);

protected:
    PRENDERHAL_INTERFACE        m_renderHal = nullptr;
    MhwCpInterface*             m_cpInterface = nullptr;
    MediaFeatureManager*        m_featureManager = nullptr;

    // Perf
    VPHAL_PERFTAG               PerfTag = VPHAL_NONE; // need to check the perf setting in codec

    // Kernel Render Data
    uint32_t                     m_kernelCount = 0;

    // Kernel Render Data
    KERNEL_PACKET_RENDER_DATA   m_renderData = {};

    // object walker: media walker/compute walker
    WALKER_TYPE                 m_walkerType = WALKER_TYPE_DISABLED;

    MHW_WALKER_PARAMS       m_mediaWalkerParams = {};

    MHW_GPGPU_WALKER_PARAMS m_gpgpuWalkerParams = {};

    PMHW_BATCH_BUFFER       pBatchBuffer = nullptr;

    MHW_PIPE_CONTROL_PARAMS m_pipeCtlParams = {};

    MHW_MEDIA_STATE_FLUSH_PARAM m_flushParam = {};
    uint32_t                m_flushMode = 0;
    PMOS_RESOURCE           m_presDest = nullptr;
    uint32_t                m_postSyncOp = 0;
    uint32_t                m_resourceOffset = 0;
    uint32_t                m_dataDW1 = 0;
    uint32_t                m_dataDW2 = 0;
    uint32_t                m_genericMediaStateClear : 1;
    uint32_t                m_IndirectStatePointersDisable : 1;
    uint32_t                m_disableCSStall : 1;
    uint32_t                m_bInvalidateTextureCache : 1;
    uint32_t                m_bFlushRenderTargetCache : 1;
    uint32_t                m_bInvalidateStateCache : 1;
    uint32_t                m_bInvalidateConstantCache : 1;
    uint32_t                m_bInvalidateVFECache : 1;
    uint32_t                m_bInvalidateInstructionCache : 1;
    uint32_t                m_bTlbInvalidate : 1;
    uint32_t                m_bHdcPipelineFlush : 1;
    uint32_t                m_bKernelFenceEnabled : 1;
    bool                    m_bFlushToGo = true;
    uint8_t                 m_ui8InterfaceDescriptorOffset = 0;

    uint32_t           m_slmSize          = 0;
    KERNEL_RENDER_DATA m_kernelRenderData = {};  // Only for MULTI_KERNELS_WITH_ONE_MEDIA_STATE case.

MEDIA_CLASS_DEFINE_END(RenderCmdPacket)
};
#endif // __MEDIA_RENDER_CMD_PACKET_H__
