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_softlet/agnostic/common/renderhal/renderhal.cpp

7817 lines
302 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.cpp
//! \brief Render Engine state heap manager for VP and CM
//! \details Platform/OS Independent Render Engine state heap management interfaces
//!
#include "renderhal.h"
#include "hal_kerneldll_next.h"
#include "renderhal_platform_interface.h"
#include "media_interfaces_renderhal.h"
#include "media_interfaces_mhw_next.h"
#include "hal_oca_interface_next.h"
#define OutputSurfaceWidthRatio 1
extern const SURFACE_STATE_TOKEN_COMMON g_cInit_SURFACE_STATE_TOKEN_COMMON =
{
// DWORD 0
{
OP_LENGTH(SIZE32(SURFACE_STATE_TOKEN_COMMON)), // Length
GFXSUBOP_SURFACE_STATE_TOKEN, // InstructionSubOpcode
GFXOP_PIPELINED, // InstructionOpcode
PIPE_3D, // InstructionPipeline
INSTRUCTION_GFX, // InstructionType
1 // Token
},
// DWORD 1
{
0, // SurfaceStateHeapOffset
0 // SurfaceAllocationIndex
},
// DWORD 2
{
0 // SurfaceOffset
},
// DWORD 3
{
0, // RenderTargetEnable
0, // YUVPlane
0 // SurfaceStateType
},
// DWORD 4
{
0 // SurfaceBaseAddress
},
// DWORD 5
{
0 // SurfaceBaseAddress64
},
};
const MHW_PIPE_CONTROL_PARAMS g_cRenderHal_InitPipeControlParams =
{
nullptr, // presDest
0, // dwResourceOffset
0, // dwDataDW1
0, // dwDataDW2
MHW_FLUSH_NONE, // dwFlushMode
MHW_FLUSH_NOWRITE, // dwPostSyncOp
false, // bDisableCSStall
false, // bInvalidateStateCache
false, // bInvalidateConstantCache
false, // bInvalidateVFECache
false, // bInvalidateInstructionCache
true, // bFlushRenderTargetCache
false, // bTlbInvalidate
false, // bInvalidateTextureCache
false, // bGenericMediaStateClear
false, // bIndirectStatePointersDisable
false, // bHdcPipelineFlush
false, // bKernelFenceEnabled
};
extern const RENDERHAL_SURFACE_STATE_ENTRY g_cInitSurfaceStateEntry =
{
RENDERHAL_SURFACE_TYPE_INVALID, // Type
nullptr, // pSurface
nullptr, // pSurfaceState
{ // SurfaceS Token
{}, //DW0
{}, //DW1
{}, //DW2
{}, //DW3
{}, //DW4
{}, //DW5
nullptr, // pResourceInfo
},
-1, // iSurfStateID
0, // dwSurfStateOffset
0, // dwFormat
0, // dwWidth
0, // dwHeight
0, // dwPitch
0, // dwQPitch
0, // YUVPlane
false, // bAVS
false, // bRenderTarget
false, // bVertStride
false, // bVertStrideOffs
false, // bWidthInDword
false, // bTiledSurface
false, // bTileWalk
false, // bHalfPitchChroma
false, // bInterleaveChroma
0, // DirectionV
0, // DirectionU
0, // AddressControl
0, // wUXOffset
0, // wUYOffset
0, // wVXOffset
0, // wVYOffset
0 // stateGfxAddress
};
const MHW_MEDIA_STATE_FLUSH_PARAM g_cRenderHal_InitMediaStateFlushParams =
{
false, // bFlushToGo
0 // ui8InterfaceDescriptorOffset
};
const RENDERHAL_KERNEL_PARAM g_cRenderHal_InitKernelParams =
{
0, // GRF_Count;
0, // BT_Count;
0, // Sampler_Count
0, // Thread_Count
0, // GRF_Start_Register
0, // CURBE_Length
0, // block_width
0, // block_height
0, // blocks_x
0 // blocks_y
};
//!
//! \brief Table only used on HSW (look @ renderhal.c for HSW- table)
//! Constants used for setting up surface states ui8PlaneID,
//! ui8ScaleWidth, ui8ScaleHeight, ui8AlignWidth, ui8AlignHeight,
//! ui8PixelsPerDword, bAdvanced, dwFormat
//!
extern const MHW_SURFACE_PLANES g_cRenderHal_SurfacePlanes[RENDERHAL_PLANES_DEFINITION_COUNT] =
{
// RENDERHAL_PLANES_PL3
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_U_PLANE , 2, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 2, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_NV12
{ 1,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8 }
}
},
// RENDERHAL_PLANES_YUY2
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_NORMAL }
}
},
// RENDERHAL_PLANES_UYVY
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPY }
}
},
// RENDERHAL_PLANES_YVYU
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUV }
}
},
// RENDERHAL_PLANES_VYUY
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUVY }
}
},
// RENDERHAL_PLANES_ARGB
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B8G8R8A8_UNORM }
}
},
// RENDERHAL_PLANES_XRGB
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B8G8R8X8_UNORM }
}
},
// RENDERHAL_PLANES_ABGR
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM }
}
},
// RENDERHAL_PLANES_XBGR
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8X8_UNORM }
}
},
// RENDERHAL_PLANES_RGB16
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B5G6R5_UNORM }
}
},
// RENDERHAL_PLANES_RGB24
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8_UNORM }
}
},
// RENDERHAL_PLANES_R16U
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UINT }
}
},
// RENDERHAL_PLANES_R16S
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_SINT }
}
},
// RENDERHAL_PLANES_R32U
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_UINT }
}
},
// RENDERHAL_PLANES_R32S
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_SINT }
}
},
// RENDERHAL_PLANES_R32F
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_FLOAT }
}
},
// RENDERHAL_PLANES_V8U8
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_SNORM }
}
},
// RENDERHAL_PLANES_R8G8_UNORM
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM }
}
},
// RENDERHAL_PLANES_411P
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_U_PLANE , 4, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 4, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_411R
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_U_PLANE , 1, 4, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 1, 4, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_422H
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_U_PLANE , 2, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 2, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_422V
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_U_PLANE , 1, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 1, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_444P
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_U_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_RGBP
{ 3,
{
{ MHW_U_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_BGRP
{ 3,
{
{ MHW_U_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_AI44_PALLETE_0
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P4A4_UNORM_PALETTE_0 }
}
},
// RENDERHAL_PLANES_IA44_PALLETE_0
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_A4P4_UNORM_PALETTE_0 }
}
},
// RENDERHAL_PLANES_P8_PALLETE_0
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8_UNORM_PALETTE_0 }
}
},
// RENDERHAL_PLANES_A8P8_PALLETE_0
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8A8_UNORM_PALETTE_0 }
}
},
// RENDERHAL_PLANES_AI44_PALLETE_1
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P4A4_UNORM_PALETTE_1 }
}
},
// RENDERHAL_PLANES_IA44_PALLETE_1
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_A4P4_UNORM_PALETTE_1 }
}
},
// RENDERHAL_PLANES_P8_PALLETE_1
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8_UNORM_PALETTE_1 }
}
},
// RENDERHAL_PLANES_A8P8_PALLETE_1
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8A8_UNORM_PALETTE_1 }
}
},
// RENDERHAL_PLANES_AYUV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8B8G8A8_UNORM }
}
},
// RENDERHAL_PLANES_STMM
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM }
}
},
// RENDERHAL_PLANES_L8
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM }
}
},
// RENDERHAL_PLANES_PL3_ADV
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
{ MHW_U_PLANE , 2, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 2, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_NV12_ADV
{ 1,
{
{ MHW_Y_PLANE , 1, 1, 2, 2, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_420_8 }
}
},
// RENDERHAL_PLANES_YUY2_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_NORMAL }
}
},
// RENDERHAL_PLANES_UYVY_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPY }
}
},
// RENDERHAL_PLANES_YVYU_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPUV }
}
},
// RENDERHAL_PLANES_VYUY_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPUVY }
}
},
// RENDERHAL_PLANES_ARGB_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_B8G8R8A8_UNORM }
}
},
// RENDERHAL_PLANES_ABGR_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8G8B8A8_UNORM }
}
},
// RENDERHAL_PLANES_AYUV_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_A8Y8U8V8_UNORM }
}
},
// RENDERHAL_PLANES_STMM_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_STMM_DN_STATISTICS }
}
},
// RENDERHAL_PLANES_L8_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_A8_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_411_8 }
}
},
// RENDERHAL_PLANES_A8
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_A8_UNORM }
}
},
// RENDERHAL_PLANES_R8
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_NV12_2PLANES
{ 2,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_U_PLANE , 2, 2, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM }
}
},
// RENDERHAL_PLANES_NV12_2PLANES_ADV
{ 2,
{
{ MHW_Y_PLANE , 1, 1, 2, 2, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
{ MHW_U_PLANE , 2, 2, 1, 1, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8B8_UNORM }
}
},
// RENDERHAL_PLANES_411P_ADV
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
{ MHW_U_PLANE , 4, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 4, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_411R_ADV
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
{ MHW_U_PLANE , 1, 4, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 1, 4, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_422H_ADV
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
{ MHW_U_PLANE , 2, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 2, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_422V_ADV
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
{ MHW_U_PLANE , 1, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 1, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_444P_ADV
{ 3,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
{ MHW_U_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_RGBP_ADV
{ 3,
{
{ MHW_U_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
{ MHW_V_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_BGRP_ADV
{ 3,
{
{ MHW_U_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_V_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
}
},
// RENDERHAL_PLANES_R16_UNORM
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }
}
},
// RENDERHAL_PLANES_Y8
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_411_8 }
}
},
// RENDERHAL_PLANES_Y1
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, 16 }
}
},
// RENDERHAL_PLANES_Y16U
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_STMM_DN_STATISTICS }
}
},
// RENDERHAL_PLANES_Y16S
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_422_8 }
}
},
// RENDERHAL_PLANES_A16B16G16R16
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM } //setting "PixelsPerDword = 0" for sampler_8x8 use
}
},
// RENDERHAL_PLANES_A16B16G16R16_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16G16B16A16 } //setting "PixelsPerDword = 0" for sampler_8x8 use
}
},
// RENDERHAL_PLANES_R10G10B10A2
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UNORM }
}
},
// RENDERHAL_PLANES_R10G10B10A2_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 1, MHW_MEDIASTATE_SURFACEFORMAT_R10G10B10A2_UNORM }
}
},
// RENDERHAL_PLANES_B10G10R10A2
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B10G10R10A2_UNORM }
}
},
// RENDERHAL_PLANES_L16
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_L16_UNORM }
}
},
// RENDERHAL_PLANES_NV21
{ 2,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_U_PLANE , 2, 2, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM }
}
},
// RENDERHAL_PLANES_YV12
{ 1,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8 }
}
},
// RENDERHAL_PLANES_P016
{ 2,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM },
{ MHW_U_PLANE , 2, 2, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM }
}
},
// RENDERHAL_PLANES_P016_2PLANES_ADV
{ 2,
{
{ MHW_Y_PLANE , 1, 1, 2, 2, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y16_UNORM },
{ MHW_U_PLANE , 2, 2, 2, 2, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16B16_UNORM }
}
},
// RENDERHAL_PLANES_P010
{ 2,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM },
{ MHW_U_PLANE , 2, 2, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM }
}
},
// RENDERHAL_PLANES_P010_1PLANE
{ 1,
{
{ MHW_Y_PLANE , 1, 1, 2, 2, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_16 }
}
},
// RENDERHAL_PLANES_P010_1PLANE_ADV
{ 1,
{
{ MHW_Y_PLANE , 1, 1, 2, 2, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_420_16 }
}
},
// RENDERHAL_PLANES_IRW0
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }
}
},
// RENDERHAL_PLANES_IRW1
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }
}
},
// RENDERHAL_PLANES_IRW2
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }
}
},
// RENDERHAL_PLANES_IRW3
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }
}
},
// RENDERHAL_PLANES_A16B16G16R16F
{1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_FLOAT } //setting "PixelsPerDword = 0" in DP R/W usage, "0" means no need to adjust dwSurfaceWidth. already DWord aligned.
}
},
// RENDERHAL_PLANES_R16G16_UNORM
{1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM }
}
},
// RENDERHAL_PLANES_R16F
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_FLOAT }
}
},
// RENDERHAL_PLANES_A16R16G16B16F
{1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_FLOAT } //setting "PixelsPerDword = 0" in DP R/W usage, "0" means no need to adjust dwSurfaceWidth. already DWord aligned.
}
},
// RENDERHAL_PLANES_YUY2_2PLANES
{ 2,
{
{ MHW_Y_PLANE, 1, 1, 2, 2, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM },
{ MHW_U_PLANE, 2, 1, 2, 2, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM }
}
},
// RENDERHAL_PLANES_Y210_ADV
{ 2,
{
{ MHW_Y_PLANE, 1, 1, 1, 1, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16B16_UNORM },
{ MHW_U_PLANE, 2, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM }
}
},
// RENDERHAL_PLANES_Y210_RT
{ 1,
{
{ MHW_GENERIC_PLANE, 2, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM }
}
},
// RENDERHAL_PLANES_Y210
{ 2,
{
{ MHW_Y_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM },
{ MHW_U_PLANE, 2, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM }
}
},
// RENDERHAL_PLANES_Y210_1PLANE_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16B16_UNORM }
}
},
// RENDERHAL_PLANES_R16G16_SINT
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_SINT }
}
},
// RENDERHAL_PLANES_R24_UNORM_X8_TYPELESS
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R24_UNORM_X8_TYPELESS }
}
},
// RENDERHAL_PLANES_R32_FLOAT_X8X24_TYPELESS
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_FLOAT_X8X24_TYPELESS }
}
},
// RENDERHAL_PLANES_P208
{ 2,
{
{ MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
{ MHW_U_PLANE , 2, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM }
}
},
// RENDERHAL_PLANES_P208_1PLANE_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_NORMAL }
}
},
// RENDERHAL_PLANES_Y416_RT
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM }
}
},
// RENDERHAL_PLANES_R32G32B32A32
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_FLOAT }
}
},
//RENDERHAL_PLANES_Y8_ADV
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM }
}
},
//RENDERHAL_PLANES_G32R32F
{ 1,
{
{ MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM }
}
},
//RENDERHAL_PLANES_NV12_2PLANES_COMBINED Combine 2 Luma Channel pixels into 1 pixel, so that kernel can reduce write times
{
2,
{
{MHW_Y_PLANE, 2, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM},
{MHW_U_PLANE, 2, 2, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM}
}
},
//RENDERHAL_PLANES_P016_2PLANES_COMBINED Combine 2 Luma Channel pixels into 1 pixel, so that kernel can reduce write times
{
2,
{
{MHW_Y_PLANE, 2, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM},
{MHW_U_PLANE, 2, 2, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM}
}
},
// RENDERHAL_PLANES_YUY2_2PLANES_WIDTH_UNALIGNED
{ 2,
{
{ MHW_Y_PLANE, 1, 1, 2, 2, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM },
{ MHW_U_PLANE, 2, 1, 1, 2, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM }
}
},
};
//!
//! \brief Get Align Unit
//! \details Set HW alignment Unit
//! \param uint16_t *pwWidthAlignUnit
//! [out] Width Align Unit
//! \param uint16_t *pwHeightAlignUnit
//! [out] Height Align Unit
//! \param PRENDERHAL_SURFACE pRenderHalSurface
//! [in] Pointer to Surface
//! \return void
//!
void RenderHal_GetAlignUnit(
uint16_t *pwWidthAlignUnit,
uint16_t *pwHeightAlignUnit,
PRENDERHAL_SURFACE pRenderHalSurface)
{
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHalSurface);
switch (pRenderHalSurface->OsSurface.Format)
{
case Format_YUY2:
case Format_UYVY:
case Format_YVYU:
case Format_VYUY:
case Format_P208:
*pwWidthAlignUnit = 1;
// Height alignment should be 1 but is currently set to 2 because
// of an issue in AVS scaling.
*pwHeightAlignUnit = 2;
break;
default:
*pwWidthAlignUnit = 1;
*pwHeightAlignUnit = 1;
break;
}
// For deinterlace messages, the width must be a multiple of 8.
if (pRenderHalSurface->bDeinterlaceEnable)
{
*pwWidthAlignUnit = 8;
}
}
//!
//! \brief Adjust Boundary
//! \details Adjust the height and width of the surface based on Boundary
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface
//! \param PRENDERHAL_SURFACE pRenderHalSurface
//! [in] Pointer to Input Surface
//! \param RENDERHAL_SS_BOUNDARY Boundary
//! [in] How the adjustment needs to be done
//! \param uint32_t *pdwSurfaceWidth
//! [out] Adjusted surface width
//! \param uint32_t *pdwSurfaceHeight
//! [out] Adjusted surface height
//! \return void
//!
void RenderHal_AdjustBoundary(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface,
RENDERHAL_SS_BOUNDARY Boundary,
uint32_t *pdwSurfaceWidth,
uint32_t *pdwSurfaceHeight)
{
uint16_t wWidthAlignUnit;
uint16_t wHeightAlignUnit;
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHalSurface);
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pdwSurfaceWidth);
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pdwSurfaceHeight);
PMOS_SURFACE pSurface = &(pRenderHalSurface->OsSurface);
pRenderHal->pfnGetAlignUnit(&wWidthAlignUnit, &wHeightAlignUnit, pRenderHalSurface);
switch (Boundary)
{
case RENDERHAL_SS_BOUNDARY_SRCRECT:
*pdwSurfaceHeight = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwHeight, (uint32_t)pRenderHalSurface->rcSrc.bottom), wHeightAlignUnit);
*pdwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcSrc.right), wWidthAlignUnit);
break;
case RENDERHAL_SS_BOUNDARY_DSTRECT:
*pdwSurfaceHeight = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwHeight, (uint32_t)pRenderHalSurface->rcDst.bottom), wHeightAlignUnit);
*pdwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcDst.right), wWidthAlignUnit);
break;
// align with max src rect
case RENDERHAL_SS_BOUNDARY_MAXSRCRECT:
*pdwSurfaceHeight = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwHeight, (uint32_t)pRenderHalSurface->rcMaxSrc.bottom), wHeightAlignUnit);
*pdwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcMaxSrc.right), wWidthAlignUnit);
break;
case RENDERHAL_SS_BOUNDARY_ORIGINAL:
default:
*pdwSurfaceHeight = (pRenderHalSurface->dwHeightInUse == 0) ? MOS_ALIGN_CEIL(pSurface->dwHeight, wHeightAlignUnit) : pRenderHalSurface->dwHeightInUse;
*pdwSurfaceWidth = (pRenderHalSurface->dwWidthInUse == 0) ? MOS_ALIGN_CEIL(pSurface->dwWidth, wWidthAlignUnit) : pRenderHalSurface->dwWidthInUse;
break;
}
}
//!
//! \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)
{
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pdwPixelsPerSampleUV);
*pdwPixelsPerSampleUV = 0;
switch (format)
{
CASE_PL3_FORMAT:
CASE_PL3_RGB_FORMAT:
*pdwPixelsPerSampleUV = 4; // 4 U/V pixels per dataport sample (uint32_t)
break;
// Y and UV surfaces have different formats
CASE_PL2_FORMAT:
case Format_400P:
*pdwPixelsPerSampleUV = 2; // 2 UV pixels per dataport sample (uint32_t)
break;
default:
*pdwPixelsPerSampleUV = 1;
MHW_RENDERHAL_ASSERTMESSAGE("Incorrect Filter Format.");
break;
}
}
//!
//! \brief Allocate GSH, SSH, ISH control structures and heaps
//! \details Allocates State Heap control structure (system memory)
//! and associated State Buffer in gfx/sys memory (GSH,ISH,SSH)
//! initializes the State Heap control structure and state buffers
/*-----------------------------------------------------------------------------
|
| GSH ORGANIZATION (GSH block in GFX memory)
|
| |===========================================|
| | SYNC/PERF TAGS (SY) |
| |-------------------------------------------|
| | |
| | MEDIA STATE [0] (MS) |
| | |
| |-------------------------------------------|
| | |
| | ... |
| | |
| |-------------------------------------------|
| | |
| | MEDIA STATE [Q-1] |
| | |
| |-------------------------------------------|
| | |
| | KERNEL SPILL AREA |
| | |
| |===========================================|
| where SY = (sSettings.iSyncSize) bytes
| MS = Media state heap entry shown below.
| Q = (sSettings.iMediaStateHeaps) Media States
|
| ISH ORGANIZATION (ISH block in GFX memory)
| ~~~~~~~~~~~~~~~~~~~~~~~~
|
| |===========================================|
| | | | | | | | | | | | |
| |---+---+---+---+---+---+---+---+---+---+---|
| | | | | | | | | | | | |
| |---+---+-- --+---+---|
| | KERNEL HEAP (KH) |
| |---+---+-- --+---+---|
| | | | | | | | | | | | |
| |---+---+---+---+---+---+---+---+---+---+---|
| | | | | | | | | | | | |
| |-------------------------------------------|
| | |
| | SYSTEM ROUTINE (SIP Kernel) |
| | |
| |===========================================|
| where KH = (sSettings.iKernelHeapSize) bytes in allocation
| blocks of (sSettings.iKernelBlockSize) bytes
|
| MEDIA STATE ORGANIZATION (Media States in GFX memory)
| ~~~~~~~~~~~~~~~~~~~~~~~~
| (Gen6, Gen7, Gen75 Layout)
| |================================================|
| | |
| | CURBE DATA (C) |
| | |
| |------------------------------------------------|
| | SAMPLER STATES [0] to [S-1] - for ID[0] |
| | . |
| | . |
| | SAMPLER STATES [0] to [S-1] - for ID[M-1] |
| |------------------------------------------------|
| | SAMPLER 8x8 TABLE [0] |
| | . |
| | SAMPLER 8x8 TABLE [AS-1] |
| |------------------------------------------------|
| | MEDIA INTERFACE DESCRIPTOR [0] |
| | . |
| | . |
| | MEDIA INTERFACE DESCRIPTOR [M-1] |
| |------------------------------------------------|
| | Kernel Execution start time (8 Bytes) |
| |------------------------------------------------|
| | Kernel Execution end time (8 Bytes) |
| |------------------------------------------------|
| | Component ID (4 Bytes) |
| |------------------------------------------------|
| | Reserved (44 Bytes) |
| |================================================|
|
| (Gen8+ Layout)
| |================================================|
| | |
| | CURBE DATA (C) |
| | |
| |------------------------------------------------|
| | SAMPLER STATES [0] to [S-1] |
| | VA SAMPLER 8x8 STATE [0] to [VA-1] | ID[0]
| | AVS SAMPLER 8x8 STATE [0] to [AS-1] |
| |------------------------------------------------|
| | . |
| | . |
| | . |
| |------------------------------------------------|
| | SAMPLER STATES [0] to [S-1] | ID[M-1]
| | VA SAMPLER 8x8 STATE [0] to [VA-1] |
| | AVS SAMPLER 8x8 STATE [0] to [AS-1] |
| |------------------------------------------------|
| | MEDIA INTERFACE DESCRIPTOR [0] |
| | . |
| | . |
| | MEDIA INTERFACE DESCRIPTOR [M-1] |
| |------------------------------------------------|
| | Kernel Execution start time (8 Bytes) |
| |------------------------------------------------|
| | Kernel Execution end time (8 Bytes) |
| |------------------------------------------------|
| | Component ID (4 Bytes) |
| |------------------------------------------------|
| | Reserved (44 Bytes) |
| |================================================|
|
| where C = (sSettings.iCurbeSize) bytes for static parameters
| S = (sSettings.iSamplers) samplers per Media ID
| AS = (sSettings.iSamplersAVS) advanced sampler 8x8 tables (preGen8)
| AS = (sSettings.iSamplersAVS) advanced sampler 8x8 states (Gen8+)
| VA = (sSettings.iSamplersVA) video analytics sampler
| M = (sSettings.iMediaIDs) Media Interface Descriptors (ID)
|
|
| STATE HEAP CONTROL STRUCTURE ORGANIZATION (in system memory)
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| |===========================================|
| | RENDERHAL_STATE_HEAP STRUCTURE |
| | |
| +---------| pSshBuffer |
| | |-------------------------------------------|
| | | Kernel Allocation [0] |
| | | . |
| | | . |
| | | Kernel Allocation [K-1] |
| | |-------------------------------------------|
| | | Media State Control Structure [0] |--+
| | | Media State Control Structure [1] |--|--+
| | | . | | |
| | | . | | |
| | | Media State Control Structure [Q-1] |--|--|--+
| | |-------------------------------------------| | | |
| | | KAID[0] to KAID[M-1] for Media State[0] |<-+ | |
| | | KAID[0] to KAID[M-1] for Media State[1] |<----+ |
| | | . | |
| | | . | |
| | | KAID[0] to KAID[M-1] for Media State[Q-1] |<-------+
| | |-------------------------------------------|
| | +------| SurfStateEntry[0] |
| | | | . |
| | | | . |
| | | +---| SurfStateEntry[P-1] |
| | | | |===========================================|
| | | |
| | | | SSH BUFFER for HW (or SW) - or IndirectBuffer
| +--|--|-->|==============================| <-- iBindingTableOffset = 0
| | | | BI[0] ...... BI[T-1] | <- BT[0] (iBindingTableSize)
| | | | BI[0] ...... BI[T-1] | <- BT[1]
| | | | . |
| | | | BI[0] ...... BI[T-1] | <- BT[N-1]
| | | |------------------------------| <-- iSurfaceStateOffset
| +--|-->| SurfState[0] |
| | | . |
| | | . |
| +-->| SurfState[P-1] |
| |==============================|
|
| where K = (sSettings.iKernelCount) Kernel Allocation Entries
| Q = (sSettings.iMediaStateHeaps) Media States
| M = (sSettings.iMediaIDs) Media Interface Descriptors (ID)
| P = (sSettings.iSurfaceStates) Surface States
| T = (sSettings.iSurfacesPerBT) Binding Index entries per Binding Table
| N = (sSettings.iBindingTables) Binding Tables
|
| BT = Binding Table (Each Binding Table contains M Binding Indices)
| BI = Binding Index
|
| KAID => Kernel Allocation ID - each value determines the kernel
| allocation entry in StateHeap (0 to sSettings.iKernelCount - 1)
|
|-----------------------------------------------------------------------------*/
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Rendering Interface Structure
//! \param PRENDERHAL_STATE_HEAP_SETTINGS pSettings
//! [in] Pointer to state heap settings (GSH/SSH/ISH)
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if state heaps were successfully allocated and initialized
//! others if bad parameters or allocation failed
//!
MOS_STATUS RenderHal_AllocateStateHeaps(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_STATE_HEAP_SETTINGS pSettings)
{
MHW_STATE_HEAP_SETTINGS MhwStateHeapSettings;
PMHW_RENDER_STATE_SIZES pHwSizes;
PRENDERHAL_STATE_HEAP pStateHeap;
int32_t *pAllocations;
uint32_t dwSizeAlloc;
uint32_t dwSizeGSH;
uint32_t dwSizeSSH;
uint32_t dwSizeISH;
uint32_t dwSizeMediaState;
PMHW_STATE_HEAP pDshHeap;
PMHW_STATE_HEAP pIshHeap;
int32_t i;
uint8_t *ptr;
uint8_t *ptrMediaState = nullptr;
MOS_STATUS eStatus;
size_t mediaStateSize = 0;
size_t stateHeapSize = 0;
// Initialize locals
eStatus = MOS_STATUS_UNKNOWN;
pStateHeap = nullptr;
//---------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes);
MHW_RENDERHAL_CHK_NULL_RETURN(pSettings);
// verify GSH parameters and alignments
MHW_RENDERHAL_ASSERT((pSettings->iSyncSize % RENDERHAL_SYNC_BLOCK_ALIGN) == 0);
MHW_RENDERHAL_ASSERT((pSettings->iCurbeSize % RENDERHAL_URB_BLOCK_ALIGN) == 0);
MHW_RENDERHAL_ASSERT((pSettings->iKernelHeapSize % RENDERHAL_KERNEL_BLOCK_ALIGN) == 0);
MHW_RENDERHAL_ASSERT((pSettings->iKernelBlockSize % RENDERHAL_KERNEL_BLOCK_ALIGN) == 0);
// verify SSH parameters
MHW_RENDERHAL_ASSERT(pSettings->iBindingTables >= RENDERHAL_SSH_BINDING_TABLES_MIN);
MHW_RENDERHAL_ASSERT(pSettings->iBindingTables <= RENDERHAL_SSH_BINDING_TABLES_MAX);
MHW_RENDERHAL_ASSERT(pSettings->iSurfaceStates >= RENDERHAL_SSH_SURFACE_STATES_MIN);
MHW_RENDERHAL_ASSERT(pSettings->iSurfaceStates <= RENDERHAL_SSH_SURFACE_STATES_MAX);
MHW_RENDERHAL_ASSERT(pSettings->iSurfacesPerBT >= RENDERHAL_SSH_SURFACES_PER_BT_MIN);
MHW_RENDERHAL_ASSERT(pSettings->iSurfacesPerBT <= RENDERHAL_SSH_SURFACES_PER_BT_MAX);
//---------------------------------------
pHwSizes = pRenderHal->pHwSizes;
mediaStateSize = pRenderHal->pRenderHalPltInterface->GetRenderHalMediaStateSize();
stateHeapSize = pRenderHal->pRenderHalPltInterface->GetRenderHalStateHeapSize();
//---------------------------------------
// Setup General State Heap
//---------------------------------------
// Calculate size of State Heap control structure
dwSizeAlloc = MOS_ALIGN_CEIL(stateHeapSize, 16);
dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iKernelCount * sizeof(RENDERHAL_KRN_ALLOCATION) , 16);
dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * mediaStateSize, 16);
dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * pSettings->iMediaIDs * sizeof(int32_t) , 16);
dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iSurfaceStates * sizeof(RENDERHAL_SURFACE_STATE_ENTRY), 16);
// Allocate State Heap control structure (aligned)
pRenderHal->pStateHeap = pStateHeap = (PRENDERHAL_STATE_HEAP)MOS_AlignedAllocMemory(dwSizeAlloc, 16);
pRenderHal->dwStateHeapSize = dwSizeAlloc;
MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap);
MOS_ZeroMemory(pStateHeap, dwSizeAlloc);
//-------------------------------------------------------------------------
// Reset resource allocations
//-------------------------------------------------------------------------
pRenderHal->pOsInterface->pfnResetResource(&pStateHeap->GshOsResource);
pStateHeap->bGshLocked = false;
pStateHeap->pGshBuffer = nullptr;
pRenderHal->pOsInterface->pfnResetResource(&pStateHeap->SshOsResource);
pStateHeap->pSshBuffer = nullptr;
pStateHeap->bSshLocked = false;
pRenderHal->pOsInterface->pfnResetResource(&pStateHeap->IshOsResource);
pStateHeap->bIshLocked = false;
pStateHeap->pIshBuffer = nullptr;
//-------------------------------------------------------------------------
// Setup State Heap control structures
//-------------------------------------------------------------------------
// Skip RENDERHAL_STATE_HEAP structure
ptr = (uint8_t*)pStateHeap;
ptr += MOS_ALIGN_CEIL(stateHeapSize, 16);
// Pointer to Kernel allocations
pStateHeap->pKernelAllocation = (PRENDERHAL_KRN_ALLOCATION) ptr;
ptr += MOS_ALIGN_CEIL(pSettings->iKernelCount * sizeof(RENDERHAL_KRN_ALLOCATION), 16);
// Pointer to Media State allocations
pStateHeap->pMediaStates = (PRENDERHAL_MEDIA_STATE) ptr;
ptr += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * mediaStateSize, 16);
// Pointer to Media ID allocations
pAllocations = (int32_t*) ptr;
ptr += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * pSettings->iMediaIDs * sizeof(int32_t), 16);
// Pointer to Surface State allocations
pStateHeap->pSurfaceEntry = (PRENDERHAL_SURFACE_STATE_ENTRY) ptr;
//-------------------------------------------------------------------------
// Calculate offsets/sizes in GSH
//-------------------------------------------------------------------------
// Synchronization, debugging data
pStateHeap->dwOffsetSync = 0;
pStateHeap->dwSizeSync = pSettings->iSyncSize;
pStateHeap->dwNextTag = 0;
pStateHeap->dwSyncTag = 0;
dwSizeGSH = pStateHeap->dwSizeSync;
// Align Media State base
dwSizeGSH = MOS_ALIGN_CEIL(dwSizeGSH, MHW_MEDIA_STATE_ALIGN);
dwSizeMediaState = 0;
// Reset current media state
pStateHeap->iCurMediaState = 0;
pStateHeap->iNextMediaState = 0;
// Constant URBs
pStateHeap->dwOffsetCurbe = dwSizeMediaState;
pStateHeap->dwSizeCurbe = pSettings->iCurbeSize;
dwSizeMediaState += pStateHeap->dwSizeCurbe;
// Allocate Samplers
if (pRenderHal->bHasCombinedAVSSamplerState == false)
{
// Sampler states
pStateHeap->dwOffsetSampler = dwSizeMediaState;
pStateHeap->dwSizeSampler = MOS_ALIGN_CEIL(pSettings->iSamplers * pHwSizes->dwSizeSamplerState, MHW_SAMPLER_STATE_ALIGN);
pStateHeap->dwSizeSamplers = pStateHeap->dwSizeSampler;
dwSizeMediaState += pSettings->iMediaIDs * pStateHeap->dwSizeSamplers;
// Sampler 8x8 State table is allocated in this area
pStateHeap->dwOffsetSampler8x8Table = dwSizeMediaState;
pStateHeap->dwSizeSampler8x8Table = MOS_ALIGN_CEIL(pHwSizes->dwSizeSamplerStateTable8x8, MHW_SAMPLER_STATE_ALIGN);
dwSizeMediaState += pSettings->iSamplersAVS * pHwSizes->dwSizeSampler8x8Table;
}
else
{
// Sampler states - Start of this area to be aligned on MHW_SAMPLER_STATE_ALIGN byte boundary
uint32_t dwOffsetSamplers = dwSizeMediaState;
pStateHeap->dwOffsetSampler = dwSizeMediaState;
pStateHeap->dwSizeSampler = MOS_ALIGN_CEIL(pSettings->iSamplers * pHwSizes->dwSizeSamplerState, MHW_SAMPLER_STATE_ALIGN);
dwSizeMediaState += pStateHeap->dwSizeSampler;
// Sampler for MinMax, Erode and Dilate - Start of this area to be aligned on MHW_SAMPLER_STATE_VA_ALIGN byte boundary
pStateHeap->dwOffsetSamplerVA = dwSizeMediaState;
pStateHeap->dwSizeSamplerVA = MOS_ALIGN_CEIL(pSettings->iSamplersVA * pHwSizes->dwSizeSamplerStateVA, MHW_SAMPLER_STATE_VA_ALIGN);
dwSizeMediaState += pStateHeap->dwSizeSamplerVA;
// Sampler for AVS - Start of this area to be aligned on 64 byte boundary
if(GFX_IS_GEN_9_OR_LATER(pRenderHal->Platform))
{
// AVS state should begin on MHW_SAMPLER_STATE_AVS_ALIGN_G9 byte boundary in g9+
dwSizeMediaState = MOS_ALIGN_CEIL((dwSizeMediaState - pStateHeap->dwSizeCurbe), MHW_SAMPLER_STATE_AVS_ALIGN_G9) + pStateHeap->dwSizeCurbe;
}
pStateHeap->dwOffsetSamplerAVS = dwSizeMediaState;
pStateHeap->dwSizeSamplerAVS = MOS_ALIGN_CEIL(pSettings->iSamplersAVS *
pHwSizes->dwSizeSamplerStateAvs, MHW_SAMPLER_STATE_AVS_ALIGN);
dwSizeMediaState += pStateHeap->dwSizeSamplerAVS;
// Sampler Indirect State
pStateHeap->dwOffsetSamplerIndirect = dwSizeMediaState;
pStateHeap->dwSizeSamplerIndirect = MOS_ALIGN_CEIL(pSettings->iSamplers * pHwSizes->dwSizeSamplerIndirectState, MHW_SAMPLER_STATE_ALIGN);
dwSizeMediaState += pStateHeap->dwSizeSamplerIndirect;
// Get the total size of all the samplers
pStateHeap->dwSizeSamplers = MOS_ALIGN_CEIL((dwSizeMediaState - dwOffsetSamplers), MHW_SAMPLER_STATE_ALIGN);
dwSizeMediaState += pSettings->iMediaIDs * pStateHeap->dwSizeSamplers;
// Sampler 8x8 State table is part of Sampler8x8 state
pStateHeap->dwOffsetSampler8x8Table = 0;
pStateHeap->dwSizeSampler8x8Table = pHwSizes->dwSizeSamplerStateTable8x8;
}
// Interface Descriptors
pStateHeap->dwOffsetMediaID = dwSizeMediaState;
pStateHeap->dwSizeMediaID = pHwSizes->dwSizeInterfaceDescriptor;
dwSizeMediaState += pSettings->iMediaIDs * pStateHeap->dwSizeMediaID;
// 3P Budget
pStateHeap->dwOffsetStartTime = dwSizeMediaState;
pStateHeap->dwStartTimeSize = sizeof(uint64_t);
dwSizeMediaState += pStateHeap->dwStartTimeSize;
pStateHeap->dwOffsetEndTime = dwSizeMediaState;
pStateHeap->dwEndTimeSize = sizeof(uint64_t);
dwSizeMediaState += pStateHeap->dwEndTimeSize;
pStateHeap->dwOffsetComponentID = dwSizeMediaState;
pStateHeap->dwComponentIDSize = sizeof(uint32_t);
dwSizeMediaState += pStateHeap->dwComponentIDSize;
pStateHeap->dwOffsetReserved = dwSizeMediaState;
pStateHeap->dwReservedSize = 44; // 64 - 2 * sizeof(uint64_t) - sizeof(uint32_t);
dwSizeMediaState += pStateHeap->dwReservedSize;
// Ensure correct alignment of consecutive Media States
if(GFX_IS_GEN_9_OR_LATER(pRenderHal->Platform))
{
dwSizeMediaState = MOS_ALIGN_CEIL(dwSizeMediaState, MHW_SAMPLER_STATE_AVS_ALIGN_G9);
}
else
{
dwSizeMediaState = MOS_ALIGN_CEIL(dwSizeMediaState, MHW_SAMPLER_STATE_AVS_ALIGN);
}
// Create multiple instances of Media state heaps for Dynamic GSH
ptrMediaState = (uint8_t*)pStateHeap->pMediaStates;
for (i = 0; i < pSettings->iMediaStateHeaps; i++)
{
PRENDERHAL_MEDIA_STATE pStat = (PRENDERHAL_MEDIA_STATE)ptrMediaState;
pStat->dwOffset = dwSizeGSH;
pStat->piAllocation = pAllocations;
dwSizeGSH += dwSizeMediaState;
pAllocations += pSettings->iMediaIDs;
// Pointer moves to next MEDIA STATE position
ptrMediaState += mediaStateSize;
}
// Kernel Spill Area
if (pSettings->iPerThreadScratchSize > 0)
{
// Scratch Space Base Pointer. Specifies the MHW_SCRATCH_SPACE_ALIGN
// aligned address offset to scratch space for use by the kernel.
// This pointer is relative to the General State Base Address.
dwSizeGSH = MOS_ALIGN_CEIL(dwSizeGSH, MHW_SCRATCH_SPACE_ALIGN);
MHW_RENDERHAL_ASSERT(pSettings->iPerThreadScratchSize ==
MOS_ALIGN_CEIL(pSettings->iPerThreadScratchSize, MHW_SCRATCH_SPACE_ALIGN));
pStateHeap->dwScratchSpaceSize = pRenderHal->pfnGetScratchSpaceSize(pRenderHal, pSettings->iPerThreadScratchSize);
pStateHeap->dwScratchSpaceBase = dwSizeGSH;
dwSizeGSH += pStateHeap->dwScratchSpaceSize;
}
pStateHeap->dwSizeGSH = dwSizeGSH;
pStateHeap->dwSizeMediaState = dwSizeMediaState;
//----------------------------------
// Instruction State Heap (Kernel Heap)
//----------------------------------
pStateHeap->dwKernelBase = 0;
dwSizeISH = MOS_ALIGN_CEIL(pSettings->iKernelHeapSize, RENDERHAL_KERNEL_BLOCK_ALIGN);
// System Routine Area, always loaded for Cm
// Don't put the allocation under bIsaAsmDebugEnable
pStateHeap->dwSipBase = dwSizeISH;
pRenderHal->SipStateParams.bSipKernel = false;
pRenderHal->SipStateParams.dwSipBase = dwSizeISH;
dwSizeISH += MOS_ALIGN_CEIL(pSettings->iSipSize, RENDERHAL_KERNEL_BLOCK_ALIGN);
pStateHeap->dwSizeISH = dwSizeISH;
//----------------------------------
// Surface State Heap
//----------------------------------
// Reset initial SSH allocations
pStateHeap->iCurSshBufferIndex = 0;
pStateHeap->iCurrentBindingTable = 0;
pStateHeap->iCurrentSurfaceState = 0;
if (pRenderHal->isBindlessHeapInUse == false)
{
// Set BT sizes
pStateHeap->iBindingTableSize = MOS_ALIGN_CEIL(pSettings->iSurfacesPerBT * pHwSizes->dwSizeBindingTableState,
pSettings->iBTAlignment);
// Set offsets to BT and SS entries
pStateHeap->iBindingTableOffset = 0;
pStateHeap->iSurfaceStateOffset = pSettings->iBindingTables * pStateHeap->iBindingTableSize;
// Calculate size of a single SSH instance and total SSH buffer size
dwSizeSSH = pStateHeap->iSurfaceStateOffset +
pSettings->iSurfaceStates * pRenderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize();
pStateHeap->dwSshIntanceSize = dwSizeSSH;
pRenderHal->dwIndirectHeapSize = MOS_ALIGN_CEIL(dwSizeSSH, MHW_PAGE_SIZE);
// Allocate SSH buffer in system memory, not Gfx
pStateHeap->dwSizeSSH = dwSizeSSH; // Single SSH instance
pStateHeap->pSshBuffer = (uint8_t *)MOS_AllocAndZeroMemory(dwSizeSSH);
}
else
{
if (!pStateHeap->surfaceStateMgr)
{
pStateHeap->surfaceStateMgr = MOS_New(SurfaceStateHeapManager, pRenderHal->pOsInterface);
if (pStateHeap->surfaceStateMgr == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("Fail to Allocate SSH manager.");
// Free State Heap control structure
MOS_AlignedFreeMemory(pStateHeap);
pRenderHal->pStateHeap = nullptr;
return MOS_STATUS_NULL_POINTER;
}
eStatus = pStateHeap->surfaceStateMgr->CreateHeap(pRenderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize());
if (eStatus != MOS_STATUS_SUCCESS)
{
MHW_RENDERHAL_ASSERTMESSAGE("Fail to Allocate SSH manager.");
MHW_RENDERHAL_CHK_STATUS_RETURN(pStateHeap->surfaceStateMgr->DestroyHeap());
// Free State Heap control structure
MOS_AlignedFreeMemory(pStateHeap);
pRenderHal->pStateHeap = nullptr;
return eStatus;
}
pStateHeap->iCurrentSurfaceState = pStateHeap->surfaceStateMgr->m_surfStateHeap->uiCurState;
}
}
do
{
if (pStateHeap->dwSizeSSH > 0 && !pStateHeap->pSshBuffer)
{
MHW_RENDERHAL_ASSERTMESSAGE("Fail to Allocate SSH buffer.");
eStatus = MOS_STATUS_NO_SPACE;
break;
}
pStateHeap->bSshLocked = true;
//----------------------------------
// Allocate State Heap in MHW
//----------------------------------
MOS_ZeroMemory(&MhwStateHeapSettings, sizeof(MhwStateHeapSettings));
MhwStateHeapSettings.dwDshSize = pStateHeap->dwSizeGSH;
MhwStateHeapSettings.dwIshSize = pStateHeap->dwSizeISH;
MhwStateHeapSettings.dwNumSyncTags = pStateHeap->dwSizeSync;
MhwStateHeapSettings.m_heapUsageType = pSettings->heapUsageType;
if (pRenderHal->pRenderHalPltInterface->AllocateHeaps(pRenderHal, MhwStateHeapSettings) != MOS_STATUS_SUCCESS)
{
break;
}
if (pRenderHal->pRenderHalPltInterface->GetStateHeapInterface(pRenderHal)==nullptr)
{
break;
}
pDshHeap = pRenderHal->pMhwStateHeap->GetDSHPointer();
if (pRenderHal->pMhwStateHeap->GetDynamicMode() == MHW_RENDER_HAL_MODE)
{
while (pDshHeap->pNext != nullptr)
{
pDshHeap = pDshHeap->pNext;
}
}
if (pRenderHal->pMhwStateHeap->LockStateHeap(pDshHeap) != MOS_STATUS_SUCCESS)
{
break;
}
pStateHeap->GshOsResource = pDshHeap->resHeap;
pStateHeap->pGshBuffer = (uint8_t *)pDshHeap->pvLockedHeap;
pStateHeap->bGshLocked = true;
pIshHeap = pRenderHal->pMhwStateHeap->GetISHPointer();
if (pRenderHal->pMhwStateHeap->GetDynamicMode() == MHW_RENDER_HAL_MODE)
{
while (pIshHeap->pNext != nullptr)
{
pIshHeap = pIshHeap->pNext;
}
}
if (pRenderHal->pMhwStateHeap->LockStateHeap(pIshHeap) != MOS_STATUS_SUCCESS)
{
break;
}
pStateHeap->IshOsResource = pIshHeap->resHeap;
pStateHeap->pIshBuffer = (uint8_t *)pIshHeap->pvLockedHeap;
pStateHeap->bIshLocked = true;
//-----------------------------
// Heap initialization
//-----------------------------
// Reset GSH contents until scratch space (excluding)
MOS_ZeroMemory(pStateHeap->pGshBuffer, pStateHeap->dwScratchSpaceBase);
// Setup pointer to sync tags
pStateHeap->pSync = (uint32_t *)(pStateHeap->pGshBuffer + pStateHeap->dwOffsetSync);
// Reset kernel allocations
pRenderHal->pfnResetKernels(pRenderHal);
eStatus = MOS_STATUS_SUCCESS;
} while (false);
if (eStatus != MOS_STATUS_SUCCESS)
{
if (pStateHeap)
{
// Free SSH buffer
if (pStateHeap->pSshBuffer)
{
MOS_FreeMemory(pStateHeap->pSshBuffer);
}
// Free State Heap control structure
MOS_AlignedFreeMemory(pStateHeap);
pRenderHal->pStateHeap = nullptr;
}
}
return eStatus;
}
MOS_STATUS RenderHal_ReAllocateStateHeapsforAdvFeatureWithSshEnlarged(
PRENDERHAL_INTERFACE pRenderHal,
bool &bAllocated)
{
PMOS_INTERFACE pOsInterface = nullptr;
PRENDERHAL_STATE_HEAP pStateHeap = nullptr;
PRENDERHAL_STATE_HEAP pOldStateHeap = nullptr;
uint8_t *ptr = nullptr;
int32_t *pAllocations = nullptr;
PRENDERHAL_STATE_HEAP_SETTINGS pSettings = nullptr;
uint8_t *ptrMediaState = nullptr;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
PMHW_RENDER_STATE_SIZES pHwSizes = {};
uint32_t dwSizeAlloc = 0;
uint32_t dwSizeSSH = 0;
int32_t i = 0;
uint32_t dwSizeGSH = 0;
uint32_t dwSizeMediaState = 0;
size_t mediaStateSize = 0;
size_t stateHeapSize = 0;
//------------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
pSettings = &pRenderHal->StateHeapSettings;
bAllocated = false;
//------------------------------------------------
if (pRenderHal->pStateHeap == nullptr)
{
return MOS_STATUS_SUCCESS;
}
if ((pSettings->iBindingTables == pRenderHal->enlargeStateHeapSettingsForAdv.iBindingTables) &&
(pSettings->iSurfaceStates == pRenderHal->enlargeStateHeapSettingsForAdv.iSurfaceStates) &&
(pSettings->iSurfacesPerBT == pRenderHal->enlargeStateHeapSettingsForAdv.iSurfacesPerBT))
{
return MOS_STATUS_SUCCESS;
}
pOsInterface = pRenderHal->pOsInterface;
pOldStateHeap = pRenderHal->pStateHeap;
pHwSizes = pRenderHal->pHwSizes;
// Free SSH Resource
if (pOldStateHeap->pSshBuffer)
{
MOS_FreeMemory(pOldStateHeap->pSshBuffer);
pOldStateHeap->pSshBuffer = nullptr;
}
// Free MOS surface in surface state entry
for (int32_t index = 0; index < pSettings->iSurfaceStates; ++index)
{
PRENDERHAL_SURFACE_STATE_ENTRY entry = pOldStateHeap->pSurfaceEntry + index;
MOS_SafeFreeMemory(entry->pSurface);
entry->pSurface = nullptr;
}
// Enlarge the binding table size and surface state size
pSettings->iBindingTables = pRenderHal->enlargeStateHeapSettingsForAdv.iBindingTables;
pSettings->iSurfaceStates = pRenderHal->enlargeStateHeapSettingsForAdv.iSurfaceStates;
pSettings->iSurfacesPerBT = pRenderHal->enlargeStateHeapSettingsForAdv.iSurfacesPerBT;
mediaStateSize = pRenderHal->pRenderHalPltInterface->GetRenderHalMediaStateSize();
stateHeapSize = pRenderHal->pRenderHalPltInterface->GetRenderHalStateHeapSize();
//---------------------------------------
// Setup General State Heap
//---------------------------------------
// Calculate size of State Heap control structure
dwSizeAlloc = MOS_ALIGN_CEIL(stateHeapSize , 16);
dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iKernelCount * sizeof(RENDERHAL_KRN_ALLOCATION) , 16);
dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * mediaStateSize , 16);
dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * pSettings->iMediaIDs * sizeof(int32_t) , 16);
dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iSurfaceStates * sizeof(RENDERHAL_SURFACE_STATE_ENTRY), 16);
// Allocate State Heap control structure (aligned)
pStateHeap = (PRENDERHAL_STATE_HEAP)MOS_AlignedAllocMemory(dwSizeAlloc, 16);
pRenderHal->dwStateHeapSize = dwSizeAlloc;
MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap);
MOS_ZeroMemory(pStateHeap, dwSizeAlloc);
MOS_SecureMemcpy(pStateHeap, dwSizeAlloc, pOldStateHeap, dwSizeAlloc - MOS_ALIGN_CEIL(pSettings->iSurfaceStates * sizeof(RENDERHAL_SURFACE_STATE_ENTRY), 16));
// Update the State Heap
pRenderHal->pStateHeap = pStateHeap;
//-------------------------------------------------------------------------
// Setup State Heap control structures
//-------------------------------------------------------------------------
// Skip RENDERHAL_STATE_HEAP structure
ptr = (uint8_t *)pStateHeap;
ptr += MOS_ALIGN_CEIL(stateHeapSize, 16);
// Pointer to Kernel allocations
pStateHeap->pKernelAllocation = (PRENDERHAL_KRN_ALLOCATION)ptr;
ptr += MOS_ALIGN_CEIL(pSettings->iKernelCount * sizeof(RENDERHAL_KRN_ALLOCATION), 16);
// Pointer to Media State allocations
pStateHeap->pMediaStates = (PRENDERHAL_MEDIA_STATE)ptr;
ptr += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * mediaStateSize, 16);
// Pointer to Media ID allocations
pAllocations = (int32_t *)ptr;
ptr += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * pSettings->iMediaIDs * sizeof(int32_t), 16);
// Pointer to Surface State allocations
pStateHeap->pSurfaceEntry = (PRENDERHAL_SURFACE_STATE_ENTRY)ptr;
dwSizeMediaState = pStateHeap->dwSizeMediaState;
// Reset current media state
pStateHeap->iCurMediaState = 0;
pStateHeap->iNextMediaState = 0;
dwSizeGSH = pStateHeap->dwSizeSync;
// Align Media State base
dwSizeGSH = MOS_ALIGN_CEIL(dwSizeGSH, MHW_MEDIA_STATE_ALIGN);
// Create multiple instances of Media state heaps for Dynamic GSH
ptrMediaState = (uint8_t *)pStateHeap->pMediaStates;
for (i = 0; i < pSettings->iMediaStateHeaps; i++)
{
PRENDERHAL_MEDIA_STATE pStat = (PRENDERHAL_MEDIA_STATE)ptrMediaState;
pStat->dwOffset = dwSizeGSH;
pStat->piAllocation = pAllocations;
dwSizeGSH += dwSizeMediaState;
pAllocations += pSettings->iMediaIDs;
// Pointer moves to next MEDIA STATE position
ptrMediaState += mediaStateSize;
}
//----------------------------------
// Surface State Heap
//----------------------------------
// Reset initial SSH allocations
pStateHeap->iCurSshBufferIndex = 0;
pStateHeap->iCurrentBindingTable = 0;
pStateHeap->iCurrentSurfaceState = 0;
// Set BT sizes
pStateHeap->iBindingTableSize = MOS_ALIGN_CEIL(pSettings->iSurfacesPerBT * pHwSizes->dwSizeBindingTableState,
pSettings->iBTAlignment);
// Set offsets to BT and SS entries
pStateHeap->iBindingTableOffset = 0;
pStateHeap->iSurfaceStateOffset = pSettings->iBindingTables * pStateHeap->iBindingTableSize;
// Calculate size of a single SSH instance and total SSH buffer size
dwSizeSSH = pStateHeap->iSurfaceStateOffset +
pSettings->iSurfaceStates * pRenderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize();
pStateHeap->dwSshIntanceSize = dwSizeSSH;
pRenderHal->dwIndirectHeapSize = MOS_ALIGN_CEIL(dwSizeSSH, MHW_PAGE_SIZE);
// Allocate SSH buffer in system memory, not Gfx
pStateHeap->dwSizeSSH = dwSizeSSH; // Single SSH instance
pStateHeap->pSshBuffer = (uint8_t*)MOS_AllocAndZeroMemory(dwSizeSSH);
if (!pStateHeap->pSshBuffer)
{
MHW_RENDERHAL_ASSERTMESSAGE("Fail to Allocate SSH buffer.");
eStatus = MOS_STATUS_NO_SPACE;
return eStatus;
}
pStateHeap->bSshLocked = true;
// Free State Heap Control structure
MOS_AlignedFreeMemory(pOldStateHeap);
pOldStateHeap = nullptr;
eStatus = MOS_STATUS_SUCCESS;
bAllocated = true;
return eStatus;
}
MOS_STATUS RenderHal_ReAllocateStateHeapsforAdvFeatureWithAllHeapsEnlarged(
PRENDERHAL_INTERFACE pRenderHal,
bool &bAllocated)
{
PRENDERHAL_STATE_HEAP_SETTINGS pRenderhalSettings = nullptr;
PRENDERHAL_ENLARGE_PARAMS pParams = nullptr;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
//------------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
pParams = &pRenderHal->enlargeStateHeapSettingsForAdv;
pRenderhalSettings = &pRenderHal->StateHeapSettings;
bAllocated = false;
//------------------------------------------------
// Enlarge the binding table size and surface state size
if ((pRenderhalSettings->iBindingTables == pParams->iBindingTables) &&
(pRenderhalSettings->iSurfaceStates == pParams->iSurfaceStates) &&
(pRenderhalSettings->iKernelCount == pParams->iKernelCount) &&
(pRenderhalSettings->iCurbeSize == pParams->iCurbeSize) &&
(pRenderhalSettings->iKernelHeapSize == pParams->iKernelHeapSize) &&
(pRenderhalSettings->iSurfacesPerBT == pParams->iSurfacesPerBT))
{
return MOS_STATUS_SUCCESS;
}
// Free State Heaps(RenderHal_FreeStateHeaps):
// Free state heap here will only destroy software allocations.
// Will not destroy resources used by hw.
MHW_RENDERHAL_CHK_STATUS_RETURN((MOS_STATUS)(pRenderHal->pfnFreeStateHeaps(pRenderHal)));
pRenderhalSettings->iBindingTables = pParams->iBindingTables;
pRenderhalSettings->iSurfaceStates = pParams->iSurfaceStates;
pRenderhalSettings->iKernelCount = pParams->iKernelCount;
pRenderhalSettings->iCurbeSize = pParams->iCurbeSize;
pRenderhalSettings->iKernelHeapSize = pParams->iKernelHeapSize;
pRenderhalSettings->iSurfacesPerBT = pParams->iSurfacesPerBT;
eStatus = pRenderHal->pfnAllocateStateHeaps(pRenderHal, pRenderhalSettings);
bAllocated = true;
return eStatus;
}
//!
//! \brief Free State Heaps (including MHW interfaces)
//! \details Free State Heap resources allocated by RenderHal
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Render Hal Interface
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_FreeStateHeaps(PRENDERHAL_INTERFACE pRenderHal)
{
PMOS_INTERFACE pOsInterface;
PRENDERHAL_STATE_HEAP pStateHeap;
MOS_STATUS eStatus;
//------------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
//------------------------------------------------
if (pRenderHal->pStateHeap == nullptr)
{
return MOS_STATUS_SUCCESS;
}
eStatus = MOS_STATUS_UNKNOWN;
pOsInterface = pRenderHal->pOsInterface;
pStateHeap = pRenderHal->pStateHeap;
// Free SSH Resource
if (pStateHeap->pSshBuffer)
{
MOS_FreeMemory(pStateHeap->pSshBuffer);
pStateHeap->pSshBuffer = nullptr;
}
if (pStateHeap->surfaceStateMgr)
{
MOS_Delete(pStateHeap->surfaceStateMgr);
pStateHeap->surfaceStateMgr = nullptr;
}
// Free MOS surface in surface state entry
for (int32_t index = 0; index < pRenderHal->StateHeapSettings.iSurfaceStates; ++index) {
PRENDERHAL_SURFACE_STATE_ENTRY entry = pStateHeap->pSurfaceEntry + index;
MOS_SafeFreeMemory(entry->pSurface);
entry->pSurface = nullptr;
}
// Free State Heap Control structure
MOS_AlignedFreeMemory(pStateHeap);
pRenderHal->pStateHeap = nullptr;
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Allocate BB
//! \details Allocate Batch Buffer resource (not BB structure),
//! attaching it to head of linked list in RenderHal.
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardwaew interface structure
//! \param PMHW_BATCH_BUFFER pBatchBuffer
//! [out] Pointer to batch buffer structure to be initialized
//! \param int32_t iSize
//! [in] Size of the batch buffer to be allocated
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if the Batch Buffer was successfully allocated
//! others if failed
//!
MOS_STATUS RenderHal_AllocateBB(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_BATCH_BUFFER pBatchBuffer,
int32_t iSize)
{
PMOS_INTERFACE pOsInterface;
MOS_RESOURCE OsResource;
MOS_ALLOC_GFXRES_PARAMS AllocParams;
MOS_STATUS eStatus;
//---------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pBatchBuffer);
//---------------------------------------------
eStatus = MOS_STATUS_UNKNOWN;
pOsInterface = pRenderHal->pOsInterface;
MOS_ZeroMemory(&OsResource, sizeof(OsResource));
MOS_ZeroMemory(&AllocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
AllocParams.Type = MOS_GFXRES_BUFFER;
AllocParams.TileType = MOS_TILE_LINEAR;
AllocParams.Format = Format_Buffer;
AllocParams.dwBytes = iSize;
AllocParams.pBufName = "RenderHalBB";
AllocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_MEDIA_BATCH_BUFFERS;
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnAllocateResource(
pOsInterface,
&AllocParams,
&OsResource));
// Reset Allocation
pOsInterface->pfnResetResourceAllocationIndex(
pOsInterface,
&OsResource);
pBatchBuffer->OsResource = OsResource;
pBatchBuffer->iRemaining = iSize;
pBatchBuffer->iSize = iSize;
pBatchBuffer->iCurrent = 0;
pBatchBuffer->bLocked = false;
pBatchBuffer->pData = nullptr;
pBatchBuffer->dwOffset = 0;
pBatchBuffer->bBusy = false;
pBatchBuffer->dwCmdBufId = 0;
// Link BB to beginning of linked list
pBatchBuffer->pPrev = nullptr;
pBatchBuffer->pNext = pRenderHal->pBatchBufferList;
pRenderHal->pBatchBufferList = pBatchBuffer;
if (pBatchBuffer->pNext)
{
pBatchBuffer->pNext->pPrev = pBatchBuffer;
}
// Reset Sync/BB Reuse data
pBatchBuffer->dwSyncTag = 0;
pBatchBuffer->bMatch = false;
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Free BB
//! \details Frees Batch Buffer Resource (not structure),
//! detaching it from linked list in RenderHal.
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param PMHW_BATCH_BUFFER pBatchBuffer
//! [in] Pointer to Batch Buffer
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_FreeBB(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_BATCH_BUFFER pBatchBuffer)
{
PMOS_INTERFACE pOsInterface;
MOS_STATUS eStatus;
//----------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pBatchBuffer);
//----------------------------------------------
eStatus = MOS_STATUS_UNKNOWN;
pOsInterface = pRenderHal->pOsInterface;
if (pBatchBuffer->bLocked)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnUnlockBB(pRenderHal, pBatchBuffer));
}
pOsInterface->pfnFreeResource(pOsInterface, &pBatchBuffer->OsResource);
pBatchBuffer->dwSyncTag = 0;
pBatchBuffer->iSize = 0;
pBatchBuffer->iCurrent = 0;
pBatchBuffer->bMatch = 0;
// Unlink BB from synchronization list
if (pBatchBuffer->pNext)
{
pBatchBuffer->pNext->pPrev = pBatchBuffer->pPrev;
}
if (pBatchBuffer->pPrev)
{
pBatchBuffer->pPrev->pNext = pBatchBuffer->pNext;
}
else
{
pRenderHal->pBatchBufferList = pBatchBuffer->pNext;
}
pBatchBuffer->pPrev = pBatchBuffer->pNext = nullptr;
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Lock BB
//! \details Locks Batch Buffer
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param PMHW_BATCH_BUFFER pBatchBuffer
//! [in] Pointer to Batch Buffer
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_LockBB(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_BATCH_BUFFER pBatchBuffer)
{
PMOS_INTERFACE pOsInterface;
MOS_LOCK_PARAMS LockFlags;
MOS_STATUS eStatus;
//-----------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pBatchBuffer);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
//-----------------------------------
eStatus = MOS_STATUS_UNKNOWN;
pOsInterface = pRenderHal->pOsInterface;
if (pBatchBuffer->bLocked)
{
MHW_RENDERHAL_ASSERTMESSAGE("Batch Buffer is already locked.");
return eStatus;
}
MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
LockFlags.WriteOnly = 1;
pBatchBuffer->pData = (uint8_t*)pOsInterface->pfnLockResource(
pOsInterface,
&pBatchBuffer->OsResource,
&LockFlags);
MHW_RENDERHAL_CHK_NULL_RETURN(pBatchBuffer->pData);
pBatchBuffer->bLocked = true;
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Unlock BB
//! \details Unlocks Batch Buffer
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param PMHW_BATCH_BUFFER pBatchBuffer
//! [in] Pointer to Batch Buffer
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_UnlockBB(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_BATCH_BUFFER pBatchBuffer)
{
PMOS_INTERFACE pOsInterface;
MOS_STATUS eStatus;
//---------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pBatchBuffer);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
//---------------------------------
eStatus = MOS_STATUS_UNKNOWN;
pOsInterface = pRenderHal->pOsInterface;
if (!pBatchBuffer->bLocked)
{
MHW_RENDERHAL_ASSERTMESSAGE("Batch buffer is locked.");
return eStatus;
}
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnUnlockResource(
pOsInterface,
&pBatchBuffer->OsResource));
pBatchBuffer->bLocked = false;
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Refresh Sync
//! \details Update Sync tags
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_RefreshSync(PRENDERHAL_INTERFACE pRenderHal)
{
PRENDERHAL_STATE_HEAP pStateHeap;
PRENDERHAL_MEDIA_STATE pCurMediaState;
PMHW_BATCH_BUFFER pBatchBuffer;
uint32_t dwCurrentTag;
int32_t i;
int32_t iStatesInUse;
int32_t iBuffersInUse;
MOS_STATUS eStatus;
MOS_NULL_RENDERING_FLAGS NullRenderingFlags;
uint8_t *pCurrentPtr;
uint64_t uiStartTime;
uint64_t uiEndTime;
uint64_t uiDiff;
uint64_t uiNS;
double TimeMS;
uint32_t uiComponent;
size_t mediaStateSize = 0;
uint8_t *ptrMediaState = nullptr;
//----------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
//----------------------------------
eStatus = MOS_STATUS_UNKNOWN;
pCurrentPtr = nullptr;
uiNS = 0;
mediaStateSize = pRenderHal->pRenderHalPltInterface->GetRenderHalMediaStateSize();
// GSH must be locked
pStateHeap = pRenderHal->pStateHeap;
if (!pStateHeap->bGshLocked)
{
return eStatus;
}
// Most recent tag
dwCurrentTag = pStateHeap->pSync[0];
pStateHeap->dwSyncTag = dwCurrentTag - 1;
// Refresh batch buffers
iBuffersInUse = 0;
pBatchBuffer = pRenderHal->pBatchBufferList;
NullRenderingFlags = pRenderHal->pOsInterface->pfnGetNullHWRenderFlags(
pRenderHal->pOsInterface);
for (; pBatchBuffer != nullptr; pBatchBuffer = pBatchBuffer->pNext)
{
if (!pBatchBuffer->bBusy) continue;
// Clear BB busy flag when Sync Tag is reached
if ((int32_t)(dwCurrentTag - pBatchBuffer->dwSyncTag) > 0 ||
NullRenderingFlags.VPGobal)
{
pBatchBuffer->bBusy = false;
}
else
{
iBuffersInUse++;
}
}
// Refresh media states
if(pRenderHal->StateHeapSettings.iMediaStateHeaps > 0)
{
MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pMediaStates);
}
ptrMediaState = (uint8_t*)pStateHeap->pMediaStates;
pCurMediaState = pStateHeap->pMediaStates;
iStatesInUse = 0;
for (i = pRenderHal->StateHeapSettings.iMediaStateHeaps; i > 0; i--, pCurMediaState = (PRENDERHAL_MEDIA_STATE)ptrMediaState)
{
ptrMediaState += mediaStateSize;
if (!pCurMediaState->bBusy) continue;
// The condition below is valid when sync tag wraps from 2^32-1 to 0
if ((int32_t)(dwCurrentTag - pCurMediaState->dwSyncTag) > 0)
{
pCurMediaState->bBusy = false;
if (pRenderHal->bKerneltimeDump)
{
// Dump Kernel execution time when media state is being freed
pCurrentPtr = pStateHeap->pGshBuffer +
pCurMediaState->dwOffset +
pStateHeap->dwOffsetStartTime;
if (pCurrentPtr)
{
uiStartTime = *((uint64_t *) pCurrentPtr);
pCurrentPtr += pStateHeap->dwStartTimeSize;
uiEndTime = *((uint64_t *) pCurrentPtr);
pCurrentPtr += pStateHeap->dwEndTimeSize;
uiComponent = *((RENDERHAL_COMPONENT *) pCurrentPtr);
if (uiComponent < (uint32_t)RENDERHAL_COMPONENT_COUNT)
{
// Convert ticks to ns
uiDiff = uiEndTime - uiStartTime;
uiNS = 0;
pRenderHal->pfnConvertToNanoSeconds(pRenderHal, uiDiff, &uiNS);
TimeMS = ((double)uiNS) / (1000 * 1000); // Convert to ms (double)
pRenderHal->kernelTime[uiComponent] += TimeMS;
}
}
}
}
else
{
iStatesInUse++;
}
}
// Save number of states/buffers in use
pRenderHal->iBuffersInUse = iBuffersInUse;
pRenderHal->iMediaStatesInUse = iStatesInUse;
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Load Kernel
//! \details Load a kernel from cache into GSH; searches for unused space in
//! the kernel heap; deallocates kernels identified as no longer in use.
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param PCRENDERHAL_KERNEL_PARAM pParameters
//! [in] Pointer to Kernel Parameters
//! \param PMHW_KERNEL_PARAMS pKernel
//! [in] Pointer to Kernel entry
//! \param Kdll_CacheEntry pKernelEntry
//! [in] The cache entry pointer maintaining the load status.
//! For cache entries from local variable,
//! set it to nullptr to avoid memory corruption
//! \return int32_t
//! Index to a kernel allocation index
//! -1 if invalid parameters, no available space and no
//! deallocation possible
//!
int32_t RenderHal_LoadKernel(
PRENDERHAL_INTERFACE pRenderHal,
PCRENDERHAL_KERNEL_PARAM pParameters,
PMHW_KERNEL_PARAM pKernel,
Kdll_CacheEntry *pKernelEntry)
{
PRENDERHAL_STATE_HEAP pStateHeap;
PRENDERHAL_KRN_ALLOCATION pKernelAllocation;
int32_t iKernelAllocationID; // Kernel allocation ID in GSH
int32_t iKernelCacheID; // Kernel cache ID
int32_t iKernelUniqueID; // Kernel unique ID
void *pKernelPtr;
int32_t iKernelSize;
int32_t iSearchIndex;
int32_t iMaxKernels; // Max number of kernels allowed in GSH
uint32_t dwOffset;
int32_t iSize;
MOS_STATUS eStatus;
iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL;
eStatus = MOS_STATUS_SUCCESS;
do
{
if (pRenderHal==nullptr)
{
break;
}
if (pRenderHal->pStateHeap == nullptr)
{
break;
}
if (pRenderHal->pStateHeap->pKernelAllocation == nullptr)
{
break;
}
if (pParameters == nullptr)
{
break;
}
if (pKernel == nullptr)
{
break;
}
pStateHeap = pRenderHal->pStateHeap;
// Validate parameters
if (pStateHeap->bGshLocked == false ||
pKernel->iSize == 0)
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
MHW_RENDERHAL_NORMALMESSAGE("Failed to load kernel - invalid parameters.");
break;
}
// Kernel parameters
pKernelPtr = pKernel->pBinary;
iKernelSize = pKernel->iSize;
iKernelUniqueID = pKernel->iKUID;
iKernelCacheID = pKernel->iKCID;
// Check if kernel is already loaded; Search free allocation index
iSearchIndex = -1;
iMaxKernels = pRenderHal->StateHeapSettings.iKernelCount;
pKernelAllocation = pStateHeap->pKernelAllocation;
for (iKernelAllocationID = 0;
iKernelAllocationID < iMaxKernels;
iKernelAllocationID++, pKernelAllocation++)
{
if (pKernelAllocation->iKUID == iKernelUniqueID &&
pKernelAllocation->iKCID == iKernelCacheID)
{
if (iKernelAllocationID != RENDERHAL_KERNEL_LOAD_FAIL)
{
// Update kernel usage
pRenderHal->pfnTouchKernel(pRenderHal, iKernelAllocationID);
// Increment reference counter
if (pKernelEntry)
{
pKernelEntry->dwLoaded = 1;
}
pRenderHal->iKernelAllocationID = iKernelAllocationID;
}
// Return kernel allocation index
return iKernelAllocationID;
}
if (iSearchIndex < 0 &&
pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE)
{
iSearchIndex = iKernelAllocationID;
}
}
// The kernel size to be dumped in oca buffer.
pStateHeap->iKernelUsedForDump = iKernelSize;
// Kernel already loaded: refresh timer; return allocation index
if (iKernelAllocationID < iMaxKernels)
{
// To reload the kernel forcibly if needed
if (pKernel->bForceReload)
{
// The ForceReload function is only utilized in legacy code.
// Since APO does not follow this execution path,
// there is no need to include padding size code here.
dwOffset = pKernelAllocation->dwOffset;
MOS_SecureMemcpy(pStateHeap->pIshBuffer + dwOffset, iKernelSize, pKernelPtr, iKernelSize);
pKernel->bForceReload = false;
}
break;
}
// Kernel parameters
pKernelPtr = pKernel->pBinary;
iKernelSize = pKernel->iSize;
iKernelUniqueID = pKernel->iKUID;
iKernelCacheID = pKernel->iKCID;
// Check if kernel is already loaded; Search free allocation index
iSearchIndex = -1;
iMaxKernels = pRenderHal->StateHeapSettings.iKernelCount;
pKernelAllocation = pStateHeap->pKernelAllocation;
for (iKernelAllocationID = 0;
iKernelAllocationID < iMaxKernels;
iKernelAllocationID++, pKernelAllocation++)
{
if (pKernelAllocation->iKUID == iKernelUniqueID &&
pKernelAllocation->iKCID == iKernelCacheID)
{
break;
}
if (iSearchIndex < 0 &&
pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE)
{
iSearchIndex = iKernelAllocationID;
}
}
// The kernel size to be dumped in oca buffer.
pStateHeap->iKernelUsedForDump = iKernelSize;
// Kernel already loaded: refresh timer; return allocation index
if (iKernelAllocationID < iMaxKernels)
{
// To reload the kernel forcibly if needed
if (pKernel->bForceReload)
{
// The ForceReload function is only utilized in legacy code.
// Since APO does not follow this execution path,
// there is no need to include padding size code here.
dwOffset = pKernelAllocation->dwOffset;
MOS_SecureMemcpy(pStateHeap->pIshBuffer + dwOffset, iKernelSize, pKernelPtr, iKernelSize);
pKernel->bForceReload = false;
}
break;
}
// Simple allocation: allocation index available, space available
if ((iSearchIndex >= 0) &&
(pStateHeap->iKernelUsed + iKernelSize <= pStateHeap->iKernelSize))
{
// Allocate kernel at the end of the heap
iKernelAllocationID = iSearchIndex;
pKernelAllocation = &(pStateHeap->pKernelAllocation[iSearchIndex]);
// Allocate block from the end of the heap
dwOffset = pStateHeap->dwKernelBase + pStateHeap->iKernelUsed;
iSize = MOS_ALIGN_CEIL(iKernelSize, pRenderHal->StateHeapSettings.iKernelBlockSize);
// Update heap
pStateHeap->iKernelUsed += iSize;
// Load kernel
goto loadkernel;
}
// Search block from deallocated entry
if (iSearchIndex >= 0)
{
int32_t iMinSize = 0;
iSearchIndex = -1;
pKernelAllocation = pStateHeap->pKernelAllocation;
for (iKernelAllocationID = 0;
iKernelAllocationID < iMaxKernels;
iKernelAllocationID++, pKernelAllocation++)
{
// Skip allocated/empty entries
if (pKernelAllocation->dwFlags != RENDERHAL_KERNEL_ALLOCATION_FREE ||
pKernelAllocation->iSize == 0)
{
continue;
}
// Allocate minimum available block
if (pKernelAllocation->iSize >= iKernelSize)
{
if (iSearchIndex < 0 ||
pKernelAllocation->iSize < iMinSize)
{
iSearchIndex = iKernelAllocationID;
iMinSize = pKernelAllocation->iSize;
}
}
}
}
// Did not find block, try to deallocate a kernel not recently used
if (iSearchIndex < 0)
{
uint32_t dwOldest = 0;
uint32_t dwLastUsed;
// Search and deallocate least used kernel
pKernelAllocation = pStateHeap->pKernelAllocation;
for (iKernelAllocationID = 0;
iKernelAllocationID < iMaxKernels;
iKernelAllocationID++, pKernelAllocation++)
{
// Skip unused entries and entries that would not fit
// Skip kernels flagged as locked (cannot be automatically deallocated)
if (pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE ||
pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_LOCKED ||
pKernelAllocation->iSize < iKernelSize)
{
continue;
}
// Check if kernel may be replaced (not in use by GPU)
if ((int32_t)(pStateHeap->dwSyncTag - pKernelAllocation->dwSync) < 0)
{
continue;
}
// Find kernel not used for the greater amount of time (measured in number of operations)
// Must not unload recently allocated kernels
dwLastUsed = (uint32_t)(pStateHeap->dwAccessCounter - pKernelAllocation->dwCount);
if (dwLastUsed > dwOldest)
{
iSearchIndex = iKernelAllocationID;
dwOldest = dwLastUsed;
}
}
// Did not found any entry for deallocation
if (iSearchIndex < 0)
{
MHW_RENDERHAL_NORMALMESSAGE("Failed to load kernel - no space available in GSH.");
iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL;
break;
}
// Free kernel entry and states associated with the kernel (if any)
if (pRenderHal->pfnUnloadKernel(pRenderHal, iSearchIndex) != MOS_STATUS_SUCCESS)
{
MHW_RENDERHAL_NORMALMESSAGE("Failed to load kernel - no space available in GSH.");
iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL;
break;
}
}
// Allocate the entry
iKernelAllocationID = iSearchIndex;
pKernelAllocation = &(pStateHeap->pKernelAllocation[iSearchIndex]);
dwOffset = pKernelAllocation->dwOffset;
iSize = pKernelAllocation->iSize;
loadkernel:
// Allocate kernel
pKernelAllocation->iKID = -1;
pKernelAllocation->iKUID = iKernelUniqueID;
pKernelAllocation->iKCID = iKernelCacheID;
pKernelAllocation->dwSync = 0;
FrameTrackerTokenFlat_Clear(&pKernelAllocation->trackerToken);
pKernelAllocation->dwOffset = dwOffset;
pKernelAllocation->iSize = iSize;
pKernelAllocation->dwFlags = RENDERHAL_KERNEL_ALLOCATION_USED;
pKernelAllocation->dwCount = 0; // will be updated by "TouchKernel"
pKernelAllocation->Params = *pParameters;
pKernelAllocation->pKernelEntry = pKernelEntry;
pKernelAllocation->iAllocIndex = iKernelAllocationID;
// Copy kernel data
int32_t iCopyKernelSize = iKernelSize - pKernel->iPaddingSize;
MOS_SecureMemcpy(pStateHeap->pIshBuffer + dwOffset, iCopyKernelSize, pKernelPtr, iCopyKernelSize);
if (iCopyKernelSize < iSize)
{
MOS_ZeroMemory(pStateHeap->pIshBuffer + dwOffset + iCopyKernelSize, iSize - iCopyKernelSize);
}
} while (false);
if (iKernelAllocationID != RENDERHAL_KERNEL_LOAD_FAIL)
{
// Update kernel usage
pRenderHal->pfnTouchKernel(pRenderHal, iKernelAllocationID);
// Increment reference counter
if (pKernelEntry)
{
pKernelEntry->dwLoaded = 1;
}
pRenderHal->iKernelAllocationID = iKernelAllocationID;
}
// Return kernel allocation index
return iKernelAllocationID;
}
//!
//! \brief Unload Kernel
//! \details Unload a kernel from GSH, free kernel heap space
//! Notify that the kernel has been unloaded (for tracking)
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param int32_t iKernelAllocationID
//! [in] Kernel allocation index in GSH
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if success
//! others if invalid parameters or if kernel cannot be unloaded
//!
MOS_STATUS RenderHal_UnloadKernel(
PRENDERHAL_INTERFACE pRenderHal,
int32_t iKernelAllocationID)
{
PRENDERHAL_STATE_HEAP pStateHeap;
PRENDERHAL_KRN_ALLOCATION pKernelAllocation;
MOS_STATUS eStatus;
//---------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN((void *)(iKernelAllocationID >= 0));
//---------------------------------------
eStatus = MOS_STATUS_UNKNOWN;
pStateHeap = pRenderHal->pStateHeap;
//---------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pKernelAllocation);
MHW_RENDERHAL_ASSERT(iKernelAllocationID < pRenderHal->StateHeapSettings.iKernelCount);
//---------------------------------------
pKernelAllocation = &(pStateHeap->pKernelAllocation[iKernelAllocationID]);
if (pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE)
{
return eStatus;
}
// Update Sync tags
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnRefreshSync(pRenderHal));
// Check if kernel may be unloaded
if ((int32_t)(pStateHeap->dwSyncTag - pKernelAllocation->dwSync) < 0)
{
return eStatus;
}
// Unload kernel
if (pKernelAllocation->pKernelEntry)
{
pKernelAllocation->pKernelEntry->dwLoaded = 0;
}
// Release kernel entry (Offset/size may be used for reallocation)
pKernelAllocation->iKID = -1;
pKernelAllocation->iKUID = -1;
pKernelAllocation->iKCID = -1;
pKernelAllocation->dwSync = 0;
FrameTrackerTokenFlat_Clear(&pKernelAllocation->trackerToken);
pKernelAllocation->dwFlags = RENDERHAL_KERNEL_ALLOCATION_FREE;
pKernelAllocation->dwCount = 0;
pKernelAllocation->pKernelEntry = nullptr;
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Touch Kernel
//! \details Touch Kernel
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param int32_t iKernelAllocationID
//! [in] Kernel Allocation ID
//! \return void
//!
void RenderHal_TouchKernel(
PRENDERHAL_INTERFACE pRenderHal,
int32_t iKernelAllocationID)
{
PRENDERHAL_STATE_HEAP pStateHeap;
PRENDERHAL_KRN_ALLOCATION pKernelAllocation;
pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr;
if (pStateHeap == nullptr ||
pStateHeap->pKernelAllocation == nullptr ||
iKernelAllocationID < 0 ||
iKernelAllocationID >= pRenderHal->StateHeapSettings.iKernelCount)
{
return;
}
// Update usage
pKernelAllocation = &(pStateHeap->pKernelAllocation[iKernelAllocationID]);
if (pKernelAllocation->dwFlags != RENDERHAL_KERNEL_ALLOCATION_FREE &&
pKernelAllocation->dwFlags != RENDERHAL_KERNEL_ALLOCATION_LOCKED)
{
pKernelAllocation->dwCount = pStateHeap->dwAccessCounter++;
}
// Set sync tag, for deallocation control
pKernelAllocation->dwSync = pStateHeap->dwNextTag;
}
//!
//! \brief Reset Kernels
//! \details Reset Kernels
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \return void
//!
void RenderHal_ResetKernels(
PRENDERHAL_INTERFACE pRenderHal)
{
PRENDERHAL_STATE_HEAP pStateHeap;
PRENDERHAL_KRN_ALLOCATION pKernelAllocation;
int32_t i;
MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
//---------------------------------------
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal->pStateHeap->pKernelAllocation);
//---------------------------------------
pStateHeap = pRenderHal->pStateHeap;
// Unload kernels and notify HAL layer
pKernelAllocation = pStateHeap->pKernelAllocation;
for (i = 0; i< pRenderHal->StateHeapSettings.iKernelCount; i++, pKernelAllocation++)
{
// Unload kernel
if (pKernelAllocation->pKernelEntry)
{
pKernelAllocation->pKernelEntry->dwLoaded = 0;
}
pKernelAllocation->iKID = -1;
pKernelAllocation->iKUID = -1;
pKernelAllocation->iKCID = -1;
pKernelAllocation->dwSync = 0;
FrameTrackerTokenFlat_Clear(&pKernelAllocation->trackerToken);
pKernelAllocation->dwOffset = 0;
pKernelAllocation->iSize = 0;
pKernelAllocation->dwFlags = RENDERHAL_KERNEL_ALLOCATION_FREE;
pKernelAllocation->dwCount = 0;
pKernelAllocation->pKernelEntry = nullptr;
pKernelAllocation->iAllocIndex = i;
pKernelAllocation->Params = g_cRenderHal_InitKernelParams;
}
// Free Kernel Heap
pStateHeap->dwAccessCounter = 0;
pStateHeap->iKernelSize = pRenderHal->StateHeapSettings.iKernelHeapSize;
pStateHeap->iKernelUsed = 0;
pStateHeap->iKernelUsedForDump = 0;
return;
}
//!
//! \brief Get Kernel Offset
//! \details Get Kernel Offset
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param int32_t iKernelAllocationIndex
//! [in] Kernel Allocation Index
//! \return int32_t
//!
int32_t RenderHal_GetKernelOffset(
PRENDERHAL_INTERFACE pRenderHal,
int32_t iKernelAllocationIndex)
{
PRENDERHAL_STATE_HEAP pStateHeap;
int32_t iResult;
pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr;
if (pStateHeap &&
pStateHeap->pKernelAllocation &&
iKernelAllocationIndex >= 0 &&
iKernelAllocationIndex < pRenderHal->StateHeapSettings.iKernelCount)
{
iResult = pStateHeap->pKernelAllocation[iKernelAllocationIndex].dwOffset;
}
else
{
iResult = -1;
}
return iResult;
}
//!
//! \brief Allocate Media ID
//! \details Allocates an setup Interface Descriptor for Media Pipeline
//! Kernel must be preloaded using pfnLoadKernel
//! Curbe must be allocated using pfnAllocateCurbe
//! Binding Table must be allocated using pfnAllocateBindingTable
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param int32_t iKernelAllocationID
//! [in] Kernel Allocation ID
//! \param int32_t iBindingTableID
//! [in] Binding Table ID
//! \param int32_t iCurbeOffset
//! [in] Curbe Offset (from Curbe base)
//! \param int32_t iCurbeLength
//! [in] Curbe Length
//! \param int32_t iCrsThrdConstDataLn
//! [in] Cross Thread constant data length
//! \param PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams
//! [in] Pointer to GpGpu Walker Params
//! \return int32_t
//! Media Interface descriptor ID
//! -1 if invalid parameters, no ID entry available in GSH
//!
int32_t RenderHal_AllocateMediaID(
PRENDERHAL_INTERFACE pRenderHal,
int32_t iKernelAllocationID,
int32_t iBindingTableID,
int32_t iCurbeOffset,
int32_t iCurbeLength,
int32_t iCrsThrdConstDataLn,
PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams)
{
PRENDERHAL_STATE_HEAP pStateHeap;
PRENDERHAL_KRN_ALLOCATION pKernelAllocation;
PRENDERHAL_MEDIA_STATE pCurMediaState;
int32_t iCurbeSize;
int32_t iInterfaceDescriptor;
RENDERHAL_INTERFACE_DESCRIPTOR_PARAMS InterfaceDescriptorParams;
iInterfaceDescriptor = -1;
// Validate GSH
pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr;
if (pStateHeap == nullptr ||
pStateHeap->pKernelAllocation == nullptr ||
pStateHeap->bGshLocked == false)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid GSH State.");
return iInterfaceDescriptor;
}
// Obtain pointer to current media state
pCurMediaState = pStateHeap->pCurMediaState;
if (pCurMediaState == nullptr ||
pCurMediaState->piAllocation == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid Media State.");
return iInterfaceDescriptor;
}
// Validate kernel allocation ID (kernel must be pre-loaded into GSH)
if (iKernelAllocationID < 0 ||
iKernelAllocationID >= pRenderHal->StateHeapSettings.iKernelCount)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid Kernel Allocation ID.");
return iInterfaceDescriptor;
}
// Obtain pointer to kernel allocation control and kernel parameters
pKernelAllocation = &(pStateHeap->pKernelAllocation[iKernelAllocationID]);
if (pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE ||
pKernelAllocation->iSize == 0)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid Kernel Allocation.");
return iInterfaceDescriptor;
}
// Check Curbe allocation (CURBE_Lenght is in 256-bit count -> convert to bytes)
iCurbeSize = iCurbeLength;
if (iCurbeSize <= 0)
{
// Curbe is not used by the kernel
iCurbeSize = iCurbeOffset = 0;
}
// Validate Curbe Offset (curbe must be pre-allocated)
else if ( iCurbeOffset < 0 || // Not allocated
(iCurbeOffset & 0x1F) != 0 || // Invalid alignment
(iCurbeOffset + iCurbeSize) > pCurMediaState->iCurbeOffset) // Invalid size
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid Curbe Allocation.");
return iInterfaceDescriptor;
}
// Search available ID in current media state heap, try to reuse index (2nd level BB reuse)
iInterfaceDescriptor = pRenderHal->pfnGetMediaID(pRenderHal, pCurMediaState, pKernelAllocation);
if (iInterfaceDescriptor < 0)
{
MHW_RENDERHAL_ASSERTMESSAGE("No Interface Descriptor available.");
return iInterfaceDescriptor;
}
MOS_ZeroMemory((void *)&InterfaceDescriptorParams, sizeof(InterfaceDescriptorParams));
InterfaceDescriptorParams.iMediaID = iInterfaceDescriptor;
InterfaceDescriptorParams.iBindingTableID = iBindingTableID;
InterfaceDescriptorParams.iCurbeOffset = iCurbeOffset;
InterfaceDescriptorParams.iCurbeLength = iCurbeLength;
InterfaceDescriptorParams.iCrsThrdConstDataLn = iCrsThrdConstDataLn;
// barrier and slm
if (pGpGpuWalkerParams && pGpGpuWalkerParams->GpGpuEnable)
{
InterfaceDescriptorParams.blBarrierEnable = true;
InterfaceDescriptorParams.iNumberThreadsInGroup = pGpGpuWalkerParams->ThreadWidth * pGpGpuWalkerParams->ThreadHeight;
InterfaceDescriptorParams.iSLMSize = pGpGpuWalkerParams->SLMSize; // The shift will be handled by pfnEncodeSLMSize()
InterfaceDescriptorParams.blGlobalBarrierEnable = false;
}
else //Reset barrier and slm setting since they may be set before
{
InterfaceDescriptorParams.blBarrierEnable = false;
InterfaceDescriptorParams.iNumberThreadsInGroup = pRenderHal->dwMinNumberThreadsInGroup;
InterfaceDescriptorParams.iSLMSize = 0;
InterfaceDescriptorParams.iCrsThrdConstDataLn &= pRenderHal->dwMaskCrsThdConDataRdLn;
InterfaceDescriptorParams.blGlobalBarrierEnable = false;
}
// Setup Media ID entry - this call could be HW dependent
if (MOS_STATUS_SUCCESS != pRenderHal->pfnSetupInterfaceDescriptor(
pRenderHal,
pCurMediaState,
pKernelAllocation,
&InterfaceDescriptorParams))
{
MHW_RENDERHAL_ASSERTMESSAGE("Failed to setup interface descriptor.");
return iInterfaceDescriptor;
}
// Update kernel usage
pRenderHal->pfnTouchKernel(pRenderHal, iInterfaceDescriptor);
return iInterfaceDescriptor;
}
int32_t RenderHal_GetMediaID(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_MEDIA_STATE pMediaState,
PRENDERHAL_KRN_ALLOCATION pKernelAllocation)
{
int32_t iInterfaceDescriptor = -1;
int32_t *Allocation;
MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
MHW_RENDERHAL_CHK_NULL_RETURN(pMediaState);
MHW_RENDERHAL_CHK_NULL_RETURN(pMediaState->piAllocation);
MHW_RENDERHAL_CHK_NULL_RETURN(pKernelAllocation);
iInterfaceDescriptor = pKernelAllocation->iKID;
Allocation = pMediaState->piAllocation;
// Try to reuse interface descriptor (for 2nd level buffer optimizations)
// Check if ID already in use by another kernel - must use a different ID
if (iInterfaceDescriptor >= 0 &&
Allocation[iInterfaceDescriptor] >= 0 &&
Allocation[iInterfaceDescriptor] != pKernelAllocation->iAllocIndex)
{
iInterfaceDescriptor = -1;
}
// Search available ID in current media state heap
if (iInterfaceDescriptor < 0)
{
int32_t iMax = pRenderHal->StateHeapSettings.iMediaIDs;
for (iInterfaceDescriptor = 0;
iInterfaceDescriptor < iMax;
iInterfaceDescriptor++)
{
if (Allocation[iInterfaceDescriptor] < 0)
{
break;
}
}
// All IDs are in use - fail
if (iInterfaceDescriptor >= iMax)
{
MHW_RENDERHAL_ASSERT("No Interface Descriptor available.");
iInterfaceDescriptor = -1;
return iInterfaceDescriptor;
}
}
// Set kernel allocation for the current Media ID
Allocation[iInterfaceDescriptor] = pKernelAllocation->iAllocIndex;
// Set preferred Media ID for the current kernel
// This is necessary for 2nd level BB optimization.
if (pKernelAllocation->iKID < 0)
{
pKernelAllocation->iKID = iInterfaceDescriptor;
}
return iInterfaceDescriptor;
}
uint32_t RenderHal_SetSurfacesPerBT(PRENDERHAL_INTERFACE pRenderHal, uint32_t dwSurfacesPerBT)
{
if (pRenderHal == nullptr)
{
MHW_RENDERHAL_ASSERT("Invalid renderhal interface.");
return dwSurfacesPerBT;
}
// Set number of surfaces per Binding Table
uint32_t dwSizeBT = (uint32_t)pRenderHal->StateHeapSettings.iBTAlignment/pRenderHal->pRenderHalPltInterface->GetBTStateCmdSize();
while (dwSizeBT < dwSurfacesPerBT) dwSizeBT <<= 1;
dwSurfacesPerBT = dwSizeBT;
// Reconfigure the binding table size
pRenderHal->pStateHeap->iBindingTableSize = MOS_ALIGN_CEIL(dwSizeBT * pRenderHal->pRenderHalPltInterface->GetBTStateCmdSize(),
pRenderHal->StateHeapSettings.iBTAlignment);
// Reconfigure the binding table number, surface per BT
pRenderHal->StateHeapSettings.iBindingTables = pRenderHal->StateHeapSettings.iBindingTables *
pRenderHal->StateHeapSettings.iSurfacesPerBT / dwSurfacesPerBT;
pRenderHal->StateHeapSettings.iSurfacesPerBT = (int32_t) dwSurfacesPerBT;
return dwSurfacesPerBT;
}
//!
//! \brief Assign Surface State
//! \details Assign a new surface state from already allocated surfState pool
//! Setup the surface state to default
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param RENDERHAL_SURFACE_STATE_TYPE Type
//! [in] Surface State Type
//! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntry
//! [in] Pointer to Surface State Entry
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_AssignSurfaceState(
PRENDERHAL_INTERFACE pRenderHal,
RENDERHAL_SURFACE_STATE_TYPE Type,
PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntry)
{
PRENDERHAL_STATE_HEAP pStateHeap;
int32_t iSurfaceEntry;
PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
uint32_t dwOffset;
MOS_STATUS eStatus;
//----------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(ppSurfaceEntry);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
//----------------------------------------------
eStatus = MOS_STATUS_UNKNOWN;
pStateHeap = pRenderHal->pStateHeap;
uint8_t *pCurSurfaceState;
uint64_t stateGfxAddress = 0;
// Calculate the Offset to the Surface State
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
if (pRenderHal->isBindlessHeapInUse == false)
{
if (pStateHeap->iCurrentSurfaceState >= pRenderHal->StateHeapSettings.iSurfaceStates)
{
MHW_RENDERHAL_ASSERTMESSAGE("Unable to allocate Surface State. Exceeds Maximum.");
return eStatus;
}
dwOffset = pStateHeap->iSurfaceStateOffset +
(pStateHeap->iCurrentSurfaceState *
pRenderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize()); // Moves the pointer to a Currently assigned Surface State
// Increment the Current Surface State Entry
// Obtain new surface entry and initialize
iSurfaceEntry = pStateHeap->iCurrentSurfaceState;
pCurSurfaceState = pStateHeap->pSshBuffer + dwOffset;
++pStateHeap->iCurrentSurfaceState;
}
else
{
MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->surfaceStateMgr);
MHW_RENDERHAL_CHK_STATUS_RETURN(pStateHeap->surfaceStateMgr->AssignSurfaceState());
SURFACE_STATES_HEAP_OBJ *sufStateHeap = pStateHeap->surfaceStateMgr->m_surfStateHeap;
MHW_RENDERHAL_CHK_NULL_RETURN(sufStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(sufStateHeap->pLockedOsResourceMem);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface->pfnGetResourceGfxAddress);
MHW_RENDERHAL_CHK_VALUE_RETURN(Mos_ResourceIsNull(&sufStateHeap->osResource), false);
dwOffset = sufStateHeap->uiCurState * sufStateHeap->uiInstanceSize;
pCurSurfaceState =sufStateHeap->pLockedOsResourceMem + dwOffset;
pStateHeap->iCurrentSurfaceState = sufStateHeap->uiCurState;
stateGfxAddress = pRenderHal->pOsInterface->pfnGetResourceGfxAddress(pRenderHal->pOsInterface, &sufStateHeap->osResource) + dwOffset;
MHW_RENDERHAL_CHK_STATUS_RETURN(pStateHeap->surfaceStateMgr->AssignUsedSurfaceState(pStateHeap->iCurrentSurfaceState));
// Obtain new surface entry and initialize
iSurfaceEntry = pStateHeap->iCurrentSurfaceState;
}
pSurfaceEntry = &pStateHeap->pSurfaceEntry[iSurfaceEntry];
if (pSurfaceEntry->pSurface)
{
MOS_SafeFreeMemory(pSurfaceEntry->pSurface);
pSurfaceEntry->pSurface = nullptr;
}
*pSurfaceEntry = g_cInitSurfaceStateEntry;
// Setup Surface Entry parameters
pSurfaceEntry->iSurfStateID = iSurfaceEntry;
pSurfaceEntry->Type = Type;
pSurfaceEntry->dwSurfStateOffset = (uint32_t)-1; // Each platform to setup
pSurfaceEntry->pSurfaceState = pCurSurfaceState;
pSurfaceEntry->pSurface = (PMOS_SURFACE)MOS_AllocAndZeroMemory(sizeof(MOS_SURFACE));
pSurfaceEntry->stateGfxAddress = stateGfxAddress;
if (pSurfaceEntry->pSurface == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("Allocating Surface failed!");
eStatus = MOS_STATUS_NO_SPACE;
return eStatus;
}
*ppSurfaceEntry = pSurfaceEntry;
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Get DI UV Offset
//! \details Get DI UV Offset
//! \param PRENDERHAL_SURFACE pRenderHalSurface
//! [in] Pointer to Surface
//! \param uint16_t *pUXOffset
//! [out] X Offset for U Plane
//! \param uint16_t *pUYOffset
//! [out] Y Offset for U Plane
//! \param uint16_t *pVXOffset
//! [out] X Offset for V Plane
//! \param uint16_t *pVYOffset
//! [out] Y Offset for V Plane
//! \return void
//!
void RenderHal_Get_DI_UVOffSet(
PRENDERHAL_SURFACE pRenderHalSurface,
uint16_t *pUXOffset,
uint16_t *pUYOffset,
uint16_t *pVXOffset,
uint16_t *pVYOffset)
{
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHalSurface);
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pUXOffset);
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pUYOffset);
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pVXOffset);
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pVXOffset);
PMOS_SURFACE pSurface = &pRenderHalSurface->OsSurface;
MOS_FORMAT fmt = pSurface->Format;
uint32_t dwNumRowsFromTopV = 0;
uint32_t dwNumRowsFromTopU = 0;
uint32_t dwNumColsFromLeftV = 0;
uint32_t dwNumColsFromLeftU = 0;
uint32_t dwHeight = pSurface->dwHeight;
uint32_t dwPitch = pSurface->dwPitch;
switch (fmt)
{
// YY
// YY
// V-
// U-
case Format_IMC1:
dwNumRowsFromTopV = dwHeight;
dwNumRowsFromTopU = dwHeight + (dwHeight >> 1);
break;
// YY
// YY
// VU
case Format_IMC2:
dwNumRowsFromTopV = dwNumRowsFromTopU = dwHeight;
dwNumColsFromLeftU = dwPitch >> 1;
break;
// YY
// YY
// U-
// V-
case Format_IMC3:
dwNumRowsFromTopU = dwHeight;
dwNumRowsFromTopV = dwHeight + (dwHeight >> 1);
break;
// YY
// YY
// UV
case Format_IMC4:
dwNumRowsFromTopU = dwNumRowsFromTopV = dwHeight;
dwNumColsFromLeftV = dwPitch >> 1;
break;
// YY
// YY
// U
// V
case Format_I420:
case Format_IYUV:
dwNumRowsFromTopU = dwHeight;
dwNumRowsFromTopV = dwHeight + (dwHeight >> 1);
break;
// YY
// YY
// V
// U
case Format_YV12:
dwNumRowsFromTopU = dwHeight + (dwHeight >> 1);
dwNumRowsFromTopV = dwHeight;
break;
// YYYY
// YYYY
// YYYY
// YYYY
// V
// U
case Format_YVU9:
dwNumRowsFromTopU = dwHeight;
dwNumRowsFromTopV = dwHeight + (dwHeight >> 2);
break;
// NV12 P208
// ---- ----
// YY YY
// YY UV (interleaved)
// UV (interleaved)
case Format_NV12:
case Format_P208:
case Format_P016:
case Format_P010:
dwNumRowsFromTopU = dwNumRowsFromTopV = dwHeight;
break;
// NV11
// ----
// YYYY
// UV (interleaved)
case Format_NV11:
dwNumRowsFromTopU = dwNumRowsFromTopV = dwHeight;
break;
default:
MHW_RENDERHAL_ASSERTMESSAGE("called with Packed or Unknown format.");
break;
}
// the Offsets must be even numbers so we round down
dwNumRowsFromTopU = MOS_ALIGN_FLOOR(dwNumRowsFromTopU, 2);
dwNumColsFromLeftU = MOS_ALIGN_FLOOR(dwNumColsFromLeftU, 2);
dwNumRowsFromTopV = MOS_ALIGN_FLOOR(dwNumRowsFromTopV, 2);
dwNumColsFromLeftV = MOS_ALIGN_FLOOR(dwNumColsFromLeftV, 2);
*pVYOffset = (uint16_t)dwNumRowsFromTopV;
*pUYOffset = (uint16_t)dwNumRowsFromTopU;
*pVXOffset = (uint16_t)dwNumColsFromLeftV;
*pUXOffset = (uint16_t)dwNumColsFromLeftU;
}
//!
//! \brief Set Slice Shutdown Mode
//! \details Sets Slice Shutdown Mode
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//! \param bool bMode
//! [in] Slice Shutdown Mode
//! \return void
//!
void RenderHal_SetSliceShutdownMode(
PRENDERHAL_INTERFACE pRenderHal,
bool bMode)
{
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
pRenderHal->bRequestSingleSlice = bMode;
}
//!
//! \brief Set General Slice Shutdown Mode
//! \details Sets General Slice Shutdown Mode
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//! \param PRENDERHAL_POWEROPTION pMode
//! [in] Slice Shutdown Mode
//! \return void
//!
void RenderHal_SetPowerOptionMode(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_POWEROPTION pMode )
{
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pMode);
pRenderHal->PowerOption = *pMode;
}
//!
//! \brief Enable Middle Batch Buffer Preemption
//! \details Enable Middle Batch Buffer Preemption
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structurev
//! \return void
//!
void RenderHal_EnableGpgpuMiddleBatchBufferPreemption(
PRENDERHAL_INTERFACE pRenderHal)
{
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
pRenderHal->bEnableGpgpuMidBatchPreEmption = MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrGpGpuMidBatchPreempt) ? true : false;
}
//!
//! \brief Enable Middle Thread Preemption
//! \details Enable Middle Thread Preemption
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structurev
//! \return void
//!
void RenderHal_EnableGpgpuMiddleThreadPreemption(
PRENDERHAL_INTERFACE pRenderHal)
{
MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
pRenderHal->bEnableGpgpuMidThreadPreEmption = MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrGpGpuMidThreadLevelPreempt) ? true : false;
}
//!
//! \brief Get Surface State Entries
//! \details Gets the Surface State Entries
//! \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 pParams
//! [in] Pointer to Surface State Params
//! \param int32_t *piNumEntries
//! [out] Number of Surface Entries (one entry per surface plane)
//! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries
//! [out] Array of Surface State Entries
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_GetSurfaceStateEntries(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface,
PRENDERHAL_SURFACE_STATE_PARAMS pParams,
int32_t *piNumEntries,
PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntries)
{
MOS_STATUS eStatus;
PCMHW_PLANE_SETTING pPlane;
PMOS_SURFACE pSurface;
RENDERHAL_PLANE_DEFINITION PlaneDefinition;
PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
uint32_t dwSurfaceWidth;
uint32_t dwSurfaceHeight;
uint32_t dwUVPitch;
int32_t i;
bool bHalfPitchForChroma;
bool bInterleaveChroma;
bool bWidthInDword;
uint8_t Direction;
uint16_t wUXOffset;
uint16_t wUYOffset;
uint16_t wVXOffset;
uint16_t wVYOffset;
bool bIsChromaSitEnabled;
bool bIsTri9YV12;
//------------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalSurface);
MHW_RENDERHAL_CHK_NULL_RETURN(pParams);
MHW_RENDERHAL_CHK_NULL_RETURN(piNumEntries);
MHW_RENDERHAL_CHK_NULL_RETURN(ppSurfaceEntries);
//------------------------------------------------
eStatus = MOS_STATUS_UNKNOWN;
pSurface = &pRenderHalSurface->OsSurface;
dwUVPitch = pSurface->dwPitch;
bHalfPitchForChroma = false;
bInterleaveChroma = false;
Direction = MEDIASTATE_VDIRECTION_FULL_FRAME;
wUXOffset = 0;
wUYOffset = 0;
wVXOffset = 0;
wVYOffset = 0;
*piNumEntries = -1;
PlaneDefinition = RENDERHAL_PLANES_DEFINITION_COUNT;
bIsChromaSitEnabled = 0;
// In trinity9, YV12 format will use 3 Planes
bIsTri9YV12 = pSurface->Format == Format_YV12 &&
pRenderHal->pOsInterface != nullptr &&
pRenderHal->pOsInterface->trinityPath == TRINITY9_ENABLED;
pRenderHal->bIsAVS = pParams->bAVS;
// Check palette allocations
if (IS_PAL_FORMAT(pSurface->Format))
{
if (pRenderHalSurface->iPaletteID < 0 ||
pRenderHalSurface->iPaletteID >= pRenderHal->iMaxPalettes)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid palette.");
return eStatus;
}
}
// adjust the U/V-Pitch for formats that have U/V-Pitch smaller than Y-Pitch
if (pSurface->Format == Format_I420 ||
pSurface->Format == Format_IYUV ||
pSurface->Format == Format_YV12 ||
pSurface->Format == Format_NV11)
{
dwUVPitch >>= 1;
}
else if (pSurface->Format == Format_YVU9)
{
dwUVPitch >>= 2;
}
if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G8 ||
pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G9 ||
pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G10)
{
// Select the surface/plane description
switch (pSurface->Format)
{
case Format_NV12:
// On G8, NV12 format needs the width and Height to be a multiple
// of 4 for both 3D sampler and 8x8 sampler; G75 needs the width
// of NV12 input surface to be a multiple of 4 for 3D sampler;
// G9+ does not has such restriction; to simplify the implementation,
// we enable 2 plane NV12 for all of the platform when the width
// or Height is not a multiple of 4
if (pRenderHal->pfnIs2PlaneNV12Needed(pRenderHal,
pRenderHalSurface,
pParams->Boundary))
{
PlaneDefinition = RENDERHAL_PLANES_NV12_2PLANES_ADV;
}
else
{
PlaneDefinition = RENDERHAL_PLANES_NV12_ADV;
wUYOffset = RenderHal_CalculateYOffset(pRenderHal->pOsInterface, &pSurface->OsResource);
}
bHalfPitchForChroma = false;
bInterleaveChroma = true;
// Set up chroma direction
Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
break;
case Format_P208:
PlaneDefinition = RENDERHAL_PLANES_P208_1PLANE_ADV;
break;
case Format_IMC1:
case Format_IMC2:
case Format_IMC3:
case Format_IMC4:
case Format_I420:
case Format_IYUV:
case Format_YV12:
case Format_YVU9:
PlaneDefinition = RENDERHAL_PLANES_PL3_ADV;
bHalfPitchForChroma = false;
if (pSurface->Format == Format_I420 ||
pSurface->Format == Format_IYUV ||
pSurface->Format == Format_YV12 ||
pSurface->Format == Format_NV11)
{
bHalfPitchForChroma = true;
}
// Set up chroma direction
Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
if (!pParams->bAVS)
{
// Get U/V offset for PL3 DNDI
RenderHal_Get_DI_UVOffSet(pRenderHalSurface,
&wUXOffset,
&wUYOffset,
&wVXOffset,
&wVYOffset);
PlaneDefinition = RENDERHAL_PLANES_NV12_ADV;
}
break;
case Format_400P:
// Single Y plane here is treated like a NV12 surface.
// U and V offsets fall inside this Y plane. Eventhough false UV pixels are
// picked by the kernel, CSC coeffecients are such that the effect of these
// are nullified.
PlaneDefinition = RENDERHAL_PLANES_NV12_ADV;
break;
case Format_411P:
PlaneDefinition = RENDERHAL_PLANES_411P_ADV;
break;
case Format_411R:
PlaneDefinition = RENDERHAL_PLANES_411R_ADV;
break;
case Format_422H:
PlaneDefinition = RENDERHAL_PLANES_422H_ADV;
break;
case Format_422V:
PlaneDefinition = RENDERHAL_PLANES_422V_ADV;
break;
case Format_444P:
PlaneDefinition = RENDERHAL_PLANES_444P_ADV;
break;
case Format_RGBP:
PlaneDefinition = RENDERHAL_PLANES_RGBP_ADV;
break;
case Format_BGRP:
PlaneDefinition = RENDERHAL_PLANES_BGRP_ADV;
break;
case Format_AYUV:
PlaneDefinition = RENDERHAL_PLANES_AYUV_ADV;
break;
case Format_YUYV:
case Format_YUY2:
if (pParams->bVmeUse)
{
//Since 422 planar is not supported on application side.
//App is using 422 packed as WA with w=w/2 and h=h*2
pSurface->dwWidth = pSurface->dwWidth * 2;
pSurface->dwHeight = pSurface->dwHeight / 2;
pRenderHalSurface->rcSrc.right = pSurface->dwWidth;
pRenderHalSurface->rcSrc.bottom = pSurface->dwHeight;
pRenderHalSurface->rcDst = pRenderHalSurface->rcSrc;
PlaneDefinition = RENDERHAL_PLANES_YUY2_ADV;
// Set up chroma direction
Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
}
else
{
PlaneDefinition = RENDERHAL_PLANES_YUY2_ADV;
// Set up chroma direction
Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
}
break;
case Format_UYVY:
PlaneDefinition = RENDERHAL_PLANES_UYVY_ADV;
// Set up chroma direction
Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
break;
case Format_YVYU:
PlaneDefinition = RENDERHAL_PLANES_YVYU_ADV;
// Set up chroma direction
Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
break;
case Format_VYUY:
PlaneDefinition = RENDERHAL_PLANES_VYUY_ADV;
// Set up chroma direction
Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
break;
case Format_A8R8G8B8:
case Format_X8R8G8B8:
if (pParams->bVASurface)
{
pSurface->dwWidth *= 32;
PlaneDefinition = RENDERHAL_PLANES_Y1;
}
else
{
PlaneDefinition = RENDERHAL_PLANES_ARGB_ADV;
}
break;
case Format_R8G8SN:
if ( pParams->bVASurface )
{
PlaneDefinition = RENDERHAL_PLANES_Y16S;
}
break;
case Format_V8U8:
if ( pParams->bVASurface )
{
PlaneDefinition = RENDERHAL_PLANES_Y16U;
}
break;
case Format_A8B8G8R8:
case Format_X8B8G8R8:
PlaneDefinition = RENDERHAL_PLANES_ABGR_ADV;
break;
case Format_STMM:
PlaneDefinition = RENDERHAL_PLANES_STMM_ADV;
break;
case Format_A8:
case Format_Buffer_2D:
if (pParams->bVASurface)
{
PlaneDefinition = RENDERHAL_PLANES_Y8;
}
break;
case Format_Y8:
PlaneDefinition = RENDERHAL_PLANES_Y8_ADV;
break;
case Format_L8:
case Format_R8UN:
if (pParams->bForceNV12)
{
PlaneDefinition = RENDERHAL_PLANES_NV12_ADV;
bHalfPitchForChroma = false;
bInterleaveChroma = true;
wUYOffset = (uint16_t) pSurface->dwHeight;
}
else
{
PlaneDefinition = RENDERHAL_PLANES_L8_ADV;
}
break;
case Format_A16B16G16R16:
case Format_Y416:
PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16_ADV;
break;
case Format_R10G10B10A2:
case Format_Y410:
PlaneDefinition = RENDERHAL_PLANES_R10G10B10A2_ADV;
break;
case Format_L16:
case Format_R16S:
if (pParams->bVASurface)
{
PlaneDefinition = RENDERHAL_PLANES_Y16S;
}
break;
case Format_D16:
case Format_R16U:
if (pParams->bVASurface)
{
PlaneDefinition = RENDERHAL_PLANES_Y16U;
}
break;
case Format_P010:
case Format_P016:
if (pParams->bVmeUse)
{
PlaneDefinition = RENDERHAL_PLANES_P010_1PLANE_ADV;
}
else if (pRenderHal->bEnableP010SinglePass &&
(pRenderHalSurface->SurfType != RENDERHAL_SURF_OUT_RENDERTARGET))
{
PlaneDefinition = RENDERHAL_PLANES_P010_1PLANE_ADV;
bHalfPitchForChroma = false;
bInterleaveChroma = true;
wUYOffset = RenderHal_CalculateYOffset(pRenderHal->pOsInterface, &pSurface->OsResource);
// Set up chroma direction
Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
}
else
{
// Format not supported with AVS - use regular format
MHW_RENDERHAL_NORMALMESSAGE("Format not supported with AVS.");
pParams->bAVS = false;
// Since the format is not supported with AVS, set the scaling mode as bilinear.
pRenderHalSurface->ScalingMode = RENDERHAL_SCALING_BILINEAR;
if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G8)
{
pParams->Type = RENDERHAL_SURFACE_TYPE_G8;
}
else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G9)
{
pParams->Type = RENDERHAL_SURFACE_TYPE_G9;
}
else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G10)
{
pParams->Type = RENDERHAL_SURFACE_TYPE_G10;
}
else
{
MHW_RENDERHAL_ASSERTMESSAGE("Unsupported surface type");
}
}
break;
case Format_Y210:
case Format_Y216:
if (pParams->bVmeUse)
{
//Since 422 planar is not supported on application side.
//App is using 422 packed as WA with w=w/2 and h=h*2
pSurface->dwWidth = pSurface->dwWidth * 2;
pSurface->dwHeight = pSurface->dwHeight / 2;
pRenderHalSurface->rcSrc.right = pSurface->dwWidth;
pRenderHalSurface->rcSrc.bottom = pSurface->dwHeight;
pRenderHalSurface->rcDst = pRenderHalSurface->rcSrc;
PlaneDefinition = RENDERHAL_PLANES_Y210_1PLANE_ADV;
}
else
{
PlaneDefinition = RENDERHAL_PLANES_Y210_ADV;
}
break;
default:
// Format not supported with AVS - use regular format
MHW_RENDERHAL_NORMALMESSAGE("Format not supported with AVS.");
pParams->bAVS = false;
// Since the format is not supported with AVS, set the scaling mode as bilinear.
pRenderHalSurface->ScalingMode = RENDERHAL_SCALING_BILINEAR;
if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G8)
{
pParams->Type = RENDERHAL_SURFACE_TYPE_G8;
}
else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G9)
{
pParams->Type = RENDERHAL_SURFACE_TYPE_G9;
}
else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G10)
{
pParams->Type = RENDERHAL_SURFACE_TYPE_G10;
}
else
{
MHW_RENDERHAL_ASSERTMESSAGE("Unsupported surface type");
}
break;
}
}
// Select the surface/plane description
if (pParams->Type == RENDERHAL_SURFACE_TYPE_G8 ||
pParams->Type == RENDERHAL_SURFACE_TYPE_G9 ||
pParams->Type == RENDERHAL_SURFACE_TYPE_G10)
{
bIsChromaSitEnabled = pRenderHal->pRenderHalPltInterface->IsChromasitingEnabled(pRenderHal, pParams);
switch (pSurface->Format)
{
case Format_IMC1:
case Format_IMC2:
case Format_IMC3:
case Format_IMC4:
case Format_I420:
case Format_IYUV:
case Format_YVU9:
PlaneDefinition = RENDERHAL_PLANES_PL3;
break;
case Format_YV12:
bHalfPitchForChroma = true;
// Y_Uoffset(Height*2 + Height/2) of RENDERHAL_PLANES_YV12 define Bitfield_Range(0, 13) on gen9+.
// The max value is 16383. So use PL3 kernel to avoid out of range when Y_Uoffset is larger than 16383.
// Use PL3 plane to avoid YV12 blending issue with DI enabled and U channel shift issue with not 4-aligned height
PlaneDefinition = (pRenderHal->bEnableYV12SinglePass &&
!pRenderHalSurface->pDeinterlaceParams &&
!pRenderHalSurface->bInterlacedScaling &&
!bIsTri9YV12 &&
MOS_IS_ALIGNED(pSurface->dwHeight, 4) &&
pRenderHalSurface->SurfType != RENDERHAL_SURF_OUT_RENDERTARGET &&
(pSurface->dwHeight * 2 + pSurface->dwHeight / 2) < RENDERHAL_MAX_YV12_PLANE_Y_U_OFFSET_G9)?
RENDERHAL_PLANES_YV12 : RENDERHAL_PLANES_PL3;
break;
case Format_400P:
// Single Y plane here is treated like a NV12 surface.
// U and V offsets fall inside this Y plane. Eventhough false UV pixels are
// picked by the kernel, CSC coeffecients are such that the effect of these
// are nullified.
PlaneDefinition = RENDERHAL_PLANES_NV12;
break;
case Format_P208:
PlaneDefinition = RENDERHAL_PLANES_P208;
break;
case Format_P010:
case Format_P016:
if (pParams->bUseSinglePlane == true)
{
PlaneDefinition = RENDERHAL_PLANES_R16_UNORM;
}
else if (pRenderHal->bEnableP010SinglePass &&
(pRenderHalSurface->SurfType != RENDERHAL_SURF_OUT_RENDERTARGET))
{
PlaneDefinition = RENDERHAL_PLANES_P010_1PLANE;
}
else
{
PlaneDefinition = RENDERHAL_PLANES_P010;
}
break;
case Format_411P:
PlaneDefinition = RENDERHAL_PLANES_411P;
break;
case Format_411R:
PlaneDefinition = RENDERHAL_PLANES_411R;
break;
case Format_422H:
PlaneDefinition = RENDERHAL_PLANES_422H;
break;
case Format_422V:
PlaneDefinition = RENDERHAL_PLANES_422V;
break;
case Format_444P:
PlaneDefinition = RENDERHAL_PLANES_444P;
break;
case Format_RGBP:
PlaneDefinition = RENDERHAL_PLANES_RGBP;
break;
case Format_BGRP:
PlaneDefinition = RENDERHAL_PLANES_BGRP;
break;
case Format_NV12:
// On Gen7.5 (Haswell) NV12 format needs a single plane instead
// of two (listed in renderhal_g75.c for RENDERHAL_PLANES_NV12), and
// is also expected by the Sampler or Media Kernels. Yet, the
// Data Port works with two planes instead. Besides, the Sampler
// uses it for input only (as there is no output) while the Data
// Port uses it for input as well as output or both for the same
// surface. Hence the check added for bWidthInDword_Y &&
// bWidthInDword_UV, which are set in vphal_render_3P.c for the
// above reason. Two plane NV12 can also be explicitly spcified.
// On G8, NV12 format needs the width and Height to be a multiple
// of 4 for both 3D sampler and 8x8 sampler; G75 needs the width
// of NV12 input surface to be a multiple of 4 for 3D sampler;
// On G9+, width need to be a multiple of 2, while height still need
// be a multiple of 4; since G9 already post PV, just keep the old logic
// to enable 2 plane NV12 when the width or Height is not a multiple of 4.
// For G10+, enable 2 plane NV12 when width is not multiple of 2 or height
// is not multiple of 4.
if (pParams->bUseSinglePlane == true)
{
PlaneDefinition = RENDERHAL_PLANES_R8;
}
else if (pRenderHalSurface->SurfType == RENDERHAL_SURF_OUT_RENDERTARGET ||
(pParams->bWidthInDword_Y && pParams->bWidthInDword_UV) ||
pParams->b2PlaneNV12NeededByKernel ||
bIsChromaSitEnabled ||
pRenderHal->pfnIs2PlaneNV12Needed(pRenderHal,
pRenderHalSurface,
pParams->Boundary))
{
PlaneDefinition = RENDERHAL_PLANES_NV12_2PLANES;
}
else
{
PlaneDefinition = RENDERHAL_PLANES_NV12;
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
pRenderHal->pRenderHalPltInterface->GetPlaneDefForFormatNV12(
PlaneDefinition);
}
break;
case Format_YUYV :
case Format_YUY2 :
if (bIsChromaSitEnabled)
{
PlaneDefinition = RENDERHAL_PLANES_YUY2_2PLANES;
}
else
{
PlaneDefinition = RENDERHAL_PLANES_YUY2;
}
break;
case Format_G8R8_G8B8:
case Format_UYVY :
PlaneDefinition = RENDERHAL_PLANES_UYVY;
break;
case Format_YVYU:
PlaneDefinition = RENDERHAL_PLANES_YVYU;
break;
case Format_VYUY:
PlaneDefinition = RENDERHAL_PLANES_VYUY;
break;
case Format_A8R8G8B8:
PlaneDefinition = RENDERHAL_PLANES_ARGB;
break;
case Format_R32U:
PlaneDefinition = RENDERHAL_PLANES_R32U;
break;
case Format_R32S:
PlaneDefinition = RENDERHAL_PLANES_R32S;
break;
case Format_R32F:
case Format_D32F:
case Format_R32:
PlaneDefinition = RENDERHAL_PLANES_R32F;
break;
case Format_G32R32F:
PlaneDefinition = RENDERHAL_PLANES_G32R32F;
break;
case Format_Y8:
PlaneDefinition = RENDERHAL_PLANES_R8;
break;
case Format_Y1:
PlaneDefinition = RENDERHAL_PLANES_Y1;
break;
case Format_Y16U:
PlaneDefinition = RENDERHAL_PLANES_Y16U;
break;
case Format_Y16S:
PlaneDefinition = RENDERHAL_PLANES_Y16S;
break;
case Format_R8G8SN:
case Format_V8U8:
PlaneDefinition = RENDERHAL_PLANES_V8U8;
break;
case Format_R16U:
PlaneDefinition = RENDERHAL_PLANES_R16U;
break;
case Format_R16S:
PlaneDefinition = RENDERHAL_PLANES_R16S;
break;
case Format_R8G8UN:
PlaneDefinition = RENDERHAL_PLANES_R8G8_UNORM;
break;
case Format_X8R8G8B8:
// h/w doesn't support XRGB render target
PlaneDefinition =
(pParams->isOutput) ? RENDERHAL_PLANES_ARGB : RENDERHAL_PLANES_XRGB;
break;
case Format_A8B8G8R8:
PlaneDefinition = RENDERHAL_PLANES_ABGR;
break;
case Format_X8B8G8R8:
// h/w doesn't support XBGR render target
PlaneDefinition =
(pParams->isOutput) ? RENDERHAL_PLANES_ABGR : RENDERHAL_PLANES_XBGR;
break;
case Format_R5G6B5:
PlaneDefinition = RENDERHAL_PLANES_RGB16;
break;
case Format_R8G8B8:
PlaneDefinition = RENDERHAL_PLANES_RGB24;
break;
case Format_AYUV :
PlaneDefinition = RENDERHAL_PLANES_AYUV;
break;
case Format_AI44 :
PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ?
RENDERHAL_PLANES_AI44_PALLETE_0 :
RENDERHAL_PLANES_AI44_PALLETE_1;
break;
case Format_IA44:
PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ?
RENDERHAL_PLANES_IA44_PALLETE_0 :
RENDERHAL_PLANES_IA44_PALLETE_1;
break;
case Format_P8:
PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ?
RENDERHAL_PLANES_P8_PALLETE_0 :
RENDERHAL_PLANES_P8_PALLETE_1;
break;
case Format_A8P8:
PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ?
RENDERHAL_PLANES_A8P8_PALLETE_0 :
RENDERHAL_PLANES_A8P8_PALLETE_1;
break;
case Format_STMM:
PlaneDefinition = RENDERHAL_PLANES_STMM;
break;
case Format_L8:
PlaneDefinition = RENDERHAL_PLANES_L8;
break;
case Format_A8:
case Format_Buffer_2D:
PlaneDefinition = RENDERHAL_PLANES_A8;
break;
case Format_R8U:
case Format_R8UN:
PlaneDefinition = RENDERHAL_PLANES_R8;
break;
case Format_R16UN:
case Format_D16:
case Format_R16:
PlaneDefinition = RENDERHAL_PLANES_R16_UNORM;
break;
case Format_A16B16G16R16:
PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16;
break;
case Format_Y416:
if (pRenderHalSurface->SurfType == RENDERHAL_SURF_OUT_RENDERTARGET)
{
PlaneDefinition = RENDERHAL_PLANES_Y416_RT;
}
else
{
PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16;
}
break;
case Format_A16B16G16R16F:
PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16F;
break;
case Format_A16R16G16B16F:
PlaneDefinition = RENDERHAL_PLANES_A16R16G16B16F;
break;
case Format_R32G32B32A32F:
PlaneDefinition = RENDERHAL_PLANES_R32G32B32A32F;
break;
case Format_NV21:
PlaneDefinition = RENDERHAL_PLANES_NV21;
break;
case Format_L16:
PlaneDefinition = RENDERHAL_PLANES_L16;
break;
case Format_R10G10B10A2:
case Format_Y410:
PlaneDefinition = RENDERHAL_PLANES_R10G10B10A2;
break;
case Format_Y210:
case Format_Y216:
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->GetPlaneDefForFormatY216(
(pRenderHalSurface->SurfType == RENDERHAL_SURF_OUT_RENDERTARGET),
pRenderHal,
PlaneDefinition));
break;
case Format_B10G10R10A2:
PlaneDefinition = RENDERHAL_PLANES_B10G10R10A2;
break;
case Format_IRW0:
PlaneDefinition = RENDERHAL_PLANES_IRW0;
break;
case Format_IRW1:
PlaneDefinition = RENDERHAL_PLANES_IRW1;
break;
case Format_IRW2:
PlaneDefinition = RENDERHAL_PLANES_IRW2;
break;
case Format_IRW3:
PlaneDefinition = RENDERHAL_PLANES_IRW3;
break;
case Format_R16G16UN:
PlaneDefinition = RENDERHAL_PLANES_R16G16_UNORM;
break;
case Format_R16G16S:
PlaneDefinition = RENDERHAL_PLANES_R16G16_SINT;
break;
case Format_R16F:
PlaneDefinition = RENDERHAL_PLANES_R16_FLOAT;
break;
case Format_R24G8:
case Format_D24S8UN:
PlaneDefinition = RENDERHAL_PLANES_R24_UNORM_X8_TYPELESS;
break;
case Format_R32G8X24:
case Format_D32S8X24_FLOAT:
PlaneDefinition = RENDERHAL_PLANES_R32_FLOAT_X8X24_TYPELESS;
break;
default:
return eStatus;
}
}
if (pParams->forceCommonSurfaceMessage)
{
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pfnGetPlaneDefinitionForCommonMessage);
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnGetPlaneDefinitionForCommonMessage(pRenderHal, pSurface->Format, pParams, pRenderHalSurface->SurfType == RENDERHAL_SURF_OUT_RENDERTARGET, PlaneDefinition));
}
// Get plane definitions
MHW_RENDERHAL_ASSERT(PlaneDefinition < RENDERHAL_PLANES_DEFINITION_COUNT);
*piNumEntries = pRenderHal->pPlaneDefinitions[PlaneDefinition].dwNumPlanes;
pPlane = pRenderHal->pPlaneDefinitions[PlaneDefinition].Plane;
if (*piNumEntries == 0)
{
return eStatus;
}
// Surface state allocation/setting loop
for (i = 0; i < *piNumEntries; i++, pPlane++)
{
// Assign a New Surface State Entry
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnAssignSurfaceState(pRenderHal,
pParams->Type,
&pSurfaceEntry));
// Save surface entry
ppSurfaceEntries[i] = pSurfaceEntry;
// Adjust the surface height and width
pRenderHal->pfnAdjustBoundary(pRenderHal,
pRenderHalSurface,
pParams->Boundary,
&dwSurfaceWidth,
&dwSurfaceHeight);
//set dwSurfaceHeight = roundup(dwSurfaceHeight / pPlane->ui8ScaleHeight) to support NV12 format with odd height
dwSurfaceHeight = (dwSurfaceHeight + pPlane->ui8ScaleHeight - 1) / pPlane->ui8ScaleHeight;
dwSurfaceWidth = dwSurfaceWidth / pPlane->ui8ScaleWidth;
// U/V/UV plane
if (pPlane->ui8PlaneID == MHW_U_PLANE ||
pPlane->ui8PlaneID == MHW_V_PLANE)
{
bWidthInDword = pParams->bWidthInDword_UV;
}
else
{
bWidthInDword = pParams->bWidthInDword_Y;
}
// Adjust the width
if (bWidthInDword)
{
if (PlaneDefinition == RENDERHAL_PLANES_R32G32B32A32F)
{
dwSurfaceWidth = dwSurfaceWidth << 2;
}
else if (PlaneDefinition == RENDERHAL_PLANES_A16B16G16R16 ||
PlaneDefinition == RENDERHAL_PLANES_A16B16G16R16_ADV ||
PlaneDefinition == RENDERHAL_PLANES_A16B16G16R16F ||
PlaneDefinition == RENDERHAL_PLANES_A16R16G16B16F ||
PlaneDefinition == RENDERHAL_PLANES_G32R32F ||
PlaneDefinition == RENDERHAL_PLANES_Y210_RT ||
PlaneDefinition == RENDERHAL_PLANES_Y416_RT ||
PlaneDefinition == RENDERHAL_PLANES_R32_FLOAT_X8X24_TYPELESS)
{
dwSurfaceWidth = dwSurfaceWidth << 1;
}
else if (MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrDisableRenderTargetWidthAdjust) &&
(PlaneDefinition == RENDERHAL_PLANES_NV12_2PLANES ||
PlaneDefinition == RENDERHAL_PLANES_P010 ||
PlaneDefinition == RENDERHAL_PLANES_YUY2_2PLANES ||
PlaneDefinition == RENDERHAL_PLANES_YUY2 ||
PlaneDefinition == RENDERHAL_PLANES_RGBP ||
PlaneDefinition == RENDERHAL_PLANES_PL3 ||
PlaneDefinition == RENDERHAL_PLANES_YV12 ||
PlaneDefinition == RENDERHAL_PLANES_R16_UNORM ||
PlaneDefinition == RENDERHAL_PLANES_R8 ||
PlaneDefinition == RENDERHAL_PLANES_A8 ||
PlaneDefinition == RENDERHAL_PLANES_RGB16 ||
PlaneDefinition == RENDERHAL_PLANES_BGRP))
{
dwSurfaceWidth = dwSurfaceWidth / OutputSurfaceWidthRatio;
}
else
{
dwSurfaceWidth = (dwSurfaceWidth + pPlane->ui8PixelsPerDword - 1) /
pPlane->ui8PixelsPerDword;
}
}
if (pParams->bVertStride)
{
dwSurfaceHeight /= 2;
dwSurfaceHeight = MOS_MAX(dwSurfaceHeight, 1);
}
dwSurfaceHeight = MOS_ALIGN_FLOOR(dwSurfaceHeight, pPlane->ui8AlignHeight);
dwSurfaceWidth = MOS_ALIGN_FLOOR(dwSurfaceWidth , pPlane->ui8AlignWidth);
// Setup surface state entry
*(pSurfaceEntry->pSurface) = *pSurface;
pSurfaceEntry->dwFormat = pPlane->dwFormat;
pSurfaceEntry->dwWidth = MOS_MAX(1, dwSurfaceWidth);
pSurfaceEntry->dwHeight = MOS_MAX(1, dwSurfaceHeight);
pSurfaceEntry->bWidthInDword = bWidthInDword;
if (pPlane->ui8PlaneID == MHW_U_PLANE || pPlane->ui8PlaneID == MHW_V_PLANE)
{
if (bIsTri9YV12)
{
pSurfaceEntry->dwPitch = (pPlane->ui8PlaneID == MHW_U_PLANE) ? pSurface->dwUPitch : pSurface->dwVPitch;
}
else
{
pSurfaceEntry->dwPitch = dwUVPitch;
}
}
else
{
pSurfaceEntry->dwPitch = bIsTri9YV12 ? pSurface->dwYPitch : pSurface->dwPitch;
}
pSurfaceEntry->dwQPitch = pSurface->dwQPitch;
pSurfaceEntry->YUVPlane = pPlane->ui8PlaneID;
pSurfaceEntry->bAVS = pPlane->bAdvanced;
pSurfaceEntry->isOutput = pParams->isOutput;
pSurfaceEntry->bVertStride = pParams->bVertStride;
pSurfaceEntry->bVertStrideOffs = pParams->bVertStrideOffs;
pSurfaceEntry->bTiledSurface = (pSurface->TileType != MOS_TILE_LINEAR)
? true
: false;
pSurfaceEntry->bTileWalk = IS_Y_MAJOR_TILE_FORMAT(pSurface->TileType)
? GFX3DSTATE_TILEWALK_YMAJOR
: GFX3DSTATE_TILEWALK_XMAJOR;
// AVS/ADI parameters
pSurfaceEntry->bHalfPitchChroma = bHalfPitchForChroma;
pSurfaceEntry->bInterleaveChroma = bInterleaveChroma;
pSurfaceEntry->DirectionV = Direction & 0x7;
pSurfaceEntry->DirectionU = Direction >> 0x3;
pSurfaceEntry->wUXOffset = wUXOffset;
pSurfaceEntry->wUYOffset = wUYOffset;
pSurfaceEntry->wVXOffset = wVXOffset;
pSurfaceEntry->wVYOffset = wVYOffset;
pSurfaceEntry->AddressControl = pParams->AddressControl;
}
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Get Plane Definition For OCL FC
//! \details Get Specific Plane Definition for OCL FC usage
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param MOS_FORMAT format
//! [in] surface format
//! \param bool isRenderTaget
//! [in] the surface type is RENDERHAL_SURF_OUT_RENDERTARGET
//! \param RENDERHAL_PLANE_DEFINITION &planeDefinition
//! [out] Plane Definition
//! \return MOS_STATUS
//! Error code if invalid parameters, MOS_STATUS_SUCCESS otherwise
//!
MOS_STATUS RenderHal_GetPlaneDefinitionForCommonMessage(
PRENDERHAL_INTERFACE pRenderHal,
MOS_FORMAT format,
PRENDERHAL_SURFACE_STATE_PARAMS &pParam,
bool isRenderTarget,
RENDERHAL_PLANE_DEFINITION &planeDefinition)
{
switch (format)
{
case Format_A8R8G8B8:
case Format_X8R8G8B8:
case Format_A16R16G16B16:
case Format_R10G10B10A2:
case Format_AYUV:
case Format_A16R16G16B16F:
case Format_A8B8G8R8:
case Format_X8B8G8R8:
case Format_A16B16G16R16:
case Format_B10G10R10A2:
case Format_A16B16G16R16F:
case Format_Y410:
case Format_P210:
case Format_P216:
case Format_I420:
case Format_IMC3:
case Format_IYUV:
case Format_R5G6B5:
case Format_R8G8B8:
case Format_RGBP:
case Format_BGRP:
case Format_444P:
case Format_422H:
case Format_422V:
case Format_411P:
case Format_R8UN:
case Format_R8G8UN:
//already handled rightly in normal non-adv GetPlaneDefinition
break;
case Format_YV12:
planeDefinition = RENDERHAL_PLANES_PL3;
break;
case Format_NV12:
if (pParam->combineChannelY)
{
planeDefinition = RENDERHAL_PLANES_NV12_2PLANES_COMBINED;
}
break;
case Format_P010:
case Format_P016:
if (pParam->combineChannelY)
{
planeDefinition = RENDERHAL_PLANES_P016_2PLANES_COMBINED;
}
break;
case Format_400P:
planeDefinition = RENDERHAL_PLANES_R8;
break;
case Format_YUY2:
case Format_YUYV:
case Format_YVYU:
case Format_UYVY:
case Format_VYUY:
if (pParam->isOutput)
{
//For writing, packed 422 formats use R8G8 to write half pixel(YU/YV) separately
planeDefinition = RENDERHAL_PLANES_R8G8_UNORM;
}
else
{
//For reading, packed 422 formats use R8G8 for Y and A8R8G8B8 for UV
planeDefinition = RENDERHAL_PLANES_YUY2_2PLANES_WIDTH_UNALIGNED;
}
break;
case Format_Y210:
case Format_Y216:
if (pParam->isOutput)
{
//For writing, packed 422 formats use R16G16 to write half pixel(YU/YV) separately
planeDefinition = RENDERHAL_PLANES_R16G16_UNORM;
}
else
{
//For reading, packed 422 formats use RG16 for Y and ARGB16 for UV
planeDefinition = RENDERHAL_PLANES_Y210;
}
break;
case Format_Y416:
planeDefinition = RENDERHAL_PLANES_A16B16G16R16;
break;
default:
return MOS_STATUS_INVALID_PARAMETER;
}
return MOS_STATUS_SUCCESS;
}
//!
//! \brief Enable Palette
//! \details Enable HW palette - reuse previous palette data
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param uint32_t uiPaletteID
//! [in] Palette ID (0 to available palettes - 1)
//! \param int32_t iPaletteSize
//! [in] Palette Size (<=0 - disable palette)
//! \return MOS_STATUS
//! Error code if invalid parameters, MOS_STATUS_SUCCESS otherwise
//!
MOS_STATUS RenderHal_EnablePalette(
PRENDERHAL_INTERFACE pRenderHal,
int32_t iPaletteID,
int32_t iPaletteSize)
{
PMHW_PALETTE_PARAMS pPalette;
//-------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_ASSERT(iPaletteID >= 0);
MHW_RENDERHAL_ASSERT(iPaletteID < pRenderHal->iMaxPalettes);
//-------------------------------------
// Palette ID provided invalid or allocation failed
//pHwCommands = pRenderHal->pHwCommands;
// Set palette size - 0 disables palette send command
iPaletteSize = MOS_MAX(iPaletteSize, 0);
iPaletteSize = MOS_MIN(iPaletteSize, pRenderHal->iMaxPaletteEntries);
pPalette = &(pRenderHal->Palette[iPaletteID]);
pPalette->iNumEntries = iPaletteSize;
return MOS_STATUS_SUCCESS;
}
//!
//! \brief Allocate Palette ID
//! \details Allocate palette ID for Client
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface structure
//! \param int32_t *pPaletteID
//! [out] Pointer to Palette ID
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS, otherwise MOS_STATUS_NO_SPACE or MOS_STATUS_NULL_POINTER
//!
MOS_STATUS RenderHal_AllocatePaletteID(
PRENDERHAL_INTERFACE pRenderHal,
int32_t *pPaletteID)
{
int32_t i;
PMHW_PALETTE_PARAMS pOutPalette;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pPaletteID);
*pPaletteID = -1;
pOutPalette = pRenderHal->Palette;
// search first palette not in use
for (i = 0;
i < pRenderHal->iMaxPalettes;
i++, pOutPalette++)
{
if (pOutPalette->iNumEntries == 0)
{
pOutPalette->iNumEntries = -1;
break;
}
}
// Allocation failed
if (i < 0 || i >= pRenderHal->iMaxPalettes)
{
MHW_RENDERHAL_ASSERTMESSAGE("cannot find valid palette ID.");
eStatus = MOS_STATUS_NO_SPACE;
return eStatus;
}
else
{
*pPaletteID = i;
}
return eStatus;
}
//!
//! \brief Get Palette Entry Size and Address
//! \details Get Palette Entry Size and Address for Client to load palette
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface structure
//! \param int32_t iPaletteID
//! [in] Input Palette ID
//! \param int32_t iInNumEntries
//! [in] Number of Input Palette entries
//! \param int32_t *piOutNumEntries
//! [out] Number of Output Palette entries
//! \param void **pPaletteData
//! [out] Pointer to Output Palette data address
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS, otherwise MOS_STATUS_INVALID_PARAMETER or MOS_STATUS_NULL_POINTER
//!
MOS_STATUS RenderHal_GetPaletteEntry(
PRENDERHAL_INTERFACE pRenderHal,
int32_t iPaletteID,
int32_t iInNumEntries,
int32_t *piOutNumEntries,
void **pPaletteData)
{
PMHW_PALETTE_PARAMS pOutPalette;
int32_t iSize;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(piOutNumEntries);
MHW_RENDERHAL_CHK_NULL_RETURN(pPaletteData);
*piOutNumEntries = -1;
*pPaletteData = nullptr;
// Palette Index provided invalid
if (iPaletteID < 0 || iPaletteID >= pRenderHal->iMaxPalettes)
{
MHW_RENDERHAL_ASSERTMESSAGE("invalid palette ID.");
eStatus = MOS_STATUS_INVALID_PARAMETER;
return eStatus;
}
// Input Palette entry number invalid
if (iInNumEntries < 1)
{
MHW_RENDERHAL_ASSERTMESSAGE("invalid Input Palette entries.");
eStatus = MOS_STATUS_INVALID_PARAMETER;
return eStatus;
}
// Get pointer to output palette
pOutPalette = &(pRenderHal->Palette[iPaletteID]);
// Pallete is too large - truncate
if (iInNumEntries > pRenderHal->iMaxPaletteEntries)
{
iSize = pRenderHal->iMaxPaletteEntries;
MHW_RENDERHAL_ASSERTMESSAGE("Palette truncated from %d to %d.", iInNumEntries, iSize);
}
else
{
iSize = iInNumEntries;
}
// Pallete is being overwritten - just log
if (pOutPalette->iNumEntries != 0 &&
pOutPalette->iNumEntries != -1)
{
MHW_RENDERHAL_ASSERTMESSAGE("overwriting palette %d.", iPaletteID);
}
pOutPalette->iNumEntries = iSize;
*piOutNumEntries = iSize;
*pPaletteData = pOutPalette->pPaletteData;
return eStatus;
}
//!
//! \brief Free Palette ID
//! \details Free palette ID
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface structure
//! \param int32_t *pPaletteID
//! [in/out] Pointer to Palette ID
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS, otherwise MOS_STATUS_INVALID_PARAMETER or MOS_STATUS_NULL_POINTER
//!
MOS_STATUS RenderHal_FreePaletteID(
PRENDERHAL_INTERFACE pRenderHal,
int32_t *pPaletteID)
{
PMHW_PALETTE_PARAMS pOutPalette;
int32_t iPaletteID;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pPaletteID);
iPaletteID = *pPaletteID;
if (iPaletteID < 0 || iPaletteID >= pRenderHal->iMaxPalettes)
{
MHW_RENDERHAL_ASSERTMESSAGE("invalid palette ID.");
eStatus = MOS_STATUS_INVALID_PARAMETER;
return eStatus;
}
pOutPalette = &(pRenderHal->Palette[iPaletteID]);
pOutPalette->iNumEntries = 0;
*pPaletteID = -1;
return eStatus;
}
//!
//! \brief Allocate ChromaKey
//! \details Allocate chroma key for use with sampler
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param uint32_t dwLow
//! Min Key Range
//! \param uint32_t dwHigh
//! Max Key Range
//! \return int32_t
//! Chroma key index
//! -1 if not available
//!
int32_t RenderHal_AllocateChromaKey(
PRENDERHAL_INTERFACE pRenderHal,
uint32_t dwLow,
uint32_t dwHigh)
{
PMHW_CHROMAKEY_PARAMS pChromaKey;
int32_t iChromaKeyIndex = -1;
// Validate parameters
if (pRenderHal == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid RenderHal interface.");
return iChromaKeyIndex;
}
if (pRenderHal->iChromaKeyCount > pRenderHal->iMaxChromaKeys)
{
MHW_RENDERHAL_ASSERTMESSAGE("Reached max number of chroma keys.");
return iChromaKeyIndex;
}
// Get chroma index - setup command
iChromaKeyIndex = pRenderHal->iChromaKeyCount++;
pChromaKey = &pRenderHal->ChromaKey[iChromaKeyIndex];
pChromaKey->dwLow = dwLow;
pChromaKey->dwHigh = dwHigh;
// Return Chroma Key Index
return iChromaKeyIndex;
}
//!
//! \brief Assign Media State
//! \details Gets a pointer to the next available media state in GSH;
//! fails if not available
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hadrware Interface Structure
//! \param RENDERHAL_COMPONENT componentID
//! [in] Identifier of the requesting component
//! \return PRENDERHAL_MEDIA_STATE
//! gets a new Media State, returns pointer to Media State structure
//! nullptr - invalid, no states available + timeout
//!
PRENDERHAL_MEDIA_STATE RenderHal_AssignMediaState(
PRENDERHAL_INTERFACE pRenderHal,
RENDERHAL_COMPONENT componentID)
{
uint32_t dwWaitMs, dwWaitTag;
PMOS_INTERFACE pOsInterface = nullptr; // OS interface
PRENDERHAL_STATE_HEAP pStateHeap = nullptr; // State Heap control struct
PRENDERHAL_MEDIA_STATE pCurMediaState; // Media state control in GSH struct
uint8_t *pCurrentPtr;
int i;
size_t mediaStateSize = 0;
uint8_t *ptrMediaState = nullptr;
pCurMediaState = nullptr;
pCurrentPtr = nullptr;
if (pRenderHal)
{
pOsInterface = pRenderHal->pOsInterface;
pStateHeap = pRenderHal->pStateHeap;
}
// Validate state
if (pRenderHal == nullptr || // invalid Hw state
pOsInterface == nullptr || // invalid OS interface
pStateHeap == nullptr || // invalid State Heap
pStateHeap->pMediaStates == nullptr || // invalid Media State Array
pStateHeap->bGshLocked == false || // State Heap not locked
pRenderHal->pRenderHalPltInterface == nullptr || // invalid RenderHal Platform Interface
pRenderHal->StateHeapSettings.iMediaStateHeaps == 0)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid state.");
return pCurMediaState;
}
mediaStateSize = pRenderHal->pRenderHalPltInterface->GetRenderHalMediaStateSize();
// Refresh sync tag for all media states
pRenderHal->pfnRefreshSync(pRenderHal);
// Get next media state and tag to check
ptrMediaState = (uint8_t*)pStateHeap->pMediaStates;
ptrMediaState += pStateHeap->iNextMediaState * mediaStateSize;
pCurMediaState = (PRENDERHAL_MEDIA_STATE)ptrMediaState;
// The code below is unlikely to be executed - unless all media states are in use
// If this ever happens, please consider increasing the number of media states
if (pCurMediaState->bBusy)
{
dwWaitTag = pCurMediaState->dwSyncTag;
// Wait for Batch Buffer complete event OR timeout
for (dwWaitMs = pRenderHal->dwTimeoutMs; dwWaitMs > 0; dwWaitMs--)
{
//MOS_GPU_CONTEXT_RENDER or MOS_GPU_CONTEXT_RENDER3
pOsInterface->pfnWaitForBBCompleteNotifyEvent(pOsInterface, pOsInterface->CurrentGpuContextOrdinal, RENDERHAL_EVENT_TIMEOUT_MS);
// Wait for tag (end of command buffer, start of next command buffer)
if ((int32_t)(pStateHeap->pSync[0] - dwWaitTag) > 0) break;
}
// Timeout
if (dwWaitMs == 0)
{
MHW_RENDERHAL_ASSERTMESSAGE("Timeout for waiting free media state.");
pStateHeap->pCurMediaState = pCurMediaState = nullptr;
return pCurMediaState;
}
}
// Setup the Current Media State
pStateHeap->pCurMediaState = pCurMediaState;
pStateHeap->iCurMediaState = pStateHeap->iNextMediaState;
// Point to the next media state
pStateHeap->iNextMediaState = (pStateHeap->iNextMediaState + 1) %
(pRenderHal->StateHeapSettings.iMediaStateHeaps);
// Reset media state
pCurMediaState->dwSyncTag = pStateHeap->dwNextTag;
pCurMediaState->dwSyncCount = 0;
pCurMediaState->iCurbeOffset = 0;
MOS_FillMemory( pCurMediaState->piAllocation,
pRenderHal->StateHeapSettings.iMediaIDs * sizeof(int32_t),
-1);
// Reset HW allocations
pRenderHal->iChromaKeyCount = 0;
for (i = 0; i < pRenderHal->iMaxPalettes; i++)
{
pRenderHal->Palette[i].iNumEntries = 0;
}
// Zero Memory start time and end time
pCurrentPtr = pStateHeap->pGshBuffer + // GSH base
pStateHeap->pCurMediaState->dwOffset +
pStateHeap->dwOffsetStartTime;
if(pCurrentPtr)
{
// Start time
*((uint64_t*)pCurrentPtr) = 0;
}
// End time
pCurrentPtr += pStateHeap->dwStartTimeSize;
*((uint64_t*)pCurrentPtr) = 0;
// Component ID
pCurrentPtr += pStateHeap->dwEndTimeSize;
*((RENDERHAL_COMPONENT *)pCurrentPtr) = componentID;
return pCurMediaState;
}
//!
//! \brief Destroy
//! \details Free all resources allocated by RenderHal
//! \param PRENDERHAL_INTERFACE pRenderHal
//! \return void
//!
MOS_STATUS RenderHal_Destroy(PRENDERHAL_INTERFACE pRenderHal)
{
MOS_STATUS eStatus;
//------------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
//------------------------------------------------
eStatus = MOS_STATUS_UNKNOWN;
// Free State Heaps
eStatus = (MOS_STATUS)(pRenderHal->pfnFreeStateHeaps(pRenderHal));
if (eStatus != MOS_STATUS_SUCCESS)
{
MHW_RENDERHAL_ASSERTMESSAGE("Failed to free state heeps, eStatus:%d.\n", eStatus);
}
// Destroy MHW Render Interface
pRenderHal->pRenderHalPltInterface->DestoryMhwInterface(pRenderHal);
// Release pBatchBufferMemPool
if (pRenderHal->pBatchBufferMemPool)
{
MOS_Delete(pRenderHal->pBatchBufferMemPool);
pRenderHal->pBatchBufferMemPool = nullptr;
}
// Release PredicationBuffer
if (!Mos_ResourceIsNull(&pRenderHal->PredicationBuffer))
{
pRenderHal->pOsInterface->pfnFreeResource(
pRenderHal->pOsInterface,
&pRenderHal->PredicationBuffer);
}
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->DestroyPerfProfiler(pRenderHal));
// Destruct Platform Interface
if (pRenderHal->pRenderHalPltInterface)
{
MOS_Delete(pRenderHal->pRenderHalPltInterface);
pRenderHal->pRenderHalPltInterface = nullptr;
}
// Free multiple trackers
pRenderHal->trackerProducer.~FrameTrackerProducer();
// Free Debug Surface
RenderHal_FreeDebugSurface(pRenderHal);
// Decrease reference count for shared pointer
pRenderHal->userSettingPtr = nullptr;
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Load Curbe Data
//! \details Allocates and load CURBE data for Media
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface structure
//! \param PRENDERHAL_MEDIA_STATE pCurMediaState
//! [out] Pointer to Current Media State structure
//! \param void *pData
//! [in] Pointer to Data
//! \param int32_t iSize
//! [in] Number of bytes to allocate
//! \return int32_t
//! Offset of the CURBE block from CURBE base (in bytes)
//! -1 if no CURBE space available in GSH
//!
int32_t RenderHal_LoadCurbeData(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_MEDIA_STATE pCurMediaState,
void *pData,
int32_t iSize)
{
int32_t iOffset;
int32_t iCurbeSize;
uint8_t *pPtrCurbe;
PRENDERHAL_STATE_HEAP pStateHeap;
iOffset = -1;
pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr;
if (pStateHeap && pCurMediaState)
{
iCurbeSize = MOS_ALIGN_CEIL(iSize, pRenderHal->dwCurbeBlockAlign);
if (pCurMediaState->iCurbeOffset + iCurbeSize <= (int)pStateHeap->dwSizeCurbe)
{
iOffset = pCurMediaState->iCurbeOffset;
pCurMediaState->iCurbeOffset += iCurbeSize;
if (pData)
{
pPtrCurbe = pStateHeap->pGshBuffer + // GSH base
pStateHeap->pCurMediaState->dwOffset + // Offset to media state
pStateHeap->dwOffsetCurbe + // Offset to curbe area
iOffset; // Current curbe offset
// Copy data to CURBE
MOS_SecureMemcpy(pPtrCurbe, iSize, pData, iSize);
// Zero remaining CURBE (for buffer alignment)
iCurbeSize -= iSize;
if (iCurbeSize > 0)
{
MOS_ZeroMemory(pPtrCurbe + iSize, iCurbeSize);
}
if (pRenderHal->curbeResourceListSize > 0)
{
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->curbeResourceList);
for (uint32_t i = 0; i < pRenderHal->curbeResourceListSize; ++i)
{
MHW_INDIRECT_STATE_RESOURCE_PARAMS &resourceParam = pRenderHal->curbeResourceList[i];
resourceParam.stateHeap = &pStateHeap->GshOsResource;
resourceParam.stateBasePtr = pStateHeap->pGshBuffer;
resourceParam.stateOffset += (pStateHeap->pCurMediaState->dwOffset + pStateHeap->dwOffsetCurbe + iOffset);
}
}
}
}
}
return iOffset;
}
//!
//! \brief Send Curbe Load
//! \details Send Curbe Load command
//! \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_SendCurbeLoad(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer)
{
MHW_CURBE_LOAD_PARAMS CurbeLoadParams;
PRENDERHAL_STATE_HEAP pStateHeap;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
PMOS_INTERFACE pOsInterface = nullptr;
MOS_CONTEXT *pOsContext = nullptr;
MOS_OCA_BUFFER_HANDLE hOcaBuf = 0;
//-----------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pCurMediaState);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface->pOsContext);
//-----------------------------------------
eStatus = MOS_STATUS_SUCCESS;
pStateHeap = pRenderHal->pStateHeap;
pOsInterface = pRenderHal->pOsInterface;
pOsContext = pOsInterface->pOsContext;
// CURBE size is in bytes
if (pStateHeap->pCurMediaState->iCurbeOffset != 0)
{
CurbeLoadParams.pKernelState = nullptr;
CurbeLoadParams.bOldInterface = false;
CurbeLoadParams.dwCURBETotalDataLength = pStateHeap->pCurMediaState->iCurbeOffset;
CurbeLoadParams.dwCURBEDataStartAddress = pStateHeap->pCurMediaState->dwOffset + pStateHeap->dwOffsetCurbe;
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMediaCurbeLoadCmd(pRenderHal, pCmdBuffer, &CurbeLoadParams));
HalOcaInterfaceNext::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, pRenderHal->StateBaseAddressParams.presDynamicState,
CurbeLoadParams.dwCURBEDataStartAddress, false, CurbeLoadParams.dwCURBETotalDataLength);
}
return eStatus;
}
MOS_STATUS RenderHal_SendMediaIdLoad(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer)
{
MHW_ID_LOAD_PARAMS IdLoadParams;
PRENDERHAL_STATE_HEAP pStateHeap;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
PMOS_INTERFACE pOsInterface = nullptr;
MOS_CONTEXT *pOsContext = nullptr;
MOS_OCA_BUFFER_HANDLE hOcaBuf = 0;
//-----------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pCurMediaState);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface->pOsContext);
//-----------------------------------------
eStatus = MOS_STATUS_SUCCESS;
pStateHeap = pRenderHal->pStateHeap;
pOsInterface = pRenderHal->pOsInterface;
pOsContext = pOsInterface->pOsContext;
IdLoadParams.pKernelState = nullptr;
IdLoadParams.dwInterfaceDescriptorStartOffset = pStateHeap->pCurMediaState->dwOffset + pStateHeap->dwOffsetMediaID;
IdLoadParams.dwInterfaceDescriptorLength = pRenderHal->StateHeapSettings.iMediaIDs * pStateHeap->dwSizeMediaID;
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMediaIDLoadCmd(pRenderHal, pCmdBuffer, &IdLoadParams));
HalOcaInterfaceNext::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, pRenderHal->StateBaseAddressParams.presDynamicState,
IdLoadParams.dwInterfaceDescriptorStartOffset, false, IdLoadParams.dwInterfaceDescriptorLength);
return eStatus;
}
//!
//! \brief Send Chroma Key
//! \details Sends Chroma Key
//! \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_SendChromaKey(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer)
{
PMHW_CHROMAKEY_PARAMS pChromaKeyParams;
int32_t i;
MOS_STATUS eStatus;
//----------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
//----------------------------------
eStatus = MOS_STATUS_SUCCESS;
// Send Chroma Keys in use
pChromaKeyParams = pRenderHal->ChromaKey;
for (i = pRenderHal->iChromaKeyCount; i > 0; i--, pChromaKeyParams++)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendChromaKey(pRenderHal, pCmdBuffer, pChromaKeyParams));
}
return eStatus;
}
//!
//! \brief Send Palette
//! \details Sends Palette
//! \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_SendPalette(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer)
{
PMHW_PALETTE_PARAMS pPaletteLoadParams;
int32_t i;
MOS_STATUS eStatus;
//-----------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
//-----------------------------------------
eStatus = MOS_STATUS_SUCCESS;
// Send Palettes in use
pPaletteLoadParams = pRenderHal->Palette;
for (i = pRenderHal->iMaxPalettes; i > 0; i--, pPaletteLoadParams++)
{
if (pPaletteLoadParams->iNumEntries > 0)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendPalette(pRenderHal, pCmdBuffer, pPaletteLoadParams));
}
}
return eStatus;
}
//!
//! \brief Reset RenderHal States
//! \details Reset RenderHal States in preparation for a new command buffer
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_Reset(
PRENDERHAL_INTERFACE pRenderHal)
{
PMOS_INTERFACE pOsInterface;
MOS_STATUS eStatus;
//----------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
//----------------------------------
eStatus = MOS_STATUS_SUCCESS;
pOsInterface = pRenderHal->pOsInterface;
if (pRenderHal->pStateHeap == nullptr)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnAllocateStateHeaps(pRenderHal, &pRenderHal->StateHeapSettings));
if (pRenderHal->pStateHeap)
{
MHW_STATE_BASE_ADDR_PARAMS *pStateBaseParams = &pRenderHal->StateBaseAddressParams;
pStateBaseParams->presGeneralState = &pRenderHal->pStateHeap->GshOsResource;
pStateBaseParams->dwGeneralStateSize = pRenderHal->pStateHeap->dwSizeGSH;
pStateBaseParams->presDynamicState = &pRenderHal->pStateHeap->GshOsResource;
pStateBaseParams->dwDynamicStateSize = pRenderHal->pStateHeap->dwSizeGSH;
pStateBaseParams->bDynamicStateRenderTarget = false;
pStateBaseParams->presIndirectObjectBuffer = &pRenderHal->pStateHeap->GshOsResource;
pStateBaseParams->dwIndirectObjectBufferSize = pRenderHal->pStateHeap->dwSizeGSH;
pStateBaseParams->presInstructionBuffer = &pRenderHal->pStateHeap->IshOsResource;
pStateBaseParams->dwInstructionBufferSize = pRenderHal->pStateHeap->dwSizeISH;
}
}
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(pOsInterface,
&pRenderHal->pStateHeap->GshOsResource,
true,
true));
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(pOsInterface,
&pRenderHal->pStateHeap->IshOsResource,
true,
true));
// Reset Slice Shutdown Mode
pRenderHal->bRequestSingleSlice = false;
pRenderHal->PowerOption.nSlice = 0;
pRenderHal->PowerOption.nEU = 0;
pRenderHal->PowerOption.nSubSlice = 0;
return eStatus;
}
//!
//! \brief Assign Ssh Instance
//! \details Get a pointer to the next available SSH Buffer Instance in SSH,
//! Reset SSH allocations
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if succeded, MOS_STATUS_UNKOWN otherwise
//!
MOS_STATUS RenderHal_AssignSshInstance(
PRENDERHAL_INTERFACE pRenderHal)
{
MOS_STATUS eStatus;
PRENDERHAL_STATE_HEAP pStateHeap;
//-----------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
//-----------------------------------------
eStatus = MOS_STATUS_SUCCESS;
pStateHeap = pRenderHal->pStateHeap;
if (pRenderHal->isBindlessHeapInUse)
{
MHW_RENDERHAL_NORMALMESSAGE("BindlessHeap does not need SSH Instance!");
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnAssignBindlessSurfaceStates(pRenderHal));
return eStatus;
}
// Init SSH Params
if (pStateHeap)
{
pStateHeap->iCurrentBindingTable = 0;
pStateHeap->iCurrentSurfaceState = 0;
}
else
{
eStatus = MOS_STATUS_UNKNOWN;
}
return eStatus;
}
//!
//! \brief Initializes command buffer attributes and inserts prolog
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//! \param PMOS_COMMAND_BUFFER pCmdBuffer
//! [in] Pointer to Command Buffer
//! \param PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParam
//! [in] Pointer to MHW generic prolog parameters
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_InitCommandBuffer(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)
{
PMOS_INTERFACE pOsInterface;
MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
MOS_STATUS eStatus;
bool isRender;
//---------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
//---------------------------------------------
eStatus = MOS_STATUS_SUCCESS;
pOsInterface = pRenderHal->pOsInterface;
// Send Start Marker command
isRender = MOS_RCS_ENGINE_USED(pOsInterface->pfnGetGpuContext(pOsInterface));
if (pRenderHal->SetMarkerParams.setMarkerEnabled)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendMarkerCommand(
pRenderHal, pCmdBuffer, isRender));
}
// Init Cmd Buffer
if (isRender)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SetCompositePrologCmd(pRenderHal, pCmdBuffer));
}
if (isRender)
{
// Set indirect heap size - limits the size of the command buffer available for rendering
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnSetIndirectStateSize(pOsInterface, pRenderHal->dwIndirectHeapSize));
}
pCmdBuffer->Attributes.bIsMdfLoad = pRenderHal->IsMDFLoad;
pCmdBuffer->Attributes.bTurboMode = pRenderHal->bTurboMode;
// Set power option status
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SetPowerOptionStatus(pRenderHal, pCmdBuffer));
// Preemption: Need to set UsesMediaPipeline, UsesGPGPUPipeline, NeedsMidBatchPreEmptionSupport in command buffer header
// Use IsMDFLoad to distinguish MDF context from other Media Contexts
pCmdBuffer->Attributes.bMediaPreemptionEnabled =
(pRenderHal->bEnableGpgpuMidBatchPreEmption ||
pRenderHal->bEnableGpgpuMidThreadPreEmption ||
pRenderHal->pRenderHalPltInterface->IsPreemptionEnabled(pRenderHal)) &&
!pRenderHal->forceDisablePreemption;
if (pGenericPrologParams)
{
if (pGenericPrologParams->bEnableMediaFrameTracking)
{
MHW_RENDERHAL_CHK_NULL_RETURN(pGenericPrologParams->presMediaFrameTrackingSurface);
pCmdBuffer->Attributes.bEnableMediaFrameTracking = pGenericPrologParams->bEnableMediaFrameTracking;
pCmdBuffer->Attributes.dwMediaFrameTrackingTag = pGenericPrologParams->dwMediaFrameTrackingTag;
pCmdBuffer->Attributes.dwMediaFrameTrackingAddrOffset = pGenericPrologParams->dwMediaFrameTrackingAddrOffset;
pCmdBuffer->Attributes.resMediaFrameTrackingSurface = pGenericPrologParams->presMediaFrameTrackingSurface;
}
else
{
pCmdBuffer->Attributes.bEnableMediaFrameTracking = false;
}
}
// Check if Override is needed
if (pRenderHal->pRenderHalPltInterface)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->IsOvrdNeeded(pRenderHal, pCmdBuffer, pGenericPrologParams));
}
MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams));
genericPrologParams.pOsInterface = pRenderHal->pOsInterface;
genericPrologParams.pvMiInterface = pRenderHal->pMhwMiInterface;
genericPrologParams.bMmcEnabled = pGenericPrologParams ? pGenericPrologParams->bMmcEnabled : false;
if (pRenderHal->pRenderHalPltInterface)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendGenericPrologCmd(pRenderHal, pCmdBuffer, &genericPrologParams));
}
// Send predication command
if (pRenderHal->pRenderHalPltInterface && pRenderHal->PredicationParams.predicationEnabled)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendPredicationCommand(pRenderHal, pCmdBuffer));
}
return eStatus;
}
//!
//! \brief Send Sync Tag
//! \details Sends Synchronization Tags
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//! \param PMOS_COMMAND_BUFFER pCmdBuffer
//! [in] Pointer to Command Buffer
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_SendSyncTag(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer)
{
PRENDERHAL_STATE_HEAP pStateHeap;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_PIPE_CONTROL_PARAMS PipeCtl;
//-------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
//-------------------------------------
pStateHeap = pRenderHal->pStateHeap;
// Send PIPE_CONTROL Token
// CMD_MI_FLUSH is disabled by default on GT, use PIPE_CONTROL
// Requires a token and the actual pipe control command
// Flush write caches
PipeCtl = g_cRenderHal_InitPipeControlParams;
PipeCtl.presDest = &pStateHeap->GshOsResource;
PipeCtl.dwPostSyncOp = MHW_FLUSH_NOWRITE;
PipeCtl.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMiPipeControl(pRenderHal, pCmdBuffer, &PipeCtl));
// Invalidate read-only caches and perform a post sync write
PipeCtl = g_cRenderHal_InitPipeControlParams;
PipeCtl.presDest = &pStateHeap->GshOsResource;
PipeCtl.dwResourceOffset = pStateHeap->dwOffsetSync;
PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA;
PipeCtl.dwFlushMode = MHW_FLUSH_READ_CACHE;
PipeCtl.dwDataDW1 = pStateHeap->dwNextTag;
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMiPipeControl(pRenderHal, pCmdBuffer, &PipeCtl));
return eStatus;
}
MOS_STATUS RenderHal_SendSyncTagIndex(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
int32_t iIndex)
{
PRENDERHAL_STATE_HEAP pStateHeap;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_PIPE_CONTROL_PARAMS PipeCtl;
//-------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
//-------------------------------------
pStateHeap = pRenderHal->pStateHeap;
// Invalidate read-only caches and perform a post sync write
PipeCtl = g_cRenderHal_InitPipeControlParams;
PipeCtl.presDest = &pStateHeap->GshOsResource;
PipeCtl.dwResourceOffset = pStateHeap->dwOffsetSync + iIndex * 8;
PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA;
PipeCtl.dwFlushMode = MHW_FLUSH_READ_CACHE;
PipeCtl.dwDataDW1 = pStateHeap->dwNextTag;
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMiPipeControl(pRenderHal, pCmdBuffer, &PipeCtl));
return eStatus;
}
//!
//! \brief Initialize
//! \details Initialize HW states
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//! \param PCRENDERHAL_SETTINGS pSettings
//! [in] Pointer to Settings
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if succeeded
//! others if failed to allocate/initialize HW commands
//!
MOS_STATUS RenderHal_Initialize(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SETTINGS pSettings)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
PMOS_INTERFACE pOsInterface;
MHW_STATE_BASE_ADDR_PARAMS *pStateBaseParams;
MOS_ALLOC_GFXRES_PARAMS AllocParams;
//------------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
//------------------------------------------------
pOsInterface = pRenderHal->pOsInterface;
// Apply settings
if (pSettings)
{
pRenderHal->StateHeapSettings.iMediaStateHeaps = pSettings->iMediaStates;
}
// Apply SSH settings for the current platform
pRenderHal->StateHeapSettings.iSurfaceStateHeaps =
pRenderHal->StateHeapSettings.iMediaStateHeaps;
if (pOsInterface->CurrentGpuContextOrdinal == MOS_GPU_CONTEXT_RENDER ||
pOsInterface->CurrentGpuContextOrdinal == MOS_GPU_CONTEXT_COMPUTE)
{
if ((pRenderHal->pOsInterface->osStreamState == nullptr) ||
(pRenderHal->pOsInterface->osStreamState &&
(pRenderHal->pOsInterface->osStreamState->component != COMPONENT_Encode &&
pRenderHal->pOsInterface->osStreamState->component != COMPONENT_Decode)))
{
// Initialize MHW interfaces
// Allocate and initialize state heaps (GSH, SSH, ISH)
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnAllocateStateHeaps(pRenderHal, &pRenderHal->StateHeapSettings));
}
}
// If ASM debug is enabled, allocate debug resource
MHW_RENDERHAL_CHK_STATUS_RETURN(RenderHal_AllocateDebugSurface(pRenderHal));
// Allocate Predication buffer
MOS_ZeroMemory(&AllocParams, sizeof(AllocParams));
AllocParams.Type = MOS_GFXRES_BUFFER;
AllocParams.TileType = MOS_TILE_LINEAR;
AllocParams.Format = Format_Buffer;
AllocParams.dwBytes = MHW_PAGE_SIZE;
AllocParams.pBufName = "PredicationBuffer";
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnAllocateResource(
pOsInterface,
&AllocParams,
&pRenderHal->PredicationBuffer));
// Setup State Base Address command
pStateBaseParams = &pRenderHal->StateBaseAddressParams;
if (pRenderHal->pStateHeap)
{
pStateBaseParams->presGeneralState = &pRenderHal->pStateHeap->GshOsResource;
pStateBaseParams->dwGeneralStateSize = pRenderHal->pStateHeap->dwSizeGSH;
pStateBaseParams->presDynamicState = &pRenderHal->pStateHeap->GshOsResource;
pStateBaseParams->dwDynamicStateSize = pRenderHal->pStateHeap->dwSizeGSH;
pStateBaseParams->bDynamicStateRenderTarget = false;
pStateBaseParams->presIndirectObjectBuffer = &pRenderHal->pStateHeap->GshOsResource;
pStateBaseParams->dwIndirectObjectBufferSize = pRenderHal->pStateHeap->dwSizeGSH;
pStateBaseParams->presInstructionBuffer = &pRenderHal->pStateHeap->IshOsResource;
pStateBaseParams->dwInstructionBufferSize = pRenderHal->pStateHeap->dwSizeISH;
}
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->CreatePerfProfiler(pRenderHal));
new(&pRenderHal->trackerProducer) FrameTrackerProducer();
return eStatus;
}
//!
//! \brief Send Rcs Status Tag
//! \details Adds pipe control command in Command Buffer
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//! \param PMOS_COMMAND_BUFFER pCmdBuffer
//! [in] Pointer to Command Buffer
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if succeeded
//! MOS_STATUS_UNKNOWN if failed to allocate/initialize HW commands
//!
MOS_STATUS RenderHal_SendRcsStatusTag(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
PMOS_INTERFACE pOsInterface;
MHW_PIPE_CONTROL_PARAMS PipeCtl;
PMOS_RESOURCE osResource = nullptr;
//------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
//------------------------------------
pOsInterface = pRenderHal->pOsInterface;
// Get the Os Resource
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnGetGpuStatusBufferResource(pOsInterface, osResource));
MHW_RENDERHAL_CHK_NULL_RETURN(osResource);
// Register the buffer
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(pOsInterface, osResource, true, true));
// Issue pipe control to write GPU Status Tag
PipeCtl = g_cRenderHal_InitPipeControlParams;
PipeCtl.presDest = osResource;
PipeCtl.dwResourceOffset = pOsInterface->pfnGetGpuStatusTagOffset(pOsInterface, pOsInterface->CurrentGpuContextOrdinal); //MOS_GPU_CONTEXT_RENDER or MOS_GPU_CONTEXT_RENDER3
PipeCtl.dwDataDW1 = pOsInterface->pfnGetGpuStatusTag(pOsInterface, pOsInterface->CurrentGpuContextOrdinal);
PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA;
PipeCtl.dwFlushMode = MHW_FLUSH_NONE;
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMiPipeControl(pRenderHal, pCmdBuffer, &PipeCtl));
// Increment GPU Status Tag
pOsInterface->pfnIncrementGpuStatusTag(pOsInterface, pOsInterface->CurrentGpuContextOrdinal);
return eStatus;
}
//!
//! \brief Send CSC Coefficient surface
//! \details Adds pipe control command in Command Buffer
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//! \param PMOS_COMMAND_BUFFER pCmdBuffer
//! [in] Pointer to Command Buffer
//! \param PMOS_RESOURCE presCscCoeff
//! [in] Pointer to CSC Coefficient Surface
//! \param Kdll_CacheEntry *pKernelEntry
//! [in] Pointer to Kernel Entry
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if succeeded
//! MOS_STATUS_UNKNOWN if failed to allocate/initialize HW commands
//!
MOS_STATUS RenderHal_SendCscCoeffSurface(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
PMOS_RESOURCE presCscCoeff,
Kdll_CacheEntry *pKernelEntry)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
PMOS_INTERFACE pOsInterface;
MHW_PIPE_CONTROL_PARAMS PipeCtl;
MOS_SURFACE Surface;
uint64_t *pTempCoeff;
uint32_t dwLow;
uint32_t dwHigh;
uint32_t dwOffset;
uint32_t dwCount;
uint8_t uiPatchMatrixID;
//------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
MHW_RENDERHAL_CHK_NULL_RETURN(presCscCoeff);
MHW_RENDERHAL_CHK_NULL_RETURN(pKernelEntry);
MHW_RENDERHAL_CHK_NULL_RETURN(pKernelEntry->pCscParams);
//------------------------------------
pOsInterface = pRenderHal->pOsInterface;
dwOffset = 0;
static_assert(
(sizeof(pKernelEntry->pCscParams->Matrix[0].Coeff) % sizeof(uint64_t)) == 0,
"Coeff array size must be multiple of 8");
dwCount = sizeof(pKernelEntry->pCscParams->Matrix[0].Coeff) / (sizeof(uint64_t));
MOS_ZeroMemory(&Surface, sizeof(Surface));
// Register the buffer
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(pOsInterface, presCscCoeff, true, true));
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnGetResourceInfo(pOsInterface, presCscCoeff, &Surface));
PipeCtl = g_cRenderHal_InitPipeControlParams;
PipeCtl.presDest = presCscCoeff;
PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA;
PipeCtl.dwFlushMode = MHW_FLUSH_READ_CACHE;
for (uint32_t j = 0; j < pKernelEntry->pCscParams->PatchMatrixNum; j++)
{
uiPatchMatrixID = pKernelEntry->pCscParams->PatchMatrixID[j];
pTempCoeff = (uint64_t *)pKernelEntry->pCscParams->Matrix[uiPatchMatrixID].Coeff;
// Issue pipe control to write CSC Coefficient Surface
for (uint16_t i = 0; i < dwCount; i++, pTempCoeff++)
{
dwLow = (uint32_t)((*pTempCoeff) & 0xFFFFFFFF);
dwHigh = (uint32_t)(((*pTempCoeff) >> 32) & 0xFFFFFFFF);
PipeCtl.dwResourceOffset = dwOffset + sizeof(uint64_t) * i;
PipeCtl.dwDataDW1 = dwLow;
PipeCtl.dwDataDW2 = dwHigh;
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMiPipeControl(pRenderHal, pCmdBuffer, &PipeCtl));
}
dwOffset += Surface.dwPitch;
}
return eStatus;
}
MOS_STATUS RenderHal_SendStateBaseAddress(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer)
{
MOS_STATUS eStatus;
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
eStatus = pRenderHal->pRenderHalPltInterface->SendStateBaseAddress(pRenderHal,
pCmdBuffer);
return eStatus;
}
//!
//! \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)
{
PMOS_INTERFACE pOsInterface = nullptr;
PRENDERHAL_STATE_HEAP pStateHeap = nullptr;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_VFE_PARAMS *pVfeStateParams = nullptr;
MOS_CONTEXT *pOsContext = nullptr;
MHW_MI_LOAD_REGISTER_IMM_PARAMS loadRegisterImmParams = {};
PMHW_MI_MMIOREGISTERS pMmioRegisters = nullptr;
MOS_OCA_BUFFER_HANDLE hOcaBuf = 0;
//---------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
MHW_RENDERHAL_ASSERT(pRenderHal->pStateHeap->bGshLocked);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface->GetMmioRegisters(pRenderHal));
//---------------------------------------
pOsInterface = pRenderHal->pOsInterface;
pStateHeap = pRenderHal->pStateHeap;
pOsContext = pOsInterface->pOsContext;
pMmioRegisters = pRenderHal->pRenderHalPltInterface->GetMmioRegisters(pRenderHal);
// This need not be secure, since PPGTT will be used here. But moving this after
// L3 cache configuration will delay UMD from fetching another media state.
// Send Sync Tag
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendSyncTag(pRenderHal, pCmdBuffer));
// Setup L3$ Config, LRI commands used here & hence must be launched from a secure bb
pRenderHal->L3CacheSettings.bEnableSLM = (pGpGpuWalkerParams && pGpGpuWalkerParams->SLMSize > 0);
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnEnableL3Caching(pRenderHal, &pRenderHal->L3CacheSettings));
// Send L3 Cache Configuration
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SetL3Cache(pRenderHal, pCmdBuffer));
// if forceDisablePreemption is true, preemption will be disabled by NeedsMidBatchPreEmptionSupport in command buffer header.
// skip preemption control bit configure as it won't take effect.
if (!pRenderHal->forceDisablePreemption)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->EnablePreemption(pRenderHal, pCmdBuffer));
}
// Send Debug Control, LRI commands used here & hence must be launched from a secure bb
MHW_RENDERHAL_CHK_STATUS_RETURN(RenderHal_AddDebugControl(pRenderHal, pCmdBuffer));
// Send Pipeline Select command
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddPipelineSelectCmd(pRenderHal, pCmdBuffer, (pGpGpuWalkerParams) ? true : false));
// The binding table for surface states is at end of command buffer. No need to add it to indirect state heap.
HalOcaInterfaceNext::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, pRenderHal->StateBaseAddressParams.presInstructionBuffer,
pStateHeap->CurIDEntryParams.dwKernelOffset, false, pStateHeap->iKernelUsedForDump);
// Send State Base Address command
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendStateBaseAddress(pRenderHal, pCmdBuffer));
if (pRenderHal->bComputeContextInUse)
{
pRenderHal->pRenderHalPltInterface->SendTo3DStateBindingTablePoolAlloc(pRenderHal, pCmdBuffer);
}
// Send Surface States
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendSurfaces(pRenderHal, pCmdBuffer));
// Send SIP State if ASM debug enabled
if (pRenderHal->bIsaAsmDebugEnable)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddSipStateCmd(pRenderHal, pCmdBuffer));
}
pVfeStateParams = pRenderHal->pRenderHalPltInterface->GetVfeStateParameters();
if (!pRenderHal->bComputeContextInUse)
{
// set VFE State
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMediaVfeCmd(pRenderHal, pCmdBuffer, pVfeStateParams));
}
else
{
// set CFE State
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddCfeStateCmd(pRenderHal, pCmdBuffer, pVfeStateParams));
}
// Send CURBE Load
if (!pRenderHal->bComputeContextInUse)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendCurbeLoad(pRenderHal, pCmdBuffer));
}
// Send Interface Descriptor Load
if (!pRenderHal->bComputeContextInUse)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendMediaIdLoad(pRenderHal, pCmdBuffer));
}
// Send Chroma Keys
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendChromaKey(pRenderHal, pCmdBuffer));
// Send Palettes in use
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendPalette(pRenderHal, pCmdBuffer));
pRenderHal->pRenderHalPltInterface->OnDispatch(pRenderHal, pCmdBuffer, pOsInterface, pMmioRegisters);
// Send Media object walker
if(pWalkerParams)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMediaObjectWalkerCmd(
pRenderHal,
pCmdBuffer,
pWalkerParams));
}
else if (pGpGpuWalkerParams && (!pRenderHal->bComputeContextInUse))
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddGpGpuWalkerStateCmd(
pRenderHal,
pCmdBuffer,
pGpGpuWalkerParams));
}
else if (pGpGpuWalkerParams && pRenderHal->bComputeContextInUse)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendComputeWalker(
pRenderHal,
pCmdBuffer,
pGpGpuWalkerParams));
}
return eStatus;
}
MOS_STATUS RenderHal_AssignBindlessSurfaceStates(
PRENDERHAL_INTERFACE pRenderHal)
{
PRENDERHAL_STATE_HEAP pStateHeap = nullptr;
MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
//----------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->surfaceStateMgr);
pStateHeap = pRenderHal->pStateHeap;
if (pStateHeap->surfaceStateMgr->m_usedStates.size() >0)
{
pStateHeap->surfaceStateMgr->m_usedStates.clear();
}
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
MOS_STATUS RenderHal_SendBindlessSurfaces(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
bool bNeedNullPatch)
{
PRENDERHAL_STATE_HEAP pStateHeap = nullptr;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_SURFACE_STATE_SEND_PARAMS SendSurfaceParams;
PMOS_INTERFACE pOsInterface;
//----------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->surfaceStateMgr);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->surfaceStateMgr->m_surfStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
pStateHeap = pRenderHal->pStateHeap;
pOsInterface = pRenderHal->pOsInterface;
if (pStateHeap->surfaceStateMgr->m_usedStates.size() == 0)
{
MHW_RENDERHAL_NORMALMESSAGE("m_usedStates is null!");
return eStatus;
}
MHW_CHK_STATUS_RETURN(pRenderHal->pStateHeap->surfaceStateMgr->RegisterHeap());
for (uint32_t i = 0; i < pStateHeap->surfaceStateMgr->m_usedStates.size(); i++)
{
uint32_t index = pStateHeap->surfaceStateMgr->m_usedStates[i];
// Null Patch is only enabled for Media Patchless
SendSurfaceParams.bNeedNullPatch = bNeedNullPatch;
SendSurfaceParams.pIndirectStateBase = pStateHeap->surfaceStateMgr->m_surfStateHeap->pLockedOsResourceMem;
SendSurfaceParams.iIndirectStateBase = 0; // No need
SendSurfaceParams.pSurfaceToken = (uint8_t *)&pStateHeap->pSurfaceEntry[index].SurfaceToken;
SendSurfaceParams.pSurfaceStateSource = (uint8_t *)pStateHeap->pSurfaceEntry[index].pSurfaceState;
SendSurfaceParams.iSurfaceStateOffset = index * pStateHeap->surfaceStateMgr->m_surfStateHeap->uiInstanceSize;
pRenderHal->pfnSendSurfaceStateEntry(pRenderHal, pCmdBuffer, &SendSurfaceParams);
}
return eStatus;
}
//!
//! \brief Assign binding Table
//! \details Assigns binding Table
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param int32_t *piBindingTable
//! [out] Pointer to Binding Table
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_AssignBindingTable(
PRENDERHAL_INTERFACE pRenderHal,
int32_t *piBindingTable)
{
PRENDERHAL_STATE_HEAP pStateHeap;
uint32_t dwOffset;
MOS_STATUS eStatus;
//----------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(piBindingTable);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap);
//----------------------------------------
*piBindingTable = -1;
pStateHeap = pRenderHal->pStateHeap;
eStatus = MOS_STATUS_UNKNOWN;
if (pRenderHal->isBindlessHeapInUse)
{
MHW_RENDERHAL_NORMALMESSAGE("BindlessHeap does not need binding table!");
return MOS_STATUS_SUCCESS;
}
if (pStateHeap->iCurrentBindingTable >= pRenderHal->StateHeapSettings.iBindingTables)
{
MHW_RENDERHAL_ASSERTMESSAGE("Unable to allocate Binding Table. Exceeds Maximum.");
return eStatus;
}
*piBindingTable = pStateHeap->iCurrentBindingTable;
// Get Offset to Current Binding Table
dwOffset = *piBindingTable * pStateHeap->iBindingTableSize; // Moves the pointer to a Particular Binding Table
// Reset Binding Table
MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pSshBuffer);
MOS_ZeroMemory(pStateHeap->pSshBuffer + dwOffset, pStateHeap->iBindingTableSize);
// Setup Debug surface state if needed
MHW_RENDERHAL_CHK_STATUS_RETURN(RenderHal_SetupDebugSurfaceState(pRenderHal));
// Increment the Current Binding Table
++pStateHeap->iCurrentBindingTable;
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Setup Buffer Surface State
//! \details Setup Buffer Surface States
//! For buffer surfaces, the number of entries in the buffer
//! ranges from 1 to 2^27. After subtracting one from the number
//! of entries, software must place the fields of the resulting
//! 27-bit value into the Height, Width, and Depth fields as
//! indicated, right-justified in each field.
//! Unused upper bits must be set to zero.
//!
//! Width: contains bits [6:0] of the number of entries in the
//! buffer 1 [0,127] --> 7 Bits
//! Height: contains bits [20:7] of the number of entries in the
//! buffer 1 [0,16383] --> 14 Bits
//! Depth: contains bits [26:21] of the number of entries in the
//! buffer 1 [0,63] --> 6 Bits
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface
//! \param PMOS_COMMAND_BUFFER pCmdBuffer
//! [in] Pointer to MOS Command Buffer
//! \param PRENDERHAL_SURFACE pRenderHalSurface
//! [in] Pointer to Render Hal Surface
//! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams
//! [in] Pointer to Surface state parameters
//! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntry
//! [out] Pointer to Surface entry
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_SetupBufferSurfaceState(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface,
PRENDERHAL_SURFACE_STATE_PARAMS pParams,
PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntry)
{
MOS_STATUS eStatus;
PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
MHW_RCS_SURFACE_PARAMS RcsSurfaceParams;
//--------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalSurface);
MHW_RENDERHAL_CHK_NULL_RETURN(pParams);
MHW_RENDERHAL_CHK_NULL_RETURN(ppSurfaceEntry);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap);
MHW_RENDERHAL_ASSERT(pRenderHalSurface->OsSurface.dwWidth > 0);
//--------------------------------------
eStatus = MOS_STATUS_SUCCESS;
// Force surface type to Default (non-AVS)
pParams->Type = pRenderHal->SurfaceTypeDefault;
// Assign Surface State
// Assign a New Surface State Entry
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnAssignSurfaceState(
pRenderHal,
pRenderHal->SurfaceTypeDefault,
ppSurfaceEntry));
pSurfaceEntry = *ppSurfaceEntry;
MHW_RENDERHAL_CHK_NULL_RETURN(pSurfaceEntry);
// Update surface state offset in SSH
*pSurfaceEntry->pSurface = pRenderHalSurface->OsSurface;
if (pRenderHal->isBindlessHeapInUse)
{
pSurfaceEntry->dwSurfStateOffset = pSurfaceEntry->iSurfStateID * pRenderHal->pHwSizes->dwSizeSurfaceState; // No binding table
}
else
{
pSurfaceEntry->dwSurfStateOffset =
pRenderHal->pStateHeap->iSurfaceStateOffset +
pSurfaceEntry->iSurfStateID * pRenderHal->pHwSizes->dwSizeSurfaceState;
}
// Setup MHW parameters
MOS_ZeroMemory(&RcsSurfaceParams, sizeof(MHW_RCS_SURFACE_PARAMS));
RcsSurfaceParams.psSurface = &pRenderHalSurface->OsSurface;
RcsSurfaceParams.dwOffsetInSSH = pSurfaceEntry->dwSurfStateOffset;
RcsSurfaceParams.dwCacheabilityControl = pRenderHal->pfnGetSurfaceMemoryObjectControl(pRenderHal, pParams);
if (pParams->surfaceType)
{
MOS_CACHE_ELEMENT element(MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC, MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC);
bool res = pRenderHal->pOsInterface->pfnGetCacheSetting(pParams->Component, pParams->surfaceType, pParams->isOutput, RENDER_ENGINE, element, false);
if (res)
{
RcsSurfaceParams.dwCacheabilityControl = (pRenderHal->pOsInterface->pfnCachePolicyGetMemoryObject(
element.mocsUsageType,
pRenderHal->pOsInterface->pfnGetGmmClientContext(pRenderHal->pOsInterface)))
.DwordValue;
}
else
{
MHW_RENDERHAL_ASSERTMESSAGE("Not found cache settings!");
}
}
else
{
MHW_RENDERHAL_NORMALMESSAGE("Not implemented yet! Will use MemObjCtl value %d", pParams->MemObjCtl);
}
RcsSurfaceParams.bIsWritable = pParams->isOutput;
RcsSurfaceParams.bRenderTarget = pParams->isOutput;
// Call MHW to setup the Surface State Heap entry for Buffer
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSetSurfaceStateBuffer(pRenderHal, &RcsSurfaceParams, pSurfaceEntry->pSurfaceState));
// Setup OS Specific States
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSetupSurfaceStatesOs(pRenderHal, pParams, pSurfaceEntry));
return eStatus;
}
//!
//! \brief Set surface state buffer
//! \param [in] pRenderHal
//! pointer to render hal
//! [in] pParams
//! pointer to surface parameters
//! \param void *pSurfaceState
//! [in/out] Surface State Pointer
//!
MOS_STATUS RenderHal_SetSurfaceStateBuffer(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_RCS_SURFACE_PARAMS pParams,
void *pSurfaceState)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_MI_CHK_NULL(pParams);
MHW_MI_CHK_NULL(pParams->psSurface);
MHW_MI_CHK_NULL(pSurfaceState);
MHW_SURFACE_STATE_PARAMS Params;
MOS_ZeroMemory(&Params, sizeof(Params));
PMOS_SURFACE pSurface = pParams->psSurface;
uint32_t dwBufferSize = pSurface->dwWidth - 1;
Params.SurfaceType3D = MOS_GFXRES_SCRATCH == pSurface->Type?
GFX3DSTATE_SURFACETYPE_SCRATCH
: GFX3DSTATE_SURFACETYPE_BUFFER;
if (MOS_GFXRES_SCRATCH == pSurface->Type)
{
Params.dwPitch = 1023;
uint32_t entry_count = pSurface->dwWidth/(Params.dwPitch + 1);
Params.dwWidth = (entry_count - 1) & MOS_MASKBITS32(0, 6);
Params.dwHeight = (((entry_count - 1) & MOS_MASKBITS32(7, 20)) >> 7);
Params.dwDepth = (((entry_count - 1) & 0xFFE00000) >> 21);
Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_RAW;
}
else
{
// Width contains bits [ 6:0] of the number of entries in the buffer
Params.dwWidth = (uint8_t)(dwBufferSize & MOS_MASKBITS32(0, 6));
// Height contains bits [20:7] of the number of entries in the buffer
Params.dwHeight = (uint16_t)((dwBufferSize & MOS_MASKBITS32(7, 20)) >> 7);
// For SURFTYPE_BUFFER, pitch is defaulted to 0. Resetting is unnecessary.
uint32_t depthMaskBuffer = pRenderHal->pRenderHalPltInterface
->GetDepthBitMaskForBuffer();
uint32_t depthMaskRawBuffer = pRenderHal->pRenderHalPltInterface
->GetDepthBitMaskForRawBuffer();
switch (pSurface->Format)
{
// We consider MOS's Format_Buffer as MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM
// format for most of cases
case Format_Buffer:
Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM;
Params.dwDepth
= (uint16_t)((dwBufferSize & depthMaskBuffer) >> 21);
break;
case Format_RAW:
Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_RAW;
Params.dwDepth
= (uint16_t)((dwBufferSize & depthMaskRawBuffer) >> 21);
break;
case Format_L8:
Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM;
Params.dwDepth
= (uint16_t)((dwBufferSize & depthMaskBuffer) >> 21);
break;
default:
MHW_ASSERTMESSAGE("Invalid buffer Resource format");
break;
}
}
Params.pSurfaceState = (uint8_t*)pSurfaceState;
Params.dwCacheabilityControl = pParams->dwCacheabilityControl;
// Default tile mode of surface state buffer is linear
Params.bGMMTileEnabled = true;
// Setup Surface State Entry via MHW state heap interface
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pMhwStateHeap->SetSurfaceStateEntry(&Params));
return eStatus;
}
//!
//! \brief Setup Interface Descriptor
//! \details Set interface descriptor
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to HW interface
//! \param PRENDERHAL_MEDIA_STATE pMediaState
//! [in] Pointer to media state
//! \param PRENDERHAL_KRN_ALLOCATION pKernelAllocation
//! [in] Pointer to kernel allocation
//! \param PRENDERHAL_INTERFACE_DESCRIPTOR_PARAMS pInterfaceDescriptorParams
//! [in] Pointer to interface descriptor parameters
//! \param PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams
//! [in] Pointer to gpgpu walker parameters
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_SetupInterfaceDescriptor(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_MEDIA_STATE pMediaState,
PRENDERHAL_KRN_ALLOCATION pKernelAllocation,
PRENDERHAL_INTERFACE_DESCRIPTOR_PARAMS pInterfaceDescriptorParams)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
PMHW_ID_ENTRY_PARAMS pParams = nullptr;
PRENDERHAL_STATE_HEAP pStateHeap = nullptr;
//-----------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pMediaState);
MHW_RENDERHAL_CHK_NULL_RETURN(pKernelAllocation);
MHW_RENDERHAL_CHK_NULL_RETURN(pInterfaceDescriptorParams);
//-----------------------------------------
// Get states, params
pStateHeap = pRenderHal->pStateHeap;
pParams = &pStateHeap->CurIDEntryParams;
pParams->dwMediaIdOffset = pMediaState->dwOffset + pStateHeap->dwOffsetMediaID;
pParams->iMediaId = pInterfaceDescriptorParams->iMediaID;
pParams->dwKernelOffset = pKernelAllocation->dwOffset;
pParams->dwSamplerOffset = pMediaState->dwOffset + pStateHeap->dwOffsetSampler +
pInterfaceDescriptorParams->iMediaID * pStateHeap->dwSizeSamplers;
pParams->dwSamplerCount = pKernelAllocation->Params.Sampler_Count;
pParams->dwBindingTableOffset = pInterfaceDescriptorParams->iBindingTableID * pStateHeap->iBindingTableSize;
pParams->iCurbeOffset = pInterfaceDescriptorParams->iCurbeOffset;
pParams->iCurbeLength = pInterfaceDescriptorParams->iCurbeLength;
pParams->bBarrierEnable = pInterfaceDescriptorParams->blBarrierEnable;
pParams->bGlobalBarrierEnable = pInterfaceDescriptorParams->blGlobalBarrierEnable; //It's only applied for BDW+
pParams->dwNumberofThreadsInGPGPUGroup = pInterfaceDescriptorParams->iNumberThreadsInGroup;
pParams->dwSharedLocalMemorySize = pRenderHal->pfnEncodeSLMSize(pRenderHal, pInterfaceDescriptorParams->iSLMSize);
pParams->iCrsThdConDataRdLn = pInterfaceDescriptorParams->iCrsThrdConstDataLn;
pParams->pGeneralStateHeap = nullptr;
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pMhwStateHeap->SetInterfaceDescriptorEntry(pParams));
return eStatus;
}
//!
//! \brief Get Media Walker Status
//! \details Returns Media Walker Enabled / Disabled
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface
//! \return bool
//!
bool RenderHal_GetMediaWalkerStatus(
PRENDERHAL_INTERFACE pRenderHal)
{
//-----------------------------------------
if (pRenderHal == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid renderhal.");
return false;
}
//-----------------------------------------
if (pRenderHal->MediaWalkerMode == MHW_WALKER_MODE_DISABLED)
{
return false;
}
return true;
}
//!
//! \brief Get surface memory object control \
//! \details Returns surface memory object control
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface
//! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams
//! [in] Pointer to surface state params
//! \return uint32_t
//!
uint32_t RenderHal_GetSurfaceMemoryObjectControl(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE_STATE_PARAMS pParams)
{
MHW_RENDERHAL_UNUSED(pRenderHal);
//-----------------------------------------
if (pParams == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("nullptr pointer.");
return 0;
}
//-----------------------------------------
return pParams->MemObjCtl;
}
//!
//! \brief Get the size of Scratch Space
//! \details Get scratch space size based on max gen config and scratch space
//! size per thread
//! FFTID is used by HW to access scratch space; since FFTID generated
//! is not continuous, need to allocate scratch space based on maximum gen config
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Hardware interface
//! \param uint32_t iPerThreadScratchSpaceSize
//! [in] Per thread scratch space size
//! \return uint32_t
//!
uint32_t RenderHal_GetScratchSpaceSize(
PRENDERHAL_INTERFACE pRenderHal,
uint32_t iPerThreadScratchSpaceSize)
{
MEDIA_SYSTEM_INFO *pGtSystemInfo;
//-----------------------------------------
if (pRenderHal == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid renderhal.");
return 0;
}
//-----------------------------------------
pGtSystemInfo = pRenderHal->pOsInterface->pfnGetGtSystemInfo(pRenderHal->pOsInterface);
uint32_t numHWThreadsPerEU = pGtSystemInfo->ThreadCount / pGtSystemInfo->EUCount;
uint32_t dwNumberOfScratchSpaceEntries = pGtSystemInfo->MaxEuPerSubSlice * numHWThreadsPerEU * pGtSystemInfo->MaxSubSlicesSupported;
uint32_t dwScratchSpaceSize = dwNumberOfScratchSpaceEntries * iPerThreadScratchSpaceSize;
return dwScratchSpaceSize;
}
//!
//! \brief Setup OS specific surface state parameters
//! \details Setup Platform and Operating System Specific Surface State
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams
//! [in] Pointer to Surface Params
//! \param PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry
//! [in] Pointer to Surface State Entry
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if successful
//!
MOS_STATUS RenderHal_SetupSurfaceStatesOs(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE_STATE_PARAMS pParams,
PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry)
{
PMOS_SURFACE pSurface;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_SURFACE_TOKEN_PARAMS TokenParams;
uint32_t additional_plane_offset = 0;
uint32_t vertical_offset_in_surface_state = 0;
//-----------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pParams);
MHW_RENDERHAL_CHK_NULL_RETURN(pSurfaceEntry);
//-----------------------------------------
pSurface = pSurfaceEntry->pSurface;
// Surface, plane, offset
TokenParams.pOsSurface = pSurface;
TokenParams.YUVPlane = pSurfaceEntry->YUVPlane;
switch (pSurfaceEntry->YUVPlane)
{
case MHW_U_PLANE:
vertical_offset_in_surface_state = pSurface->UPlaneOffset.iYOffset;
vertical_offset_in_surface_state &= 0x1C; // The offset value in surface state commands.
additional_plane_offset = pSurface->UPlaneOffset.iYOffset
- vertical_offset_in_surface_state;
additional_plane_offset *= pSurface->dwPitch;
TokenParams.dwSurfaceOffset = pSurface->UPlaneOffset.iSurfaceOffset
+ additional_plane_offset;
break;
case MHW_V_PLANE:
vertical_offset_in_surface_state = pSurface->VPlaneOffset.iYOffset;
vertical_offset_in_surface_state &= 0x1C;
additional_plane_offset = pSurface->VPlaneOffset.iYOffset
- vertical_offset_in_surface_state;
additional_plane_offset *= pSurface->dwPitch;
TokenParams.dwSurfaceOffset = pSurface->VPlaneOffset.iSurfaceOffset
+ additional_plane_offset;
break;
default:
vertical_offset_in_surface_state = pSurface->YPlaneOffset.iYOffset;
vertical_offset_in_surface_state &= 0x1C;
additional_plane_offset = pSurface->YPlaneOffset.iYOffset
- vertical_offset_in_surface_state;
additional_plane_offset *= pSurface->dwPitch;
TokenParams.dwSurfaceOffset
= pSurface->dwOffset + additional_plane_offset;
//force it to 0 for 1D buffer
if (pParams->bBufferUse)
{
TokenParams.dwSurfaceOffset = 0;
}
break;
}
// Surface type
TokenParams.bRenderTarget = pParams->isOutput;
TokenParams.bSurfaceTypeAvs = pSurfaceEntry->bAVS;
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSetSurfaceStateToken(
pRenderHal,
&TokenParams,
&pSurfaceEntry->SurfaceToken));
return eStatus;
}
//!
//! \brief Bind Surface State
//! \details Binds Surface State
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface
//! \param int32_t iBindingTableIndex
//! [in] Binding Table Index
//! \param int32_t iBindingTableEntry
//! [out] Binding Table Entry
//! \param PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry
//! [in] Pointer to Surface State Entry
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_BindSurfaceState(
PRENDERHAL_INTERFACE pRenderHal,
int32_t iBindingTableIndex,
int32_t iBindingTableEntry,
PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry)
{
PRENDERHAL_STATE_HEAP pStateHeap;
PMHW_RENDER_STATE_SIZES pHwSizes;
MHW_BINDING_TABLE_PARAMS Params;
uint32_t dwOffset;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
//--------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pSurfaceEntry);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes);
MHW_RENDERHAL_ASSERT(iBindingTableIndex >= 0);
MHW_RENDERHAL_ASSERT(iBindingTableEntry >= 0);
if (iBindingTableEntry >= pRenderHal->StateHeapSettings.iSurfacesPerBT)
{
MHW_RENDERHAL_ASSERTMESSAGE("Unable to Bind Surface State. Exceeds Maximum. BTI %d. Maximum %d", iBindingTableEntry, pRenderHal->StateHeapSettings.iSurfacesPerBT);
return MOS_STATUS_INVALID_PARAMETER;
}
//--------------------------------------------
pStateHeap = pRenderHal->pStateHeap;
pHwSizes = pRenderHal->pHwSizes;
// Get Offset to Current Binding Table
dwOffset = (pStateHeap->iCurSshBufferIndex * pStateHeap->dwSshIntanceSize) + // Points to the Base of Current SSH Buffer Instance
(pStateHeap->iBindingTableOffset) + // Moves the pointer to Base of Array of Binding Tables
(iBindingTableIndex * pStateHeap->iBindingTableSize) + // Moves the pointer to a Particular Binding Table
(iBindingTableEntry * pHwSizes->dwSizeBindingTableState); // Move the pointer to correct entry
MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pSshBuffer);
Params.pBindingTableEntry = pStateHeap->pSshBuffer + dwOffset;
Params.dwSurfaceStateOffset = pSurfaceEntry->dwSurfStateOffset;
Params.bSurfaceStateAvs = (pSurfaceEntry->Type == pRenderHal->SurfaceTypeAdvanced ) ? true : false;
Params.iBindingTableEntry = iBindingTableEntry;
// Set binding table entry in MHW
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pMhwStateHeap->SetBindingTableEntry(&Params));
return eStatus;
}
//!
//! \brief Set Vfe State Params
//! \details Sets VFE State parameters
//! this functions must be called to setup
//! parameters for Mhw Render->AddMediaVfeCmd()
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param uint32_t dwDebugCounterControl
//! [in] Debug Counter Control
//! \param uint32_t dwMaximumNumberofThreads
//! [in] Maximum Number of Threads
//! \param uint32_t dwCURBEAllocationSize
//! [in] CURBE Allocation Size
//! \param uint32_t dwURBEntryAllocationSize
//! [in] URB Entry Allocation Size
//! \param PRENDERHAL_SCOREBOARD_PARAMS pScoreboardParams
//! [in] Pointer to Scoreboard Params
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_SetVfeStateParams(
PRENDERHAL_INTERFACE pRenderHal,
uint32_t dwDebugCounterControl,
uint32_t dwMaximumNumberofThreads,
uint32_t dwCURBEAllocationSize,
uint32_t dwURBEntryAllocationSize,
PMHW_VFE_SCOREBOARD pScoreboardParams)
{
PMHW_VFE_PARAMS pVfeParams;
PRENDERHAL_STATE_HEAP pStateHeap;
PMHW_RENDER_ENGINE_CAPS pHwCaps;
PRENDERHAL_STATE_HEAP_SETTINGS pSettings;
uint32_t dwMaxURBSize;
uint32_t dwMaxCURBEAllocationSize;
uint32_t dwMaxURBEntryAllocationSize;
uint32_t dwNumberofURBEntries;
uint32_t dwMaxURBEntries;
uint32_t dwMaxInterfaceDescriptorEntries;
MOS_STATUS eStatus;
uint32_t i;
//---------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pWaTable);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwCaps);
//---------------------------------------------
eStatus = MOS_STATUS_SUCCESS;
pStateHeap = pRenderHal->pStateHeap;
pHwCaps = pRenderHal->pHwCaps;
pVfeParams = pRenderHal->pRenderHalPltInterface->GetVfeStateParameters();
MHW_RENDERHAL_CHK_NULL_RETURN(pVfeParams);
pSettings = &(pRenderHal->StateHeapSettings);
pVfeParams->pKernelState = nullptr;
pVfeParams->eVfeSliceDisable = MHW_VFE_SLICE_ALL;
//-------------------------------------------------------------------------
// --Gen6 GT1--
// In this calculation, URBEntryAllocationSize and CURBEAllocationSize are
// in 256-bit units:
// (URBEntryAllocationSize * NumberofURBEntries + CURBEAllocationSize +
// MaxInterfaceDescriptorEntries) <= 1024
//
// --Gen6 GT2 + Gen7--
// In this calculation, URBEntryAllocationSize and CURBEAllocationSize are
// in 256-bit units:
// (URBEntryAllocationSize * NumberofURBEntries + CURBEAllocationSize +
// MaxInterfaceDescriptorEntries) <= 2048
//-------------------------------------------------------------------------
// get the Max for all the fields
dwMaxURBSize = pHwCaps->dwMaxURBSize;
dwMaxURBEntries = pHwCaps->dwMaxURBEntries;
dwMaxURBEntryAllocationSize = pHwCaps->dwMaxURBEntryAllocationSize;
dwMaxCURBEAllocationSize = pHwCaps->dwMaxCURBEAllocationSize;
dwMaxInterfaceDescriptorEntries = pHwCaps->dwMaxInterfaceDescriptorEntries;
// CURBEAllocationSize must be >= CurbeTotalDataLength in CURBE_LOAD.
MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pCurMediaState);
dwCURBEAllocationSize = MOS_MAX(dwCURBEAllocationSize, (uint32_t)pStateHeap->pCurMediaState->iCurbeOffset);
// CURBEAllocationSize is in 256-bit (32-byte) units, so we round up to
// 32. We do not force it to be greater than zero because a Kernel may not
// be using any CURBE parameters.
dwCURBEAllocationSize = MOS_ROUNDUP_SHIFT(dwCURBEAllocationSize, 5);
// URBEntryAllocationSize is in 256-bit (32-byte) units, so we round up to
// 32. We ensure that it is greater than zero, because we will use this in
// division when we calculate dwNumberofURBEntries, so we need a value
// that is greater than zero.
// URBEntryAllocationSize sets the size of the Inline Data. All the Inline
// Data will be placed in the URB which is a buffer that is managed by the
// hardware. When the thread is dispatched, the data in the URB will be
// copied to the GRF.
dwURBEntryAllocationSize = MOS_ROUNDUP_SHIFT(dwURBEntryAllocationSize, 5);
dwURBEntryAllocationSize = MOS_MAX(1, dwURBEntryAllocationSize);
// NumberofURBEntries defines the depth of the dispatch queue. Up to this
// many threads can be in the queue. It's related to performance. For hardware,
// we use the size of the Inline Data to calculate the maximum number of entries
// we can use. We cap it to 32 URB entries, and then ensure that it is greater
// than zero.
dwNumberofURBEntries =
(dwMaxURBSize - dwCURBEAllocationSize - dwMaxInterfaceDescriptorEntries) /
dwURBEntryAllocationSize;
dwNumberofURBEntries = MOS_CLAMP_MIN_MAX(dwNumberofURBEntries, 1, 32);
pVfeParams->dwDebugCounterControl = dwDebugCounterControl;
pVfeParams->dwNumberofURBEntries = dwNumberofURBEntries;
pVfeParams->dwMaximumNumberofThreads = (dwMaximumNumberofThreads == RENDERHAL_USE_MEDIA_THREADS_MAX) ?
pHwCaps->dwMaxThreads :
MOS_MIN(dwMaximumNumberofThreads, pHwCaps->dwMaxThreads);
pVfeParams->dwCURBEAllocationSize = dwCURBEAllocationSize << 5;
pVfeParams->dwURBEntryAllocationSize = dwURBEntryAllocationSize;
MHW_RENDERHAL_ASSERT(dwNumberofURBEntries <= dwMaxURBEntries);
MHW_RENDERHAL_ASSERT(dwCURBEAllocationSize <= dwMaxCURBEAllocationSize);
MHW_RENDERHAL_ASSERT(dwURBEntryAllocationSize <= dwMaxURBEntryAllocationSize);
MHW_RENDERHAL_ASSERT(dwNumberofURBEntries * dwURBEntryAllocationSize +
dwCURBEAllocationSize + dwMaxInterfaceDescriptorEntries <= dwMaxURBSize);
// Setup Scoreboard Parameters
if (pScoreboardParams)
{
MHW_RENDERHAL_ASSERT(pScoreboardParams->ScoreboardMask < 8);
pRenderHal->VfeScoreboard.ScoreboardEnable = true;
pRenderHal->VfeScoreboard.ScoreboardMask = (1 << pScoreboardParams->ScoreboardMask) - 1;
pRenderHal->VfeScoreboard.ScoreboardType = pScoreboardParams->ScoreboardType;
for (i = 0; i < pScoreboardParams->ScoreboardMask; i++)
{
pRenderHal->VfeScoreboard.ScoreboardDelta[i].x = pScoreboardParams->ScoreboardDelta[i].x;
pRenderHal->VfeScoreboard.ScoreboardDelta[i].y = pScoreboardParams->ScoreboardDelta[i].y;
}
}
else
{
pRenderHal->VfeScoreboard.ScoreboardEnable = true;
pRenderHal->VfeScoreboard.ScoreboardMask = 0x0;
}
// Setup VFE Scoreboard parameters
pVfeParams->Scoreboard = pRenderHal->VfeScoreboard;
// Setup Kernel Scratch Space
if (pSettings->iPerThreadScratchSize > 0)
{
int32_t iSize;
int32_t iRemain;
int32_t iPerThreadScratchSize;
MHW_RENDERHAL_ASSERT(pSettings->iPerThreadScratchSize ==
MOS_ALIGN_CEIL(pSettings->iPerThreadScratchSize, 1024));
iPerThreadScratchSize = pSettings->iPerThreadScratchSize >> 10;
iRemain = iPerThreadScratchSize % 2;
iPerThreadScratchSize = iPerThreadScratchSize / 2;
iSize = 0;
while (!iRemain && (iPerThreadScratchSize / 2))
{
iSize++;
iRemain = iPerThreadScratchSize % 2;
iPerThreadScratchSize = iPerThreadScratchSize / 2;
}
MHW_RENDERHAL_ASSERT(!iRemain && iPerThreadScratchSize);
MHW_RENDERHAL_ASSERT(iSize < 12);
// Specifies the amount of scratch space allowed to be used by each
// thread. The driver must allocate enough contiguous scratch space,
// pointed to by the Scratch Space Pointer, to ensure that the Maximum
// Number of Threads each get Per Thread Scratch Space size without
// exceeding the driver-allocated scratch space.
// Range = [0,11] indicating [1k bytes, 12k bytes]
pVfeParams->dwPerThreadScratchSpace = (uint32_t) iSize;
// Specifies the 1k-byte aligned address offset to scratch space for
// use by the kernel. This pointer is relative to the
// General State Base Address (1k aligned)
// Format = GeneralStateOffset[31:10]
pVfeParams->dwScratchSpaceBasePointer = pStateHeap->dwScratchSpaceBase;
}
else
{
pVfeParams->dwPerThreadScratchSpace = 0;
pVfeParams->dwScratchSpaceBasePointer = 0;
}
return eStatus;
}
//!
//! \brief Is two Planes NV12 Needed
//! \details Judge whether 2 plane NV12 is needed based on the width/height
//! and its rectangle for each boundary type
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] pointer to RenderHal Interface
//! \param PRENDERHAL_SURFACE pRenderHalSurface
//! [in] pointer to input Surface
//! \param RENDERHAL_SS_BOUNDARY Boundary
//! [in] How the adjustment needs to be done
//! \return bool
//!
bool RenderHal_Is2PlaneNV12Needed(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface,
RENDERHAL_SS_BOUNDARY Boundary)
{
PMOS_SURFACE pSurface;
uint16_t wWidthAlignUnit;
uint16_t wHeightAlignUnit;
uint32_t dwSurfaceHeight;
uint32_t dwSurfaceWidth;
uint32_t widthAlignUnit;
uint32_t heightAlignUnit;
bool bRet = false;
//---------------------------------------------
if (pRenderHal == nullptr
|| pRenderHalSurface == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("nullptr pointer detected.");
return bRet;
}
//---------------------------------------------
pRenderHal->pfnGetAlignUnit(&wWidthAlignUnit, &wHeightAlignUnit, pRenderHalSurface);
pSurface = &pRenderHalSurface->OsSurface;
switch (Boundary)
{
case RENDERHAL_SS_BOUNDARY_SRCRECT:
dwSurfaceHeight = pSurface->dwHeight;
dwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcSrc.right), wWidthAlignUnit);
break;
// align with max src rect
case RENDERHAL_SS_BOUNDARY_MAXSRCRECT:
dwSurfaceHeight = pSurface->dwHeight;
dwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcMaxSrc.right), wWidthAlignUnit);
break;
default:
dwSurfaceHeight = MOS_ALIGN_CEIL(pSurface->dwHeight, wHeightAlignUnit);
dwSurfaceWidth = MOS_ALIGN_CEIL(pSurface->dwWidth, wWidthAlignUnit);
break;
}
// NV12 format needs the width and height to be a multiple for both 3D sampler and 8x8 sampler.
// For AVS sampler, no limitation for 4 alignment.
pRenderHal->pRenderHalPltInterface->GetSamplerResolutionAlignUnit(pRenderHal,
RENDERHAL_SCALING_AVS == pRenderHalSurface->ScalingMode,
widthAlignUnit,
heightAlignUnit);
bRet = (!MOS_IS_ALIGNED(dwSurfaceHeight, heightAlignUnit) || !MOS_IS_ALIGNED(dwSurfaceWidth, widthAlignUnit));
// Note: Always using 2 plane NV12 as WA for the corruption of NV12 input, of which the height is greater than 16352
// For 16k case, the height (16384) > 16383 which is the maximum capacity of DW (13:0).
// Gmm (OS level) need 32 aligned for planar height in the driver and we are processing height as 16384 for the height from 16353 to 16384.
bRet = bRet || (dwSurfaceHeight > 16352);
return bRet;
}
//!
//! \brief Print Sampler Params
//! \details
//! \param PMHW_SAMPLER_STATE_PARAM pSamplerParams
//! [in] SamplerParams
void PrintSamplerParams(int32_t iSamplerIndex, PMHW_SAMPLER_STATE_PARAM pSamplerParams)
{
#if (_DEBUG || _RELEASE_INTERNAL)
if (pSamplerParams == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("The SamplerParams pointer is null");
return;
}
if (pSamplerParams->SamplerType == MHW_SAMPLER_TYPE_3D)
{
MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, bInUse = %x, SamplerType = %x, ElementType = %x, SamplerFilterMode = %x, MagFilter = %x, MinFilter = %x",
iSamplerIndex,
pSamplerParams->bInUse,
pSamplerParams->SamplerType,
pSamplerParams->ElementType,
pSamplerParams->Unorm.SamplerFilterMode,
pSamplerParams->Unorm.MagFilter,
pSamplerParams->Unorm.MinFilter);
MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, AddressU = %x, AddressV = %x, AddressW = %x, SurfaceFormat = %x, BorderColorRedU = %x, BorderColorGreenU = %x",
iSamplerIndex,
pSamplerParams->Unorm.AddressU,
pSamplerParams->Unorm.AddressV,
pSamplerParams->Unorm.AddressW,
pSamplerParams->Unorm.SurfaceFormat,
pSamplerParams->Unorm.BorderColorRedU,
pSamplerParams->Unorm.BorderColorGreenU);
MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, BorderColorBlueU = %x, BorderColorAlphaU = %x, IndirectStateOffset = %x, bBorderColorIsValid = %x, bChromaKeyEnable = %x, ChromaKeyIndex = %x, ChromaKeyMode = %x",
iSamplerIndex,
pSamplerParams->Unorm.BorderColorBlueU,
pSamplerParams->Unorm.BorderColorAlphaU,
pSamplerParams->Unorm.IndirectStateOffset,
pSamplerParams->Unorm.bBorderColorIsValid,
pSamplerParams->Unorm.bChromaKeyEnable,
pSamplerParams->Unorm.ChromaKeyIndex,
pSamplerParams->Unorm.ChromaKeyMode);
}
else
{
MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, bInUse = %x, SamplerType = %x, ElementType = %x",
iSamplerIndex,
pSamplerParams->bInUse,
pSamplerParams->SamplerType,
pSamplerParams->ElementType);
}
#endif
}
//!
//! \brief Sets Sampler States for Gen8
//! \details Initialize and set sampler states
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to HW interface
//! \param int32_t iMediaID
//! [in] Media Interface Descriptor ID
//! \param PRENDERHAL_SAMPLER_STATE_PARAMS pSamplerParams
//! [in] Pointer to sampler state parameters
//! \param int32_t iSamplers
//! [in] Number of samplers
//! \return MOS_STATUS MOS_STATUS_SUCCESS if success, otherwise MOS_STATUS_UNKNOWN
//!
MOS_STATUS RenderHal_SetSamplerStates(
PRENDERHAL_INTERFACE pRenderHal,
int32_t iMediaID,
PMHW_SAMPLER_STATE_PARAM pSamplerParams,
int32_t iSamplers)
{
MOS_STATUS eStatus;
PRENDERHAL_STATE_HEAP pStateHeap;
PMHW_SAMPLER_STATE_PARAM pSamplerStateParams;
PRENDERHAL_MEDIA_STATE pMediaState;
int32_t iOffsetSampler;
uint8_t *pPtrSampler;
uint8_t *pPtrSamplerAvs;
int32_t i;
eStatus = MOS_STATUS_UNKNOWN;
//-----------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pSamplerParams);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pCurMediaState);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pGshBuffer);
MHW_RENDERHAL_ASSERT( iSamplers <= pRenderHal->StateHeapSettings.iSamplers );
MHW_RENDERHAL_ASSERT((iMediaID >= 0) && (iMediaID < pRenderHal->StateHeapSettings.iMediaIDs));
//-----------------------------------------------
pStateHeap = pRenderHal->pStateHeap;
pMediaState = pRenderHal->pStateHeap->pCurMediaState;
// Offset/Pointer to Samplers
iOffsetSampler = pMediaState->dwOffset + // Offset to media state
pStateHeap->dwOffsetSampler + // Offset to sampler area
iMediaID * pStateHeap->dwSizeSamplers; // Samplers for media ID
pPtrSampler = pStateHeap->pGshBuffer + iOffsetSampler; // Pointer to Samplers
iOffsetSampler = pMediaState->dwOffset + // Offset to media state
pStateHeap->dwOffsetSamplerAVS + // Offset to sampler area
iMediaID * pStateHeap->dwSizeSamplers; // Samplers for media ID
pPtrSamplerAvs = pStateHeap->pGshBuffer + iOffsetSampler; // Pointer to AVS Samplers
// Setup sampler states
pSamplerStateParams = pSamplerParams; // Pointer to First Sampler State in array
for (i = 0; i < iSamplers; i++, pSamplerStateParams++,
pPtrSampler += pRenderHal->pHwSizes->dwSizeSamplerState)
{
PrintSamplerParams(i, pSamplerStateParams);
if (pSamplerStateParams->bInUse)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pOsInterface->pfnSetCmdBufferDebugInfo(
pRenderHal->pOsInterface,
true, //bSamplerState
false, //bSurfaceState
i,
pSamplerStateParams->SamplerType));
switch (pSamplerStateParams->SamplerType)
{
case MHW_SAMPLER_TYPE_3D:
eStatus = pRenderHal->pMhwStateHeap->SetSamplerState(pPtrSampler, pSamplerStateParams);
break;
case MHW_SAMPLER_TYPE_AVS:
eStatus = pRenderHal->pMhwStateHeap->SetSamplerState(pPtrSamplerAvs, pSamplerStateParams);
pPtrSamplerAvs += pRenderHal->dwSamplerAvsIncrement;
break;
default:
eStatus = MOS_STATUS_INVALID_PARAMETER;
MHW_RENDERHAL_ASSERTMESSAGE("Unknown Sampler Type.");
break;
}
if (MOS_FAILED(eStatus))
{
MHW_RENDERHAL_ASSERTMESSAGE("Failed to setup Sampler");
return eStatus;
}
}
}
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
//!
//! \brief Sets Sampler States for Gen8
//! \details Initialize and set sampler states
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to HW interface
//! \param int32_t iMediaID
//! [in] Media Interface Descriptor ID
//! \param PRENDERHAL_SAMPLER_STATE_PARAMS pSamplerParams
//! [in] Pointer to sampler state parameters
//! \param int32_t iSamplers
//! [in] Number of samplers
//! \return MOS_STATUS MOS_STATUS_SUCCESS if success, otherwise MOS_STATUS_UNKNOWN
//!
MOS_STATUS RenderHal_SetAndGetSamplerStates(
PRENDERHAL_INTERFACE pRenderHal,
int32_t iMediaID,
PMHW_SAMPLER_STATE_PARAM pSamplerParams,
int32_t iSamplers,
std::map<uint32_t, uint64_t> &samplerMap)
{
MOS_STATUS eStatus;
PRENDERHAL_STATE_HEAP pStateHeap;
PMHW_SAMPLER_STATE_PARAM pSamplerStateParams;
PRENDERHAL_MEDIA_STATE pMediaState;
int32_t iOffsetSampler;
uint8_t *pPtrSampler;
int32_t i;
uint64_t stateGfxAddress = 0;
eStatus = MOS_STATUS_UNKNOWN;
//-----------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pSamplerParams);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pCurMediaState);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pGshBuffer);
MHW_RENDERHAL_ASSERT(iSamplers <= pRenderHal->StateHeapSettings.iSamplers);
MHW_RENDERHAL_ASSERT((iMediaID >= 0) && (iMediaID < pRenderHal->StateHeapSettings.iMediaIDs));
//-----------------------------------------------
if (pRenderHal->isBindlessHeapInUse == false)
{
return RenderHal_SetSamplerStates(pRenderHal, iMediaID, pSamplerParams, iSamplers);
}
else
{
pStateHeap = pRenderHal->pStateHeap;
pMediaState = pRenderHal->pStateHeap->pCurMediaState;
// Offset/Pointer to Samplers
iOffsetSampler = pMediaState->dwOffset + // Offset to media state
pStateHeap->dwOffsetSampler + // Offset to sampler area
iMediaID * pStateHeap->dwSizeSamplers; // Samplers for media ID
pPtrSampler = pStateHeap->pGshBuffer + iOffsetSampler; // Pointer to Samplers
// Setup sampler states
pSamplerStateParams = pSamplerParams; // Pointer to First Sampler State in array
if (samplerMap.size() != 0)
{
MHW_RENDERHAL_ASSERTMESSAGE("samplerMap is not empty!");
samplerMap.clear();
}
for (i = 0; i < iSamplers; i++, pSamplerStateParams++, pPtrSampler += pRenderHal->pHwSizes->dwSizeSamplerState)
{
PrintSamplerParams(i, pSamplerStateParams);
if (pSamplerStateParams->bInUse)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pOsInterface->pfnSetCmdBufferDebugInfo(
pRenderHal->pOsInterface,
true, //bSamplerState
false, //bSurfaceState
i,
pSamplerStateParams->SamplerType));
switch (pSamplerStateParams->SamplerType)
{
case MHW_SAMPLER_TYPE_3D:
MHW_RENDERHAL_CHK_VALUE_RETURN(Mos_ResourceIsNull(&pStateHeap->GshOsResource), false);
stateGfxAddress = pRenderHal->pOsInterface->pfnGetResourceGfxAddress(pRenderHal->pOsInterface, &pStateHeap->GshOsResource) + iOffsetSampler;
stateGfxAddress += (static_cast<uint64_t>(pRenderHal->pHwSizes->dwSizeSamplerState) * static_cast<uint64_t>(i));
eStatus = pRenderHal->pMhwStateHeap->SetSamplerState(pPtrSampler, pSamplerStateParams);
break;
default:
eStatus = MOS_STATUS_INVALID_PARAMETER;
MHW_RENDERHAL_ASSERTMESSAGE("Unknown Sampler Type.");
break;
}
samplerMap.insert(std::make_pair(i, stateGfxAddress));
if (MOS_FAILED(eStatus))
{
MHW_RENDERHAL_ASSERTMESSAGE("Failed to setup Sampler");
return eStatus;
}
}
}
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
}
//!
//! \brief Setup Surface State
//! \details Setup Surface States
//! \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 pParams
//! [in] Pointer to Surface State Params
//! \param int32_t *piNumEntries
//! [out] Pointer to Number of Surface State Entries (Num Planes)
//! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries
//! [out] Array of Surface State Entries
//! \param PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride
//! [in] If not nullptr, provides adjustments to Y, UV plane offsets,
//! used for kernel in a few cases. nullptr is the most common usage.
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_SetupSurfaceState(
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 eStatus = MOS_STATUS_SUCCESS;
//-----------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
//-----------------------------------------------
if (pParams->surfaceType)
{
MOS_CACHE_ELEMENT element(MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC, MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC);
bool res = pRenderHal->pOsInterface->pfnGetCacheSetting(pParams->Component, pParams->surfaceType, pParams->isOutput, RENDER_ENGINE, element, false);
if (res)
{
pParams->MemObjCtl = (pRenderHal->pOsInterface->pfnCachePolicyGetMemoryObject(
element.mocsUsageType,
pRenderHal->pOsInterface->pfnGetGmmClientContext(pRenderHal->pOsInterface)))
.DwordValue;
}
else
{
MHW_RENDERHAL_ASSERTMESSAGE("Not found cache settings!");
}
}
else
{
MHW_RENDERHAL_NORMALMESSAGE("Not implemented yet! Will use MemObjCtl value %d", pParams->MemObjCtl);
}
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SetupSurfaceState(
pRenderHal, pRenderHalSurface, pParams, piNumEntries, ppSurfaceEntries, pOffsetOverride));
return eStatus;
}
//!
//! \brief Get offset and/or pointer to sampler state
//! \details Get offset and/or pointer to sampler state in General State Heap
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface
//! \param int32_t iMediaID
//! [in] Media ID associated with sampler
//! \param int32_t iSamplerID
//! [in] Sampler ID
//! \param uint32_t *pdwSamplerOffset
//! [out] optional; offset of sampler state from GSH base
//! \param void **ppSampler
//! [out] optional; pointer to sampler state in GSH
//! \return MOS_STATUS
//!
MOS_STATUS RenderHal_GetSamplerOffsetAndPtr(
PRENDERHAL_INTERFACE pRenderHal,
int32_t iMediaID,
int32_t iSamplerID,
PMHW_SAMPLER_STATE_PARAM pSamplerParams,
uint32_t *pdwSamplerOffset,
void **ppSampler)
{
PRENDERHAL_STATE_HEAP pStateHeap;
uint32_t dwOffset = 0;
MHW_SAMPLER_ELEMENT_TYPE ElementType;
MHW_SAMPLER_TYPE SamplerType;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
uint32_t ElementSize[MHW_SamplerTotalElements] = {1, 2, 4, 8, 64, 128};
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes);
pStateHeap = pRenderHal->pStateHeap;
MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pCurMediaState);
MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pGshBuffer);
MHW_ASSERT(iMediaID < pRenderHal->StateHeapSettings.iMediaIDs);
MHW_ASSERT(iSamplerID < pRenderHal->StateHeapSettings.iSamplers);
MHW_RENDERHAL_CHK_NULL_RETURN(pSamplerParams);
ElementType = pSamplerParams->ElementType;
SamplerType = pSamplerParams->SamplerType;
if (SamplerType == MHW_SAMPLER_TYPE_VME)
{
dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
pStateHeap->dwOffsetSampler + // Go to base of the sampler area
iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerState; // Goto to "samplerID" sampler state
}
else
{
switch (ElementType)
{
case MHW_Sampler1Element:
case MHW_Sampler4Elements:
{
dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
pStateHeap->dwOffsetSampler + // Go to base of the sampler area
iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerState; // Goto to "samplerID" sampler state
if (pSamplerParams)
{
pSamplerParams->Unorm.IndirectStateOffset =
pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
pStateHeap->dwOffsetSamplerIndirect + // Go to base of the sampler indirect area
iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerIndirectState; // Goto to "samplerID" sampler indirect state
pSamplerParams->Unorm.pIndirectState = (void *)(pStateHeap->pGshBuffer + pSamplerParams->Unorm.IndirectStateOffset);
}
break;
}
case MHW_Sampler2Elements:
case MHW_Sampler8Elements:
dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
pStateHeap->dwOffsetSampler + // Go to base of the sampler area
iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
iSamplerID * ElementSize[ElementType] * 16; // Goto to "samplerID" sampler state
break;
case MHW_Sampler64Elements:
dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
pStateHeap->dwOffsetSampler + // Go to base of the sampler area
iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
iSamplerID * 32 * 16; // Goto to "samplerID" sampler state
break;
case MHW_Sampler128Elements:
if (pRenderHal->pRenderHalPltInterface->IsSampler128ElementsSupported())
{
dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
pStateHeap->dwOffsetSampler + // Go to base of the sampler area
iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
iSamplerID * ElementSize[ElementType] * 16; // Goto to "samplerID" sampler state
} else
{
MHW_RENDERHAL_NORMALMESSAGE("Platform doesn't have any 128 element sampler, quit!");
eStatus = MOS_STATUS_INVALID_PARAMETER;
}
break;
default:
MHW_RENDERHAL_NORMALMESSAGE("Failed to parse sampler - invalid sampler type.");
eStatus = MOS_STATUS_INVALID_PARAMETER;
break;
}
}
if (pdwSamplerOffset)
{
*pdwSamplerOffset = dwOffset;
}
if (ppSampler)
{
*ppSampler = (void *)(pStateHeap->pGshBuffer + dwOffset);
}
return eStatus;
}
//!
//! \brief Checks how per thread scratch space size bits in VFE state are interpreted by HW
//! \details For BDW GT1/2/3 A0 steppings, per thread scratch space size in VFE state
//! is 11 bits indicating [2k bytes, 2 Mbytes]: 0=2k, 1=4k, 2=8k ... 10=2M
//! BDW+ excluding A0 step is 12 bits indicating [1k bytes, 2 Mbytes]: 0=1k, 1=2k, 2=4k, 3=8k ... 11=2M
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal interface
//! \return true if BDW A0 stepping, false otherwise
//!
bool RenderHal_PerThreadScratchSpaceStart2K(
PRENDERHAL_INTERFACE pRenderHal)
{
if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer.");
return false;
}
return pRenderHal->pRenderHalPltInterface->PerThreadScratchSpaceStart2K(pRenderHal);
}
//!
//! \brief Encode SLM Size for Interface Descriptor
//! \details Setup SLM size
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal interface
//! \param uint32_t SLMSize
//! [in] SLM size in 1K
//! \return encoded output
//!
uint32_t RenderHal_EncodeSLMSize(
PRENDERHAL_INTERFACE pRenderHal,
uint32_t SLMSize)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer.");
return 0;
}
return pRenderHal->pRenderHalPltInterface->EncodeSLMSize(SLMSize);
}
//!
//! \brief Set Chroma Direction
//! \details Setup Chroma Direction
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface
//! \param PRENDERHAL_SURFACE pRenderHalSurface
//! [in] Pointer to Render Hal Surface
//! \return uint8_t
//!
uint8_t RenderHal_SetChromaDirection(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_SURFACE pRenderHalSurface)
{
if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer.");
return false;
}
return pRenderHal->pRenderHalPltInterface->SetChromaDirection(pRenderHal, pRenderHalSurface);
}
//!
//! \brief Convert To Nano Seconds
//! \details Convert to Nano Seconds
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface Structure
//! \param uint64_t iTicks
//! [in] Ticks
//! \param uint64_t *piNs
//! [in] Nano Seconds
//! \return void
//!
void RenderHal_ConvertToNanoSeconds(
PRENDERHAL_INTERFACE pRenderHal,
uint64_t iTicks,
uint64_t *piNs)
{
if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr)
{
MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer.");
return;
}
pRenderHal->pRenderHalPltInterface->ConvertToNanoSeconds(pRenderHal, iTicks, piNs);
}
//!
//! \brief Enables L3 cacheing flag and sets related registers/values
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to Hardware Interface
//! \param pCacheSettings
//! [in] L3 Cache Configurations
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS RenderHal_EnableL3Caching(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->EnableL3Caching(pRenderHal, pCacheSettings));
return eStatus;
}
//!
//! \brief Set L3 cache override config parameters
//! \param [in] pRenderHal
//! Pointer to RenderHal Interface Structure
//! \param [in,out] pCacheSettings
//! Pointer to pCacheSettings
//! \param [in] bEnableSLM
//! Flag to enable SLM
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if success. Error code otherwise
//!
MOS_STATUS RenderHal_SetCacheOverrideParams(
PRENDERHAL_INTERFACE pRenderHal,
PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings,
bool bEnableSLM)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SetCacheOverrideParams(
pRenderHal,
pCacheSettings,
bEnableSLM)
);
pCacheSettings->bOverride =
pCacheSettings->bCntlRegOverride ||
pCacheSettings->bCntlReg2Override ||
pCacheSettings->bCntlReg3Override ||
pCacheSettings->bLra1RegOverride ||
pCacheSettings->bSqcReg1Override;
return eStatus;
}
//!
//! \brief Send Surface State Entry
//! \param [in] pRenderHal
//! pointer to render hal
//! \param [in] pCmdBuffer
//! pointer to command buffer
//! \param [in] pParams
//! pointer to surface state send parameters
//! \return MOS_STATUS
//! MOS_STATUS_SUCCESS if success, else fail reason
//!
MOS_STATUS RenderHal_SendSurfaceStateEntry(
PRENDERHAL_INTERFACE pRenderHal,
PMOS_COMMAND_BUFFER pCmdBuffer,
PMHW_SURFACE_STATE_SEND_PARAMS pParams)
{
//-----------------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pParams);
//-----------------------------------------------
uint8_t *pbPtrCmdBuf;
if (pRenderHal->isBindlessHeapInUse)
{
MHW_RENDERHAL_CHK_NULL_RETURN(pParams->pIndirectStateBase);
pbPtrCmdBuf = pParams->pIndirectStateBase;
}
else
{
MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
pbPtrCmdBuf = (uint8_t *)pCmdBuffer->pCmdBase;
}
PMOS_INTERFACE pOsInterface = pRenderHal->pOsInterface;
uint8_t *pSurfaceState = pParams->pSurfaceStateSource;
int32_t iSurfaceStateOffset = pParams->iSurfaceStateOffset;
int32_t iIndirectStateBase = pParams->iIndirectStateBase;
SURFACE_STATE_TOKEN_COMMON *pSurfaceStateToken = (SURFACE_STATE_TOKEN_COMMON*)pParams->pSurfaceToken;
uint32_t* pdwCmd = (uint32_t*)(pParams->pIndirectStateBase + iSurfaceStateOffset);
uint32_t locationInCmd = 0;
// Copy surface state from system memory to graphics memory/indirect state
if (pSurfaceStateToken->DW3.SurfaceStateType == MEDIASTATE_BTS_DEFAULT_TYPE)
{
MOS_SecureMemcpy(pdwCmd, pRenderHal->pHwSizes->dwSizeSurfaceState,
pSurfaceState, pRenderHal->pHwSizes->dwSizeSurfaceState);
// Patch offset is 8 DW from the surface state base
pdwCmd += 8;
iSurfaceStateOffset += 8 * sizeof(uint32_t);
locationInCmd = 8;
}
else
{
MOS_SecureMemcpy(pdwCmd, pRenderHal->pHwSizes->dwSizeSurfaceStateAvs,
pSurfaceState, pRenderHal->pHwSizes->dwSizeSurfaceStateAvs);
// Patch offset is 6 DW from the surface state base
pdwCmd += 6;
iSurfaceStateOffset += 6 * sizeof(uint32_t);
locationInCmd = 6;
}
if (pOsInterface->bUsesGfxAddress)
{
*pdwCmd = pSurfaceStateToken->DW4.SurfaceBaseAddress;
*(pdwCmd + 1) = pSurfaceStateToken->DW5.SurfaceBaseAddress64;
}
if (pSurfaceStateToken->pResourceInfo)
{
HalOcaInterfaceNext::DumpResourceInfo(*pCmdBuffer, *pOsInterface, *(PMOS_RESOURCE)(pSurfaceStateToken->pResourceInfo), (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID,
locationInCmd, 0);
}
MOS_PATCH_ENTRY_PARAMS PatchEntryParams;
MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
PatchEntryParams.uiAllocationIndex = pSurfaceStateToken->DW1.SurfaceAllocationIndex;
PatchEntryParams.uiResourceOffset = pSurfaceStateToken->DW2.SurfaceOffset;
PatchEntryParams.uiPatchOffset = iIndirectStateBase + iSurfaceStateOffset;
PatchEntryParams.bWrite = pSurfaceStateToken->DW3.RenderTargetEnable;
PatchEntryParams.HwCommandType = (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID;
PatchEntryParams.forceDwordOffset = 0;
PatchEntryParams.cmdBufBase = pbPtrCmdBuf;
PatchEntryParams.presResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo;
// Set patch for surface state address
pOsInterface->pfnSetPatchEntry(
pOsInterface,
&PatchEntryParams);
MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
PMOS_RESOURCE pMosResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo;
MHW_RENDERHAL_CHK_NULL_RETURN(pMosResource);
if (pOsInterface->pfnGetMemoryCompressionMode)
{
pOsInterface->pfnGetMemoryCompressionMode(pOsInterface, pMosResource, &mmcMode);
}
if (mmcMode == MOS_MEMCOMP_RC && pSurfaceStateToken->DW3.SurfaceStateType == MEDIASTATE_BTS_DEFAULT_TYPE)
{
# if !EMUL
if (pOsInterface->bUsesGfxAddress)
{
uint64_t ui64GfxAddress = 0;
uint64_t ui64GfxAddressWithoutOffset = 0;
ui64GfxAddress |= (uint64_t)(pSurfaceStateToken->DW5.SurfaceBaseAddress64 & 0x0000FFFF) << 32;
ui64GfxAddress |= (uint64_t)(pSurfaceStateToken->DW4.SurfaceBaseAddress);
//Original Resouce Address without surface offset
ui64GfxAddressWithoutOffset = ui64GfxAddress - pSurfaceStateToken->DW2.SurfaceOffset;
pdwCmd = (uint32_t*)(pParams->pIndirectStateBase + pParams->iSurfaceStateOffset); //point to the start of current RENDER_SURFACE_STATE_CMD
if (pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS))
{
// Set GFX address of AuxiliarySurfaceBaseAddress
// Should use original resource address here
uint64_t auxAddress = ui64GfxAddressWithoutOffset + (uint64_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS);
*(pdwCmd + 10) = (*(pdwCmd + 10) & 0x00000FFF) | (uint32_t)(auxAddress & 0x00000000FFFFF000);
*(pdwCmd + 11) = *(pdwCmd + 11) | (uint32_t)((auxAddress & 0x0000FFFF00000000) >> 32);
}
uint64_t clearAddress = 0;
if (pOsInterface->trinityPath != TRINITY_DISABLED)
{
clearAddress = pOsInterface->pfnGetResourceClearAddress(pOsInterface, pMosResource);
}
else if (pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CC))
{
// Set GFX address of ClearAddress
// Should use original resource address here
clearAddress = ui64GfxAddressWithoutOffset + (uint32_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CC);
}
if (clearAddress)
{
*(pdwCmd + 12) = (*(pdwCmd + 12) & 0x0000001F) | (uint32_t)(clearAddress & 0x00000000FFFFFFE0);
*(pdwCmd + 13) = *(pdwCmd + 13) | (uint32_t)((clearAddress & 0x0000FFFF00000000) >> 32);
}
}
else
{
// Set patch for AuxiliarySurfaceBaseAddress
MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
PatchEntryParams.uiAllocationIndex = pSurfaceStateToken->DW1.SurfaceAllocationIndex;
PatchEntryParams.uiResourceOffset = pSurfaceStateToken->DW2.SurfaceOffset
+ (uint32_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS);
PatchEntryParams.uiPatchOffset = iIndirectStateBase + pParams->iSurfaceStateOffset + 10 * sizeof(uint32_t);
PatchEntryParams.bWrite = pSurfaceStateToken->DW3.RenderTargetEnable;
PatchEntryParams.HwCommandType = (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID;
PatchEntryParams.forceDwordOffset = 0;
PatchEntryParams.cmdBufBase = pbPtrCmdBuf;
PatchEntryParams.presResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo;
pOsInterface->pfnSetPatchEntry(pOsInterface, &PatchEntryParams);
// Set patch for ClearAddress
MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
PatchEntryParams.uiAllocationIndex = pSurfaceStateToken->DW1.SurfaceAllocationIndex;
PatchEntryParams.uiResourceOffset = pSurfaceStateToken->DW2.SurfaceOffset
+ (uint32_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CC);
PatchEntryParams.uiPatchOffset = iIndirectStateBase + pParams->iSurfaceStateOffset + 12 * sizeof(uint32_t);
PatchEntryParams.bWrite = pSurfaceStateToken->DW3.RenderTargetEnable;
PatchEntryParams.HwCommandType = (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID;
PatchEntryParams.forceDwordOffset = 0;
PatchEntryParams.cmdBufBase = pbPtrCmdBuf;
PatchEntryParams.presResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo;
pOsInterface->pfnSetPatchEntry(pOsInterface, &PatchEntryParams);
}
#endif
}
return MOS_STATUS_SUCCESS;
}
//!
//! \brief Init 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
//! \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)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MHW_VFE_PARAMS *pVfeStateParams = nullptr;
//---------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(ppCpInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pOsInterface);
//---------------------------------------
// Basic initialization
pRenderHal->pOsInterface = pOsInterface;
pRenderHal->bKerneltimeDump = false;
MOS_ZeroMemory(&pRenderHal->kernelTime, sizeof(pRenderHal->kernelTime));
pOsInterface->pfnGetPlatform(pOsInterface, &pRenderHal->Platform);
pRenderHal->pSkuTable = pOsInterface->pfnGetSkuTable(pOsInterface);
pRenderHal->pWaTable = pOsInterface->pfnGetWaTable(pOsInterface);
pRenderHal->userSettingPtr = pOsInterface->pfnGetUserSettingInstance(pOsInterface);
// Initialize hardware resources for the current Os/Platform
pRenderHal->pRenderHalPltInterface = RenderHalDevice::CreateFactory(pOsInterface);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
// create mhw interfaces including mhw_render, cp, and mi
pRenderHal->pRenderHalPltInterface->CreateMhwInterfaces(pRenderHal, pOsInterface);
// Set Cp Interface
*ppCpInterface = pRenderHal->pCpInterface;
// Initialize MHW State Heap Interface
// Note: there are two pStateHeapInterface in below line. First one is pointer to legacy MHW_STATE_HEAP
// sturcture, while the last one points to the new class.
if (pRenderHal->pRenderHalPltInterface->GetStateHeapInterface(pRenderHal) != nullptr)
{
pRenderHal->pMhwStateHeap = pRenderHal->pRenderHalPltInterface->GetStateHeapInterface(pRenderHal)->pStateHeapInterface;
}
pRenderHal->pHwCaps = pRenderHal->pRenderHalPltInterface->GetHwCaps(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwCaps);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap);
pRenderHal->pHwSizes = pRenderHal->pMhwStateHeap->GetHwSizesPointer();
pRenderHal->dwTimeoutMs = RENDERHAL_TIMEOUT_MS_DEFAULT;
pRenderHal->iMaxPalettes = RENDERHAL_PALETTE_MAX;
pRenderHal->iMaxPaletteEntries = RENDERHAL_PALETTE_ENTRIES_MAX;
pRenderHal->iMaxChromaKeys = RENDERHAL_CHROMA_KEY_MAX;
//set MDF load to default value false
pRenderHal->IsMDFLoad = false;
//set AVS to default value false
pRenderHal->bIsAVS = false;
pRenderHal->iChromaKeyCount = 0;
for (int i = 0; i < pRenderHal->iMaxChromaKeys; i++)
{
pRenderHal->ChromaKey[i].dwIndex = i;
}
pRenderHal->bVDIWalker = true;
int32_t walkerMode = MHW_WALKER_MODE_NOT_SET;
#if (_DEBUG || _RELEASE_INTERNAL)
if (pRenderHal->userSettingPtr != nullptr)
{
// Read VDI Walker Regkey once during initialization
ReadUserSettingForDebug(
pRenderHal->userSettingPtr,
pRenderHal->bVDIWalker,
__MEDIA_USER_FEATURE_VALUE_VDI_MODE,
MediaUserSetting::Group::Device,
true,
true);
// Read Media Walker Mode from RegKey once in initialization
ReadUserSettingForDebug(
pRenderHal->userSettingPtr,
walkerMode,
__MEDIA_USER_FEATURE_VALUE_MEDIA_WALKER_MODE,
MediaUserSetting::Group::Device,
int32_t(-1),
true);
}
#endif
pRenderHal->MediaWalkerMode = (MHW_WALKER_MODE)walkerMode;
pRenderHal->pPlaneDefinitions = g_cRenderHal_SurfacePlanes;
// disable RenderHal kernel debugging.
pRenderHal->bIsaAsmDebugEnable = false;
pRenderHal->iMaxPalettes = RENDERHAL_PALETTE_COUNT;
pRenderHal->iMaxPaletteEntries = RENDERHAL_PALETTE_ENTRIES;
pRenderHal->iMaxChromaKeys = RENDERHAL_CHROMA_KEY_COUNT;
MOS_ZeroMemory(&pRenderHal->PredicationParams, sizeof(pRenderHal->PredicationParams));
MOS_ZeroMemory(&pRenderHal->SetMarkerParams, sizeof(pRenderHal->SetMarkerParams));
// CMFC CSC Coefficient Surface update
pRenderHal->bCmfcCoeffUpdate = false;
pRenderHal->iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL;
pRenderHal->pCmfcCoeffSurface = nullptr;
// Initialization/Cleanup function
pRenderHal->pfnInitialize = RenderHal_Initialize;
pRenderHal->pfnDestroy = RenderHal_Destroy;
// Allocate/Destroy state heaps
pRenderHal->pfnAllocateStateHeaps = RenderHal_AllocateStateHeaps;
pRenderHal->pfnFreeStateHeaps = RenderHal_FreeStateHeaps;
pRenderHal->pfnReAllocateStateHeapsforAdvFeatureWithSshEnlarged = RenderHal_ReAllocateStateHeapsforAdvFeatureWithSshEnlarged;
pRenderHal->pfnReAllocateStateHeapsforAdvFeatureWithAllHeapsEnlarged = RenderHal_ReAllocateStateHeapsforAdvFeatureWithAllHeapsEnlarged;
// Slice Shutdown Mode
pRenderHal->pfnSetSliceShutdownMode = RenderHal_SetSliceShutdownMode;
pRenderHal->pfnSetPowerOptionMode = RenderHal_SetPowerOptionMode;
// Preemption
pRenderHal->pfnEnableGpgpuMiddleBatchBufferPreemption =
RenderHal_EnableGpgpuMiddleBatchBufferPreemption;
pRenderHal->pfnEnableGpgpuMiddleThreadPreemption =
RenderHal_EnableGpgpuMiddleThreadPreemption;
// Surface State and Binding Table management functions
pRenderHal->pfnSetSurfacesPerBT = RenderHal_SetSurfacesPerBT;
pRenderHal->pfnGetSurfaceStateEntries = RenderHal_GetSurfaceStateEntries;
pRenderHal->pfnAssignSurfaceState = RenderHal_AssignSurfaceState;
pRenderHal->pfnGetAlignUnit = RenderHal_GetAlignUnit;
pRenderHal->pfnAdjustBoundary = RenderHal_AdjustBoundary;
pRenderHal->pfnAssignBindingTable = RenderHal_AssignBindingTable;
pRenderHal->pfnSetupBufferSurfaceState = RenderHal_SetupBufferSurfaceState;
pRenderHal->pfnSetupSurfaceStatesOs = RenderHal_SetupSurfaceStatesOs;
pRenderHal->pfnBindSurfaceState = RenderHal_BindSurfaceState;
pRenderHal->pfnSendSurfaces = RenderHal_SendSurfaces_PatchList;
pRenderHal->pfnSendSurfaceStateEntry = RenderHal_SendSurfaceStateEntry;
pRenderHal->pfnSetSurfaceStateToken = RenderHal_SetSurfaceStateToken;
pRenderHal->pfnSetSurfaceStateBuffer = RenderHal_SetSurfaceStateBuffer;
pRenderHal->pfnCalculateYOffset = RenderHal_CalculateYOffset;
pRenderHal->pfnAssignBindlessSurfaceStates = RenderHal_AssignBindlessSurfaceStates;
pRenderHal->pfnSendBindlessSurfaceStates = RenderHal_SendBindlessSurfaces;
pRenderHal->pfnGetPlaneDefinitionForCommonMessage = RenderHal_GetPlaneDefinitionForCommonMessage;
// Media states management functions
pRenderHal->pfnAllocateBB = RenderHal_AllocateBB;
pRenderHal->pfnFreeBB = RenderHal_FreeBB;
pRenderHal->pfnLockBB = RenderHal_LockBB;
pRenderHal->pfnUnlockBB = RenderHal_UnlockBB;
pRenderHal->pfnEnablePalette = RenderHal_EnablePalette;
pRenderHal->pfnGetPaletteEntry = RenderHal_GetPaletteEntry;
pRenderHal->pfnAllocatePaletteID = RenderHal_AllocatePaletteID;
pRenderHal->pfnFreePaletteID = RenderHal_FreePaletteID;
pRenderHal->pfnAllocateChromaKey = RenderHal_AllocateChromaKey;
pRenderHal->pfnAssignMediaState = RenderHal_AssignMediaState;
pRenderHal->pfnAllocateMediaID = RenderHal_AllocateMediaID;
pRenderHal->pfnGetMediaID = RenderHal_GetMediaID;
// Old-style Kernel management functions
pRenderHal->pfnRefreshSync = RenderHal_RefreshSync;
pRenderHal->pfnLoadKernel = RenderHal_LoadKernel;
pRenderHal->pfnUnloadKernel = RenderHal_UnloadKernel;
pRenderHal->pfnResetKernels = RenderHal_ResetKernels;
pRenderHal->pfnTouchKernel = RenderHal_TouchKernel;
pRenderHal->pfnGetKernelOffset = RenderHal_GetKernelOffset;
// Command buffer programming functions
pRenderHal->pfnLoadCurbeData = RenderHal_LoadCurbeData;
pRenderHal->pfnSendCurbeLoad = RenderHal_SendCurbeLoad;
pRenderHal->pfnSendMediaIdLoad = RenderHal_SendMediaIdLoad;
pRenderHal->pfnSendChromaKey = RenderHal_SendChromaKey;
pRenderHal->pfnSendPalette = RenderHal_SendPalette;
pRenderHal->pfnSendMediaStates = RenderHal_SendMediaStates;
pRenderHal->pfnSendStateBaseAddress = RenderHal_SendStateBaseAddress;
pRenderHal->pfnSetCurbeResourceList = RenderHal_SetCurbeResourceList;
pRenderHal->pfnSetInlineResourceList = RenderHal_SetInlineResourceList;
// Initialize OS dependent RenderHal Interfaces common to all platforms
pRenderHal->pfnReset = RenderHal_Reset;
pRenderHal->pfnAssignSshInstance = RenderHal_AssignSshInstance;
pRenderHal->pfnInitCommandBuffer = RenderHal_InitCommandBuffer;
pRenderHal->pfnSendTimingData = RenderHal_SendTimingData;
pRenderHal->pfnSendRcsStatusTag = RenderHal_SendRcsStatusTag;
pRenderHal->pfnSendSyncTag = RenderHal_SendSyncTag;
pRenderHal->pfnSendCscCoeffSurface = RenderHal_SendCscCoeffSurface;
// InterfaceDescriptor
pRenderHal->pfnSetupInterfaceDescriptor = RenderHal_SetupInterfaceDescriptor;
// Media Walker
pRenderHal->pfnGetMediaWalkerStatus = RenderHal_GetMediaWalkerStatus;
//Surface Memory Object Control
pRenderHal->pfnGetSurfaceMemoryObjectControl
= RenderHal_GetSurfaceMemoryObjectControl;
//Scratch Space
pRenderHal->pfnGetScratchSpaceSize = RenderHal_GetScratchSpaceSize;
// Other states
pRenderHal->pfnSetVfeStateParams = RenderHal_SetVfeStateParams;
pRenderHal->pfnSetSamplerStates = RenderHal_SetSamplerStates;
pRenderHal->pfnSetAndGetSamplerStates = RenderHal_SetAndGetSamplerStates;
pRenderHal->pfnIs2PlaneNV12Needed = RenderHal_Is2PlaneNV12Needed;
// Set the platform-specific fields in renderhal
// Set State Heap settings
MOS_ZeroMemory(&pRenderHal->enlargeStateHeapSettingsForAdv, sizeof(pRenderHal->enlargeStateHeapSettingsForAdv));
pRenderHal->pRenderHalPltInterface->InitStateHeapSettings(pRenderHal);
// Set default / advanced surface types
pRenderHal->pRenderHalPltInterface->InitSurfaceTypes(pRenderHal);
// Set MMC Enabled status
pRenderHal->pRenderHalPltInterface->IsRenderHalMMCEnabled(pRenderHal);
// Set platform dependent parameters
pRenderHal->bHasCombinedAVSSamplerState = true;
pRenderHal->bEnableYV12SinglePass = pRenderHal->pRenderHalPltInterface->IsEnableYV12SinglePass(pRenderHal);
pRenderHal->dwSamplerAvsIncrement = pRenderHal->pRenderHalPltInterface->GetSizeSamplerStateAvs(pRenderHal);
pRenderHal->bComputeContextInUse = pRenderHal->pRenderHalPltInterface->IsComputeContextInUse(pRenderHal);
pRenderHal->isBindlessHeapInUse = pRenderHal->pRenderHalPltInterface->IsBindlessHeapInUse(pRenderHal);
pRenderHal->dwMaskCrsThdConDataRdLn = (uint32_t) -1;
pRenderHal->dwMinNumberThreadsInGroup = 1;
pRenderHal->dwCurbeBlockAlign = RENDERHAL_CURBE_BLOCK_ALIGN;
pRenderHal->dwScratchSpaceMaxThreads = pRenderHal->pHwCaps->dwMaxThreads;
// Set palette data
for (int i = 0; i < pRenderHal->iMaxPalettes; i++)
{
pRenderHal->Palette[i].iPaletteID = i;
pRenderHal->Palette[i].iNumEntries = 0;
pRenderHal->Palette[i].pPaletteData =
pRenderHal->pRenderHalPltInterface->GetPaletteDataAddress(i);
}
// Set default VFEState Params
pVfeStateParams = pRenderHal->pRenderHalPltInterface->GetVfeStateParameters();
pVfeStateParams->dwDebugCounterControl = MEDIASTATE_DEBUG_COUNTER_FREE_RUNNING;
pVfeStateParams->dwMaximumNumberofThreads = pRenderHal->pHwCaps->dwMaxThreads;
// Hardware dependent calls
pRenderHal->pfnGetSamplerOffsetAndPtr = RenderHal_GetSamplerOffsetAndPtr;
pRenderHal->pfnSetupSurfaceState = RenderHal_SetupSurfaceState;
pRenderHal->pfnEncodeSLMSize = RenderHal_EncodeSLMSize;
pRenderHal->pfnSetChromaDirection = RenderHal_SetChromaDirection;
pRenderHal->pfnEnableL3Caching = RenderHal_EnableL3Caching;
pRenderHal->pfnSetCacheOverrideParams = RenderHal_SetCacheOverrideParams;
// CM specific function
pRenderHal->pfnConvertToNanoSeconds = RenderHal_ConvertToNanoSeconds;
pRenderHal->pfnPerThreadScratchSpaceStart2K = RenderHal_PerThreadScratchSpaceStart2K;
// Special functions
RenderHal_InitInterfaceEx(pRenderHal);
return eStatus;
}
//!
//! \brief Set Surface for HW Access
//! \details Common Function for setting up surface state
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//! \param PRENDERHAL_SURFACE pRenderHalSurface
//! [in] Pointer to RenderHal 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)
{
PMOS_INTERFACE pOsInterface;
PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntries[MHW_MAX_SURFACE_PLANES];
int32_t iSurfaceEntries;
int32_t i;
MOS_STATUS eStatus;
//---------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
//---------------------------------------
// Initialize Variables
eStatus = MOS_STATUS_SUCCESS;
pOsInterface = pRenderHal->pOsInterface;
// Register surfaces for rendering (GfxAddress/Allocation index)
// Register resource
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(
pOsInterface,
&pRenderHalSurface->OsSurface.OsResource,
bWrite,
true));
// Setup surface states-----------------------------------------------------
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSetupSurfaceState(
pRenderHal,
pRenderHalSurface,
pSurfaceParams,
&iSurfaceEntries,
pSurfaceEntries,
nullptr));
// Bind surface states------------------------------------------------------
for (i = 0; i < iSurfaceEntries; i++, iBTEntry++)
{
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnBindSurfaceState(
pRenderHal,
iBindingTable,
iBTEntry,
pSurfaceEntries[i]));
}
return eStatus;
}
//!
//! \brief Set Buffer Surface for HW Access
//! \details Common Function for setting up buffer surface state
//! \param PRENDERHAL_INTERFACE pRenderHal
//! [in] Pointer to RenderHal Interface Structure
//! \param PRENDERHAL_SURFACE pRenderHalSurface
//! [in] Pointer to RenderHal 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)
{
PMOS_INTERFACE pOsInterface;
RENDERHAL_SURFACE_STATE_PARAMS SurfaceParam;
PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
MOS_STATUS eStatus;
//---------------------------------------
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
//---------------------------------------
// Initialize Variables
eStatus = MOS_STATUS_SUCCESS;
pOsInterface = pRenderHal->pOsInterface;
// Register surfaces for rendering (GfxAddress/Allocation index)
// Register resource
MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(
pOsInterface,
&pRenderHalSurface->OsSurface.OsResource,
bWrite,
true));
// Setup Buffer surface-----------------------------------------------------
if (pSurfaceParams == nullptr)
{
MOS_ZeroMemory(&SurfaceParam, sizeof(SurfaceParam));
auto memObjCtrlState = pOsInterface->pfnGetResourceCachePolicyMemoryObject(pRenderHal->pOsInterface, &pRenderHalSurface->OsSurface.OsResource);
SurfaceParam.MemObjCtl = memObjCtrlState.DwordValue;
pSurfaceParams = &SurfaceParam;
}
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSetupBufferSurfaceState(
pRenderHal,
pRenderHalSurface,
pSurfaceParams,
&pSurfaceEntry));
// Bind surface state-------------------------------------------------------
MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnBindSurfaceState(
pRenderHal,
iBindingTable,
iBTEntry,
pSurfaceEntry));
return eStatus;
}
MOS_STATUS RenderHal_SetInlineResourceList(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_INDIRECT_STATE_RESOURCE_PARAMS inlineResourceList,
uint32_t inlineResourceListSize)
{
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
if (inlineResourceListSize > 0)
{
MHW_RENDERHAL_CHK_NULL_RETURN(inlineResourceList);
pRenderHal->inlineResourceList = inlineResourceList;
pRenderHal->inlineResourceListSize = inlineResourceListSize;
}
else
{
pRenderHal->inlineResourceList = nullptr;
pRenderHal->inlineResourceListSize = 0;
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS RenderHal_SetCurbeResourceList(
PRENDERHAL_INTERFACE pRenderHal,
PMHW_INDIRECT_STATE_RESOURCE_PARAMS curbeResourceList,
uint32_t curbeResourceListSize)
{
MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
if (curbeResourceListSize > 0)
{
MHW_RENDERHAL_CHK_NULL_RETURN(curbeResourceList);
pRenderHal->curbeResourceList = curbeResourceList;
pRenderHal->curbeResourceListSize = curbeResourceListSize;
}
else
{
pRenderHal->curbeResourceList = nullptr;
pRenderHal->curbeResourceListSize = 0;
}
return MOS_STATUS_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink