Media
/
media-driver
mirror of https://github.com/intel/media-driver.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
media-driver/media_common/agnostic/common/renderhal/renderhal.h

1980 lines
88 KiB
C++
Raw Blame History

/*
* Copyright (c) 2009-2022, 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 renderhal.h
//! \brief
//!
//!
//! \file renderhal.h
//! \brief Render Engine Interfaces shared across platforms
//! \details Platform Independent Hardware Interfaces
//!
#ifndef __RENDERHAL_H__
#define __RENDERHAL_H__
#include "mos_os.h" // Interface to OS functions
#include "mhw_state_heap.h"
#include "mhw_render.h"
#include "mhw_memory_pool.h"
#include "media_perf_profiler.h"
#include "frame_tracker.h"
#include "media_common_defs.h"
#include "surface_state_heap_mgr.h"
class XRenderHal_Platform_Interface;
//------------------------------------------------------------------------------
// Macros specific to RenderHal sub-comp
//------------------------------------------------------------------------------
#define MHW_RENDERHAL_ASSERT(_expr) \
MOS_ASSERT(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL, _expr)
#define MHW_RENDERHAL_ASSERTMESSAGE(_message, ...) \
MOS_ASSERTMESSAGE(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL, _message, ##__VA_ARGS__)
#define MHW_RENDERHAL_NORMALMESSAGE(_message, ...) \
MOS_NORMALMESSAGE(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL, _message, ##__VA_ARGS__)
#define MHW_RENDERHAL_VERBOSEMESSAGE(_message, ...) \
MOS_VERBOSEMESSAGE(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL, _message, ##__VA_ARGS__)
#define MHW_RENDERHAL_FUNCTION_ENTER \
MOS_FUNCTION_ENTER(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL)
#define MHW_RENDERHAL_FUNCTION_EXIT \
MOS_FUNCTION_EXIT(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL, eStatus)
#define MHW_RENDERHAL_CHK_STATUS(_stmt) \
MOS_CHK_STATUS(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL, _stmt)
#define MHW_RENDERHAL_CHK_STATUS_RETURN(_stmt) \
MOS_CHK_STATUS_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _stmt)
#define MHW_RENDERHAL_CHK_STATUS_MESSAGE(_stmt, _message, ...) \
MOS_CHK_STATUS_MESSAGE(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL, _stmt, _message, ##__VA_ARGS__)
#define MHW_RENDERHAL_CHK_NULL(_ptr) \
MOS_CHK_NULL(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL, _ptr)
#define MHW_RENDERHAL_CHK_NULL_NO_STATUS(_ptr) \
MOS_CHK_NULL_NO_STATUS(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL, _ptr)
#define MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(_ptr) \
MOS_CHK_NULL_NO_STATUS_RETURN(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL, _ptr)
#define MHW_RENDERHAL_CHK_NULL_RETURN(_ptr) \
MOS_CHK_NULL_RETURN(MOS_COMPONENT_CM, MOS_CM_SUBCOMP_RENDERHAL, _ptr)
#define MHW_RENDERHAL_CHK_VALUE_RETURN(_value, _expect_value) \
MOS_CHK_STATUS_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, ((_value) == (_expect_value)) ? MOS_STATUS_SUCCESS : MOS_STATUS_INVALID_PARAMETER)
#define MHW_RENDERHAL_UNUSED(x) \
MOS_UNUSED(x)
//!
//! \brief Kernel allocation control
//!
#define RENDERHAL_KERNEL_LOAD_FAIL -1
#define RENDERHAL_KERNEL_ALLOCATION_FREE 0 // Kernel entry free
#define RENDERHAL_KERNEL_ALLOCATION_USED 1 // Kernel entry in use
#define RENDERHAL_KERNEL_ALLOCATION_LOCKED 2 // Kernel entry locked (no garbage collection)
#define RENDERHAL_KERNEL_ALLOCATION_REMOVED 3 // Kernel entry in use, but no longer loaded in ISH to make room for others
#define RENDERHAL_KERNEL_ALLOCATION_LOADING 4 // Kernel selected to be loaded (was stale or used)
#define RENDERHAL_KERNEL_ALLOCATION_STALE 5 // Kernel memory block became invalid, needs to be reloaded
//!
//! \brief SSH defaults and limits
//!
#define RENDERHAL_SSH_INSTANCES 16
#define RENDERHAL_SSH_INSTANCES_MAX 64
#define RENDERHAL_SSH_BINDING_TABLES 1
#define RENDERHAL_SSH_BINDING_TABLES_MIN 1
#define RENDERHAL_SSH_BINDING_TABLES_MAX 16
#define RENDERHAL_SSH_BINDING_TABLE_ALIGN 64
#define RENDERHAL_SSH_SURFACE_STATES 40
#define RENDERHAL_SSH_SURFACE_STATES_MIN 16
#define RENDERHAL_SSH_SURFACE_STATES_MAX 256
#define RENDERHAL_SSH_SURFACES_PER_BT 64
#define RENDERHAL_SSH_SURFACES_PER_BT_MIN 4
#define RENDERHAL_SSH_SURFACES_PER_BT_MAX 256
//!
//! \brief Default size of area for sync, debugging, performance collecting
//!
#define RENDERHAL_SYNC_SIZE_MIN 128
#define RENDERHAL_SYNC_SIZE_MAX 4096
#define RENDERHAL_SYNC_SIZE 128
//!
//! \brief Default number of media states (Dynamic GSH mode)
//!
#define RENDERHAL_MEDIA_STATES 16
//!
//! \brief Default number of media IDs
//!
#define RENDERHAL_MEDIA_IDS 16
//!
//! \brief Max URB Size
//!
#define RENDERHAL_URB_SIZE_MAX 2048
//!
//! \brief Interface Descriptor Entries
//!
#define RENDERHAL_INTERFACE_DESCRIPTOR_ENTRIES_MAX 64
//!
//! \brief Max URB Entry Size
//!
#define RENDERHAL_URB_ENTRY_SIZE_MAX (RENDERHAL_URB_SIZE_MAX - RENDERHAL_INTERFACE_DESCRIPTOR_ENTRIES_MAX)
//!
//! \brief Max CURBE Allocation Size
//!
#define RENDERHAL_CURBE_SIZE_MAX (RENDERHAL_URB_SIZE_MAX - RENDERHAL_INTERFACE_DESCRIPTOR_ENTRIES_MAX)
//!
//! \brief Max Samplers
//!
#define RENDERHAL_SAMPLERS_AVS_MAX 8
//!
//! \brief Default Samplers
//!
#define RENDERHAL_SAMPLERS 16
#define RENDERHAL_SAMPLERS_VA 8
//!
//! \brief Default CURBE size in GSH
//! Use the size of composition kernel static param since it's the largest of all
//!
#define RENDERHAL_CURBE_SIZE 832 // MOS ALIGN CEIL(sizeof(GPGPU_WALKER_ISTAB_GMC_STATIC_DATA_G8), RENDERHAL_URB_BLOCK_ALIGN)
//!
//! \brief Default number of kernels that may be cached in GSH
//!
#define RENDERHAL_KERNEL_COUNT 32
//!
//! \brief Max number of kernels cached in GSH
//!
#define RENDERHAL_KERNEL_COUNT_MIN 2
//!
//! \brief Default kernel heap size
//!
#define RENDERHAL_KERNEL_HEAP 2097152
//!
//! \brief Min kernel heap size
//!
#define RENDERHAL_KERNEL_HEAP_MIN 65536
#define RENDERHAL_KERNEL_HEAP_MAX 2097152
//!
//! \brief Default kernel block size (granularity for kernel allocation)
//!
#define RENDERHAL_KERNEL_BLOCK_SIZE 65536
//!
//! \brief Default ISA ASM Debug Surface BTI
//!
#define RENDERHAL_ISA_ASM_SURFACE_BTI_DEFAULT 39
//!
//! \brief Min kernel block size
//!
#define RENDERHAL_KERNEL_BLOCK_MIN 1024
#define RENDERHAL_KERNEL_BLOCK_MAX 65536
//!
//! \brief Max number of Media Threads
//!
#define RENDERHAL_USE_MEDIA_THREADS_MAX 0
//!
//! \brief Number and size of palettes
//!
#define RENDERHAL_PALETTE_COUNT 2
#define RENDERHAL_PALETTE_MAX 2
#define RENDERHAL_PALETTE_ENTRIES 256
#define RENDERHAL_PALETTE_ENTRIES_MAX 256
//!
//! \brief SIP Size
//!
#define RENDERHAL_MAX_SIP_SIZE 0x4000
//!
//! \brief Number of chroma keys
//!
#define RENDERHAL_CHROMA_KEY_COUNT 4
#define RENDERHAL_CHROMA_KEY_MAX 4
//!
//! \brief Alignment
//!
#define RENDERHAL_KERNEL_BLOCK_ALIGN 64
#define RENDERHAL_URB_BLOCK_ALIGN 64
#define RENDERHAL_SYNC_BLOCK_ALIGN 128
#define RENDERHAL_CURBE_BLOCK_ALIGN 64
//!
//! \brief Max number of Y_Uoffset size
//!
#define RENDERHAL_MAX_YV12_PLANE_Y_U_OFFSET_G9 16383
//!
//! \brief Palette allocation id
//!
#define RENDERHAL_PALETTE_ID_ALLOCATE_ONLY -2 // Allocate but don't load palette
#define RENDERHAL_PALETTE_ID_ALLOCATE_LOAD -1 // Allocate and load palette
//!
//! \brief Hw Interface defaults
//!
#define RENDERHAL_TIMEOUT_MS_DEFAULT 100
#define RENDERHAL_EVENT_TIMEOUT_MS 5
//!
//! \brief Sampler State Indices
//!
#define RENDERHAL_SAMPLER_Y 1
#define RENDERHAL_SAMPLER_U 2
#define RENDERHAL_SAMPLER_V 3
#define RENDERHAL_SAMPLER_8x8_AVS_Y 4
#define RENDERHAL_SAMPLER_8x8_AVS_U 8
#define RENDERHAL_SAMPLER_8x8_AVS_V 12
//*-----------------------------------------------------------------------------
//| MMIO register offsets used for the EU debug support
//*-----------------------------------------------------------------------------
#define MEDIASTATE_AVS_MAX_DERIVATIVE_4_PIXELS 7
#define MEDIASTATE_AVS_MAX_DERIVATIVE_8_PIXELS 20
#define MEDIASTATE_AVS_TRANSITION_AREA_4_PIXELS 4
#define MEDIASTATE_AVS_TRANSITION_AREA_8_PIXELS 5
enum GFX_COMMON_TOKEN_SUBOPCODE
{
GFXSUBOP_BINDING_TABLE_STATE_TOKEN = 0xFE,
GFXSUBOP_SURFACE_STATE_TOKEN = 0xFF
};
enum MEDIASTATE_AVS_SHARPNESS_LEVEL
{
MEDIASTATE_AVS_SHARPNESS_LEVEL_SMOOTH = 0,
MEDIASTATE_AVS_SHARPNESS_LEVEL_SHARP = 255
};
// Render chroma siting vertical value
enum CHROMA_SITING_VDIRECTION
{
CHROMA_SITING_VDIRECTION_0 = 0x0,
CHROMA_SITING_VDIRECTION_1_4 = 0x1,
CHROMA_SITING_VDIRECTION_1_2 = 0x2,
CHROMA_SITING_VDIRECTION_3_4 = 0x3,
CHROMA_SITING_VDIRECTION_1 = 0x4
};
// Render chroma siting horizontal value
enum CHROMA_SITING_UDIRECTION
{
CHROMA_SITING_UDIRECTION_LEFT = 0x0,
CHROMA_SITING_UDIRECTION_CENTER = 0x1
};
enum GFX3DSTATE_TILEWALK
{
GFX3DSTATE_TILEWALK_XMAJOR = 0,
GFX3DSTATE_TILEWALK_YMAJOR = 1
};
enum MEDIA_STATE_DEBUG_COUNTER_CONTROL
{
MEDIASTATE_DEBUG_COUNTER_FREE_RUNNING = 0,
MEDIASTATE_DEBUG_COUNTER_FROZEN = 1,
MEDIASTATE_DEBUG_COUNTER_INITIALIZED_ONCE = 2,
MEDIASTATE_DEBUG_COUNTER_INITIALIZED_ALWAYS = 3
};
enum MEDIASTATE_BINDING_TABLE_STATE_TYPE
{
MEDIASTATE_BTS_DEFAULT_TYPE = 0,
MEDIASTATE_BTS_DI_SAMPLE8x8_VME_TYPE = 1
};
struct SURFACE_STATE_TOKEN_COMMON
{
// DWORD 0
union
{
struct
{
uint32_t Length : 8; // OP_LENGTH
uint32_t : 8;
uint32_t InstructionSubOpcode : 8; // GFX3DSTATE_PIPELINED_SUBOPCODE
uint32_t InstructionOpcode : 3; // GFX_OPCODE
uint32_t InstructionPipeLine : 2; // INSTRUCTION_PIPELINE
uint32_t InstructionType : 2; // INSTRUCTION_TYPE
uint32_t Token : 1; // bool
};
// DriverID for IMOLA patching
struct
{
uint32_t DriverID;
};
struct
{
uint32_t Value;
};
} DW0;
// DWORD 1
union
{
struct
{
uint32_t SurfaceStateHeapOffset : 16; // U16 32-byte aligned
uint32_t SurfaceAllocationIndex : 16; // U16
};
struct
{
uint32_t Value;
};
} DW1;
// DWORD 2
union
{
struct
{
uint32_t SurfaceOffset : 32;
};
struct
{
uint32_t Value;
};
} DW2;
// DWORD 3
union
{
struct
{
uint32_t RenderTargetEnable : 1; // bool
uint32_t YUVPlane : 2; // U2
uint32_t SurfaceStateType : 1; // U1
uint32_t: 28;
};
struct
{
uint32_t Value;
};
} DW3;
// DWORD 4
union
{
struct
{
uint32_t SurfaceBaseAddress; // SurfaceBaseAddress[31:12]
};
struct
{
uint32_t Value;
};
} DW4;
// DWORD 5
union
{
struct
{
uint32_t SurfaceBaseAddress64 : BITFIELD_RANGE(0, 15); // SurfaceBaseAddress[47:32]
uint32_t : BITFIELD_RANGE(16, 31);
};
struct
{
uint32_t Value;
};
} DW5;
void* pResourceInfo;
};
// Forward declarations
typedef struct _RENDERHAL_SURFACE RENDERHAL_SURFACE, *PRENDERHAL_SURFACE;
typedef struct _RENDERHAL_INTERFACE RENDERHAL_INTERFACE, *PRENDERHAL_INTERFACE;
typedef struct _RENDERHAL_SURFACE_STATE_ENTRY *PRENDERHAL_SURFACE_STATE_ENTRY;
typedef const struct _RENDERHAL_KERNEL_PARAM CRENDERHAL_KERNEL_PARAM, *PCRENDERHAL_KERNEL_PARAM;
//!
//! Structure RENDERHAL_SETTINGS
//! \brief RenderHal Settings - creation parameters for RenderHal
//!
typedef struct _RENDERHAL_SETTINGS
{
int32_t iMediaStates;
} RENDERHAL_SETTINGS, *PRENDERHAL_SETTINGS;
//!
//! Enum RENDERHAL_COMPONENT
//! \brief RenderHal client component ID (for debugging/timing)
//!
typedef enum _RENDERHAL_COMPONENT
{
RENDERHAL_COMPONENT_UNKNOWN = 0,
RENDERHAL_COMPONENT_COMP,
RENDERHAL_COMPONENT_DNDI,
RENDERHAL_COMPONENT_VEBOX,
RENDERHAL_COMPONENT_CM,
RENDERHAL_COMPONENT_PACKET,
RENDERHAL_COMPONENT_16ALIGN,
RENDERHAL_COMPONENT_FAST1TON,
RENDERHAL_COMPONENT_HDR,
RENDERHAL_COMPONENT_COUNT_BASE,
RENDERHAL_COMPONENT_RENDER_COPY,
RENDERHAL_COMPONENT_RESERVED_NUM = 16,
RENDERHAL_COMPONENT_COUNT
} RENDERHAL_COMPONENT;
//!
//! \brief Scaling Mode enum
//!
typedef enum _RENDERHAL_SCALING_MODE
{
RENDERHAL_SCALING_NEAREST,
RENDERHAL_SCALING_BILINEAR,
RENDERHAL_SCALING_AVS
} RENDERHAL_SCALING_MODE;
//!
//! \brief Surface types enum
//! IMPORTANT : SurfaceType_Layer[] must be updated to match this enum type
//!
typedef enum _RENDERHAL_SURFACE_TYPE
{
RENDERHAL_SURF_NONE = 0,
RENDERHAL_SURF_IN_BACKGROUND,
RENDERHAL_SURF_IN_PRIMARY,
RENDERHAL_SURF_IN_SUBSTREAM,
RENDERHAL_SURF_IN_REFERENCE,
RENDERHAL_SURF_OUT_RENDERTARGET,
RENDERHAL_SURF_TYPE_COUNT //!< Keep this line at the end
} RENDERHAL_SURFACE_TYPE;
//!
//! \brief Batch buffer types enum
//!
typedef enum _RENDERHAL_BB_TYPE
{
RENDERHAL_BB_TYPE_UNKNOWN = 0, // Batch Buffer created by unknown client
RENDERHAL_BB_TYPE_CM = 6, // Batch Buffer created by Media Development Framework (CM) component
RENDERHAL_BB_TYPE_COUNT
} RENDERHAL_BB_TYPE;
//!
//! \brief Sample Type enum
//!
typedef enum _RENDERHAL_SAMPLE_TYPE
{
RENDERHAL_SAMPLE_PROGRESSIVE,
RENDERHAL_SAMPLE_SINGLE_TOP_FIELD,
RENDERHAL_SAMPLE_SINGLE_BOTTOM_FIELD,
RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD,
RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD,
RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD,
RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD,
RENDERHAL_SAMPLE_INVALID //!< Keep this line at the end
} RENDERHAL_SAMPLE_TYPE;
//!
//! Structure RENDERHAL_GET_SURFACE_INFO
//! \brief Structure to retrieve Surface Infomation Parameters
//!
typedef struct _RENDERHAL_GET_SURFACE_INFO
{
uint32_t ArraySlice;
uint32_t MipSlice;
MOS_S3D_CHANNEL S3dChannel;
} RENDERHAL_GET_SURFACE_INFO, *PRENDERHAL_GET_SURFACE_INFO;
//!
//! \brief Structure of power control info
//!
typedef struct _RENDERHAL_POWEROPTION
{
uint16_t nSlice; //!< Number of slices to use: 0 (default), 1, 2...
uint16_t nSubSlice; //!< Number of subslices to use: 0 (default), 1, 2...
uint16_t nEU; //!< Number of EUs to use: 0 (default), 1, 2...
} RENDERHAL_POWEROPTION, *PRENDERHAL_POWEROPTION;
//!
//! Structure RENDERHAL_SURFACE
//! \brief RENDERHAL surface definition
//!
typedef struct _RENDERHAL_SURFACE
{
MOS_SURFACE OsSurface; //!< Surface provided by the client
// Auxiliary rendering parameters
RENDERHAL_SURFACE_TYPE SurfType; //!< Surface Type (context)
RENDERHAL_SCALING_MODE ScalingMode; //!< Scaling Mode
MHW_ROTATION Rotation; //!< Rotation Mode
uint32_t ChromaSiting; //!< Chroma Siting
// Src/Dst rectangles
RECT rcSrc; //!< Source rectangle
RECT rcDst; //!< Destination rectangle
RECT rcMaxSrc; //!< Max source rectangle
// Auxiliary VP parameters provided by client
bool bDeinterlaceEnable; //!< Active Deinterlace messages
bool bQueryVariance; //!< enable variance query
bool bInterlacedScaling; //!< Interlaced scaling
void *pDeinterlaceParams; //!< Pointer to Deinterlacing parameters
RENDERHAL_SAMPLE_TYPE SampleType; //!< Interlaced/Progressive sample type
int32_t iPaletteID; //!<Palette ID
uint32_t dwWidthInUse; //!< the actual width in use
uint32_t dwHeightInUse; //!< the actual height in use
} RENDERHAL_SURFACE , *PRENDERHAL_SURFACE;
//!
//! Structure RENDERHAL_OFFSET_OVERRIDE
//! \brief structure used to alloce Surface State overrides for Kernel
//!
typedef struct _RENDERHAL_OFFSET_OVERRIDE
{
// Y plane adjustment
int32_t iYOffsetAdjust; //!< Surface Offset adjustment for Y plane
int32_t iYOffsetX; //!< X-Offset override for Y plane
int32_t iYOffsetY; //!< Y-Offset override for Y plane
// UV plane overrides/adjustmenty
int32_t iUVOffsetAdjust; //!< Surface Offset adjustment for UV plane
int32_t iUVOffsetX; //!< X-Offset override for UV plane
int32_t iUVOffsetY; //!< Y-Offset override for UV plane
} RENDERHAL_OFFSET_OVERRIDE, *PRENDERHAL_OFFSET_OVERRIDE;
typedef enum _RENDERHAL_SURFACE_STATE_TYPE
{
RENDERHAL_SURFACE_TYPE_INVALID = 0,
RENDERHAL_SURFACE_TYPE_G8 ,
RENDERHAL_SURFACE_TYPE_G9 ,
RENDERHAL_SURFACE_TYPE_G10 ,
RENDERHAL_SURFACE_TYPE_ADV_G8 ,
RENDERHAL_SURFACE_TYPE_ADV_G9 ,
RENDERHAL_SURFACE_TYPE_ADV_G10
} RENDERHAL_SURFACE_STATE_TYPE, *PRENDERHAL_SURFACE_STATE_TYPE;
typedef enum _RENDERHAL_PLANE_DEFINITION
{
RENDERHAL_PLANES_PL3 = 0,
RENDERHAL_PLANES_NV12 ,
RENDERHAL_PLANES_YUY2 ,
RENDERHAL_PLANES_UYVY ,
RENDERHAL_PLANES_YVYU ,
RENDERHAL_PLANES_VYUY ,
RENDERHAL_PLANES_ARGB ,
RENDERHAL_PLANES_XRGB ,
RENDERHAL_PLANES_ABGR ,
RENDERHAL_PLANES_XBGR ,
RENDERHAL_PLANES_RGB16 ,
RENDERHAL_PLANES_RGB24 ,
RENDERHAL_PLANES_R16U ,
RENDERHAL_PLANES_R16S ,
RENDERHAL_PLANES_R32U ,
RENDERHAL_PLANES_R32S ,
RENDERHAL_PLANES_R32F ,
RENDERHAL_PLANES_V8U8 ,
RENDERHAL_PLANES_R8G8_UNORM ,
RENDERHAL_PLANES_411P ,
RENDERHAL_PLANES_411R ,
RENDERHAL_PLANES_422H ,
RENDERHAL_PLANES_422V ,
RENDERHAL_PLANES_444P ,
RENDERHAL_PLANES_RGBP ,
RENDERHAL_PLANES_BGRP ,
RENDERHAL_PLANES_AI44_PALLETE_0 ,
RENDERHAL_PLANES_IA44_PALLETE_0 ,
RENDERHAL_PLANES_P8_PALLETE_0 ,
RENDERHAL_PLANES_A8P8_PALLETE_0 ,
RENDERHAL_PLANES_AI44_PALLETE_1 ,
RENDERHAL_PLANES_IA44_PALLETE_1 ,
RENDERHAL_PLANES_P8_PALLETE_1 ,
RENDERHAL_PLANES_A8P8_PALLETE_1 ,
RENDERHAL_PLANES_AYUV ,
RENDERHAL_PLANES_STMM ,
RENDERHAL_PLANES_L8 ,
RENDERHAL_PLANES_PL3_ADV ,
RENDERHAL_PLANES_NV12_ADV ,
RENDERHAL_PLANES_YUY2_ADV ,
RENDERHAL_PLANES_UYVY_ADV ,
RENDERHAL_PLANES_YVYU_ADV ,
RENDERHAL_PLANES_VYUY_ADV ,
RENDERHAL_PLANES_ARGB_ADV ,
RENDERHAL_PLANES_ABGR_ADV ,
RENDERHAL_PLANES_AYUV_ADV ,
RENDERHAL_PLANES_STMM_ADV ,
RENDERHAL_PLANES_L8_ADV ,
RENDERHAL_PLANES_A8_ADV ,
RENDERHAL_PLANES_A8 ,
RENDERHAL_PLANES_R8 ,
RENDERHAL_PLANES_NV12_2PLANES ,
RENDERHAL_PLANES_NV12_2PLANES_ADV ,
RENDERHAL_PLANES_411P_ADV ,
RENDERHAL_PLANES_411R_ADV ,
RENDERHAL_PLANES_422H_ADV ,
RENDERHAL_PLANES_422V_ADV ,
RENDERHAL_PLANES_444P_ADV ,
RENDERHAL_PLANES_RGBP_ADV ,
RENDERHAL_PLANES_BGRP_ADV ,
RENDERHAL_PLANES_R16_UNORM ,
RENDERHAL_PLANES_Y8 ,
RENDERHAL_PLANES_Y1 ,
RENDERHAL_PLANES_Y16U ,
RENDERHAL_PLANES_Y16S ,
RENDERHAL_PLANES_A16B16G16R16 ,
RENDERHAL_PLANES_A16B16G16R16_ADV ,
RENDERHAL_PLANES_R10G10B10A2 ,
RENDERHAL_PLANES_R10G10B10A2_ADV ,
RENDERHAL_PLANES_B10G10R10A2 ,
RENDERHAL_PLANES_L16 ,
RENDERHAL_PLANES_NV21 ,
RENDERHAL_PLANES_YV12 ,
RENDERHAL_PLANES_P016 ,
RENDERHAL_PLANES_P016_2PLANES_ADV ,
RENDERHAL_PLANES_P010 ,
RENDERHAL_PLANES_P010_1PLANE ,
RENDERHAL_PLANES_P010_1PLANE_ADV ,
RENDERHAL_PLANES_IRW0 ,
RENDERHAL_PLANES_IRW1 ,
RENDERHAL_PLANES_IRW2 ,
RENDERHAL_PLANES_IRW3 ,
RENDERHAL_PLANES_A16B16G16R16F ,
RENDERHAL_PLANES_R16G16_UNORM ,
RENDERHAL_PLANES_R16_FLOAT ,
RENDERHAL_PLANES_A16R16G16B16F ,
RENDERHAL_PLANES_YUY2_2PLANES ,
RENDERHAL_PLANES_Y210_ADV ,
RENDERHAL_PLANES_Y210_RT ,
RENDERHAL_PLANES_Y210 ,
RENDERHAL_PLANES_Y210_1PLANE_ADV ,
RENDERHAL_PLANES_R16G16_SINT ,
RENDERHAL_PLANES_R24_UNORM_X8_TYPELESS,
RENDERHAL_PLANES_R32_FLOAT_X8X24_TYPELESS,
RENDERHAL_PLANES_P208,
RENDERHAL_PLANES_P208_1PLANE_ADV,
RENDERHAL_PLANES_Y416_RT,
RENDERHAL_PLANES_R32G32B32A32F,
RENDERHAL_PLANES_Y8_ADV,
RENDERHAL_PLANES_G32R32F,
RENDERHAL_PLANES_NV12_2PLANES_COMBINED,
RENDERHAL_PLANES_P016_2PLANES_COMBINED,
RENDERHAL_PLANES_YUY2_2PLANES_WIDTH_UNALIGNED,
RENDERHAL_PLANES_DEFINITION_COUNT
} RENDERHAL_PLANE_DEFINITION, *PRENDERHAL_PLANE_DEFINITION;
typedef enum _RENDERHAL_SS_BOUNDARY
{
RENDERHAL_SS_BOUNDARY_SRCRECT = 0, // use for sources read via sampler
RENDERHAL_SS_BOUNDARY_DSTRECT , // use for RT by default
RENDERHAL_SS_BOUNDARY_MAXSRCRECT, // use max source rect
RENDERHAL_SS_BOUNDARY_ORIGINAL, // use for surfs that are not source or RT
} RENDERHAL_SS_BOUNDARY;
//!
//! \brief Surface cache attributes
//!
#define RENDERHAL_MEMORY_OBJECT_CONTROL uint32_t
typedef struct _RENDERHAL_KERNEL_PARAM
{
int32_t GRF_Count; // Number of registers
int32_t BT_Count; // Number of BT entries
int32_t Sampler_Count; // Number of samplers
int32_t Thread_Count; // Number of threads (max)
int32_t GRF_Start_Register; // Start register
int32_t CURBE_Length; // Constant URB length (in 256-bits)
int32_t block_width; // Block width
int32_t block_height; // Block height
int32_t blocks_x; // Blocks in x
int32_t blocks_y; // Blocks in y
} RENDERHAL_KERNEL_PARAM, *PRENDERHAL_KERNEL_PARAM;
typedef struct _RENDERHAL_CLONE_KERNEL_PARAM
{
bool isClone; // If kernel has been cloned from another kernel (i.e. share same kernel binary)
bool isHeadKernel; // If kernel is the "head" kernel (i.e. this allocation contains the kernel binary)
int32_t referenceCount; // Number of cloned kernels currently pointing to the head kernel
int32_t cloneKernelID; // Kernel ID of source kernel (i.e. kernel used to clone)
int32_t kernelBinaryAllocID; // Allocation ID of the head kernel that contains the actual kernel binary
uint32_t dwOffsetForAllocID; // Save the offset for this allocation ID, if clone using a different offset to point to head kernel binary
}RENDERHAL_CLONE_KERNEL_PARAM, *PRENDERHAL_CLONE_KERNEL_PARAM;
typedef struct tagKdll_CacheEntry Kdll_CacheEntry;
typedef struct _RENDERHAL_KRN_ALLOCATION *PRENDERHAL_KRN_ALLOCATION;
typedef struct _RENDERHAL_KRN_ALLOC_LIST *PRENDERHAL_KRN_ALLOC_LIST;
typedef struct _RENDERHAL_KRN_ALLOCATION
{
int32_t iKID; // Interface descriptor ID for the kernel (for 2nd level buffer)
int32_t iKUID; // Kernel Unique ID
int32_t iKCID; // Kernel Cache ID
uint32_t dwSync; // Kernel last sync (used to determine whether the kernel may be unloaded)
FrameTrackerTokenFlat trackerToken; // Kernel last sync with multiple trackers
uint32_t dwOffset; // Kernel offset in GSH (from GSH base, 0 is KAC entry is available)
int32_t iSize; // Kernel block size in GSH (0 if not loaded)
uint32_t dwFlags : 4; // Kernel allocation flag
uint32_t dwCount : 28; // Kernel refresh counter
RENDERHAL_KERNEL_PARAM Params; // Kernel parameters for RenderHal (states, rendering, etc)
PMHW_KERNEL_PARAM pMhwKernelParam; // Pointer to Kernel parameters for MHW
Kdll_CacheEntry *pKernelEntry; // Pointer to Kernel entry for VP/KDLL
RENDERHAL_CLONE_KERNEL_PARAM cloneKernelParams; // CM - Clone kernel information
int32_t iAllocIndex; // Kernel allocation index (index in kernel allocation table)
// DSH - Dynamic list of kernel allocations
PMHW_STATE_HEAP_MEMORY_BLOCK pMemoryBlock; // Memory block in ISH
PRENDERHAL_KRN_ALLOCATION pNext; // Next kernel in list
PRENDERHAL_KRN_ALLOCATION pPrev; // Prev kernel in list
PRENDERHAL_KRN_ALLOC_LIST pList; // Points to current list, regardless of flag
uint32_t Reserved : 16; // Reserved - used for debugging
uint32_t : 16; //
char *szKernelName; // Kernel name - used for debugging
} RENDERHAL_KRN_ALLOCATION, *PRENDERHAL_KRN_ALLOCATION;
typedef struct _RENDERHAL_KRN_ALLOC_LIST
{
PRENDERHAL_KRN_ALLOCATION pHead; // Head of the list
PRENDERHAL_KRN_ALLOCATION pTail; // Tail of the list
int32_t iCount; // Number of objects
} RENDERHAL_KRN_ALLOC_LIST, *PRENDERHAL_KRN_ALLOC_LIST;
typedef struct _RENDERHAL_MEDIA_STATE *PRENDERHAL_MEDIA_STATE;
typedef struct _RENDERHAL_MEDIA_STATE
{
// set at creation time
uint32_t dwOffset; // Media State Base Address (from GSH base) - VFE
int32_t *piAllocation; // Kernel allocation table
// set at runtime
uint32_t dwSyncTag; // Sync Tag
FrameTrackerTokenFlat trackerToken;
uint32_t dwSyncCount; // Number of sync tags
int32_t iCurbeOffset; // Current CURBE Offset
uint32_t bBusy : 1; // 1 if the state is in use (must sync before use)
uint32_t : 15;
uint32_t Reserved: 16;
PRENDERHAL_MEDIA_STATE pPrev; // Next Media State
PRENDERHAL_MEDIA_STATE pNext; // Previous Media State
} RENDERHAL_MEDIA_STATE, *PRENDERHAL_MEDIA_STATE;
typedef struct _RENDERHAL_MEDIA_STATE_LIST
{
PRENDERHAL_MEDIA_STATE pHead; // Head of the list
PRENDERHAL_MEDIA_STATE pTail; // Tail of the list
int32_t iCount; // Number of objects
} RENDERHAL_MEDIA_STATE_LIST, *PRENDERHAL_MEDIA_STATE_LIST;
struct RENDERHAL_TR_RESOURCE {
MOS_RESOURCE osResource;
bool locked;
uint32_t *data;
uint32_t currentTrackerId;
};
typedef struct _RENDERHAL_STATE_HEAP_SETTINGS
{
// Global GSH Allocation parameters
int32_t iSyncSize; // Sync area for sync, perf, debug
// Media State Allocation parameters
int32_t iMediaStateHeaps; // Number of Media State heaps
int32_t iMediaIDs; // Number of Media Interface Descriptors
int32_t iCurbeSize; // Size of CURBE area
int32_t iSamplers; // Number of Samplers/ID
int32_t iSamplersAVS; // Number of AVS Samplers/ID
int32_t iSamplersVA; // Number of Video Analytics Samplers/ID
int32_t iKernelCount; // Number of Kernels that can be loaded
int32_t iKernelHeapSize; // Size of GSH block for kernels
int32_t iKernelBlockSize; // Kernel allocation block
// Media VFE/ID configuration, limits
int32_t iPerThreadScratchSize; // Size of the Scratch memory per Thread
int32_t iSipSize; // SIP size
// Surface State Heap Settings
int32_t iSurfaceStateHeaps; // Number of SSH instances (same as iMediaStateHeaps)
int32_t iBindingTables; // Number of BT per SSH instance
int32_t iSurfaceStates; // Number of Surfaces per SSH
int32_t iSurfacesPerBT; // Number of Surfaces per BT
int32_t iBTAlignment; // BT Alignment size
MOS_HW_RESOURCE_DEF heapUsageType;
} RENDERHAL_STATE_HEAP_SETTINGS, *PRENDERHAL_STATE_HEAP_SETTINGS;
typedef struct _RENDERHAL_STATE_HEAP
{
//---------------------------
// General State Heap
//---------------------------
uint32_t dwSizeGSH; // GSH size
MOS_RESOURCE GshOsResource; // GSH OS Buffer
bool bGshLocked; // GSH is locked
uint8_t *pGshBuffer; // Pointer to GSH buffer data
// Dynamic GSH sync
uint32_t dwOffsetSync; // Offset of sync/perf data in GSH
uint32_t dwSizeSync; // Size of sync data
// Synchronization / Performance / Statistics
volatile uint32_t *pSync; // Pointer to sync area (when locked)
uint32_t dwNextTag; // Next sync tag value to use
uint32_t dwSyncTag; // Last sync tag completed
uint32_t dwFrameId; // Last frame id completed
// Media states
int32_t iCurMediaState; // Current Media State Index
int32_t iNextMediaState; // Next Media State Index
PRENDERHAL_MEDIA_STATE pCurMediaState; // Current Media state in use
uint32_t dwSizeMediaState; // Size of Media state
uint32_t dwOffsetMediaID; // Offset to Media IDs from Media State Base
uint32_t dwSizeMediaID; // Size of each Media ID
MHW_ID_ENTRY_PARAMS CurIDEntryParams = {}; // Parameters for current Interface Descriptor Entry
// Performance capture
uint32_t dwOffsetStartTime; // Offset to the start time of the media state
uint32_t dwStartTimeSize; // Size of Start time
uint32_t dwOffsetEndTime; // Offset to the end time of the media state
uint32_t dwEndTimeSize; // Size of end time
uint32_t dwOffsetComponentID; // Render Component
uint32_t dwComponentIDSize; // Render ComponentID size
uint32_t dwOffsetReserved; // Reserved (Curbe should be 64 aligned)
uint32_t dwReservedSize; // 64 - (start time + end time + component)
uint32_t dwOffsetCurbe; // Offset to Media CURBE data from Media State Base
uint32_t dwSizeCurbe; // Size of CURBE area
uint32_t dwOffsetSampler; // Offset to Media Samplers from Media State Base
uint32_t dwSizeSampler; // Size of Samplers
uint32_t dwOffsetSamplerIndirect; // Offset to Media Samplers Indirect State from Media State Base
uint32_t dwSizeSamplerIndirect; // Size of Samplers Indirect State
uint32_t dwOffsetSampler8x8Table; // Offset to Media Sampler State Table for AVS from Media State Base
uint32_t dwSizeSampler8x8Table; // Size of Sampler State Table for AVS
uint32_t dwOffsetSamplerVA; // Offset to Video Analytics Samplers from Media State Base
uint32_t dwSizeSamplerVA; // Size of VA Samplers
uint32_t dwOffsetSamplerAVS; // Offset to 8x8 Samplers from Media State Base
uint32_t dwSizeSamplerAVS; // Size of 8x8 Samplers
uint32_t dwSizeSamplers; // Size of All Samplers
PRENDERHAL_MEDIA_STATE pMediaStates; // Media state table
// Dynamic Media states
PMHW_MEMORY_POOL pMediaStatesMemPool; // Media state memory allocations
RENDERHAL_MEDIA_STATE_LIST FreeStates; // Free media state objects (pool)
RENDERHAL_MEDIA_STATE_LIST ReservedStates; // Reserved media states
RENDERHAL_MEDIA_STATE_LIST SubmittedStates; // Submitted media states
//---------------------------
// Surface State Heap
//---------------------------
uint32_t dwSizeSSH; // SSH size
MOS_RESOURCE SshOsResource; // SSH OS Buffer
bool bSshLocked; // SSH is locked
uint8_t *pSshBuffer; // Pointer to SSH buffer base
uint32_t dwSshIntanceSize; // SSH instance size
// BT size, offsets to BT/SS entries in SSH
int32_t iBindingTableSize; // Size of each BT (in bytes)
int32_t iBindingTableOffset; // First BT offset in SSH buffer
int32_t iSurfaceStateOffset; // First SS offset in SSH buffer
// Array of Surface State control structures
PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
// Current allocations
int32_t iCurSshBufferIndex; // Current SSH Buffer instance in the SSH heap
int32_t iCurrentBindingTable; // Current BT
int32_t iCurrentSurfaceState; // Current SS
//---------------------------
// Instruction State Heap
//---------------------------
uint32_t dwSizeISH; // ISH size
MOS_RESOURCE IshOsResource; // ISH OS Buffer
bool bIshLocked; // ISH is locked
uint8_t *pIshBuffer; // Pointer to ISH buffer data
uint32_t dwKernelBase; // Offset of kernels in ISH
// Kernel Allocation
int32_t iKernelSize; // Kernel heap size
int32_t iKernelUsed; // Kernel heap used size
uint8_t *pKernelLoadMap; // Kernel load map
uint32_t dwAccessCounter; // Incremented when a kernel is loaded/used, for dynamic allocation
int32_t iKernelUsedForDump; // The kernel size to be dumped in oca buffer.
// Kernel Spill Area
uint32_t dwScratchSpaceSize; // Size of the Scratch Area
uint32_t dwScratchSpaceBase; // Base of the Scratch area
// System Routine
uint32_t dwSipBase; // Base of the System Routine
// Arrays created dynamically
PRENDERHAL_KRN_ALLOCATION pKernelAllocation; // Kernel allocation table (or linked list)
// Dynamic Kernel States
PMHW_MEMORY_POOL pKernelAllocMemPool; // Kernel states memory pool (mallocs)
RENDERHAL_KRN_ALLOC_LIST KernelAllocationPool; // Pool of kernel allocation objects
RENDERHAL_KRN_ALLOC_LIST KernelsSubmitted; // Kernel submission list
RENDERHAL_KRN_ALLOC_LIST KernelsAllocated; // kernel allocation list (kernels in ISH not currently being executed)
SurfaceStateHeapManager *surfaceStateMgr; // Surface state manager
} RENDERHAL_STATE_HEAP, *PRENDERHAL_STATE_HEAP;
typedef struct _RENDERHAL_DYNAMIC_MEDIA_STATE_PARAMS
{
int32_t iMaxMediaIDs; // Maximum number of media interface descriptors
int32_t iMaxThreads; // Maximum number of threads to be executed (0 = limited to HW threads) - for scratch space allocation
int32_t iMaxSpillSize; // Maximum spill sizes among all kernels to be executed - used for scratch space allocation
int32_t iMaxCurbeOffset; // Maximum offset reserved for CURBE
int32_t iMaxCurbeSize; // Maximum size reserved for CURBE
int32_t iMaxSamplerIndex3D; // Maximum 3D sampler index
int32_t iMaxSamplerIndexAVS; // Maximum AVS sampler index
int32_t iMaxSamplerIndexConv; // Maximum Conv sampler index
int32_t iMaxSamplerIndexMisc; // Maximum Misc (VA) sampler index
int32_t iMax8x8Tables; // Maximum Number of 8x8 tables per MediaID
} RENDERHAL_DYNAMIC_MEDIA_STATE_PARAMS, *PRENDERHAL_DYNAMIC_MEDIA_STATE_PARAMS;
typedef struct _RENDERHAL_INTERFACE_DESCRIPTOR_PARAMS
{
int32_t iMediaID;
int32_t iBindingTableID;
int32_t iCurbeOffset;
int32_t iCurbeLength;
int32_t iCrsThrdConstDataLn;
int32_t iNumberThreadsInGroup;
bool blGlobalBarrierEnable;
bool blBarrierEnable;
int32_t iSLMSize;
} RENDERHAL_INTERFACE_DESCRIPTOR_PARAMS, *PRENDERHAL_INTERFACE_DESCRIPTOR_PARAMS;
//!
//! \brief ======== HW Abstraction Params ===================================
//!
typedef struct _RENDERHAL_SURFACE_STATE_PARAMS
{
RENDERHAL_SURFACE_STATE_TYPE Type : 5; // Type of surface state
uint32_t isOutput : 1; // Render output flag
uint32_t bVertStride : 1; // VL Stride
uint32_t bVertStrideOffs : 1; // VL Stride Offset
uint32_t bWidthInDword_Y : 1; // Width in dwords
uint32_t bWidthInDword_UV : 1;
uint32_t bAVS : 1; // AVS scaling
RENDERHAL_SS_BOUNDARY Boundary : 3; // boundary to be aligned to rcSrc/rcDst/actual wd/ht
uint32_t bWidth16Align : 1; // When VDI Walker is enabled, input surface width must be 16 aligned
uint32_t b2PlaneNV12NeededByKernel : 1; // Kernel needs surface state for both Y and UV
uint32_t bForceNV12 : 1; // Forces format to be treated as NV12. Only used in FRC.
uint32_t bUseSinglePlane : 1; // 1 indicates using one plane only
uint32_t b32MWColorFillKern : 1; // Flag for 32x32 Media walker + ColorFill kernel case
uint32_t bVASurface : 1; // Value is 1 if VA surface, 0 if AVS surface
uint32_t AddressControl : 2; // 0 clamp, 1 mirror, 2, 3 reserved
uint32_t bWAUseSrcHeight : 1; // Surface state height use src height or surface height
uint32_t bWAUseSrcWidth : 1; // Surface state width use src width or surface width
uint32_t bForce3DLUTR16G16 : 1; // Flag for 3D LUT source and targetsurface
uint32_t bChromasiting : 1; // Flag for chromasiting use
uint32_t bVmeUse : 1; // Flag for VME use
uint32_t bBufferUse : 1; // Flags for 1D buffer use
uint32_t bSurfaceTypeDefined : 1;
uint32_t forceCommonSurfaceMessage : 1;
uint32_t surfaceType : 11;
MOS_COMPONENT Component : 4;
uint32_t combineChannelY : 1; // Combine 2 Luma Channel pixels into 1 pixel, so that kernel can reduce write times
RENDERHAL_MEMORY_OBJECT_CONTROL MemObjCtl; // Caching attributes
} RENDERHAL_SURFACE_STATE_PARAMS, *PRENDERHAL_SURFACE_STATE_PARAMS;
typedef struct _RENDERHAL_SURFACE_STATE_ENTRY
{
RENDERHAL_SURFACE_STATE_TYPE Type; // Type of surface state
PMOS_SURFACE pSurface; // Pointer to OS surface
uint8_t *pSurfaceState; // Pointer to Surface State
SURFACE_STATE_TOKEN_COMMON SurfaceToken; // SurfaceS Token
int32_t iSurfStateID; // Surface state ID
uint32_t dwSurfStateOffset; // Surface state offset (SSH)
uint32_t dwFormat; // Surface format
uint32_t dwWidth; // Surface width
uint32_t dwHeight; // Surface heigth
uint32_t dwPitch; // Surface pitch
uint32_t dwQPitch; // Surface qpitch
uint32_t YUVPlane : 2; // Plane
uint32_t bAVS : 1; // AVS scaling
uint32_t isOutput : 1; // Render output flag
uint32_t bVertStride : 1; // VL Stride
uint32_t bVertStrideOffs : 1; // VL Stride Offset
uint32_t bWidthInDword : 1; // Width in dwords
uint32_t bTiledSurface : 1; // Tiled surface
uint32_t bTileWalk : 1; // Walk 0-X; 1-Y
uint32_t bHalfPitchChroma : 1; // Half pitch for choma (AVS)
uint32_t bInterleaveChroma: 1; // Interleaved chroma (AVS)
uint32_t DirectionV : 3; // UV direction (AVS)
uint32_t DirectionU : 1; // UV direction (AVS)
uint32_t AddressControl : 2; // 0 Clamp, 1 Mirror, 2, 3 resserved
uint32_t : 15; // RESERVED
uint16_t wUXOffset; // (X,Y) offset U (AVS/ADI)
uint16_t wUYOffset; //
uint16_t wVXOffset; // (X,Y) offset V (AVS/ADI)
uint16_t wVYOffset; //
uint64_t stateGfxAddress; // Gfx Address of Surface State
} RENDERHAL_SURFACE_STATE_ENTRY, *PRENDERHAL_SURFACE_STATE_ENTRY;
//!
// \brief Helper parameters used by Mhw_SendGenericPrologCmd and to initiate command buffer attributes
//!
typedef struct _RENDERHAL_GENERIC_PROLOG_PARAMS
{
bool bMmcEnabled = 0;
bool bEnableMediaFrameTracking = 0;
uint32_t dwMediaFrameTrackingTag = 0;
uint32_t dwMediaFrameTrackingAddrOffset = 0;
PMOS_RESOURCE presMediaFrameTrackingSurface = nullptr;
virtual ~_RENDERHAL_GENERIC_PROLOG_PARAMS() {}
} RENDERHAL_GENERIC_PROLOG_PARAMS, *PRENDERHAL_GENERIC_PROLOG_PARAMS;
//!
// \brief Settings help to decide the value of L3 cache enabling register used for renderhal
//!
typedef struct _RENDERHAL_L3_CACHE_SETTINGS
{
bool bEnableSLM; // Enable SLM cache configuration
bool bOverride; // Override cache settings
// Override values
bool bL3CachingEnabled;
bool bCntlRegOverride;
bool bCntlReg2Override;
bool bCntlReg3Override;
bool bSqcReg1Override;
bool bSqcReg4Override;
bool bLra1RegOverride;
uint32_t dwCntlReg;
uint32_t dwCntlReg2;
uint32_t dwCntlReg3;
uint32_t dwSqcReg1;
uint32_t dwSqcReg4;
uint32_t dwLra1Reg;
} RENDERHAL_L3_CACHE_SETTINGS, *PRENDERHAL_L3_CACHE_SETTINGS;
//!
// \brief Settings of Predication
//!
typedef struct _RENDERHAL_PREDICATION_SETTINGS
{
MOS_RESOURCE *pPredicationResource; // Resource for predication
MOS_RESOURCE *ptempPredicationBuffer; // Additional temp buffer for Predication due to the limitation of Cond_BB_End
uint64_t predicationResOffset; // Offset for Predication resource
bool predicationNotEqualZero; // Predication mode
bool predicationEnabled; // Indicates whether or not Predication is enabled
} RENDERHAL_PREDICATION_SETTINGS;
//!
// \brief Settings of SetMarker
//!
typedef struct _RENDERHAL_SETMARKER_SETTINGS
{
MOS_RESOURCE *pSetMarkerResource; // Resource for SetMarker
bool setMarkerEnabled; // Indicates whether or not SetMarker is enabled
uint32_t setMarkerNumTs; // Number Timestamp for SetMarker
} RENDERHAL_SETMARKER_SETTINGS;
typedef MhwMiInterface *PMHW_MI_INTERFACE;
typedef struct _RENDERHAL_ENLARGE_PARAMS
{
//for ReAllocateStateHeapsforAdvFeatureWithSshEnlarged and ReAllocateStateHeapsforAdvFeatureWithAllHeapsEnlarged
int32_t iBindingTables; // Number of BT per SSH instance
int32_t iSurfaceStates; // Number of Surfaces per SSH
int32_t iSurfacesPerBT; // Size of BT
//for ReAllocateStateHeapsforAdvFeatureWithAllHeapsEnlarged only
int32_t iKernelCount; // Number of Kernels that can be loaded
int32_t iKernelHeapSize; // Size of GSH block for kernels
int32_t iCurbeSize; // Size of CURBE area
} RENDERHAL_ENLARGE_PARAMS, *PRENDERHAL_ENLARGE_PARAMS;
//!
// \brief Hardware dependent render engine interface
//!
typedef struct _RENDERHAL_INTERFACE
{
// MOS/MHW Interfaces
PMOS_INTERFACE pOsInterface;
MhwCpInterface *pCpInterface;
PXMHW_STATE_HEAP_INTERFACE pMhwStateHeap;
PMHW_MI_INTERFACE pMhwMiInterface;
// RenderHal State Heap
PRENDERHAL_STATE_HEAP pStateHeap;
uint32_t dwStateHeapSize;
// Linked list of batch buffers for synchronization
PMHW_BATCH_BUFFER pBatchBufferList; // List of BB submitted
PMHW_MEMORY_POOL pBatchBufferMemPool; // Batch Buffer memory allocations (malloc)
PMHW_BATCH_BUFFER_LIST BatchBufferPool; // Pool of BB objects (no GFX buffer)
PMHW_BATCH_BUFFER_LIST BatchBuffersAllocated; // List of BB allocated (not executing, backed by GFX buffer)
// Auxiliary
PLATFORM Platform;
MEDIA_FEATURE_TABLE *pSkuTable;
MEDIA_WA_TABLE *pWaTable;
// Hardware dependent parameters
MHW_VFE_SCOREBOARD VfeScoreboard;
PCMHW_SURFACE_PLANES pPlaneDefinitions;
// Settings and capabilities
PMHW_RENDER_ENGINE_CAPS pHwCaps; // HW Capabilities
PMHW_RENDER_STATE_SIZES pHwSizes; // Sizes of HW commands/states
RENDERHAL_STATE_HEAP_SETTINGS StateHeapSettings; // State Heap Settings
RENDERHAL_ENLARGE_PARAMS enlargeStateHeapSettingsForAdv; // State Heap Settings for Adv Feature
// MHW parameters
MHW_STATE_BASE_ADDR_PARAMS StateBaseAddressParams;
MHW_SIP_STATE_PARAMS SipStateParams;
MHW_WALKER_MODE MediaWalkerMode; // Media object walker mode from Regkey: repel, dual mode, quad mode
uint32_t euThreadSchedulingMode;
uint32_t largeGrfMode;
RENDERHAL_SURFACE_STATE_TYPE SurfaceTypeDefault; // Surface State type default
RENDERHAL_SURFACE_STATE_TYPE SurfaceTypeAdvanced; // Surface State type advanced
RENDERHAL_L3_CACHE_SETTINGS L3CacheSettings; // L3 Cache settings
bool bEnableYV12SinglePass; // Enabled YV12 single pass in 3D sampler
bool bEnableP010SinglePass; // Enabled P010 single pass in sampler
bool bSIPKernel; // SIP loaded
bool bCSRKernel; // CSR loaded
bool bTurboMode; // Turbo mode info to pass in cmdBuf
bool bVDIWalker; // VDI Walker info from Regkey
bool bRequestSingleSlice; // Single Slice Request flag
bool bEUSaturationNoSSD; // No slice shutdown, must request 2 slices [CM EU saturation on]
bool bEnableGpgpuMidBatchPreEmption; // Middle Batch Buffer Preemption
bool bEnableGpgpuMidThreadPreEmption; // Middle Thread Preemption
bool bComputeContextInUse; // Compute Context use for media
bool isBindlessHeapInUse; // Bindless Heap Mode use
uint32_t dwMaskCrsThdConDataRdLn; // Unifies pfnSetupInterfaceDescriptor for g75,g8,...
uint32_t dwMinNumberThreadsInGroup; // Unifies pfnSetupInterfaceDescriptor for g75,g8,...
uint32_t dwCurbeBlockAlign; // Unifies pfnLoadCurbeData - Curbe Block Alignment
uint32_t dwScratchSpaceMaxThreads; // Unifies pfnGetScratchSpaceSize - Threads used for scratch space calculation
uint32_t dwSamplerAvsIncrement; // Unifies pfnSetSamplerStates
const void *sseuTable; // pointer of const VphalSseuSetting table on a platform
uint32_t dwIndirectHeapSize;
uint32_t dwTimeoutMs;
int32_t iMaxPalettes;
int32_t iMaxPaletteEntries;
MHW_PALETTE_PARAMS Palette[RENDERHAL_PALETTE_MAX];
int32_t iMaxChromaKeys;
int32_t iChromaKeyCount;
MHW_CHROMAKEY_PARAMS ChromaKey[RENDERHAL_CHROMA_KEY_MAX];
bool bHasCombinedAVSSamplerState;
// GD2 kernel debugging
bool bIsaAsmDebugEnable;
uint8_t cIsaAsmDebugSurfaceBTI;
RENDERHAL_SURFACE IsaAsmDebugSurface;
// Performance collection
bool bKerneltimeDump;
double kernelTime[RENDERHAL_COMPONENT_COUNT];
// Auxiliary data - for debugging purposes
int32_t iMediaStatesInUse; // Media states in use
int32_t iKernelsInUse; // Kernels in use
int32_t iBuffersInUse; // BB in use
// Power option to control slice/subslice/EU shutdown
RENDERHAL_POWEROPTION PowerOption;
// Indicates whether it's MDF load or not
bool IsMDFLoad;
bool bDynamicStateHeap; //!< Indicates that DSH is in use
FrameTrackerProducer trackerProducer; // Resource to mark command buffer completion
RENDERHAL_TR_RESOURCE veBoxTrackerRes; // Resource to mark command buffer completion
uint32_t currentTrackerIndex; // Record the tracker index
HeapManager *dgsheapManager; // Dynamic general state heap manager
#if (_DEBUG || _RELEASE_INTERNAL)
// Dump state for VP debugging
void *pStateDumper;
#endif
// Pointer to vphal oca dumper object to dump vphal parameters.
void *pVphalOcaDumper;
// Predication
RENDERHAL_PREDICATION_SETTINGS PredicationParams; //!< Predication
MOS_RESOURCE PredicationBuffer; //!< Predication buffer
// CSC Coefficient
bool bCmfcCoeffUpdate; //!< CMFC CSC Coefficient Surface update flag
int32_t iKernelAllocationID; //!< CMFC CSC Kernel Allocation ID
PMOS_RESOURCE pCmfcCoeffSurface; //!< CMFC CSC Coefficient Surface
// SetMarker
RENDERHAL_SETMARKER_SETTINGS SetMarkerParams; //!< SetMarker
// Indicates whether it's AVS or not
bool bIsAVS;
bool isMMCEnabled;
#if (_DEBUG || _RELEASE_INTERNAL)
// RT Old cacheSetting
uint32_t oldCacheSettingForTargetSurface = 0;
#endif
MediaPerfProfiler *pPerfProfiler = nullptr; //!< Performance data profiler
bool eufusionBypass = false;
MediaUserSettingSharedPtr userSettingPtr = nullptr; //!< Shared pointer to User Setting instance
// if it's true, will disable preemption by setting NeedsMidBatchPreEmptionSupport flag in command buffer attribute as false;
// will also skip preemption control bits configure.
bool forceDisablePreemption = false;
//---------------------------
// HW interface functions
//---------------------------
MOS_STATUS (* pfnInitialize)(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SETTINGS pSettings);
MOS_STATUS (* pfnDestroy) (
PRENDERHAL_INTERFACE pRenderHal);
MOS_STATUS (* pfnReset) (
PRENDERHAL_INTERFACE pRenderHal);
//---------------------------
// State Heap Functions
//---------------------------
MOS_STATUS (* pfnAllocateStateHeaps) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_STATE_HEAP_SETTINGS pSettings);
MOS_STATUS (* pfnReAllocateStateHeapsforAdvFeatureWithSshEnlarged)(
PRENDERHAL_INTERFACE pRenderHal,
bool &bAllocated);
MOS_STATUS (*pfnReAllocateStateHeapsforAdvFeatureWithAllHeapsEnlarged)(
PRENDERHAL_INTERFACE pRenderHal,
bool &bAllocated);
MOS_STATUS (* pfnFreeStateHeaps) (
PRENDERHAL_INTERFACE pRenderHal);
MOS_STATUS (* pfnRefreshSync) (
PRENDERHAL_INTERFACE pRenderHal);
//---------------------------
// SSH, surface states
//---------------------------
MOS_STATUS (* pfnAssignSshInstance) (
PRENDERHAL_INTERFACE pRenderHal);
MOS_STATUS (* pfnGetSurfaceStateEntries) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface,
PRENDERHAL_SURFACE_STATE_PARAMS pParams,
int32_t *piNumEntries,
PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntries);
MOS_STATUS (* pfnSetupSurfaceState) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface,
PRENDERHAL_SURFACE_STATE_PARAMS pParams,
int32_t *piNumEntries,
PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntries,
PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride);
MOS_STATUS (*pfnSetupBufferSurfaceState) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface,
PRENDERHAL_SURFACE_STATE_PARAMS pParams,
PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntry);
MOS_STATUS (* pfnAssignSurfaceState) (
PRENDERHAL_INTERFACE pRenderHal,
RENDERHAL_SURFACE_STATE_TYPE Type,
PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntry);
void (* pfnGetAlignUnit) (
uint16_t *pwWidthAlignUnit,
uint16_t *pwHeightAlignUnit,
PRENDERHAL_SURFACE pRenderHalSurface);
void (* pfnAdjustBoundary) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface,
RENDERHAL_SS_BOUNDARY Boundary,
uint32_t *pdwSurfaceWidth,
uint32_t *pdwSurfaceHeight);
uint32_t (* pfnSetSurfacesPerBT) (
PRENDERHAL_INTERFACE pRenderHal,
uint32_t dwSurfacesPerBT);
uint16_t (* pfnCalculateYOffset) (
PMOS_INTERFACE pOsInterface,
PMOS_RESOURCE pOsResource);
MOS_STATUS (* pfnAssignBindingTable) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t *piBindingTable);
MOS_STATUS (* pfnAssignBindlessSurfaceStates) (
PRENDERHAL_INTERFACE pRenderHal);
MOS_STATUS (*pfnSendBindlessSurfaceStates) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
bool bNeedNullPatch);
MOS_STATUS (* pfnBindSurfaceState) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iBindingTableIndex,
int32_t iBindingTableEntry,
PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry);
uint32_t (* pfnGetSurfaceMemoryObjectControl) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE_STATE_PARAMS pParams);
MOS_STATUS (*pfnGetPlaneDefinitionForCommonMessage) (
PRENDERHAL_INTERFACE pRenderHal,
MOS_FORMAT format,
PRENDERHAL_SURFACE_STATE_PARAMS &pParam,
bool isRenderTarget,
RENDERHAL_PLANE_DEFINITION &planeDefinition);
//---------------------------
// State Setup - HW + OS Specific
//---------------------------
MOS_STATUS (* pfnSetupSurfaceStatesOs) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE_STATE_PARAMS pParams,
PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceStateEntry);
//---------------------------
// Batch Buffer
//---------------------------
MOS_STATUS (* pfnAllocateBB) (
PRENDERHAL_INTERFACE pRenderHal,
PMHW_BATCH_BUFFER pBatchBuffer,
int32_t iSize);
MOS_STATUS (* pfnFreeBB) (
PRENDERHAL_INTERFACE pRenderHal,
PMHW_BATCH_BUFFER pBatchBuffer);
MOS_STATUS (* pfnLockBB) (
PRENDERHAL_INTERFACE pRenderHal,
PMHW_BATCH_BUFFER pBatchBuffer);
MOS_STATUS (* pfnUnlockBB) (
PRENDERHAL_INTERFACE pRenderHal,
PMHW_BATCH_BUFFER pBatchBuffer);
//---------------------------
// Media State
//---------------------------
PRENDERHAL_MEDIA_STATE (* pfnAssignMediaState) (
PRENDERHAL_INTERFACE pRenderHal,
RENDERHAL_COMPONENT componentID);
//---------------------------
// Allocation
//---------------------------
MOS_STATUS (* pfnEnablePalette) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iPaletteID,
int32_t iPaletteSize);
MOS_STATUS (* pfnAllocatePaletteID) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t *pPaletteID);
MOS_STATUS (* pfnFreePaletteID) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t *pPaletteID);
MOS_STATUS (* pfnGetPaletteEntry) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iPaletteID,
int32_t iInNumEntries,
int32_t *piOutNumEntries,
void **pPaletteData);
int32_t (* pfnAllocateChromaKey) (
PRENDERHAL_INTERFACE pRenderHal,
uint32_t dwLow,
uint32_t dwHigh);
int32_t (* pfnLoadCurbeData) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_MEDIA_STATE pMediaState,
void *pData,
int32_t iSize);
MOS_STATUS (* pfnSetSamplerStates) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iMediaID,
PMHW_SAMPLER_STATE_PARAM pSamplerParams,
int32_t iSamplers);
MOS_STATUS (*pfnSetAndGetSamplerStates) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iMediaID,
PMHW_SAMPLER_STATE_PARAM pSamplerParams,
int32_t iSamplers,
std::map<uint32_t, uint64_t> &samplerMap);
int32_t (* pfnAllocateMediaID) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iKernelAllocationID,
int32_t iBindingTableID,
int32_t iCurbeOffset,
int32_t iCurbeLength,
int32_t iCrsThrdConstDataLn,
PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams);
int32_t (* pfnGetMediaID) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_MEDIA_STATE pMediaState,
PRENDERHAL_KRN_ALLOCATION pKernelAllocation);
MOS_STATUS (* pfnSetupInterfaceDescriptor) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_MEDIA_STATE pMediaState,
PRENDERHAL_KRN_ALLOCATION pKernelAllocation,
PRENDERHAL_INTERFACE_DESCRIPTOR_PARAMS pInterfaceDescriptorParams);
uint32_t (* pfnEncodeSLMSize)(PRENDERHAL_INTERFACE pRenderHal, uint32_t SLMSize);
//---------------------------
// Kernels
//---------------------------
int32_t (* pfnLoadKernel) (
PRENDERHAL_INTERFACE pRenderHal,
PCRENDERHAL_KERNEL_PARAM pParameters,
PMHW_KERNEL_PARAM pKernel,
Kdll_CacheEntry *pKernelEntry);
MOS_STATUS (* pfnUnloadKernel) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iKernelAllocationID);
void (* pfnResetKernels) (
PRENDERHAL_INTERFACE pRenderHal);
void (* pfnTouchKernel) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iKernelAllocationID);
int32_t (* pfnGetKernelOffset) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iKernelAllocationIndex);
MOS_STATUS (* pfnUnregisterKernel) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_KRN_ALLOCATION pKernelAllocation);
//---------------------------
// New Dynamic State Heap interfaces
//---------------------------
MOS_STATUS(*pfnAssignSpaceInStateHeap)(
uint32_t trackerIndex,
FrameTrackerProducer *trackerProducer,
HeapManager *heapManager,
MemoryBlock *block,
uint32_t size);
PRENDERHAL_MEDIA_STATE (* pfnAssignDynamicState) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_DYNAMIC_MEDIA_STATE_PARAMS pParams,
RENDERHAL_COMPONENT componentID);
MOS_STATUS (* pfnReleaseDynamicState) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_MEDIA_STATE pMediaState);
MOS_STATUS (* pfnSubmitDynamicState) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_MEDIA_STATE pMediaState);
int32_t (* pfnAllocateDynamicMediaID) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_KRN_ALLOCATION pKernelAllocation,
int32_t iBindingTableID,
int32_t iCurbeOffset,
int32_t iCurbeLength,
int32_t iCrsThrdConstDataLn,
PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams);
PRENDERHAL_KRN_ALLOCATION (* pfnLoadDynamicKernel) (
PRENDERHAL_INTERFACE pRenderHal,
PCRENDERHAL_KERNEL_PARAM pParameters,
PMHW_KERNEL_PARAM pKernel,
uint32_t *pdwLoaded);
PRENDERHAL_KRN_ALLOCATION (* pfnSearchDynamicKernel) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iKernelUniqueID,
int32_t iCacheID);
PRENDERHAL_KRN_ALLOCATION (* pfnAllocateDynamicKernel) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iKernelUniqueID,
int32_t iCacheID);
MOS_STATUS (* pfnUnloadDynamicKernel) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_KRN_ALLOCATION pKernelAllocation);
MOS_STATUS (* pfnRefreshDynamicKernels) (
PRENDERHAL_INTERFACE pRenderHal,
uint32_t dwSpaceNeeded,
uint32_t *pdwSizes,
int32_t iCount);
void (* pfnResetDynamicKernels) (
PRENDERHAL_INTERFACE pRenderHal);
void (* pfnTouchDynamicKernel) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_KRN_ALLOCATION pKernelAllocation);
MOS_STATUS (* pfnExpandKernelStateHeap)(
PRENDERHAL_INTERFACE pRenderHal,
uint32_t dwAdditionalKernelSpaceNeeded);
//---------------------------
// HW interface configuration functions
//---------------------------
MOS_STATUS (* pfnSetVfeStateParams) (
PRENDERHAL_INTERFACE pRenderHal,
uint32_t dwDebugCounterControl,
uint32_t dwMaximumNumberofThreads,
uint32_t dwCURBEAllocationSize,
uint32_t dwURBEntryAllocationSize,
PMHW_VFE_SCOREBOARD pScoreboardParams);
bool (* pfnGetMediaWalkerStatus) (
PRENDERHAL_INTERFACE pRenderHal);
//---------------------------
// Command buffer programming functions
//---------------------------
MOS_STATUS (* pfnSendStateBaseAddress) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer);
MOS_STATUS (* pfnSendMediaStates) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
PMHW_WALKER_PARAMS pWalkerParams,
PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams);
MOS_STATUS (* pfnInitCommandBuffer) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams);
MOS_STATUS (* pfnSendSurfaces) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer);
MOS_STATUS (* pfnSendSyncTag) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer);
MOS_STATUS (*pfnSendCscCoeffSurface) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
PMOS_RESOURCE presCscCoeff,
Kdll_CacheEntry *pKernelEntry);
// Samplers and other states
MOS_STATUS (*pfnGetSamplerOffsetAndPtr) (
PRENDERHAL_INTERFACE pRenderHal,
int32_t iMediaID,
int32_t iSamplerID,
PMHW_SAMPLER_STATE_PARAM pSamplerParams,
uint32_t *pdwSamplerOffset,
void **ppSampler);
MOS_STATUS (* pfnSendCurbeLoad) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer);
MOS_STATUS (* pfnSendMediaIdLoad) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer);
MOS_STATUS (* pfnSendChromaKey) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer);
MOS_STATUS (* pfnSendPalette) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer);
MOS_STATUS (* pfnSendSurfaceStateEntry) (
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
PMHW_SURFACE_STATE_SEND_PARAMS pParams);
MOS_STATUS (* pfnSetSurfaceStateToken)(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_SURFACE_TOKEN_PARAMS pParams,
void *pSurfaceStateToken);
MOS_STATUS (* pfnSetSurfaceStateBuffer)(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_RCS_SURFACE_PARAMS pParams,
void *pSurfaceState);
//-----------------------------
// Slice Shutdown Mode function
//-----------------------------
void (* pfnSetSliceShutdownMode) (
PRENDERHAL_INTERFACE pRenderHal,
bool bMode);
//-----------------------------
// General Slice Shut Down Mode function
//-----------------------------
void( *pfnSetPowerOptionMode ) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_POWEROPTION pMode);
//-----------------------------
// Enable Middle Batch Buffer Preemption
//-----------------------------
void (* pfnEnableGpgpuMiddleBatchBufferPreemption) (
PRENDERHAL_INTERFACE pRenderHal);
//-----------------------------
// Enable Middle Thread Preemption
//-----------------------------
void (* pfnEnableGpgpuMiddleThreadPreemption) (
PRENDERHAL_INTERFACE pRenderHal);
//---------------------------
// Generic HAL Layer Commands and State Functions
//---------------------------
void (* pfnConvertToNanoSeconds) (
PRENDERHAL_INTERFACE pRenderHal,
uint64_t iTicks,
uint64_t *piNs);
MOS_STATUS (* pfnSendRcsStatusTag) (
PRENDERHAL_INTERFACE pRenderHal, // [in] Hardware interface
PMOS_COMMAND_BUFFER pCmdBuffer); // [in] Command Buffer
MOS_STATUS (* pfnSendTimingData) (
PRENDERHAL_INTERFACE pRenderHal, // [in] Hardware interface
PMOS_COMMAND_BUFFER pCmdBuffer, // [in] Command Buffer
bool bStartTime); // [in] Start Timestamp flag
uint32_t (* pfnGetScratchSpaceSize)(
PRENDERHAL_INTERFACE pRenderHal, // [in] Hardware interface
uint32_t iPerThreadScratchSpaceSize); // [in] Per thread scrach space size
bool (* pfnIs2PlaneNV12Needed) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface,
RENDERHAL_SS_BOUNDARY Boundary);
uint8_t (* pfnSetChromaDirection) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface);
bool(*pfnPerThreadScratchSpaceStart2K) (
PRENDERHAL_INTERFACE pRenderHal);
//---------------------------
// Overwrite L3 Cache control register
//---------------------------
MOS_STATUS (* pfnEnableL3Caching) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings);
MOS_STATUS(*pfnSetCacheOverrideParams) (
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings,
bool bEnableSLM);
//!
//! \brief Get mmio registers address
//! \details Get mmio registers address
//! \return [out] PMHW_MI_MMIOREGISTERS*
//! mmio registers got.
//!
PMHW_MI_MMIOREGISTERS GetMmioRegisters();
//-----------------------------
//Platform related interface
XRenderHal_Platform_Interface *pRenderHalPltInterface;
} RENDERHAL_INTERFACE;
//!
//! \brief Functions
//!
//!
//! \brief Init Interface
//! \details Initializes Render Hal Interface structure, responsible for HW
//! abstraction of Render Engine for MDF/VP
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param MhwCpInterface** ppCpInterface
//! [in/out] Pointer of pointer to MHW CP Interface Structure, which
//! is created during renderhal initialization
//! \param PMOS_INTERFACE pOsInterface
//! [in] Pointer to OS Interface Structure
//! \return MOS_STATUS
//! MOS_STATUS_UNKNOWN : Invalid parameters
//!
MOS_STATUS RenderHal_InitInterface(
PRENDERHAL_INTERFACE pRenderHal,
MhwCpInterface **ppCpInterface,
PMOS_INTERFACE pOsInterface);
//!
//! \brief Get Pixels Per Sample
//! \details Get Number of Pixels per Dataport Sample
//! \param MOS_FORMAT format
//! [in] Surface Format
//! \param uint32_t *pdwPixelsPerSampleUV
//! [in] Pointer to dwPixelsPerSampleUV
//! \return void
//!
void RenderHal_GetPixelsPerSample(
MOS_FORMAT format,
uint32_t *pdwPixelsPerSampleUV);
//!
//! \brief Set Surface for HW Access
//! \details Common Function for setting up surface state
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param PRENDERHAL_SURFACE pRenderHalSurface
//! [in] Pointer to Render Hal Surface
//! \param PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams
//! [in] Pointer to Surface Params
//! \param int32_t iBindingTable
//! [in] Binding Table to bind surface
//! \param int32_t iBTEntry
//! [in] Binding Table Entry index
//! \param bool bWrite
//! [in] Write mode flag
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if success. Error code otherwise
//!
MOS_STATUS RenderHal_SetSurfaceForHwAccess(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface,
PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
int32_t iBindingTable,
int32_t iBTEntry,
bool bWrite);
//!
//! \brief Set Buffer Surface for HW Access
//! \details Common Function for setting up buffer surface state
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param PRENDERHAL_SURFACE pRenderHalSurface
//! [in] Pointer to Render Hal Surface
//! \param PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams
//! [in] Pointer to Surface Params
//! \param int32_t iBindingTable
//! [in] Binding Table to Bind Surface
//! \param int32_t iBTEntry
//! [in] Binding Table Entry index
//! \param bool bWrite
//! Write mode flag
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if success. Error code otherwise
//!
MOS_STATUS RenderHal_SetBufferSurfaceForHwAccess(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface,
PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
int32_t iBindingTable,
int32_t iBTEntry,
bool bWrite);
//!
//! \brief Get Surface Info from OsResource
//! \details Update surface info in PRENDERHAL_SURFACE based on allocated OsResource
//! \param PMOS_INTERFACE pOsInterface
//! [in] Pointer to MOS_INTERFACE
//! \param PRENDERHAL_GET_SURFACE_INFO pInfo
//! [in] Pointer to RENDERHAL_GET_SURFACE_INFO
//! \param PMOS_SURFACE pSurface
//! [in/out] Pointer to PMOS_SURFACE
//! \return MOS_STATUS
//! Return MOS_STATUS_SUCCESS if successful, otherwise failed
//!
MOS_STATUS RenderHal_GetSurfaceInfo(
PMOS_INTERFACE pOsInterface,
PRENDERHAL_GET_SURFACE_INFO pInfo,
PMOS_SURFACE pSurface);
//!
//! \brief Send Media States
//! \details Send Media States
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param PMOS_COMMAND_BUFFER pCmdBuffer
//! [in] Pointer to Command Buffer
//! \param PRENDERHAL_GPGPU_WALKER_PARAMS pGpGpuWalkerParams
//! [in] Pointer to GPGPU walker parameters
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_SendMediaStates(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
PMHW_WALKER_PARAMS pWalkerParams,
PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams);
//!
//! \brief Issue command to write timestamp
//! \param [in] pRenderHal
//! \param [in] pCmdBuffer
//! \param [in] bStartTime
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_SendTimingData(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
bool bStartTime);
//!
//! \brief Get Y Offset according to the planeOffset struct and surface pitch
//! \details Get Y Offset according to the planeOffset struct and surface pitch
//! \param pOsInterface
//! [in] pointer to OS Interface
//! \param pOsResource
//! [in] Pointers to Surface OsResource
//! \return uint16_t
//! [out] the plane Y offset
//!
uint16_t RenderHal_CalculateYOffset(
PMOS_INTERFACE pOsInterface,
PMOS_RESOURCE pOsResource);
MOS_STATUS RenderHal_AllocateDebugSurface(
PRENDERHAL_INTERFACE pRenderHal);
MOS_STATUS RenderHal_SetupDebugSurfaceState(
PRENDERHAL_INTERFACE pRenderHal);
void RenderHal_FreeDebugSurface(
PRENDERHAL_INTERFACE pRenderHal);
MOS_STATUS RenderHal_AddDebugControl(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer);
MOS_STATUS RenderHal_SetSurfaceStateToken(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_SURFACE_TOKEN_PARAMS pParams,
void *pSurfaceStateToken);
//!
//! \brief Send Surfaces PatchList
//! \details Send Surface State commands
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param PMOS_COMMAND_BUFFER pCmdBuffer
//! [in] Pointer to Command Buffer
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_SendSurfaces_PatchList(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer);
//!
//! \brief Init Special Interface
//! \details Initializes RenderHal Interface structure, responsible for HW
//! abstraction of HW Rendering Engine for CM(MDF) and VP.
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//!
void RenderHal_InitInterfaceEx(
PRENDERHAL_INTERFACE pRenderHal);
// Constants defined in RenderHal interface
extern const SURFACE_STATE_TOKEN_COMMON g_cInit_SURFACE_STATE_TOKEN_COMMON;
extern const MHW_PIPE_CONTROL_PARAMS g_cRenderHal_InitPipeControlParams;
extern const MHW_VFE_PARAMS g_cRenderHal_InitVfeParams;
extern const MHW_MEDIA_STATE_FLUSH_PARAM g_cRenderHal_InitMediaStateFlushParams;
extern const RENDERHAL_KERNEL_PARAM g_cRenderHal_InitKernelParams;
#endif // __RENDERHAL_H__
Reference in New Issue View Git Blame Copy Permalink