Google Git
Sign in
fuchsia / third_party / github.com / intel / media-driver / d02c20bfbda7f50ba580efd09b0f1d4957b76e11 / . / media_driver / agnostic / common / vp / hal / vphal_debug.c
blob: 3b20091dd4e7f82532500bd8ac832d27b96d06d1 [file] [log] [blame]
/*
* Copyright (c) 2011-2021, 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 vphal_debug.c
//! \brief
//!
//!
//! \file vphal_debug.c
//! \brief Implementation of functions for debugging VPHAL
//! \details This file contains the Implementation of functions for
//! surface dumper, hw state dumper, perf counter dumper, and render
//! parameter dumper
//!
#if (_DEBUG || _RELEASE_INTERNAL)
#include <stdio.h>
#include "vphal.h"
#include "mhw_vebox.h"
#include "mos_os.h"
#include "vphal_debug.h"
#include "vphal_render_vebox_base.h"
#include "renderhal_platform_interface.h"
#include "ctype.h" // isupper, tolower, toupper
#define ALLOC_GRANULARITY 5000000
//==<Dump Surface>==============================================================
#define VPHAL_DBG_SURF_DUMP_OUTFILE_KEY_NAME "outfileLocation"
#define VPHAL_DBG_SURF_DUMP_LOCATION_KEY_NAME "dumpLocations"
#define VPHAL_DBG_SURF_DUMP_START_FRAME_KEY_NAME "startFrame"
#define VPHAL_DBG_SURF_DUMP_END_FRAME_KEY_NAME "endFrame"
#define VPHAL_DBG_SURF_DUMP_MAX_DATA_LEN 200
#define VPHAL_DBG_SURF_DUMP_TYPE_BACKGROUND "background"
#define VPHAL_DBG_SURF_DUMP_TYPE_PRIMARY "primary"
#define VPHAL_DBG_SURF_DUMP_TYPE_SUBSTREAM "substream"
#define VPHAL_DBG_SURF_DUMP_TYPE_REFERENCE "reference"
#define VPHAL_DBG_SURF_DUMP_TYPE_RENDERTARGET "rendertarget"
#define VPHAL_DBG_SURF_DUMP_LOC_PREALL "preall"
#define VPHAL_DBG_SURF_DUMP_LOC_PREDNDI "predndi"
#define VPHAL_DBG_SURF_DUMP_LOC_POSTDNDI "postdndi"
#define VPHAL_DBG_SURF_DUMP_LOC_PRECOMP "precomp"
#define VPHAL_DBG_SURF_DUMP_LOC_POSTCOMP "postcomp"
#define VPHAL_DBG_SURF_DUMP_LOC_PREMEMDECOMP "prememdecomp"
#define VPHAL_DBG_SURF_DUMP_LOC_POSTMEMDECOMP "postmemdecomp"
#define VPHAL_DBG_SURF_DUMP_LOC_POSTALL "postall"
#define VPHAL_DBG_STATE_DUMP_OUTFILE_KEY_NAME "outfileLocation"
#define VPHAL_DBG_STATE_DUMP_LOCATION_KEY_NAME "dumpLocations"
#define VPHAL_DBG_STATE_DUMP_START_FRAME_KEY_NAME "startFrame"
#define VPHAL_DBG_STATE_DUMP_END_FRAME_KEY_NAME "endFrame"
#define VPHAL_DBG_STATE_DUMP_LOC_DNDI "dndi"
#define VPHAL_DBG_STATE_DUMP_LOC_VEBOX "vebox"
#define VPHAL_DBG_STATE_DUMP_LOC_COMP "comp"
#define VPHAL_DBG_GSH_DUMP_TYPE "GSH"
#define VPHAL_DBG_SSH_DUMP_TYPE "SSH"
#define VPHAL_DBG_BB_DUMP_TYPE "BB"
#define VPHAL_DBG_CB_DUMP_TYPE "CB"
#define VPHAL_DBG_VEBOXSTATE_DUMP_TYPE "VeboxState"
#define VPHAL_DBG_STATISTICS_DUMP_TYPE "Statistics"
#define ALLOCLIST_SIZE 15
#define VPHAL_VEBOX_STATISTICS_SIZE_MAX (288 * 4) //!< Max Statistics size
#define MAX_DW_STRLEN 7
#define KERNEL_FIELD_NAME "Kernel"
#define VPDEBUG_VERSION "1.0"
#define XMLHEADER "<?xml version=\"1.0\"?>\r\n"
//==<Dump Render Parameters>====================================================
#define VPHAL_DBG_PARAMS_DUMP_OUTFILE_KEY_NAME "outxmlLocation"
#define VPHAL_DBG_PARAMS_DUMP_START_FRAME_KEY_NAME "startxmlFrame"
#define VPHAL_DBG_PARAMS_DUMP_END_FRAME_KEY_NAME "endxmlFrame"
void VphalDumperTool::GetOsFilePath(
const char* pcFilePath,
char* pOsFilePath)
{
MOS_SecureMemcpy(pOsFilePath, MAX_PATH, (void*)pcFilePath, strlen(pcFilePath));
}
MOS_STATUS VphalSurfaceDumper::GetPlaneDefs(
PVPHAL_SURFACE pSurface,
VPHAL_DBG_SURF_DUMP_SURFACE_DEF *pPlanes,
uint32_t *pdwNumPlanes,
uint32_t *pdwSize,
bool auxEnable,
bool isDeswizzled)
{
MOS_STATUS eStatus;
uint32_t i;
bool PaddingEnable = false;
eStatus = MOS_STATUS_SUCCESS;
// Caller should supply this much!
MOS_ZeroMemory(pPlanes, sizeof(VPHAL_DBG_SURF_DUMP_SURFACE_DEF) * 3);
switch (pSurface->Format)
{
case Format_AI44:
case Format_IA44:
case Format_A4L4:
case Format_P8:
case Format_L8:
case Format_A8:
case Format_Buffer:
case Format_STMM:
case Format_IRW4:
case Format_IRW5:
case Format_IRW6:
case Format_IRW7:
case Format_RAW:
case Format_Y8:
*pdwNumPlanes = 1;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
break;
case Format_R5G6B5:
case Format_A8P8:
case Format_A8L8:
case Format_YUY2:
case Format_YUYV:
case Format_YVYU:
case Format_UYVY:
case Format_VYUY:
case Format_IRW0:
case Format_IRW1:
case Format_IRW2:
case Format_IRW3:
case Format_V8U8:
case Format_R16F:
case Format_Y16S:
case Format_Y16U:
*pdwNumPlanes = 1;
pPlanes[0].dwWidth = pSurface->dwWidth * 2;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
break;
case Format_R32U:
case Format_R32F:
case Format_A8R8G8B8:
case Format_X8R8G8B8:
case Format_A8B8G8R8:
case Format_X8B8G8R8:
case Format_R8G8B8:
case Format_AYUV:
case Format_AUYV:
case Format_R10G10B10A2:
case Format_B10G10R10A2:
case Format_Y410:
*pdwNumPlanes = 1;
pPlanes[0].dwWidth = pSurface->dwWidth * 4;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
break;
case Format_Y416:
case Format_A16B16G16R16:
case Format_A16R16G16B16:
case Format_A16B16G16R16F:
case Format_A16R16G16B16F:
*pdwNumPlanes = 1;
pPlanes[0].dwWidth = pSurface->dwWidth * 8;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
break;
case Format_NV12:
*pdwNumPlanes = 2;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pPlanes[0].dwWidth;
pPlanes[1].dwHeight = pPlanes[0].dwHeight / 2;
pPlanes[1].dwPitch = pSurface->dwPitch;
break;
case Format_P010:
case Format_P016:
*pdwNumPlanes = 2;
pPlanes[0].dwWidth = pSurface->dwWidth * 2;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pPlanes[0].dwWidth;
pPlanes[1].dwHeight = pPlanes[0].dwHeight / 2;
pPlanes[1].dwPitch = pSurface->dwPitch;
break;
case Format_IMC2:
case Format_IMC4:
*pdwNumPlanes = 2;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pPlanes[0].dwWidth;
pPlanes[1].dwHeight = pPlanes[0].dwHeight / 2;
pPlanes[1].dwPitch = pPlanes[0].dwPitch;
break;
case Format_YVU9:
*pdwNumPlanes = 3;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pPlanes[0].dwWidth / 4;
pPlanes[1].dwHeight = pPlanes[0].dwHeight / 4;
pPlanes[1].dwPitch = pPlanes[0].dwPitch;
pPlanes[2].dwWidth = pPlanes[0].dwWidth / 4;
pPlanes[2].dwHeight = pPlanes[0].dwHeight / 4;
pPlanes[2].dwPitch = pPlanes[0].dwPitch;
break;
case Format_IMC1:
case Format_IMC3:
*pdwNumPlanes = 3;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pPlanes[0].dwWidth / 2;
pPlanes[1].dwHeight = pPlanes[0].dwHeight / 2;
pPlanes[1].dwPitch = pPlanes[0].dwPitch;
pPlanes[2].dwWidth = pPlanes[0].dwWidth / 2;
pPlanes[2].dwHeight = pPlanes[0].dwHeight / 2;
pPlanes[2].dwPitch = pPlanes[0].dwPitch;
break;
case Format_I420:
case Format_IYUV:
case Format_YV12:
*pdwNumPlanes = 3;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pPlanes[0].dwWidth / 2;
pPlanes[1].dwHeight = pPlanes[0].dwHeight / 2;
pPlanes[1].dwPitch = pPlanes[0].dwPitch / 2;
pPlanes[2].dwWidth = pPlanes[0].dwWidth / 2;
pPlanes[2].dwHeight = pPlanes[0].dwHeight / 2;
pPlanes[2].dwPitch = pPlanes[0].dwPitch / 2;
break;
case Format_400P:
*pdwNumPlanes = 1;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
break;
case Format_411P:
*pdwNumPlanes = 3;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pPlanes[0].dwWidth / 4;
pPlanes[1].dwHeight = pPlanes[0].dwHeight;
pPlanes[1].dwPitch = pPlanes[0].dwPitch;
pPlanes[2].dwWidth = pPlanes[0].dwWidth / 4;
pPlanes[2].dwHeight = pPlanes[0].dwHeight;
pPlanes[2].dwPitch = pPlanes[0].dwPitch;
break;
case Format_411R:
*pdwNumPlanes = 3;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pPlanes[0].dwWidth;
pPlanes[1].dwHeight = pPlanes[0].dwHeight / 4;
pPlanes[1].dwPitch = pPlanes[0].dwPitch;
pPlanes[2].dwWidth = pPlanes[0].dwWidth;
pPlanes[2].dwHeight = pPlanes[0].dwHeight / 4;
pPlanes[2].dwPitch = pPlanes[0].dwPitch;
break;
case Format_422H:
*pdwNumPlanes = 3;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pPlanes[0].dwWidth / 2;
pPlanes[1].dwHeight = pPlanes[0].dwHeight;
pPlanes[1].dwPitch = pPlanes[0].dwPitch;
pPlanes[2].dwWidth = pPlanes[0].dwWidth / 2;
pPlanes[2].dwHeight = pPlanes[0].dwHeight;
pPlanes[2].dwPitch = pPlanes[0].dwPitch;
break;
case Format_422V:
*pdwNumPlanes = 3;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pPlanes[0].dwWidth;
pPlanes[1].dwHeight = pPlanes[0].dwHeight / 2;
pPlanes[1].dwPitch = pPlanes[0].dwPitch;
pPlanes[2].dwWidth = pPlanes[0].dwWidth;
pPlanes[2].dwHeight = pPlanes[0].dwHeight / 2;
pPlanes[2].dwPitch = pPlanes[0].dwPitch;
break;
case Format_444P:
case Format_RGBP:
case Format_BGRP:
*pdwNumPlanes = 3;
pPlanes[0].dwWidth = pSurface->dwWidth;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pPlanes[0].dwWidth;
pPlanes[1].dwHeight = pPlanes[0].dwHeight;
pPlanes[1].dwPitch = pPlanes[0].dwPitch;
pPlanes[2].dwWidth = pPlanes[0].dwWidth;
pPlanes[2].dwHeight = pPlanes[0].dwHeight;
pPlanes[2].dwPitch = pPlanes[0].dwPitch;
break;
case Format_Y210:
case Format_Y216:
*pdwNumPlanes = 1;
pPlanes[0].dwWidth = pSurface->dwWidth * 4;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
break;
case Format_P210:
case Format_P216:
*pdwNumPlanes = 2;
pPlanes[0].dwWidth = pSurface->dwWidth * 2;
pPlanes[0].dwHeight = pSurface->dwHeight;
pPlanes[0].dwPitch = pSurface->dwPitch;
pPlanes[1].dwWidth = pSurface->dwWidth * 2;
pPlanes[1].dwHeight = pSurface->dwHeight;
pPlanes[1].dwPitch = pSurface->dwPitch;
break;
default:
VPHAL_DEBUG_ASSERTMESSAGE("Format '%d' not supported.", pSurface->Format);
eStatus = MOS_STATUS_UNKNOWN;
goto finish;
}
// For Deswizzled surfaces, Mos_Specific_LockResource() already do the de-padding between Y and UV surf.
// so, don't use the info of U/V PlaneOffset, as the padding is already removed.
for (i = 0; i < *pdwNumPlanes; i++)
{
switch (i)
{
case 0:
pPlanes[i].dwOffset = pSurface->YPlaneOffset.iSurfaceOffset +
(pSurface->YPlaneOffset.iYOffset * pSurface->dwPitch) +
pSurface->YPlaneOffset.iXOffset;
break;
case 1:
if (pSurface->Format == Format_YV12)
{
pPlanes[i].dwOffset = (isDeswizzled ? pPlanes[0].dwPitch * pPlanes[0].dwHeight + pPlanes[0].dwOffset : pSurface->VPlaneOffset.iSurfaceOffset) +
(pSurface->VPlaneOffset.iYOffset * pSurface->dwPitch) +
pSurface->VPlaneOffset.iXOffset;
}
else
{
pPlanes[i].dwOffset = (isDeswizzled ? pPlanes[0].dwPitch * pPlanes[0].dwHeight + pPlanes[0].dwOffset : pSurface->UPlaneOffset.iSurfaceOffset) +
(pSurface->UPlaneOffset.iYOffset * pSurface->dwPitch) +
pSurface->UPlaneOffset.iXOffset;
}
break;
case 2:
if (pSurface->Format == Format_YV12)
{
pPlanes[i].dwOffset = (isDeswizzled ? pPlanes[1].dwOffset + pPlanes[1].dwPitch * pPlanes[1].dwHeight : pSurface->UPlaneOffset.iSurfaceOffset) +
(pSurface->UPlaneOffset.iYOffset * pSurface->dwPitch) +
pSurface->UPlaneOffset.iXOffset;
}
else
{
pPlanes[i].dwOffset = (isDeswizzled ? pPlanes[1].dwOffset + pPlanes[1].dwPitch * pPlanes[1].dwHeight : pSurface->VPlaneOffset.iSurfaceOffset) +
(pSurface->VPlaneOffset.iYOffset * pSurface->dwPitch) +
pSurface->VPlaneOffset.iXOffset;
}
break;
default:
VPHAL_DEBUG_ASSERTMESSAGE("More than 3 planes not supported.");
}
}
//compressed surface need 32 align on height
if (auxEnable && !isDeswizzled)
{
for (i = 0; i < *pdwNumPlanes; i++)
{
pPlanes[i].dwHeight = MOS_ALIGN_CEIL(pPlanes[i].dwHeight, 32);
}
}
// For uncompressed surface, padding data is not needed. For compressed surface, padding data is needed for offline check
if (auxEnable)
{
*pdwSize = (pPlanes[0].dwPitch * pPlanes[0].dwHeight) +
(pPlanes[1].dwPitch * pPlanes[1].dwHeight) +
(pPlanes[2].dwPitch * pPlanes[2].dwHeight);
}
else
{
*pdwSize = (pPlanes[0].dwWidth * pPlanes[0].dwHeight) +
(pPlanes[1].dwWidth * pPlanes[1].dwHeight) +
(pPlanes[2].dwWidth * pPlanes[2].dwHeight);
}
finish:
return eStatus;
}
bool VphalSurfaceDumper::HasAuxSurf(
PMOS_RESOURCE osResource)
{
bool hasAuxSurf = false;
#if !EMUL
GMM_RESOURCE_FLAG gmmFlags;
MOS_ZeroMemory(&gmmFlags, sizeof(gmmFlags));
gmmFlags = osResource->pGmmResInfo->GetResFlags();
hasAuxSurf = (gmmFlags.Gpu.MMC && gmmFlags.Gpu.UnifiedAuxSurface) ||
(gmmFlags.Gpu.CCS && gmmFlags.Gpu.UnifiedAuxSurface && gmmFlags.Info.MediaCompressed);
#endif
return hasAuxSurf;
}
MOS_STATUS VphalSurfaceDumper::DumpSurfaceToFile(
PMOS_INTERFACE pOsInterface,
PVPHAL_SURFACE pSurface,
const char *psPathPrefix,
uint64_t iCounter,
bool bLockSurface,
bool bNoDecompWhenLock,
uint8_t* pData)
{
MOS_STATUS eStatus;
bool isSurfaceLocked;
char sPath[MAX_PATH], sOsPath[MAX_PATH];
uint8_t *pDst, *pTmpSrc, *pTmpDst;
uint32_t dwNumPlanes, dwSize, j, i;
VPHAL_DBG_SURF_DUMP_SURFACE_DEF planes[3];
uint32_t dstPlaneOffset[3] = {0};
MOS_LOCK_PARAMS LockFlags;
MOS_USER_FEATURE_VALUE_WRITE_DATA UserFeatureWriteData;
bool hasAuxSurf;
bool enableAuxDump;
bool enablePlaneDump = false;
PMOS_RESOURCE pLockedResource = nullptr;
VPHAL_DEBUG_ASSERT(pSurface);
VPHAL_DEBUG_ASSERT(pOsInterface);
VPHAL_DEBUG_ASSERT(psPathPrefix);
eStatus = MOS_STATUS_SUCCESS;
isSurfaceLocked = false;
hasAuxSurf = false;
pDst = nullptr;
enableAuxDump = m_dumpSpec.enableAuxDump;
MOS_ZeroMemory(sPath, MAX_PATH);
MOS_ZeroMemory(sOsPath, MAX_PATH);
dwNumPlanes = 0;
enablePlaneDump = m_dumpSpec.enablePlaneDump;
if (pSurface->dwDepth == 0)
{
pSurface->dwDepth = 1;
}
hasAuxSurf = HasAuxSurf(&pSurface->OsResource);
// get plane definitions
VPHAL_DEBUG_CHK_STATUS(GetPlaneDefs(
pSurface,
planes,
&dwNumPlanes,
&dwSize,
hasAuxSurf, //(hasAuxSurf && enableAuxDump),
!enableAuxDump));// !(hasAuxSurf && enableAuxDump)));
if (bLockSurface)
{
// Caller should not give pData when it expect the function to lock surf
VPHAL_DEBUG_ASSERT(pData = nullptr);
LockFlags.Value = 0;
LockFlags.ReadOnly = 1;
// If aux data exist and enable aux dump, no swizzle and no decompress
if (hasAuxSurf && enableAuxDump)
{
LockFlags.TiledAsTiled = 1;
LockFlags.NoDecompress = 1;
}
if (bNoDecompWhenLock)
{
LockFlags.NoDecompress = 1;
}
bool isPlanar = false;
isPlanar = (pSurface->Format == Format_NV12) || (pSurface->Format == Format_P010) || (pSurface->Format == Format_P016);
if (isPlanar && pSurface->TileType != MOS_TILE_LINEAR)
{
bool bAllocated;
PVPHAL_SURFACE m_temp2DSurfForCopy = (PVPHAL_SURFACE)MOS_AllocAndZeroMemory(sizeof(VPHAL_SURFACE));
VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
pOsInterface,
m_temp2DSurfForCopy,
"Temp2DSurfForSurfDumper",
pSurface->Format,
MOS_GFXRES_2D,
MOS_TILE_LINEAR,
pSurface->dwWidth,
pSurface->dwHeight,
false,
MOS_MMC_DISABLED,
&bAllocated));
m_osInterface->pfnDoubleBufferCopyResource(
m_osInterface,
&pSurface->OsResource,
&m_temp2DSurfForCopy->OsResource,
false);
pData = (uint8_t *)pOsInterface->pfnLockResource(
pOsInterface,
&m_temp2DSurfForCopy->OsResource,
&LockFlags);
pLockedResource = &m_temp2DSurfForCopy->OsResource;
// get plane definitions
VPHAL_DEBUG_CHK_STATUS(GetPlaneDefs(
m_temp2DSurfForCopy,
planes,
&dwNumPlanes,
&dwSize,
hasAuxSurf, //(hasAuxSurf && enableAuxDump),
!enableAuxDump)); // !(hasAuxSurf && enableAuxDump)));
}
else
{
pData = (uint8_t *)pOsInterface->pfnLockResource(
pOsInterface,
&pSurface->OsResource,
&LockFlags);
pLockedResource = &pSurface->OsResource;
}
VPHAL_DEBUG_CHK_NULL(pData);
// Write error to user feauture key
MOS_ZeroMemory(&UserFeatureWriteData, sizeof(UserFeatureWriteData));
UserFeatureWriteData.Value.u32Data = 1;
UserFeatureWriteData.ValueID = __VPHAL_DBG_SURF_DUMPER_RESOURCE_LOCK_ID;
eStatus = MOS_UserFeature_WriteValues_ID(
nullptr,
&UserFeatureWriteData,
1,
pOsInterface->pOsContext);
VPHAL_DEBUG_ASSERT(eStatus == MOS_STATUS_SUCCESS);
isSurfaceLocked = true;
}
MOS_SecureStringPrint(
sPath,
MAX_PATH,
sizeof(sPath),
"%s_f[%03lld]_w[%d]_h[%d]_p[%d].%s",
psPathPrefix,
iCounter,
pSurface->dwWidth,
pSurface->dwHeight,
pSurface->dwPitch,
VphalDumperTool::GetFormatStr(pSurface->Format));
VphalDumperTool::GetOsFilePath(sPath, sOsPath);
pDst = (uint8_t*)MOS_AllocAndZeroMemory(dwSize);
VPHAL_DEBUG_CHK_NULL(pDst);
VPHAL_DEBUG_CHK_NULL(pData);
pTmpSrc = pData;
pTmpDst = pDst;
for (j = 0; j < dwNumPlanes; j++)
{
pTmpSrc = pData + planes[j].dwOffset;
for (i = 0; i < planes[j].dwHeight; i++)
{
if (hasAuxSurf && enableAuxDump)
{
MOS_SecureMemcpy(
pTmpDst,
planes[j].dwPitch,
pTmpSrc,
planes[j].dwPitch);
pTmpSrc += planes[j].dwPitch;
pTmpDst += planes[j].dwPitch;
dstPlaneOffset[j+1] += planes[j].dwPitch;
}
else
{
MOS_SecureMemcpy(
pTmpDst,
planes[j].dwWidth,
pTmpSrc,
planes[j].dwWidth);
pTmpSrc += planes[j].dwPitch;
pTmpDst += planes[j].dwWidth;
dstPlaneOffset[j+1] += planes[j].dwWidth;
}
}
//if more than 1 plane, dump each plane's surface for offline analysis
if (enablePlaneDump)
{
if ((dwNumPlanes > 1) && (dwNumPlanes <= 3))
{
char sPlanePath[MAX_PATH], sPlaneOsPath[MAX_PATH];
MOS_ZeroMemory(sPlanePath, MAX_PATH);
MOS_ZeroMemory(sPlaneOsPath, MAX_PATH);
MOS_SecureStringPrint(
sPlanePath,
MAX_PATH,
sizeof(sPlanePath),
"%s_f[%03lld]_w[%d]_h[%d]_p[%d].%s",
psPathPrefix,
iCounter,
planes[j].dwWidth,
planes[j].dwHeight,
planes[j].dwPitch,
(j == 0 ? "Y" : ((dwNumPlanes == 2) ? "UV" : ((j == 1) ? "U" : "V"))));
VphalDumperTool::GetOsFilePath(sPlanePath, sPlaneOsPath);
VPHAL_DEBUG_CHK_STATUS(MOS_WriteFileFromPtr(sPlaneOsPath, pDst + dstPlaneOffset[j], dstPlaneOffset[j + 1]));
}
else
{
VPHAL_DEBUG_ASSERTMESSAGE("More than 3 planes not supported during plane dump.");
}
}
}
VPHAL_DEBUG_CHK_STATUS(MOS_WriteFileFromPtr(sOsPath, pDst, dwSize));
#if !EMUL
// Dump Aux surface data
if (hasAuxSurf && enableAuxDump)
{
uint32_t resourceIndex;
bool isPlanar;
uint8_t *auxDataY;
uint8_t *auxDataUV;
uint32_t auxSizeY;
uint32_t auxSizeUV;
uint8_t *pSurfaceBase;
resourceIndex = 0;
pSurfaceBase = pData;
isPlanar = (pOsInterface->pfnGetGmmClientContext(pOsInterface)->IsPlanar(pSurface->OsResource.pGmmResInfo->GetResourceFormat()) != 0);
auxDataY = (uint8_t*)pSurfaceBase + pSurface->OsResource.pGmmResInfo->GetPlanarAuxOffset(resourceIndex, GMM_AUX_Y_CCS);
auxDataUV = (uint8_t*)pSurfaceBase + pSurface->OsResource.pGmmResInfo->GetPlanarAuxOffset(resourceIndex, GMM_AUX_UV_CCS);
if (isPlanar)
{
auxSizeY = (uint32_t)(pSurface->OsResource.pGmmResInfo->GetPlanarAuxOffset(resourceIndex, GMM_AUX_UV_CCS) -
pSurface->OsResource.pGmmResInfo->GetPlanarAuxOffset(resourceIndex, GMM_AUX_Y_CCS));
}else
{
auxSizeY = (uint32_t)(pSurface->OsResource.pGmmResInfo->GetSizeAuxSurface(GMM_AUX_CCS));
}
auxSizeUV = (uint32_t)(pSurface->OsResource.pGmmResInfo->GetPlanarAuxOffset(resourceIndex, GMM_AUX_COMP_STATE) -
pSurface->OsResource.pGmmResInfo->GetPlanarAuxOffset(resourceIndex, GMM_AUX_UV_CCS));
if (auxSizeUV == 0)
{
auxSizeUV = (uint32_t)(pSurface->OsResource.pGmmResInfo->GetSizeAuxSurface(GMM_AUX_SURF)) /
(pSurface->OsResource.pGmmResInfo)->GetArraySize() - auxSizeY;
}
// Dump Y Aux data
MOS_SecureStringPrint(
sPath,
MAX_PATH,
sizeof(sPath),
"%s_f[%03lld]_w[%d]_h[%d]_p[%d].Yaux",
psPathPrefix,
iCounter,
pSurface->dwWidth,
pSurface->dwHeight,
pSurface->dwPitch);
VphalDumperTool::GetOsFilePath(sPath, sOsPath);
uint8_t *pDstAux = (uint8_t*)MOS_AllocAndZeroMemory(auxSizeY);
VPHAL_DEBUG_CHK_NULL(pDstAux);
MOS_SecureMemcpy(
pDstAux,
auxSizeY,
auxDataY,
auxSizeY);
VPHAL_DEBUG_CHK_STATUS(MOS_WriteFileFromPtr(sOsPath, pDstAux, auxSizeY));
MOS_SafeFreeMemory(pDstAux);
if (auxSizeUV && isPlanar)
{
// Dump UV Aux data
MOS_SecureStringPrint(
sPath,
MAX_PATH,
sizeof(sPath),
"%s_f[%03lld]_w[%d]_h[%d]_p[%d].UVaux",
psPathPrefix,
iCounter,
pSurface->dwWidth,
pSurface->dwHeight,
pSurface->dwPitch);
VphalDumperTool::GetOsFilePath(sPath, sOsPath);
uint8_t *pDstUVAux = (uint8_t*)MOS_AllocAndZeroMemory(auxSizeUV);
VPHAL_DEBUG_CHK_NULL(pDstUVAux);
MOS_SecureMemcpy(
pDstUVAux,
auxSizeUV,
auxDataUV,
auxSizeUV);
VPHAL_DEBUG_CHK_STATUS(MOS_WriteFileFromPtr(sOsPath, pDstUVAux, auxSizeUV));
MOS_SafeFreeMemory(pDstUVAux);
}
}
#endif
finish:
MOS_SafeFreeMemory(pDst);
if (isSurfaceLocked && pLockedResource != nullptr)
{
eStatus = (MOS_STATUS)pOsInterface->pfnUnlockResource(pOsInterface, pLockedResource);
VPHAL_DEBUG_ASSERT(eStatus == MOS_STATUS_SUCCESS);
}
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DefGsh(
VPHAL_DBG_FIELD_LAYOUT* *ppGshLayout,
uint32_t* puiNumGSHFields)
{
MOS_STATUS eStatus;
PRENDERHAL_STATE_HEAP pStateHeap;
PRENDERHAL_STATE_HEAP_SETTINGS pStateHeapSettings;
uint32_t i;
uint32_t j;
// MEDIA STATE LAYOUT
VPHAL_DBG_FIELD_LAYOUT* pmediaStateLayout;
uint32_t uiNumMediaStateFields;
// GSH SAMPLER STATE LAYOUT
VPHAL_DBG_FIELD_LAYOUT* psamplerStateLayout;
uint32_t uiNumSamplerStateFields;
eStatus = MOS_STATUS_SUCCESS;
pStateHeap = m_stateHeap;
pStateHeapSettings = m_stateHeapSettings;
// GSH LAYOUT
*puiNumGSHFields = 4;
(*ppGshLayout) = (VPHAL_DBG_FIELD_LAYOUT*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_FIELD_LAYOUT) *
(*puiNumGSHFields));
VPHAL_DEBUG_CHK_NULL((*ppGshLayout));
i = 0;
MOS_SecureStringPrint((*ppGshLayout)[i].pcName, MAX_NAME_LEN, MAX_NAME_LEN, "Sync/Perf Tags (SY)");
(*ppGshLayout)[i].dwOffset = pStateHeap->dwOffsetSync;
(*ppGshLayout)[i].dwSize = pStateHeap->dwSizeSync;
(*ppGshLayout)[i].uiNumber = 1;
(*ppGshLayout)[i].pChildLayout = nullptr;
(*ppGshLayout)[i].uiNumChildren = 0;
MOS_SecureStringPrint((*ppGshLayout)[i++].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "");
MOS_SecureStringPrint((*ppGshLayout)[i].pcName, MAX_NAME_LEN, MAX_NAME_LEN, "Media State");
(*ppGshLayout)[i].dwOffset = pStateHeap->pMediaStates->dwOffset;
(*ppGshLayout)[i].dwSize = pStateHeap->dwOffsetMediaID +
pStateHeapSettings->iMediaIDs *
pStateHeap->dwSizeMediaID;
(*ppGshLayout)[i].uiNumber = pStateHeapSettings->iMediaStateHeaps;
// MEDIA STATE LAYOUT -- Indented to make hierarchy clear
{
uiNumMediaStateFields = 6;
pmediaStateLayout = (VPHAL_DBG_FIELD_LAYOUT*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_FIELD_LAYOUT) *
uiNumMediaStateFields);
VPHAL_DEBUG_CHK_NULL(pmediaStateLayout);
j = 0;
MOS_SecureStringPrint(pmediaStateLayout[j].pcName, MAX_NAME_LEN, MAX_NAME_LEN, "CURBE Data");
pmediaStateLayout[j].dwOffset = pStateHeap->dwOffsetCurbe;
pmediaStateLayout[j].dwSize = pStateHeap->dwSizeCurbe;
pmediaStateLayout[j].uiNumber = 1;
pmediaStateLayout[j].pChildLayout = nullptr;
pmediaStateLayout[j].uiNumChildren = 0;
MOS_SecureStringPrint(pmediaStateLayout[j++].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "");
MOS_SecureStringPrint(pmediaStateLayout[j].pcName, MAX_NAME_LEN, MAX_NAME_LEN, "Sampler States for MID");
pmediaStateLayout[j].dwOffset = pStateHeap->dwOffsetSampler;
pmediaStateLayout[j].dwSize = m_hwSizes->dwSizeSamplerState *
pStateHeapSettings->iSamplers;
pmediaStateLayout[j].uiNumber = pStateHeapSettings->iMediaIDs;
// GSH SAMPLER STATE LAYOUT -- Indented to make hierarchy clear
{
uiNumSamplerStateFields = 1;
psamplerStateLayout = (VPHAL_DBG_FIELD_LAYOUT*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_FIELD_LAYOUT) * uiNumSamplerStateFields);
VPHAL_DEBUG_CHK_NULL(psamplerStateLayout);
MOS_SecureStringPrint(psamplerStateLayout[0].pcName, MAX_NAME_LEN, MAX_NAME_LEN, "Sampler State");
psamplerStateLayout[0].dwOffset = 0;
psamplerStateLayout[0].dwSize = m_hwSizes->dwSizeSamplerState;
psamplerStateLayout[0].uiNumber = pStateHeapSettings->iSamplers;
psamplerStateLayout[0].pChildLayout = nullptr;
psamplerStateLayout[0].uiNumChildren = 0;
MOS_SecureStringPrint(psamplerStateLayout[0].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "_SAMPLER_STATE_");
}
pmediaStateLayout[j].pChildLayout = psamplerStateLayout;
pmediaStateLayout[j].uiNumChildren = uiNumSamplerStateFields;
MOS_SecureStringPrint(pmediaStateLayout[j++].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "");
MOS_SecureStringPrint(pmediaStateLayout[j].pcName, MAX_NAME_LEN, MAX_NAME_LEN, "Sampler 8x8 Table");
pmediaStateLayout[j].dwOffset = pStateHeap->dwOffsetSamplerAVS;
pmediaStateLayout[j].dwSize = pStateHeap->dwSizeSamplerAVS;
pmediaStateLayout[j].uiNumber = pStateHeapSettings->iSamplersAVS;
pmediaStateLayout[j].pChildLayout = nullptr;
pmediaStateLayout[j].uiNumChildren = 0;
MOS_SecureStringPrint(pmediaStateLayout[j++].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "_SAMPLER_8x8_STATE_TABLE_");
MOS_SecureStringPrint(pmediaStateLayout[j].pcName, MAX_NAME_LEN, MAX_NAME_LEN, "Media ID");
pmediaStateLayout[j].dwOffset = pStateHeap->dwOffsetMediaID;
pmediaStateLayout[j].dwSize = pStateHeap->dwSizeMediaID;
pmediaStateLayout[j].uiNumber = pStateHeapSettings->iMediaIDs;
pmediaStateLayout[j].pChildLayout = nullptr;
pmediaStateLayout[j].uiNumChildren = 0;
MOS_SecureStringPrint(pmediaStateLayout[j++].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "_INTERFACE_DESCRIPTOR_DATA_");
}
(*ppGshLayout)[i].pChildLayout = pmediaStateLayout;
(*ppGshLayout)[i].uiNumChildren = uiNumMediaStateFields;
MOS_SecureStringPrint((*ppGshLayout)[i++].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "");
MOS_SecureStringPrint((*ppGshLayout)[i].pcName, MAX_NAME_LEN, MAX_NAME_LEN, "Kernel");
(*ppGshLayout)[i].dwOffset = pStateHeap->dwKernelBase;
(*ppGshLayout)[i].dwSize = pStateHeap->iKernelSize / pStateHeapSettings->iKernelCount;
(*ppGshLayout)[i].uiNumber = pStateHeapSettings->iKernelCount;
(*ppGshLayout)[i].pChildLayout = nullptr;
(*ppGshLayout)[i].uiNumChildren = 0;
MOS_SecureStringPrint((*ppGshLayout)[i++].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "");
finish:
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DefSsh(
VPHAL_DBG_FIELD_LAYOUT* *ppSshLayout,
uint32_t* puiNumSSHFields)
{
MOS_STATUS eStatus;
PRENDERHAL_STATE_HEAP pStateHeap;
PRENDERHAL_STATE_HEAP_SETTINGS pStateHeapSettings;
uint32_t i;
int32_t k;
// BINDING TABLE LAYOUT
VPHAL_DBG_FIELD_LAYOUT* pbtLayout;
uint32_t uiNumBTFields;
eStatus = MOS_STATUS_SUCCESS;
pStateHeap = m_stateHeap;
pStateHeapSettings = m_stateHeapSettings;
// SSH LAYOUT
(*puiNumSSHFields) = 1 + pStateHeapSettings->iSurfaceStates;
(*ppSshLayout) = (VPHAL_DBG_FIELD_LAYOUT*)MOS_AllocAndZeroMemory(sizeof(VPHAL_DBG_FIELD_LAYOUT) *
(*puiNumSSHFields));
VPHAL_DEBUG_CHK_NULL((*ppSshLayout));
i = 0;
MOS_SecureStringPrint((*ppSshLayout)[i].pcName, MAX_NAME_LEN, MAX_NAME_LEN, "Binding Table");
(*ppSshLayout)[i].dwOffset = pStateHeap->iBindingTableOffset;
(*ppSshLayout)[i].dwSize = pStateHeap->iBindingTableSize;
(*ppSshLayout)[i].uiNumber = pStateHeapSettings->iBindingTables;
// BINDING TABLE LAYOUT -- Indented to make hierarchy clear
{
pbtLayout = (VPHAL_DBG_FIELD_LAYOUT*)MOS_AllocAndZeroMemory(sizeof(VPHAL_DBG_FIELD_LAYOUT) * 1);
VPHAL_DEBUG_CHK_NULL(pbtLayout);
uiNumBTFields = 1;
MOS_SecureStringPrint(pbtLayout[0].pcName, MAX_NAME_LEN, MAX_NAME_LEN, "Binding Index");
pbtLayout[0].dwOffset = pStateHeap->iBindingTableOffset;
pbtLayout[0].dwSize = pStateHeap->iBindingTableSize / pStateHeapSettings->iSurfacesPerBT;
pbtLayout[0].uiNumber = pStateHeapSettings->iSurfacesPerBT;
pbtLayout[0].pChildLayout = nullptr;
pbtLayout[0].uiNumChildren = 0;
MOS_SecureStringPrint(pbtLayout[0].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "_BINDING_TABLE_STATE_");
}
(*ppSshLayout)[i].pChildLayout = pbtLayout;
(*ppSshLayout)[i].uiNumChildren = 1;
MOS_SecureStringPrint((*ppSshLayout)[i++].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "");
for (k = 0; k < pStateHeapSettings->iSurfaceStates; k++)
{// Not indented to make hierarchy levels clear
MOS_SecureStringPrint((*ppSshLayout)[i+k].pcName, MAX_NAME_LEN, MAX_NAME_LEN, "Surface State %d", k);
(*ppSshLayout)[i+k].dwOffset = pStateHeap->iSurfaceStateOffset +
m_renderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize() * k;
(*ppSshLayout)[i+k].dwSize = m_renderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize();
(*ppSshLayout)[i+k].uiNumber = 1;
(*ppSshLayout)[i+k].pChildLayout = nullptr;
(*ppSshLayout)[i+k].uiNumChildren = 0;
switch(pStateHeap->pSurfaceEntry[k].Type)
{
case RENDERHAL_SURFACE_TYPE_G8:
MOS_SecureStringPrint((*ppSshLayout)[i+k].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "_SURFACE_STATE_G8");
break;
case RENDERHAL_SURFACE_TYPE_G9:
MOS_SecureStringPrint((*ppSshLayout)[i+k].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "_SURFACE_STATE_G9");
break;
case RENDERHAL_SURFACE_TYPE_G10:
MOS_SecureStringPrint((*ppSshLayout)[i+k].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "_SURFACE_STATE_G10");
break;
case RENDERHAL_SURFACE_TYPE_ADV_G8:
MOS_SecureStringPrint((*ppSshLayout)[i+k].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "_SURFACE_STATE_ADV_G8");
break;
case RENDERHAL_SURFACE_TYPE_ADV_G9:
MOS_SecureStringPrint((*ppSshLayout)[i+k].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "_SURFACE_STATE_ADV_G9");
break;
case RENDERHAL_SURFACE_TYPE_ADV_G10:
MOS_SecureStringPrint((*ppSshLayout)[i+k].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "_SURFACE_STATE_ADV_G10");
break;
case RENDERHAL_SURFACE_TYPE_INVALID:
MOS_SecureStringPrint((*ppSshLayout)[i+k].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "No surface");
break;
default:
// When type is zero, its un-initialized, so just show string of DW
VPHAL_DEBUG_ASSERT(0);
MOS_SecureStringPrint((*ppSshLayout)[i+k].pcStructName, MAX_NAME_LEN, MAX_NAME_LEN, "");
break;
} // Not indented to make hierarchy clear
}
finish:
return eStatus;
}
void VphalHwStateDumper::FreeLayout(
VPHAL_DBG_FIELD_LAYOUT *pLayout,
uint32_t uiNumFields)
{
uint32_t i;
for (i = 0; i < uiNumFields; i++)
{
if (pLayout[i].pChildLayout != nullptr)
{
FreeLayout(pLayout[i].pChildLayout, pLayout[i].uiNumChildren);
}
}
MOS_SafeFreeMemory(pLayout);
}
MOS_STATUS VphalHwStateDumper::DumpXmlFieldHeader(
char **ppcOutContents,
char *pcName,
uint32_t ulLoc,
uint32_t ulSize,
bool bIsByte,
bool bHasCont,
bool bStruct)
{
MOS_STATUS eStatus;
MOS_UNUSED(bHasCont);
eStatus = MOS_STATUS_SUCCESS;
if (!ppcOutContents)
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
goto finish;
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, ppcOutContents,
"<FIELD%s><NAME>%s</NAME><LOC>0x%x</LOC><SIZE unit=\"%s\">0x%x</SIZE>\r\n",
bStruct ? " struct=\"TRUE\"" : "", pcName, ulLoc,
bIsByte ? "byte" : "bit", ulSize));
finish:
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DumpXmlFieldFooter(
char **ppcOutContents,
bool bHasCont)
{
MOS_STATUS eStatus;
MOS_UNUSED(bHasCont);
eStatus = MOS_STATUS_SUCCESS;
if (!ppcOutContents)
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
goto finish;
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, ppcOutContents, "</FIELD>\r\n"));
finish:
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DumpDwords(
char **ppcOutContents,
uint32_t dwSizeField)
{
MOS_STATUS eStatus;
char* pcName;
int32_t iNumFields;
int32_t iDWSize;
int32_t iOffset;
int32_t i;
eStatus = MOS_STATUS_SUCCESS;
pcName = nullptr;
iNumFields = 0;
iDWSize = 0;
iOffset = 0;
i = 0;
if (!ppcOutContents)
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
goto finish;
}
VPHAL_DEBUG_ASSERT(dwSizeField % sizeof(uint32_t) == 0);
pcName = (char*)MOS_AllocAndZeroMemory(MAX_DW_STRLEN);
VPHAL_DEBUG_CHK_NULL(pcName);
iNumFields = MOS_BYTES_TO_DWORDS(dwSizeField);//Change macro to >> 2 if optimizer doesn't
iDWSize = sizeof(uint32_t);
for (i = 0; i < iNumFields; i++)
{
MOS_SecureStringPrint(pcName, MAX_DW_STRLEN, MAX_DW_STRLEN, "DW%d", i);
VPHAL_DEBUG_CHK_STATUS(DumpXmlFieldHeader(ppcOutContents, pcName, iOffset,
iDWSize, true, false, false));
VPHAL_DEBUG_CHK_STATUS(DumpXmlFieldFooter(ppcOutContents, false));;
iOffset += iDWSize;
}
finish:
MOS_SafeFreeMemory(pcName);
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DumpFieldHeap(
char **ppcOutContents,
VPHAL_DBG_FIELD_LAYOUT *parLayout)
{
MOS_STATUS eStatus;
char* pcName;
int32_t iOffset;
uint32_t i;
eStatus = MOS_STATUS_SUCCESS;
pcName = nullptr;
iOffset = 0;
i = 0;
if (!ppcOutContents || !parLayout)
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
goto finish;
}
pcName = (char*)MOS_AllocAndZeroMemory(MAX_NAME_LEN);
VPHAL_DEBUG_CHK_NULL(pcName);
// For each instance of this field type
for (i = 0; i < parLayout->uiNumber; i++)
{
MOS_SecureStringPrint(pcName, MAX_NAME_LEN, MAX_NAME_LEN, "%s %d", parLayout->pcName, i);
VPHAL_DEBUG_CHK_STATUS(DumpXmlFieldHeader(ppcOutContents, pcName, iOffset,
parLayout->dwSize, true, true,
false));
VPHAL_DEBUG_CHK_STATUS(DumpSubfields(ppcOutContents, parLayout, parLayout->pChildLayout,
parLayout->uiNumChildren));
VPHAL_DEBUG_CHK_STATUS(DumpXmlFieldFooter(ppcOutContents, true));
iOffset += parLayout->dwSize;
}
finish:
MOS_SafeFreeMemory(pcName);
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DumpSubfields(
char **ppcOutContents,
VPHAL_DBG_FIELD_LAYOUT* pParLayout,
VPHAL_DBG_FIELD_LAYOUT* pChildLayout,
uint32_t uiNumChild)
{
MOS_STATUS eStatus;
uint32_t i;
eStatus = MOS_STATUS_SUCCESS;
i = 0;
if (!ppcOutContents || (!pParLayout && uiNumChild == 0) ||
(!pChildLayout && uiNumChild > 0))
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
goto finish;
}
if (uiNumChild > 0)
{
for (i = 0; i < uiNumChild; i++)
{
if (pChildLayout[i].uiNumber > 0)
{
VPHAL_DEBUG_CHK_STATUS(DumpField(ppcOutContents, &(pChildLayout[i])));
}// end if exists
}// end for each field
}// if has fields
else if (pParLayout->pcStructName[0] != '\0')
{
// second last param is not zero in such cases as 8x8 table
// (arrays, multi structs) -- this is now handled by indirect recursion
VPHAL_DEBUG_CHK_STATUS(DumpXmlFieldHeader(ppcOutContents, pParLayout->pcStructName,
0, pParLayout->dwSize, true,
false, true));
VPHAL_DEBUG_CHK_STATUS(DumpXmlFieldFooter(ppcOutContents, false));
}
else
{
// Skip uint32_t dumping for kernel section
if (strcmp(pParLayout->pcName, KERNEL_FIELD_NAME) != 0)
{
VPHAL_DEBUG_CHK_STATUS(DumpDwords(ppcOutContents, pParLayout->dwSize));
}
}
finish:
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DumpField(
char **ppcOutContents,
VPHAL_DBG_FIELD_LAYOUT* pLayout)
{
MOS_STATUS eStatus;
char* pcName;
eStatus = MOS_STATUS_SUCCESS;
pcName = nullptr;
if (!ppcOutContents || !pLayout)
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
goto finish;
}
// Header
pcName = (char*)MOS_AllocAndZeroMemory(MAX_NAME_LEN);
VPHAL_DEBUG_CHK_NULL(pcName);
if (pLayout->uiNumber > 1)
{
MOS_SecureStringPrint(pcName, MAX_NAME_LEN, MAX_NAME_LEN, "%s Heap", pLayout->pcName);
}
else
{
MOS_SecureStringPrint(pcName, MAX_NAME_LEN, MAX_NAME_LEN, "%s", pLayout->pcName);
}
VPHAL_DEBUG_CHK_STATUS(DumpXmlFieldHeader(ppcOutContents, pcName, pLayout->dwOffset,
pLayout->dwSize * pLayout->uiNumber,
true, true, false));
// Contents
if (pLayout->uiNumber > 1)
{
VPHAL_DEBUG_CHK_STATUS(DumpFieldHeap(ppcOutContents, pLayout));
}
else
{
VPHAL_DEBUG_CHK_STATUS(DumpSubfields(ppcOutContents, pLayout, pLayout->pChildLayout,
pLayout->uiNumChildren));
}
// footer
VPHAL_DEBUG_CHK_STATUS(DumpXmlFieldFooter(ppcOutContents, true));
finish:
return eStatus;
}
void VphalHwStateDumper::GetLastFieldIndex(
VPHAL_DBG_FIELD_LAYOUT fl[],
uint32_t uiNumFields,
uint32_t *puiLastIndex)
{
uint32_t i;
i = 0;
if (uiNumFields < 1)
{
puiLastIndex = nullptr;
}
else
{
*puiLastIndex = 0;
for (i = 1; i < uiNumFields; i++)
{
if (fl[i].dwOffset > fl[*puiLastIndex].dwOffset)
{
*puiLastIndex = i;
}
}
}
}
MOS_STATUS VphalHwStateDumper::CheckPath(
char* *ppcPath)
{
MOS_STATUS eStatus;
size_t iStrLen;
char* pcTmpPtr;
eStatus = MOS_STATUS_SUCCESS;
iStrLen = 0;
pcTmpPtr = nullptr;
if (!ppcPath || !*ppcPath)
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
goto finish;
}
iStrLen = strlen(*ppcPath);
if (iStrLen > 1)
{
if (((*ppcPath)[iStrLen - 1] == '\\') || ((*ppcPath)[iStrLen - 1] == '/'))
{
(*ppcPath)[iStrLen - 1] = '\0';
}
}
finish:
return eStatus;
}
char* VphalSurfaceDumper::WhitespaceTrim(
char* ptr)
{
char* pcTemp; // pointer to temp string to remove spces
VPHAL_DEBUG_ASSERT(ptr);
if(strlen(ptr) == 0)
{
goto finish;
}
//remove left spaces
while (*ptr == ' ' || *ptr == '\t')
{
ptr++;
}
//remove right spaces
pcTemp = ptr + strlen(ptr)-1;
while(*pcTemp == ' '|| *pcTemp == '\t')
{
pcTemp--;
}
*(++pcTemp) = '\0';
finish:
return ptr;
}
//------------------------------------------------------------------------------
//
// TOP LEVEL FUNCTIONS
// These are for dumping structures and binary data.
// Many of these will be called directly from the driver.
//
//------------------------------------------------------------------------------
MOS_STATUS VphalHwStateDumper::DumpBinaryStruct(
VPHAL_DBG_FIELD_LAYOUT* fields,
uint32_t uiNumFields,
void *pvStructToDump,
char* pcPath,
PCCHAR pcName,
int32_t iID)
{
MOS_STATUS eStatus;
uint32_t lLastFieldOffset;
uint32_t lLastFieldSize;
uint32_t lSize;
uint32_t uiLastIndex;
int32_t iStrLenPath;
int32_t iStrLenName;
char* pcOutFileName;
char* pcOutContents;
char pcTargetFileName[MAX_PATH];
eStatus = MOS_STATUS_SUCCESS;
lLastFieldOffset = 0;
lLastFieldSize = 0;
lSize = 0;
uiLastIndex = 0;
iStrLenPath = 0;
iStrLenName = 0;
pcOutFileName = nullptr;
pcOutContents = nullptr;
memset(pcTargetFileName, '\0', MAX_PATH);
VPHAL_DEBUG_CHK_STATUS(VphalHwStateDumper::CheckPath(&pcPath));
pcOutFileName = (char*)MOS_AllocAndZeroMemory(sizeof(char) * MAX_PATH);
VPHAL_DEBUG_CHK_NULL(pcOutFileName);
MOS_SecureStringPrint(pcOutFileName, MAX_PATH, MAX_PATH, "%s%s_%d.bin", pcPath, pcName, iID);
GetLastFieldIndex(fields, uiNumFields, &uiLastIndex);
lLastFieldOffset = fields[uiLastIndex].dwOffset;
lLastFieldSize = fields[uiLastIndex].dwSize;
lSize = lLastFieldOffset + lLastFieldSize;
VphalDumperTool::GetOsFilePath(pcOutFileName, pcTargetFileName);
VPHAL_DEBUG_CHK_STATUS(MOS_WriteFileFromPtr(pcTargetFileName, pvStructToDump, lSize));
finish:
MOS_SafeFreeMemory(pcOutFileName);
MOS_SafeFreeMemory(pcOutContents);
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DumpBatchBufferBinary(
PMHW_BATCH_BUFFER pBatchBuffer,
const char* pcFileLoc,
int32_t iID)
{
MOS_STATUS eStatus;
VPHAL_DBG_FIELD_LAYOUT field;
char* pcPath;
size_t iStrLen;
bool bLockNeeded;
eStatus = MOS_STATUS_SUCCESS;
pcPath = nullptr;
iStrLen = 0;
bLockNeeded = false;
if (!pBatchBuffer->pData)
{
bLockNeeded = true;
VPHAL_DEBUG_CHK_STATUS(m_renderHal->pfnLockBB(m_renderHal, pBatchBuffer));
}
iStrLen = strlen(pcFileLoc) + 1;
field.dwOffset = 0;
field.uiNumChildren = 0;
field.uiNumber = 1;
pcPath = (char*)MOS_AllocAndZeroMemory(sizeof(char) * iStrLen);
VPHAL_DEBUG_CHK_NULL(pcPath);
MOS_SecureStringPrint(pcPath, iStrLen, iStrLen, "%s", pcFileLoc);
VPHAL_DEBUG_CHK_STATUS(VphalHwStateDumper::CheckPath(&pcPath));
field.dwSize = pBatchBuffer->iSize;
VPHAL_DEBUG_CHK_STATUS(DumpBinaryStruct(&field, 1,
pBatchBuffer->pData,
pcPath, "BB", iID));
if (bLockNeeded)
{
VPHAL_DEBUG_CHK_STATUS(m_renderHal->pfnUnlockBB(m_renderHal, pBatchBuffer));
}
finish:
MOS_SafeFreeMemory(pcPath);
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DumpCommandBufferBinary(
PMOS_COMMAND_BUFFER pCmd_buff,
const char* pcFileLoc,
int32_t iID)
{
/*
MOS_COMMAND_BUFFER
DW0,DW1,DW2,DW3,DW4,DW5,DW6, ...
/-------------------------------------------------------------------------\
| | | | | | | |
| | | | | | | .... |
| | | | | | | |
| | | | | | | |
\-------------------------------------------------------------------------/
|\_________________/|\___________________________________________________/
| | | |
pCmdBase iOffset pCmdPtr iRemaining
pCmdBase : First command in the buffer
pCmdPtr : End of current command (place to put next command)
iOffset : Space being used by commands (pCmdPtr - pCmdBase)
iRemaining: Space left for comments till end of buffer
*/
MOS_STATUS eStatus;
VPHAL_DBG_FIELD_LAYOUT field;
char* pcPath;
size_t iStrLen;
eStatus = MOS_STATUS_SUCCESS;
pcPath = nullptr;
iStrLen = strlen(pcFileLoc) + 1;
field.dwOffset = 0;
field.uiNumber = 1;
field.uiNumChildren = 0;
field.dwSize = pCmd_buff->iOffset;
pcPath = (char*)MOS_AllocAndZeroMemory(sizeof(char) * iStrLen);
VPHAL_DEBUG_CHK_NULL(pcPath);
MOS_SecureStringPrint(pcPath, iStrLen, iStrLen, "%s", pcFileLoc);
VPHAL_DEBUG_CHK_STATUS(VphalHwStateDumper::CheckPath(&pcPath));
VPHAL_DEBUG_CHK_STATUS(DumpBinaryStruct(&field, 1,
pCmd_buff->pCmdBase,
pcPath, "CMB", iID));
finish:
MOS_SafeFreeMemory(pcPath);
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DumpGshBinary(
const char* pcFileLoc,
int32_t iID)
{
MOS_STATUS eStatus;
uint32_t dwSizeMS;
size_t iStrLen;
char* pcPath;
char* pcOutFileName;
char* pcOutContents;
char* pcTargetFileName;
PRENDERHAL_STATE_HEAP pStateHeap;
PRENDERHAL_STATE_HEAP_SETTINGS pStateHeapSettings;
// GSH LAYOUT
VPHAL_DBG_FIELD_LAYOUT* pGshLayout = nullptr;
uint32_t uiNumGSHFields = 0;
eStatus = MOS_STATUS_SUCCESS;
dwSizeMS = 0;
iStrLen = 0;
pcPath = nullptr;
pcOutFileName = nullptr;
pcOutContents = nullptr;
pcTargetFileName = nullptr;
pStateHeap = nullptr;
pStateHeapSettings = nullptr;
pcTargetFileName = (char*)MOS_AllocAndZeroMemory(MAX_PATH);
VPHAL_DEBUG_CHK_NULL(pcTargetFileName);
memset(pcTargetFileName, '\0', MAX_PATH);
pStateHeap = m_stateHeap;
pStateHeapSettings = m_stateHeapSettings;
iStrLen = strlen(pcFileLoc) + 1;
pcPath = (char*)MOS_AllocAndZeroMemory(sizeof(char) * iStrLen);
VPHAL_DEBUG_CHK_NULL(pcPath);
MOS_SecureStringPrint(pcPath, iStrLen, iStrLen, "%s", pcFileLoc);
VPHAL_DEBUG_CHK_STATUS(VphalHwStateDumper::CheckPath(&pcPath));
pcOutFileName = (char*)MOS_AllocAndZeroMemory(sizeof(char) * MAX_PATH);
VPHAL_DEBUG_CHK_NULL(pcOutFileName);
MOS_SecureStringPrint(pcOutFileName, MAX_PATH, MAX_PATH, "%sGSH_%d.xml", pcPath, iID);
VPHAL_DEBUG_CHK_STATUS(DefGsh(&pGshLayout, &uiNumGSHFields));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(true, &pcOutContents, XMLHEADER));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents,
"<GSH><NAME>GSH</NAME><LOC>0x%x</LOC><VERSION>%s</VERSION>\r\n",
(uintptr_t)pStateHeap->pGshBuffer, VPDEBUG_VERSION));
VPHAL_DEBUG_CHK_STATUS(DumpSubfields(&pcOutContents, nullptr, pGshLayout, uiNumGSHFields));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "</GSH>\r\n"));
VphalDumperTool::GetOsFilePath(pcOutFileName, pcTargetFileName);
iStrLen = strlen(pcOutContents);
if(iStrLen > ULONG_MAX)
{
eStatus = MOS_STATUS_UNKNOWN;
goto finish;
}
dwSizeMS = (uint32_t)iStrLen;
VPHAL_DEBUG_CHK_STATUS(MOS_WriteFileFromPtr(pcTargetFileName,
pcOutContents,
dwSizeMS));
VPHAL_DEBUG_CHK_STATUS(DumpBinaryStruct(pGshLayout,
uiNumGSHFields, pStateHeap->pGshBuffer,
pcPath, "GSH", iID));
finish:
MOS_SafeFreeMemory(pcPath);
MOS_SafeFreeMemory(pcTargetFileName);
MOS_SafeFreeMemory(pcOutFileName);
MOS_SafeFreeMemory(pcOutContents);
FreeLayout(pGshLayout, uiNumGSHFields);
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DumpSshBinary(
const char* pcFileLoc,
int32_t iID)
{
MOS_STATUS eStatus;
size_t iStrLen;
int32_t i;
char* pcPath;
char* pcOutFileName;
char* pcOutContents;
char* pcTargetFileName;
uint32_t dwSizeMS;
PRENDERHAL_STATE_HEAP pStateHeap;
PRENDERHAL_STATE_HEAP_SETTINGS pStateHeapSettings;
// SSH LAYOUT
uint32_t uiNumSSHFields = 0;
VPHAL_DBG_FIELD_LAYOUT* pSshLayout = nullptr;
eStatus = MOS_STATUS_SUCCESS;
iStrLen = 0;
i = 0;
pcPath = nullptr;
pcOutFileName = nullptr;
pcOutContents = nullptr;
pcTargetFileName = nullptr;
dwSizeMS = 0;
pcTargetFileName = (char*)MOS_AllocAndZeroMemory(MAX_PATH);
VPHAL_DEBUG_CHK_NULL(pcTargetFileName);
memset(pcTargetFileName, '\0', MAX_PATH);
pStateHeap = m_stateHeap;
pStateHeapSettings = m_stateHeapSettings;
iStrLen = strlen(pcFileLoc) + 1;
pcPath = (char*)MOS_AllocAndZeroMemory(sizeof(char) * iStrLen);
VPHAL_DEBUG_CHK_NULL(pcPath);
MOS_SecureStringPrint(pcPath, iStrLen, iStrLen, "%s", pcFileLoc);
VPHAL_DEBUG_CHK_STATUS(VphalHwStateDumper::CheckPath(&pcPath));
pcOutFileName = (char*)MOS_AllocAndZeroMemory(sizeof(char) * (iStrLen + 20));
VPHAL_DEBUG_CHK_NULL(pcOutFileName);
MOS_SecureStringPrint(pcOutFileName, iStrLen + 20, iStrLen + 20, "%sSSH_%d.xml", pcPath, iID);
VPHAL_DEBUG_CHK_STATUS(DefSsh(&pSshLayout, &uiNumSSHFields));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(true, &pcOutContents, XMLHEADER));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents,
"<SSH><NAME>SSH</NAME><LOC>0x%x</LOC><VERSION>%s</VERSION>\r\n",
(uintptr_t)pStateHeap->pSshBuffer, VPDEBUG_VERSION));
VPHAL_DEBUG_CHK_STATUS(DumpSubfields(&pcOutContents, nullptr, pSshLayout,
uiNumSSHFields));
VphalDumperTool::AppendString(false, &pcOutContents, "</SSH>\r\n");
VphalDumperTool::GetOsFilePath(pcOutFileName, pcTargetFileName);
iStrLen = strlen(pcOutContents);
if(iStrLen > ULONG_MAX)
{
eStatus = MOS_STATUS_UNKNOWN;
goto finish;
}
dwSizeMS = (uint32_t)iStrLen;
VPHAL_DEBUG_CHK_STATUS(MOS_WriteFileFromPtr(pcTargetFileName,
pcOutContents,
dwSizeMS));
VPHAL_DEBUG_CHK_STATUS(DumpBinaryStruct(pSshLayout,
uiNumSSHFields, pStateHeap->pSshBuffer,
pcPath, "SSH", iID));
finish:
MOS_SafeFreeMemory(pcPath);
MOS_SafeFreeMemory(pcOutFileName);
MOS_SafeFreeMemory(pcOutContents);
FreeLayout(pSshLayout, uiNumSSHFields);
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DumpVeboxStateBinary(
PMHW_VEBOX_INTERFACE pVeboxInterface,
const char* pcFileLoc,
int32_t iID)
{
MOS_STATUS eStatus;
VPHAL_DBG_FIELD_LAYOUT field;
char* pcPath;
size_t iStrLen;
const MHW_VEBOX_HEAP *pVeboxHeap = nullptr;
eStatus = MOS_STATUS_SUCCESS;
pcPath = nullptr;
iStrLen = strlen(pcFileLoc) + 1;
VPHAL_DEBUG_CHK_STATUS(pVeboxInterface->GetVeboxHeapInfo(
&pVeboxHeap));
VPHAL_DEBUG_CHK_NULL(pVeboxHeap);
field.dwOffset = 0;
field.uiNumChildren = 0;
field.uiNumber = 1;
pcPath = (char*)MOS_AllocAndZeroMemory(sizeof(char) * iStrLen);
VPHAL_DEBUG_CHK_NULL(pcPath);
MOS_SecureStringPrint(pcPath, iStrLen, iStrLen, "%s", pcFileLoc);
field.dwSize = pVeboxHeap->uiInstanceSize;
VPHAL_DEBUG_CHK_STATUS(DumpBinaryStruct(&field, 1,
(pVeboxHeap->pLockedDriverResourceMem +pVeboxHeap->uiCurState * pVeboxHeap->uiInstanceSize) ,
pcPath, nullptr, iID));
finish:
MOS_SafeFreeMemory(pcPath);
return eStatus;
}
MOS_STATUS VphalHwStateDumper::DumpStatisticsBinary(
PVPHAL_VEBOX_STATE pVeboxState,
uint8_t* pStat0Base,
uint8_t* pStat1Base,
const char* pcFileLoc,
int32_t iID)
{
MOS_STATUS eStatus;
VPHAL_DBG_FIELD_LAYOUT field;
size_t iStrLen;
char* pcOutFileName0;
char* pcOutFileName1;
int32_t dwWidth,dwHeight;
void *pState0, *pState1;
eStatus = MOS_STATUS_SUCCESS;
iStrLen = 0;
pcOutFileName0 = nullptr;
pcOutFileName1 = nullptr;
iStrLen = strlen(pcFileLoc) + 4;
pState0 = (void*)(pStat0Base);
pState1 = (void*)(pStat1Base);
pcOutFileName0 = (char*)MOS_AllocAndZeroMemory(sizeof(char) * iStrLen);
VPHAL_DEBUG_CHK_NULL(pcOutFileName0);
MOS_SecureStringPrint(pcOutFileName0, iStrLen, iStrLen, "%s[slice0]", pcFileLoc);
pcOutFileName1 = (char*)MOS_AllocAndZeroMemory(sizeof(char) * iStrLen);
VPHAL_DEBUG_CHK_NULL(pcOutFileName1);
MOS_SecureStringPrint(pcOutFileName1, iStrLen, iStrLen, "%s[slice1]", pcFileLoc);
field.dwOffset = 0;
field.uiNumChildren = 0;
field.uiNumber = 1;
dwWidth = MOS_ALIGN_CEIL(pVeboxState->m_currentSurface->dwWidth, 64);
dwHeight = MOS_ROUNDUP_DIVIDE(pVeboxState->m_currentSurface->dwHeight, 4) +
MOS_ROUNDUP_DIVIDE(VPHAL_VEBOX_STATISTICS_SIZE_MAX * sizeof(uint32_t), dwWidth);
field.dwSize = dwWidth * dwHeight;
VPHAL_DEBUG_CHK_STATUS(DumpBinaryStruct(&field, 1,
pState0 , pcOutFileName0, nullptr, iID));
VPHAL_DEBUG_CHK_STATUS(DumpBinaryStruct(&field, 1,
pState1 , pcOutFileName1, nullptr, iID));
finish:
MOS_SafeFreeMemory(pcOutFileName0);
MOS_SafeFreeMemory(pcOutFileName1);
return eStatus;
}
void VphalDumperTool::StringToLower(
char* pcString)
{
size_t stStrLen; // length of string
size_t i; // loop iterator
stStrLen = strlen(pcString);
for (i = 0; i < stStrLen; i++)
{
if (isupper(pcString[i]))
{
pcString[i] = (char)tolower(pcString[i]);
}
}
}
MOS_STATUS VphalSurfaceDumper::LocStringToEnum(
char* pcLocString,
uint32_t *pLocation)
{
MOS_STATUS eStatus;
eStatus = MOS_STATUS_SUCCESS;
VphalDumperTool::StringToLower(pcLocString);
if (strcmp(pcLocString, VPHAL_DBG_SURF_DUMP_LOC_PREALL) == 0)
{
*pLocation = VPHAL_DBG_DUMP_TYPE_PRE_ALL;
}
else if (strcmp(pcLocString, VPHAL_DBG_SURF_DUMP_LOC_PREDNDI) == 0)
{
*pLocation = VPHAL_DBG_DUMP_TYPE_PRE_DNDI;
}
else if (strcmp(pcLocString, VPHAL_DBG_SURF_DUMP_LOC_POSTDNDI) == 0)
{
*pLocation = VPHAL_DBG_DUMP_TYPE_POST_DNDI;
}
else if (strcmp(pcLocString, VPHAL_DBG_SURF_DUMP_LOC_PRECOMP) == 0)
{
*pLocation = VPHAL_DBG_DUMP_TYPE_PRE_COMP;
}
else if (strcmp(pcLocString, VPHAL_DBG_SURF_DUMP_LOC_POSTCOMP) == 0)
{
*pLocation = VPHAL_DBG_DUMP_TYPE_POST_COMP;
}
else if (strcmp(pcLocString, VPHAL_DBG_SURF_DUMP_LOC_PREMEMDECOMP) == 0)
{
*pLocation = VPHAL_DBG_DUMP_TYPE_PRE_MEMDECOMP;
}
else if (strcmp(pcLocString, VPHAL_DBG_SURF_DUMP_LOC_POSTMEMDECOMP) == 0)
{
*pLocation = VPHAL_DBG_DUMP_TYPE_POST_MEMDECOMP;
}
else if (strcmp(pcLocString, VPHAL_DBG_SURF_DUMP_LOC_POSTALL) == 0)
{
*pLocation = VPHAL_DBG_DUMP_TYPE_POST_ALL;
}
else
{
VPHAL_DEBUG_NORMALMESSAGE("Unknown dump location \"%s\".", pcLocString);
eStatus = MOS_STATUS_UNKNOWN;
goto finish;
}
finish:
return eStatus;
}
MOS_STATUS VphalSurfaceDumper::EnumToLocString(
uint32_t Location,
char* pcLocString)
{
MOS_STATUS eStatus;
uint32_t i;
size_t stStrLen;
eStatus = MOS_STATUS_SUCCESS;
if (pcLocString == nullptr)
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
goto finish;
}
switch (Location)
{
case VPHAL_DBG_DUMP_TYPE_PRE_ALL:
MOS_SecureStringPrint(pcLocString, MAX_PATH, MAX_PATH, VPHAL_DBG_SURF_DUMP_LOC_PREALL);
break;
case VPHAL_DBG_DUMP_TYPE_PRE_DNDI:
MOS_SecureStringPrint(pcLocString, MAX_PATH, MAX_PATH, VPHAL_DBG_SURF_DUMP_LOC_PREDNDI);
break;
case VPHAL_DBG_DUMP_TYPE_POST_DNDI:
MOS_SecureStringPrint(pcLocString, MAX_PATH, MAX_PATH, VPHAL_DBG_SURF_DUMP_LOC_POSTDNDI);
break;
case VPHAL_DBG_DUMP_TYPE_PRE_COMP:
MOS_SecureStringPrint(pcLocString, MAX_PATH, MAX_PATH, VPHAL_DBG_SURF_DUMP_LOC_PRECOMP);
break;
case VPHAL_DBG_DUMP_TYPE_POST_COMP:
MOS_SecureStringPrint(pcLocString, MAX_PATH, MAX_PATH, VPHAL_DBG_SURF_DUMP_LOC_POSTCOMP);
break;
case VPHAL_DBG_DUMP_TYPE_PRE_MEMDECOMP:
MOS_SecureStringPrint(pcLocString, MAX_PATH, MAX_PATH, VPHAL_DBG_SURF_DUMP_LOC_PREMEMDECOMP);
break;
case VPHAL_DBG_DUMP_TYPE_POST_MEMDECOMP:
MOS_SecureStringPrint(pcLocString, MAX_PATH, MAX_PATH, VPHAL_DBG_SURF_DUMP_LOC_POSTMEMDECOMP);
break;
case VPHAL_DBG_DUMP_TYPE_POST_ALL:
MOS_SecureStringPrint(pcLocString, MAX_PATH, MAX_PATH, VPHAL_DBG_SURF_DUMP_LOC_POSTALL);
break;
default:
VPHAL_DEBUG_ASSERTMESSAGE("Unknown dump location \"%d\".", Location);
eStatus = MOS_STATUS_UNKNOWN;
goto finish;
} // end switch
stStrLen = strlen(pcLocString);
VPHAL_DEBUG_ASSERT(stStrLen > 1); // assert b/c invalid access if <= 1
i = pcLocString[1] == 'r' ? 3 : 4; // If pre, start i at 3, else 4
// Maybe should add error case in case macros get changed later?
for (; i < stStrLen; i++)
{
pcLocString[i] = (char)toupper(pcLocString[i]);
}
finish:
return eStatus;
}
MOS_STATUS VphalHwStateDumper::EnumToLocString(
VPHAL_DEBUG_STAGE Location,
char* pcLocString)
{
MOS_STATUS eStatus;
uint32_t i;
size_t stStrLen;
eStatus = MOS_STATUS_SUCCESS;
if (pcLocString == nullptr)
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
goto finish;
}
switch (Location)
{
case VPHAL_DBG_STAGE_DNDI:
MOS_SecureStringPrint(pcLocString, MAX_PATH, MAX_PATH, VPHAL_DBG_STATE_DUMP_LOC_DNDI);
break;
case VPHAL_DBG_STAGE_VEBOX:
MOS_SecureStringPrint(pcLocString, MAX_PATH, MAX_PATH, VPHAL_DBG_STATE_DUMP_LOC_VEBOX);
break;
case VPHAL_DBG_STAGE_COMP:
MOS_SecureStringPrint(pcLocString, MAX_PATH, MAX_PATH, VPHAL_DBG_STATE_DUMP_LOC_COMP);
break;
default:
VPHAL_DEBUG_NORMALMESSAGE("Unknown dump location \"%d\".", Location);
eStatus = MOS_STATUS_UNKNOWN;
goto finish;
} // end switch
stStrLen = strlen(pcLocString);
for (i=0; i < stStrLen; i++)
{
pcLocString[i] = (char)toupper(pcLocString[i]);
}
finish:
return eStatus;
}
MOS_STATUS VphalSurfaceDumper::SurfTypeStringToEnum(
char* pcSurfType,
VPHAL_SURFACE_TYPE *pSurfType)
{
MOS_STATUS eStatus;
eStatus = MOS_STATUS_SUCCESS;
VphalDumperTool::StringToLower(pcSurfType);
if (strcmp(pcSurfType, VPHAL_DBG_SURF_DUMP_TYPE_BACKGROUND) == 0)
{
*pSurfType = SURF_IN_BACKGROUND;
}
else if (strcmp(pcSurfType, VPHAL_DBG_SURF_DUMP_TYPE_PRIMARY) == 0)
{
*pSurfType = SURF_IN_PRIMARY;
}
else if (strcmp(pcSurfType, VPHAL_DBG_SURF_DUMP_TYPE_SUBSTREAM) == 0)
{
*pSurfType = SURF_IN_SUBSTREAM;
}
else if (strcmp(pcSurfType, VPHAL_DBG_SURF_DUMP_TYPE_REFERENCE) == 0)
{
*pSurfType = SURF_IN_REFERENCE;
}
else if (strcmp(pcSurfType, VPHAL_DBG_SURF_DUMP_TYPE_RENDERTARGET) == 0)
{
*pSurfType = SURF_OUT_RENDERTARGET;
}
else
{
VPHAL_DEBUG_ASSERTMESSAGE("Unknown surface type \"%s\".", pcSurfType);
eStatus = MOS_STATUS_UNKNOWN;
goto finish;
}
finish:
return eStatus;
}
MOS_STATUS VphalHwStateDumper::StateTypeStringToEnum(
char* pcStateType,
uint32_t *pStateType)
{
MOS_STATUS eStatus;
eStatus = MOS_STATUS_SUCCESS;
VphalDumperTool::StringToLower(pcStateType);
if (strcmp(pcStateType, VPHAL_DBG_STATE_DUMP_LOC_DNDI) == 0)
{
*pStateType = VPHAL_DBG_STAGE_DNDI;
}
else if (strcmp(pcStateType, VPHAL_DBG_STATE_DUMP_LOC_VEBOX) == 0)
{
*pStateType = VPHAL_DBG_STAGE_VEBOX;
}
else if (strcmp(pcStateType, VPHAL_DBG_STATE_DUMP_LOC_COMP) == 0)
{
*pStateType = VPHAL_DBG_STAGE_COMP;
}
else
{
VPHAL_DEBUG_NORMALMESSAGE("Unknown surface type \"%s\".", pcStateType);
eStatus = MOS_STATUS_UNKNOWN;
goto finish;
}
finish:
return eStatus;
}
MOS_STATUS VphalSurfaceDumper::ProcessDumpLocations(
char* pcDumpLocData)
{
MOS_STATUS eStatus;
char* pcCommaLoc; // pointer to next comma in dump location string
char* pcCurrToken; // pointer to current token in a string
char* pcColonLoc; // pointer to next colon in location string
int32_t iNumStrings; // number of dump locations
int32_t i; // loop iteration counter
VPHAL_DBG_SURF_DUMP_SPEC *pDumpSpec = &m_dumpSpec;
eStatus = MOS_STATUS_SUCCESS;
iNumStrings = 0;
if (strlen(pcDumpLocData) > 0)
{
// Count number of strings in key data
// If non empty string, there is at least one value
iNumStrings++;
// Count the rest
pcCommaLoc = pcDumpLocData;
while ((pcCommaLoc = strchr(pcCommaLoc + 1, ',')) != nullptr)
{
iNumStrings++;
}
// Set number of strings and allocate space for them
pDumpSpec->iNumDumpLocs = iNumStrings;
pDumpSpec->pDumpLocations = (VPHAL_DBG_SURF_DUMP_LOC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_SURF_DUMP_LOC) * pDumpSpec->iNumDumpLocs);
pcCurrToken = pcDumpLocData;
// Determine each part of the string
for (i = 0; i < pDumpSpec->iNumDumpLocs; i++)
{
pcCommaLoc = strchr(pcCurrToken, ',');
if (pcCommaLoc != nullptr)
{
*pcCommaLoc = '\0';
}
// Handle surface type
pcColonLoc = strchr(pcCurrToken, ':');
if (pcColonLoc == nullptr)
{
// Dump all
pDumpSpec->pDumpLocations[i].SurfType = SURF_NONE;
}
else
{
// Remove surface type from dump location
*pcColonLoc = '\0';
// Set surface type
pcColonLoc++;
pcColonLoc = WhitespaceTrim(pcColonLoc);
VPHAL_DEBUG_CHK_STATUS(SurfTypeStringToEnum(pcColonLoc,
&(pDumpSpec->pDumpLocations[i].SurfType)));
}
//trim the whitespaces from dump location
pcCurrToken = WhitespaceTrim(pcCurrToken);
VPHAL_DEBUG_CHK_STATUS(LocStringToEnum(pcCurrToken,
&(pDumpSpec->pDumpLocations[i].DumpLocation)));
if (pcCommaLoc != nullptr)
{
pcCurrToken = pcCommaLoc + 1;
}
} // end for each part of the string
} // if data length > 0
finish:
return eStatus;
}
void VphalSurfaceDumper::GetSurfaceDumpSpec()
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MOS_USER_FEATURE_VALUE_DATA UserFeatureData;
bool bDumpEnabled;
char cStringData[MOS_USER_CONTROL_MAX_DATA_SIZE];
char pcDumpLocData[VPHAL_DBG_SURF_DUMP_MAX_DATA_LEN];
VPHAL_DBG_SURF_DUMP_SPEC *pDumpSpec = &m_dumpSpec;
pDumpSpec->uiStartFrame = 0xFFFFFFFF;
pDumpSpec->uiEndFrame = 0;
pDumpSpec->pcOutputPath[0] = '\0';
pcDumpLocData[0] = '\0';
bDumpEnabled = false;
// Get start frame
// if start frame is not got assign a default value of 0
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_SURF_DUMP_START_FRAME_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext));
pDumpSpec->uiStartFrame = UserFeatureData.u32Data;
// Get end frame
// if end frame is not got assign a default value of max
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_SURF_DUMP_END_FRAME_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext));
pDumpSpec->uiEndFrame = UserFeatureData.u32Data;
// Get out file path
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
UserFeatureData.StringData.pStringData = cStringData;
UserFeatureData.StringData.uMaxSize = MOS_USER_CONTROL_MAX_DATA_SIZE;
UserFeatureData.StringData.uSize = 0; //set the default value. 0 is empty buffer.
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_SURF_DUMP_OUTFILE_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext));
if (UserFeatureData.StringData.uSize > 0)
{
// Copy the Output path
MOS_SecureMemcpy(
pDumpSpec->pcOutputPath,
MAX_PATH,
UserFeatureData.StringData.pStringData,
UserFeatureData.StringData.uSize);
}
#if !defined(LINUX) && !defined(ANDROID)
else
{
std::string vphalDumpFilePath;
// Use state separation APIs to obtain appropriate storage location
if (SUCCEEDED(GetDriverPersistentStorageLocation(vphalDumpFilePath)))
{
std::string m_outputFilePath;
MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
m_outputFilePath = vphalDumpFilePath.c_str();
m_outputFilePath.append(VPHAL_DBG_DUMP_OUTPUT_FOLDER);
// Copy the Output path
MOS_SecureMemcpy(
pDumpSpec->pcOutputPath,
MAX_PATH,
m_outputFilePath.c_str(),
m_outputFilePath.size());
MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData));
userFeatureWriteData.Value.StringData.pStringData = cStringData;
userFeatureWriteData.Value.StringData.pStringData = const_cast<char *>(m_outputFilePath.c_str());
userFeatureWriteData.Value.StringData.uSize = m_outputFilePath.size();
userFeatureWriteData.ValueID = __VPHAL_DBG_DUMP_OUTPUT_DIRECTORY_ID;
MOS_UserFeature_WriteValues_ID(NULL, &userFeatureWriteData, 1, m_osInterface->pOsContext);
}
}
#endif
// Get dump locations
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
UserFeatureData.StringData.pStringData = cStringData;
UserFeatureData.StringData.uMaxSize = MOS_USER_CONTROL_MAX_DATA_SIZE;
UserFeatureData.StringData.uSize = 0; //set the default value. 0 is empty buffer.
MOS_CHK_STATUS_SAFE(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_SURF_DUMP_LOCATION_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext));
if (UserFeatureData.StringData.uSize > 0)
{
bDumpEnabled = ((pDumpSpec->pcOutputPath[0] != '\0') &&
(UserFeatureData.StringData.pStringData[0] != '\0'));
}
if (bDumpEnabled)
{
VPHAL_DEBUG_CHK_STATUS(ProcessDumpLocations(
UserFeatureData.StringData.pStringData));
}
// Get enableAuxDump
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_SURF_DUMP_ENABLE_AUX_DUMP_ID,
&UserFeatureData,
m_osInterface->pOsContext));
pDumpSpec->enableAuxDump = UserFeatureData.u32Data;
// Get plane dump enabled flag
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_SURF_DUMPER_ENABLE_PLANE_DUMP,
&UserFeatureData,
m_osInterface->pOsContext));
pDumpSpec->enablePlaneDump = UserFeatureData.u32Data;
finish:
if ((eStatus != MOS_STATUS_SUCCESS) || (!bDumpEnabled))
{
pDumpSpec->uiStartFrame = 1;
pDumpSpec->uiEndFrame = 0;
}
}
MOS_STATUS VphalHwStateDumper::ProcessDumpStateLocations(
char* pcDumpLocData)
{
MOS_STATUS eStatus;
char* pcCommaLoc; // pointer to next comma in dump location string
char* pcCurrToken; // pointer to current token in a string
char* pcRender; //pointer to video process type string
int32_t iNumStrings; // number of dump locations
int32_t iNumDumpLocs;
int32_t i = 0;
VPHAL_DBG_DUMP_SPEC *pDumpSpec = &m_dumpSpec;
eStatus = MOS_STATUS_SUCCESS;
iNumStrings = 0;
if (strlen(pcDumpLocData) > 0)
{
// Count number of strings in key data
// If non empty string, there is at least one value
iNumStrings++;
// Count the rest
pcCommaLoc = pcDumpLocData;
while ((pcCommaLoc = strchr(pcCommaLoc + 1, ';')) != nullptr)
{
iNumStrings++;
}
//calucate the number of GSH,SSH,CB,SB,VeboxState.
pcCurrToken = pcDumpLocData;
while(iNumStrings !=0)
{
pcCommaLoc = strchr(pcCurrToken, ';');
if (pcCommaLoc != nullptr)
{
*pcCommaLoc = '\0';
}
pcRender = strchr(pcCurrToken, ':');
if (pcRender != nullptr)
{
iNumDumpLocs = 1;
pcRender = pcRender + 1;
while ((pcRender = strchr(pcRender + 1, ',')) != nullptr)
{
iNumDumpLocs++;
}
}
else
{
iNumDumpLocs = 1;
}
if (!strncmp(pcCurrToken, "GSH", 3))
{
pDumpSpec->pGSHDumpSpec = (VPHAL_DBG_GSH_DUMP_SPEC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_GSH_DUMP_SPEC));
pDumpSpec->pGSHDumpSpec->iNumDumpLocs=iNumDumpLocs;
pDumpSpec->pGSHDumpSpec->pDumpLocations = (VPHAL_DBG_GSH_DUMP_LOC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_GSH_DUMP_LOC)*iNumDumpLocs);
pcCurrToken = pcCurrToken+4;
i = 0;
while(iNumDumpLocs!=0)
{
pcRender = strchr(pcCurrToken, ',');
if (pcRender != nullptr)
{
*pcRender = '\0';
}
if(i<pDumpSpec->pGSHDumpSpec->iNumDumpLocs)
{
VPHAL_DEBUG_CHK_STATUS(StateTypeStringToEnum(pcCurrToken,
&(pDumpSpec->pGSHDumpSpec->pDumpLocations[i].DumpStage)));
i++;
}
if (pcRender != nullptr)
{
pcCurrToken = pcRender + 1;
}
iNumDumpLocs--;
}
}
else if (!strncmp(pcCurrToken, "SSH", 3))
{
pDumpSpec->pSSHDumpSpec = (VPHAL_DBG_SSH_DUMP_SPEC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_SSH_DUMP_SPEC));
pDumpSpec->pSSHDumpSpec->iNumDumpLocs=iNumDumpLocs;
pDumpSpec->pSSHDumpSpec->pDumpLocations = (VPHAL_DBG_SSH_DUMP_LOC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_SSH_DUMP_LOC)*iNumDumpLocs);
pcCurrToken = pcCurrToken+4;
i = 0;
while(iNumDumpLocs!=0)
{
pcRender = strchr(pcCurrToken, ',');
if (pcRender != nullptr)
{
*pcRender = '\0';
}
if(i<pDumpSpec->pSSHDumpSpec->iNumDumpLocs)
{
VPHAL_DEBUG_CHK_STATUS(StateTypeStringToEnum(pcCurrToken,
&(pDumpSpec->pSSHDumpSpec->pDumpLocations[i].DumpStage)));
i++;
}
if(pcRender != nullptr)
{
pcCurrToken = pcRender + 1;
}
iNumDumpLocs--;
}
}
else if (!strncmp(pcCurrToken, "BB", 2))
{
pDumpSpec->pBBDumpSpec = (VPHAL_DBG_BB_DUMP_SPEC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_BB_DUMP_SPEC));
pDumpSpec->pBBDumpSpec->iNumDumpLocs=iNumDumpLocs;
pDumpSpec->pBBDumpSpec->pDumpLocations = (VPHAL_DBG_BB_DUMP_LOC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_BB_DUMP_LOC)*iNumDumpLocs);
pcCurrToken = pcCurrToken+3;
i = 0;
while(iNumDumpLocs!=0)
{
pcRender = strchr(pcCurrToken, ',');
if (pcRender != nullptr)
{
*pcRender = '\0';
}
if(i<pDumpSpec->pBBDumpSpec->iNumDumpLocs)
{
VPHAL_DEBUG_CHK_STATUS(StateTypeStringToEnum(pcCurrToken,
&(pDumpSpec->pBBDumpSpec->pDumpLocations[i].DumpStage)));
i++;
}
if(pcRender != nullptr)
{
pcCurrToken = pcRender + 1;
}
iNumDumpLocs--;
}
}
else if (!strncmp(pcCurrToken, "CB", 2))
{
pDumpSpec->pCBDumpSpec = (VPHAL_DBG_CB_DUMP_SPEC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_CB_DUMP_SPEC));
pDumpSpec->pCBDumpSpec->iNumDumpLocs=iNumDumpLocs;
pDumpSpec->pCBDumpSpec->pDumpLocations = (VPHAL_DBG_CB_DUMP_LOC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_CB_DUMP_LOC)*iNumDumpLocs);
pcCurrToken = pcCurrToken+3;
i = 0;
while(iNumDumpLocs!=0)
{
pcRender = strchr(pcCurrToken, ',');
if (pcRender != nullptr)
{
*pcRender = '\0';
}
if(i<pDumpSpec->pCBDumpSpec->iNumDumpLocs)
{
VPHAL_DEBUG_CHK_STATUS(StateTypeStringToEnum(pcCurrToken,
&(pDumpSpec->pCBDumpSpec->pDumpLocations[i].DumpStage)));
i++;
}
if (pcRender != nullptr)
{
pcCurrToken = pcRender + 1;
}
iNumDumpLocs--;
}
}
else if (!strncmp(pcCurrToken, "VeboxState", 10))
{
pDumpSpec->pVeboxStateDumpSpec = (VPHAL_DBG_VEBOXSTATE_DUMP_SPEC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_VEBOXSTATE_DUMP_SPEC));
pDumpSpec->pVeboxStateDumpSpec->iNumDumpLocs=iNumDumpLocs;
pDumpSpec->pVeboxStateDumpSpec->pDumpLocations = (VPHAL_DBG_VEBOXSTATE_DUMP_LOC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_VEBOXSTATE_DUMP_LOC)*iNumDumpLocs);
pDumpSpec->pVeboxStateDumpSpec->pDumpLocations->DumpStage=VPHAL_DBG_STAGE_VEBOX;
pcCurrToken = pcCurrToken+11;
}
else if (!strncmp(pcCurrToken, "Statistics", 10))
{
pDumpSpec->pStatisticsDumpSpec = (VPHAL_DBG_STATISTICS_DUMP_SPEC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_STATISTICS_DUMP_SPEC));
pDumpSpec->pStatisticsDumpSpec->iNumDumpLocs=iNumDumpLocs;
pDumpSpec->pStatisticsDumpSpec->pDumpLocations = (VPHAL_DBG_STATISTICS_DUMP_LOC*)MOS_AllocAndZeroMemory(
sizeof(VPHAL_DBG_STATISTICS_DUMP_LOC)*iNumDumpLocs);
pDumpSpec->pVeboxStateDumpSpec->pDumpLocations->DumpStage=VPHAL_DBG_STAGE_VEBOX;
pcCurrToken = pcCurrToken+11;
}
if (pcCommaLoc != nullptr)
{
pcCurrToken = pcCommaLoc + 1;
}
iNumStrings--;
}
} // if data length > 0
finish:
return eStatus;
}
void VphalHwStateDumper::GetStateDumpSpec()
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MOS_USER_FEATURE_VALUE_DATA UserFeatureData;
PMOS_USER_FEATURE_VALUE_DATA pUserFeatureData = &UserFeatureData;
bool bDumpEnabled;
char pcDumpLocData[VPHAL_DBG_SURF_DUMP_MAX_DATA_LEN];
char cStringData[MOS_USER_CONTROL_MAX_DATA_SIZE];
VPHAL_DBG_DUMP_SPEC *pDumpSpec = &m_dumpSpec;
pDumpSpec->uiStartFrame = 0xFFFFFFFF;
pDumpSpec->uiEndFrame = 0;
pDumpSpec->pcOutputPath[0] = '\0';
pcDumpLocData[0] = '\0';
bDumpEnabled = false;
// Get start frame
// if start frame is not got assign a default value of 0
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_STATE_DUMP_START_FRAME_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext));
pDumpSpec->uiStartFrame = UserFeatureData.u32Data;
// Get end frame
// if end frame is not got assign a default value of max
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_STATE_DUMP_END_FRAME_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext));
pDumpSpec->uiEndFrame = UserFeatureData.u32Data;
// Get out file path
UserFeatureData.StringData.pStringData = cStringData;
UserFeatureData.StringData.uMaxSize = MOS_USER_CONTROL_MAX_DATA_SIZE;
UserFeatureData.StringData.uSize = 0; // set the default value. 0 is empty buffer.
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_STATE_DUMP_OUTFILE_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext));
if (pUserFeatureData->StringData.uSize > 0)
{
// Copy the Output path
MOS_SecureMemcpy(
pDumpSpec->pcOutputPath,
MAX_PATH,
pUserFeatureData->StringData.pStringData,
pUserFeatureData->StringData.uSize);
}
#if !defined(LINUX) && !defined(ANDROID)
else
{
std::string vphalDumpFilePath;
// Use state separation APIs to obtain appropriate storage location
if (SUCCEEDED(GetDriverPersistentStorageLocation(vphalDumpFilePath)))
{
std::string m_outputFilePath;
MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
m_outputFilePath = vphalDumpFilePath.c_str();
m_outputFilePath.append(VPHAL_DBG_DUMP_OUTPUT_FOLDER);
// Copy the Output path
MOS_SecureMemcpy(
pDumpSpec->pcOutputPath,
MAX_PATH,
m_outputFilePath.c_str(),
m_outputFilePath.size());
MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData));
userFeatureWriteData.Value.StringData.pStringData = cStringData;
userFeatureWriteData.Value.StringData.pStringData = const_cast<char *>(m_outputFilePath.c_str());
userFeatureWriteData.Value.StringData.uSize = m_outputFilePath.size();
userFeatureWriteData.ValueID = __VPHAL_DBG_DUMP_OUTPUT_DIRECTORY_ID;
MOS_UserFeature_WriteValues_ID(NULL, &userFeatureWriteData, 1, m_osInterface->pOsContext);
}
}
#endif
// Get dump locations
UserFeatureData.StringData.pStringData = cStringData;
UserFeatureData.StringData.uMaxSize = MOS_USER_CONTROL_MAX_DATA_SIZE;
UserFeatureData.StringData.uSize = 0; // set the default value. 0 is empty buffer.
MOS_CHK_STATUS_SAFE(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_STATE_DUMP_LOCATION_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext));
if (pUserFeatureData->StringData.uSize > 0)
{
bDumpEnabled = ((pDumpSpec->pcOutputPath[0] != '\0') &&
(pUserFeatureData->StringData.pStringData[0] != '\0'));
}
if (bDumpEnabled)
{
VPHAL_DEBUG_CHK_STATUS(ProcessDumpStateLocations(
pUserFeatureData->StringData.pStringData));
}
finish:
if ((eStatus != MOS_STATUS_SUCCESS) || (!bDumpEnabled))
{
pDumpSpec->uiStartFrame = 1;
pDumpSpec->uiEndFrame = 0;
}
}
VphalSurfaceDumper::~VphalSurfaceDumper()
{
MOS_SafeFreeMemory(m_dumpSpec.pDumpLocations);
}
VphalHwStateDumper::~VphalHwStateDumper()
{
VPHAL_DBG_DUMP_SPEC *pDumpSpec = &m_dumpSpec;
if (pDumpSpec != nullptr)
{
if(pDumpSpec->pGSHDumpSpec != nullptr)
MOS_SafeFreeMemory(pDumpSpec->pGSHDumpSpec->pDumpLocations);
if(pDumpSpec->pSSHDumpSpec != nullptr)
MOS_SafeFreeMemory(pDumpSpec->pSSHDumpSpec->pDumpLocations);
if(pDumpSpec->pBBDumpSpec != nullptr)
MOS_SafeFreeMemory(pDumpSpec->pBBDumpSpec->pDumpLocations);
if(pDumpSpec->pCBDumpSpec != nullptr)
MOS_SafeFreeMemory(pDumpSpec->pCBDumpSpec->pDumpLocations);
if(pDumpSpec->pVeboxStateDumpSpec != nullptr)
MOS_SafeFreeMemory(pDumpSpec->pVeboxStateDumpSpec->pDumpLocations);
if(pDumpSpec->pStatisticsDumpSpec != nullptr)
MOS_SafeFreeMemory(pDumpSpec->pStatisticsDumpSpec->pDumpLocations);
MOS_SafeFreeMemory(pDumpSpec->pGSHDumpSpec);
MOS_SafeFreeMemory(pDumpSpec->pSSHDumpSpec);
MOS_SafeFreeMemory(pDumpSpec->pBBDumpSpec);
MOS_SafeFreeMemory(pDumpSpec->pCBDumpSpec);
MOS_SafeFreeMemory(pDumpSpec->pVeboxStateDumpSpec);
MOS_SafeFreeMemory(pDumpSpec->pStatisticsDumpSpec);
}
}
uint32_t VphalSurfaceDumper::m_frameNumInVp = 0xffffffff;
char VphalSurfaceDumper::m_dumpLocInVp[MAX_PATH];
MOS_STATUS VphalSurfaceDumper::DumpSurface(
PVPHAL_SURFACE pSurf,
uint32_t uiFrameNumber,
uint32_t uiCounter,
uint32_t Location)
{
MOS_USER_FEATURE_VALUE_DATA UserFeatureData;
int32_t VphalSurfDumpManualTrigger = VPHAL_DBG_SURF_DUMP_MANUAL_TRIGGER_DEFAULT_NOT_SET;
MOS_STATUS eStatus;
int32_t i;
VPHAL_DBG_SURF_DUMP_SPEC* pDumpSpec = &m_dumpSpec;
bool isDumpFromDecomp;
bool orgDumpAuxEnable;
eStatus = MOS_STATUS_SUCCESS;
i = 0;
isDumpFromDecomp = (Location == VPHAL_DBG_DUMP_TYPE_PRE_MEMDECOMP || Location == VPHAL_DBG_DUMP_TYPE_POST_MEMDECOMP);
orgDumpAuxEnable = m_dumpSpec.enableAuxDump;
if ((Location == VPHAL_DBG_DUMP_TYPE_PRE_MEMDECOMP) ||
(Location == VPHAL_DBG_DUMP_TYPE_POST_MEMDECOMP && m_frameNumInVp != 0xffffffff))
{
// For PreMemDecomp, dump without aux is meaningless
// and, if we don't turn on aux dump, the surface will be deswizzled,
// while Mos_Specific_LockResource() will perform deswilling to temp buffer and then copy to locked buffer
// This will break the compressed surface.
// So, we cannot dump compressed surf with deswizzling under current implementation.
// And, for PostMemDecomp, although aux surf should be zero, we can dump it out for comparison.
// Besides, we don't need to deswizzle as the original dump from VP (preAll etc) will do the deswizzling
// For pre/post mem decomp from Codec/3D, doing deswizzling might help to check the result visually
m_dumpSpec.enableAuxDump = true;
}
if (m_frameNumInVp != 0xffffffff && isDumpFromDecomp)
{
// override the uiFrameNumer as it is during Vphal dumping its surface and already in lock and decomp phase
uiFrameNumber = m_frameNumInVp;
}
if (!isDumpFromDecomp)
{
m_frameNumInVp = uiFrameNumber;
}
// Get if manual triggered build
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_SURF_DUMP_MANUAL_TRIGGER_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext);
VphalSurfDumpManualTrigger = UserFeatureData.u32Data;
if (VphalSurfDumpManualTrigger != VPHAL_DBG_SURF_DUMP_MANUAL_TRIGGER_DEFAULT_NOT_SET)
{
if (VphalSurfDumpManualTrigger == VPHAL_DBG_SURF_DUMP_MANUAL_TRIGGER_STARTED)
{
VPHAL_DEBUG_NORMALMESSAGE("Dump manaul trigger enabled, dump started: %d \n", VphalSurfDumpManualTrigger);
for (i = 0; i < pDumpSpec->iNumDumpLocs; i++)
{
if (pDumpSpec->pDumpLocations[i].DumpLocation == Location && // should dump at this pipeline location AND
(pDumpSpec->pDumpLocations[i].SurfType == pSurf->SurfType || // should dump for this surface type OR
pDumpSpec->pDumpLocations[i].SurfType == SURF_NONE)) // should dump for any surface type
{
VPHAL_DEBUG_CHK_STATUS(EnumToLocString(Location, m_dumpLoc));
if (!isDumpFromDecomp && pSurf->bIsCompressed)
{
EnumToLocString(Location, m_dumpLocInVp);
}
if (!isDumpFromDecomp || m_dumpLocInVp[0] == 0)
{
MOS_SecureStringPrint(m_dumpPrefix, MAX_PATH, MAX_PATH, "%s/surfdump_loc[%s]_lyr[%d]", pDumpSpec->pcOutputPath, m_dumpLoc, uiCounter);
}
else
{
MOS_SecureStringPrint(m_dumpPrefix, MAX_PATH, MAX_PATH, "%s/surfdump_loc[%s_%s]_lyr[%d]", pDumpSpec->pcOutputPath, m_dumpLocInVp, m_dumpLoc, uiCounter);
}
DumpSurfaceToFile(
m_osInterface,
pSurf,
m_dumpPrefix,
uiFrameNumber,
true,
isDumpFromDecomp,
nullptr);
break;
}
}
}
else if (VphalSurfDumpManualTrigger == VPHAL_DBG_SURF_DUMP_MANUAL_TRIGGER_STOPPED)
{
VPHAL_DEBUG_NORMALMESSAGE("Dump manaul trigger enabled, dump stopped: %d \n", VphalSurfDumpManualTrigger);
}
else
{
VPHAL_DEBUG_NORMALMESSAGE("Dump manaul trigger flag: %d \n", VphalSurfDumpManualTrigger);
}
}
else if (pDumpSpec->uiStartFrame <= uiFrameNumber &&
uiFrameNumber <= pDumpSpec->uiEndFrame)
{
for (i = 0; i < pDumpSpec->iNumDumpLocs; i++)
{
if (pDumpSpec->pDumpLocations[i].DumpLocation == Location && // should dump at this pipeline location AND
(pDumpSpec->pDumpLocations[i].SurfType == pSurf->SurfType || // should dump for this surface type OR
pDumpSpec->pDumpLocations[i].SurfType == SURF_NONE)) // should dump for any surface type
{
VPHAL_DEBUG_CHK_STATUS(EnumToLocString(Location, m_dumpLoc));
if (!isDumpFromDecomp && pSurf->bIsCompressed)
{
EnumToLocString(Location, m_dumpLocInVp);
}
if (!isDumpFromDecomp || m_dumpLocInVp[0] == 0)
{
MOS_SecureStringPrint(m_dumpPrefix, MAX_PATH, MAX_PATH, "%s/surfdump_loc[%s]_lyr[%d]",
pDumpSpec->pcOutputPath, m_dumpLoc, uiCounter);
}
else
{
MOS_SecureStringPrint(m_dumpPrefix, MAX_PATH, MAX_PATH, "%s/surfdump_loc[%s_%s]_lyr[%d]",
pDumpSpec->pcOutputPath, m_dumpLocInVp, m_dumpLoc, uiCounter);
}
DumpSurfaceToFile(
m_osInterface,
pSurf,
m_dumpPrefix,
uiFrameNumber,
true,
isDumpFromDecomp,
nullptr);
break;
}
}
}
else
{
VPHAL_DEBUG_VERBOSEMESSAGE("No surface dumpped, VphalSurfDumpManualTrigger: %d, uiStartFrame: %d, uiEndFrame: %d\n", VphalSurfDumpManualTrigger, pDumpSpec->uiStartFrame, pDumpSpec->uiEndFrame);
}
finish:
if (!isDumpFromDecomp)
{
m_frameNumInVp = 0xffffffff;
m_dumpLocInVp[0] = 0;
}
m_dumpSpec.enableAuxDump = orgDumpAuxEnable;
return eStatus;
}
MOS_STATUS VphalSurfaceDumper::DumpSurfaceArray(
PVPHAL_SURFACE *ppSurfaces,
uint32_t uiMaxSurfaces,
uint32_t uiNumSurfaces,
uint32_t uiFrameNumber,
uint32_t Location)
{
MOS_STATUS eStatus;
uint32_t uiIndex;
uint32_t uiLayer;
//---------------------------------------------------
VPHAL_DEBUG_ASSERT(ppSurfaces);
//---------------------------------------------------
eStatus = MOS_STATUS_SUCCESS;
for (uiIndex = 0, uiLayer = 0;
uiLayer < uiNumSurfaces && uiIndex < uiMaxSurfaces; uiIndex++)
{
if (ppSurfaces[uiIndex])
{
VPHAL_DEBUG_ASSERT(!Mos_ResourceIsNull(&ppSurfaces[uiIndex]->OsResource));
VPHAL_DEBUG_CHK_STATUS(DumpSurface(
ppSurfaces[uiIndex],
uiFrameNumber,
uiLayer,
Location));
uiLayer++;
}
}
finish:
return eStatus;
}
void VphalHwStateDumper::DumpGSH()
{
MOS_STATUS eStatus;
int32_t iIndex;
uint64_t uiPhase;
VPHAL_DBG_DUMP_SPEC* pDumpSpec;
VPHAL_DEBUG_STAGE Location;
char pcDumpPrefix[MAX_PATH];
char pcDumpLoc[MAX_PATH];
Location = (VPHAL_DEBUG_STAGE)iDebugStage;
uiPhase = iPhase;
pDumpSpec = &m_dumpSpec;
if ((pDumpSpec->pGSHDumpSpec == nullptr) ||
(pDumpSpec->pGSHDumpSpec->pDumpLocations == nullptr) ||
(pDumpSpec->pGSHDumpSpec->pDumpLocations->DumpStage == 0))
{
goto finish;
}
MOS_ZeroMemory(pcDumpPrefix, MAX_PATH);
MOS_ZeroMemory(pcDumpLoc, MAX_PATH);
if(pDumpSpec->uiStartFrame <= pDumpSpec->uiCurrentFrame &&
pDumpSpec->uiCurrentFrame <= pDumpSpec->uiEndFrame)
{
for (iIndex= 0; iIndex< pDumpSpec->pGSHDumpSpec->iNumDumpLocs; iIndex++)
{
if (pDumpSpec->pGSHDumpSpec->pDumpLocations[iIndex].DumpStage == Location)
{
VPHAL_DEBUG_CHK_STATUS(EnumToLocString(Location, pcDumpLoc));
MOS_SecureStringPrint(pcDumpPrefix, MAX_PATH, MAX_PATH, "%s/GSH_dump_loc[%s]_[%lld]",
pDumpSpec->pcOutputPath, pcDumpLoc, uiPhase);
DumpGshBinary(
pcDumpPrefix,
pDumpSpec->uiCurrentFrame);
break;
}
}
}
finish:
return;
}
void VphalHwStateDumper::DumpSSH()
{
MOS_STATUS eStatus;
int32_t iIndex;
uint64_t uiPhase;
VPHAL_DBG_DUMP_SPEC* pDumpSpec;
VPHAL_DEBUG_STAGE Location;
char pcDumpPrefix[MAX_PATH];
char pcDumpLoc[MAX_PATH];
Location = (VPHAL_DEBUG_STAGE)iDebugStage;
uiPhase = iPhase;
pDumpSpec = &m_dumpSpec;
if ((pDumpSpec->pSSHDumpSpec == nullptr) ||
(pDumpSpec->pSSHDumpSpec->pDumpLocations == nullptr) ||
(pDumpSpec->pSSHDumpSpec->pDumpLocations->DumpStage == 0))
{
goto finish;
}
MOS_ZeroMemory(pcDumpPrefix, MAX_PATH);
MOS_ZeroMemory(pcDumpLoc, MAX_PATH);
if(pDumpSpec->uiStartFrame <= pDumpSpec->uiCurrentFrame &&
pDumpSpec->uiCurrentFrame <= pDumpSpec->uiEndFrame)
{
for (iIndex= 0; iIndex< pDumpSpec->pSSHDumpSpec->iNumDumpLocs; iIndex++)
{
if (pDumpSpec->pSSHDumpSpec->pDumpLocations[iIndex].DumpStage == Location)
{
VPHAL_DEBUG_CHK_STATUS(EnumToLocString(Location, pcDumpLoc));
MOS_SecureStringPrint(pcDumpPrefix, MAX_PATH, MAX_PATH, "%s/SSH_dump_loc[%s]_[%lld]",
pDumpSpec->pcOutputPath, pcDumpLoc, uiPhase);
DumpSshBinary(
pcDumpPrefix,
pDumpSpec->uiCurrentFrame);
break;
}
}
}
finish:
return;
}
void VphalHwStateDumper::DumpBatchBuffer(
PMHW_BATCH_BUFFER pBatchBuffer)
{
MOS_STATUS eStatus;
int32_t iIndex;
uint64_t uiPhase;
VPHAL_DBG_DUMP_SPEC* pDumpSpec;
VPHAL_DEBUG_STAGE Location;
char pcDumpPrefix[MAX_PATH];
char pcDumpLoc[MAX_PATH];
Location = (VPHAL_DEBUG_STAGE)iDebugStage;
uiPhase = iPhase;
pDumpSpec = &m_dumpSpec;
if ((pDumpSpec->pBBDumpSpec == nullptr) ||
(pDumpSpec->pBBDumpSpec->pDumpLocations == nullptr) ||
(pDumpSpec->pBBDumpSpec->pDumpLocations->DumpStage == 0))
{
goto finish;
}
MOS_ZeroMemory(pcDumpPrefix, MAX_PATH);
MOS_ZeroMemory(pcDumpLoc, MAX_PATH);
if(pDumpSpec->uiStartFrame <= pDumpSpec->uiCurrentFrame &&
pDumpSpec->uiCurrentFrame <= pDumpSpec->uiEndFrame)
{
for (iIndex= 0; iIndex< pDumpSpec->pBBDumpSpec->iNumDumpLocs; iIndex++)
{
if (pDumpSpec->pBBDumpSpec->pDumpLocations[iIndex].DumpStage == Location)
{
VPHAL_DEBUG_CHK_STATUS(EnumToLocString(Location, pcDumpLoc));
MOS_SecureStringPrint(pcDumpPrefix, MAX_PATH, MAX_PATH, "%s/BB_dump_loc[%s]_[%lld]",
pDumpSpec->pcOutputPath, pcDumpLoc, uiPhase);
DumpBatchBufferBinary(
pBatchBuffer,
pcDumpPrefix,
pDumpSpec->uiCurrentFrame);
break;
}
}
}
finish:
return;
}
void VphalHwStateDumper::DumpCommandBuffer(
PMOS_COMMAND_BUFFER pCommandBuffer)
{
MOS_STATUS eStatus;
int32_t iIndex;
uint64_t uiPhase;
VPHAL_DBG_DUMP_SPEC* pDumpSpec;
VPHAL_DEBUG_STAGE Location;
char pcDumpPrefix[MAX_PATH];
char pcDumpLoc[MAX_PATH];
Location = (VPHAL_DEBUG_STAGE)iDebugStage;
uiPhase = iPhase;
pDumpSpec = &m_dumpSpec;
if ((pDumpSpec->pCBDumpSpec == nullptr) ||
(pDumpSpec->pCBDumpSpec->pDumpLocations == nullptr) ||
(pDumpSpec->pCBDumpSpec->pDumpLocations->DumpStage == 0))
{
goto finish;
}
MOS_ZeroMemory(pcDumpPrefix, MAX_PATH);
MOS_ZeroMemory(pcDumpLoc, MAX_PATH);
if(pDumpSpec->uiStartFrame <= pDumpSpec->uiCurrentFrame &&
pDumpSpec->uiCurrentFrame <= pDumpSpec->uiEndFrame)
{
for (iIndex= 0; iIndex< pDumpSpec->pCBDumpSpec->iNumDumpLocs; iIndex++)
{
if (pDumpSpec->pCBDumpSpec->pDumpLocations[iIndex].DumpStage == Location)
{
VPHAL_DEBUG_CHK_STATUS(EnumToLocString(Location, pcDumpLoc));
MOS_SecureStringPrint(pcDumpPrefix, MAX_PATH, MAX_PATH, "%s/CB_dump_loc[%s]_[%lld]",
pDumpSpec->pcOutputPath, pcDumpLoc, uiPhase);
DumpCommandBufferBinary(
pCommandBuffer,
pcDumpPrefix,
pDumpSpec->uiCurrentFrame);
break;
}
}
}
finish:
return;
}
void VphalHwStateDumper::DumpVeboxState(PVPHAL_VEBOX_STATE pVeboxState)
{
MOS_STATUS eStatus;
int32_t iIndex;
uint64_t uiPhase;
VPHAL_DBG_DUMP_SPEC* pDumpSpec;
VPHAL_DEBUG_STAGE Location;
PVPHAL_VEBOX_STATE pVeboxRndrState = (PVPHAL_VEBOX_STATE)pVeboxState;
char pcDumpPrefix[MAX_PATH];
char pcDumpLoc[MAX_PATH];
Location = (VPHAL_DEBUG_STAGE)iDebugStage;
uiPhase = iPhase;
pDumpSpec = &m_dumpSpec;
if ((pDumpSpec->pVeboxStateDumpSpec == nullptr) ||
(pDumpSpec->pVeboxStateDumpSpec->pDumpLocations == nullptr) ||
(pDumpSpec->pVeboxStateDumpSpec->pDumpLocations->DumpStage == 0))
{
goto finish;
}
MOS_ZeroMemory(pcDumpPrefix, MAX_PATH);
MOS_ZeroMemory(pcDumpLoc, MAX_PATH);
if(pDumpSpec->uiStartFrame <= pDumpSpec->uiCurrentFrame &&
pDumpSpec->uiCurrentFrame <= pDumpSpec->uiEndFrame)
{
for (iIndex= 0; iIndex< pDumpSpec->pVeboxStateDumpSpec->iNumDumpLocs; iIndex++)
{
if (pDumpSpec->pVeboxStateDumpSpec->pDumpLocations[iIndex].DumpStage == Location)
{
VPHAL_DEBUG_CHK_STATUS(EnumToLocString(Location, pcDumpLoc));
MOS_SecureStringPrint(pcDumpPrefix, MAX_PATH, MAX_PATH, "%s/VeboxState_dump_loc[%s]_",
pDumpSpec->pcOutputPath,pcDumpLoc);
DumpVeboxStateBinary(
pVeboxRndrState->m_pVeboxInterface,
pcDumpPrefix,
pDumpSpec->uiCurrentFrame);
break;
}
}
}
finish:
return;
}
void VphalHwStateDumper::DumpStatistics(
void* pVeboxState,
uint8_t* pStat0Base,
uint8_t* pStat1Base)
{
MOS_STATUS eStatus;
int32_t iIndex;
uint64_t uiPhase;
VPHAL_DBG_DUMP_SPEC* pDumpSpec;
VPHAL_DEBUG_STAGE Location;
char pcDumpPrefix[MAX_PATH];
char pcDumpLoc[MAX_PATH];
Location = (VPHAL_DEBUG_STAGE)iDebugStage;
uiPhase = iPhase;
pDumpSpec = &m_dumpSpec;
if ((pDumpSpec->pStatisticsDumpSpec == nullptr) ||
(pDumpSpec->pStatisticsDumpSpec->pDumpLocations == nullptr) ||
(pDumpSpec->pStatisticsDumpSpec->pDumpLocations->DumpStage == 0))
{
goto finish;
}
MOS_ZeroMemory(pcDumpPrefix, MAX_PATH);
MOS_ZeroMemory(pcDumpLoc, MAX_PATH);
if(pDumpSpec->uiStartFrame <= pDumpSpec->uiCurrentFrame &&
pDumpSpec->uiCurrentFrame <= pDumpSpec->uiEndFrame)
{
for (iIndex= 0; iIndex< pDumpSpec->pStatisticsDumpSpec->iNumDumpLocs; iIndex++)
{
if (pDumpSpec->pStatisticsDumpSpec->pDumpLocations[iIndex].DumpStage == Location)
{
VPHAL_DEBUG_CHK_STATUS(EnumToLocString(Location, pcDumpLoc));
MOS_SecureStringPrint(pcDumpPrefix, MAX_PATH, MAX_PATH, "%s/Statistics_dump_loc[%s]_",
pDumpSpec->pcOutputPath,pcDumpLoc);
DumpStatisticsBinary(
(PVPHAL_VEBOX_STATE)pVeboxState,
pStat0Base,
pStat1Base,
pcDumpPrefix,
pDumpSpec->uiCurrentFrame);
break;
}
}
}
finish:
return;
}
void VphalParameterDumper::GetParametersDumpSpec()
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MOS_USER_FEATURE_VALUE_DATA UserFeatureData;
bool bDumpEnabled;
char cStringData[MOS_USER_CONTROL_MAX_DATA_SIZE];
VPHAL_DBG_PARAMS_DUMP_SPEC *pDumpSpec = &m_dumpSpec;
pDumpSpec->uiStartFrame = 0xFFFFFFFF;
pDumpSpec->uiEndFrame = 0;
pDumpSpec->outFileLocation[0] = '\0';
cStringData[0] = '\0';
bDumpEnabled = false;
// Get start frame
// if start frame is not got assign a default value of 0
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_PARAM_DUMP_START_FRAME_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext));
pDumpSpec->uiStartFrame = UserFeatureData.u32Data;
// Get end frame
// if end frame is not got assign a default value of max
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_PARAM_DUMP_END_FRAME_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext));
pDumpSpec->uiEndFrame = UserFeatureData.u32Data;
// Get out file path
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
UserFeatureData.StringData.pStringData = cStringData;
UserFeatureData.StringData.uMaxSize = MOS_USER_CONTROL_MAX_DATA_SIZE;
UserFeatureData.StringData.uSize = 0; //set the default value. 0 is empty buffer.
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_PARAM_DUMP_OUTFILE_KEY_NAME_ID,
&UserFeatureData,
m_osInterface->pOsContext));
if (UserFeatureData.StringData.uSize > 0)
{
// Copy the Output path
MOS_SecureMemcpy(
pDumpSpec->outFileLocation,
MAX_PATH,
UserFeatureData.StringData.pStringData,
UserFeatureData.StringData.uSize);
bDumpEnabled = true;
}
#if !defined(LINUX) && !defined(ANDROID)
else
{
std::string vphalDumpFilePath;
// Use state separation APIs to obtain appropriate storage location
if (SUCCEEDED(GetDriverPersistentStorageLocation(vphalDumpFilePath)))
{
std::string m_outputFilePath;
MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
m_outputFilePath = vphalDumpFilePath.c_str();
m_outputFilePath.append(VPHAL_DBG_DUMP_OUTPUT_FOLDER);
// Copy the Output path
MOS_SecureMemcpy(
pDumpSpec->outFileLocation,
MAX_PATH,
m_outputFilePath.c_str(),
m_outputFilePath.size());
MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData));
userFeatureWriteData.Value.StringData.pStringData = cStringData;
userFeatureWriteData.Value.StringData.pStringData = const_cast<char *>(m_outputFilePath.c_str());
userFeatureWriteData.Value.StringData.uSize = m_outputFilePath.size();
userFeatureWriteData.ValueID = __VPHAL_DBG_DUMP_OUTPUT_DIRECTORY_ID;
MOS_UserFeature_WriteValues_ID(NULL, &userFeatureWriteData, 1, m_osInterface->pOsContext);
bDumpEnabled = true;
}
}
#endif
// Get enableSkuWaDump
MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
MOS_USER_FEATURE_INVALID_KEY_ASSERT(MOS_UserFeature_ReadValue_ID(
nullptr,
__VPHAL_DBG_PARA_DUMP_ENABLE_SKUWA_DUMP_ID,
&UserFeatureData,
m_osInterface->pOsContext));
pDumpSpec->enableSkuWaDump = UserFeatureData.u32Data;
if ((eStatus != MOS_STATUS_SUCCESS) || (!bDumpEnabled))
{
pDumpSpec->uiStartFrame = 1;
pDumpSpec->uiEndFrame = 0;
}
}
MOS_STATUS VphalParameterDumper::DumpSourceSurface(
uint32_t uiFrameCounter,
char *pcOutputPath,
PVPHAL_SURFACE pSrc,
uint32_t index,
char* &pcOutContents)
{
MOS_STATUS eStatus;
char sSurfaceFilePath[MAX_PATH] = { 0 }, sOsSurfaceFilePath[MAX_PATH] = { 0 };
eStatus = MOS_STATUS_SUCCESS;
//Color Information
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<!-- Color Information -->\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_CSPACE>%s</VPHAL_CSPACE>\n", GetColorSpaceStr(pSrc->ColorSpace)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<EXTENDED_GAMUT></EXTENDED_GAMUT>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<PALETTE_ALLOCATION>%d</PALETTE_ALLOCATION>\n", (pSrc->iPalette)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<PALETTE_DATA>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<PALETTE_DATA_TYPE>%s</PALETTE_DATA_TYPE>\n", GetPaletteTypeStr(pSrc->Palette.PaletteType)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<VPHAL_CSPACE>%s</VPHAL_CSPACE>\n", GetColorSpaceStr(pSrc->Palette.ColorSpace)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<HAS_ALPHA>%d</HAS_ALPHA>\n", pSrc->Palette.bHasAlpha ? 1 : 0));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<TOTAL_ENTRIES>%d</TOTAL_ENTRIES>\n", pSrc->Palette.iTotalEntries));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<NUM_ENTRIES>%d</NUM_ENTRIES>\n", pSrc->Palette.iNumEntries));
for (int nIndex = 0; nIndex < pSrc->Palette.iTotalEntries; nIndex++)
{
if (pSrc->Palette.pPalette8)
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<PVPHAL_COLOR_SAMPLE>%08x</PVPHAL_COLOR_SAMPLE>\n", pSrc->Palette.pPalette8[nIndex].dwValue));
}
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</PALETTE_DATA>\n"));
//Rendering parameters
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<!-- Rendering parameters -->\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_BLENDING_PARAMS>\n"));
if (pSrc->pBlendingParams)
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<VPHAL_BLEND_TYPE>%s</VPHAL_BLEND_TYPE>\n", GetBlendTypeStr(pSrc->pBlendingParams->BlendType)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ALPHA type=\"real\">%.3f</ALPHA>\n", pSrc->pBlendingParams->fAlpha));
}
else
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ALPHA type=\"real\"></ALPHA>\n"));
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</VPHAL_BLENDING_PARAMS>\n"));
//Luma key params
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_LUMAKEY_PARAMS>\n"));
if (pSrc->pLumaKeyParams)
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<LUMA_LOW>%d</LUMA_LOW>\n", pSrc->pLumaKeyParams->LumaLow));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<LUMA_HIGH>%d</LUMA_HIGH>\n", pSrc->pLumaKeyParams->LumaHigh));
}
else
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<LUMA_LOW></LUMA_LOW>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<LUMA_HIGH></LUMA_HIGH>\n"));
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</VPHAL_LUMAKEY_PARAMS>\n"));
//Propcamp params
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_PROCAMP_PARAMS>\n"));
if (pSrc->pProcampParams)
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLED>%d</ENABLED>\n", (pSrc->pProcampParams->bEnabled ? 1 : 0)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<BRIGHTNESS type=\"real\">%.3f</BRIGHTNESS>\n", pSrc->pProcampParams->fBrightness));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<CONTRAST type=\"real\">%.3f</CONTRAST>\n", pSrc->pProcampParams->fContrast));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<HUE type=\"real\">%.3f</HUE>\n", pSrc->pProcampParams->fHue));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<SATURATION type=\"real\">%.3f</SATURATION>\n", pSrc->pProcampParams->fSaturation));
}
else
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLED></ENABLED>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<BRIGHTNESS type=\"real\"></BRIGHTNESS>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<CONTRAST type=\"real\"></CONTRAST>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<HUE type=\"real\"></HUE>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<SATURATION type=\"real\"></SATURATION>\n"));
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</VPHAL_PROCAMP_PARAMS>\n"));
//IEF parameter
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_IEF_PARAMS>\n"));
if (pSrc->pIEFParams)
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<IEFFACTOR type = \"real\">%.3f</IEFFACTOR>\n", pSrc->pIEFParams->fIEFFactor));
}
else
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<IEFFACTOR type = \"real\"></IEFFACTOR>\n"));
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</VPHAL_IEF_PARAMS>\n"));
//Advanced processing
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<!-- Advanced processing -->\n"));
//DI
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_DI_PARAMS>\n"));
if (pSrc->pDeinterlaceParams)
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<DIMODE>%s</DIMODE>\n", GetDIModeStr(pSrc->pDeinterlaceParams->DIMode)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<ENABLE_FMD>%d</ENABLE_FMD>\n", (pSrc->pDeinterlaceParams->bEnableFMD ? 1 : 0)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<SINGLE_FIELD>%d</SINGLE_FIELD>\n", (pSrc->pDeinterlaceParams->bSingleField ? 1 : 0)));
}
else
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<DIMODE></DIMODE>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<ENABLE_FMD></ENABLE_FMD>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<SINGLE_FIELD></SINGLE_FIELD>\n"));
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</VPHAL_DI_PARAMS>\n"));
//Denoise
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_DENOISE_PARAMS>\n"));
if (pSrc->pDenoiseParams)
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLE_LUMA>%d</ENABLE_LUMA>\n", (pSrc->pDenoiseParams->bEnableLuma ? 1 : 0)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLE_CHROMA>%d</ENABLE_CHROMA>\n", (pSrc->pDenoiseParams->bEnableChroma ? 1 : 0)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<AUTO_DETECT>%d</AUTO_DETECT>\n", (pSrc->pDenoiseParams->bAutoDetect ? 1 : 0)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<DENOISE_FACTOR>%.3f</DENOISE_FACTOR>\n", (pSrc->pDenoiseParams->fDenoiseFactor)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<NOISE_LEVEL>%s</NOISE_LEVEL>\n", GetDenoiseModeStr(pSrc->pDenoiseParams->NoiseLevel)));
}
else
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLE_LUMA></ENABLE_LUMA>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLE_CHROMA></ENABLE_CHROMA>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<AUTO_DETECT></AUTO_DETECT>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<DENOISE_FACTOR></DENOISE_FACTOR>\n"));
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</VPHAL_DENOISE_PARAMS>\n"));
//ColorPipe
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_COLORPIPE_PARAMS>\n"));
if (pSrc->pColorPipeParams)
{
VPHAL_TCC_PARAMS TccParams = pSrc->pColorPipeParams->TccParams;
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLE_ACE>%d</ENABLE_ACE>\n", (pSrc->pColorPipeParams->bEnableACE ? 1 : 0)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLE_STE>%d</ENABLE_STE>\n", (pSrc->pColorPipeParams->bEnableSTE ? 1 : 0)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLE_TCC>%d</ENABLE_TCC>\n", (pSrc->pColorPipeParams->bEnableTCC ? 1 : 0)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ACE_LEVEL>%d</ACE_LEVEL>\n", (pSrc->pColorPipeParams->dwAceLevel)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ACE_STRENGHTH>%d</ACE_STRENGHTH>\n", (pSrc->pColorPipeParams->dwAceStrength)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<STE_PARAMS>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t\t<STE_FACTOR>%d</STE_FACTOR>\n", (pSrc->pColorPipeParams->SteParams.dwSTEFactor)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t</STE_PARAMS>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<TCC_PARAMS>%d,%d,%d,%d,%d,%d</TCC_PARAMS>\n", TccParams.Blue, TccParams.Cyan, TccParams.Green, TccParams.Magenta, TccParams.Red, TccParams.Yellow));
}
else
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLE_ACE></ENABLE_ACE>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLE_STE></ENABLE_STE>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ENABLE_TCC></ENABLE_TCC>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<ACE_LEVEL></ACE_LEVEL>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<STE_PARAMS></STE_PARAMS>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<TCC_PARAMS></TCC_PARAMS>\n"));
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</VPHAL_COLORPIPE_PARAMS>\n"));
//Gamut
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_GAMUT_PARAMS>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<GCOMP_MODE></GCOMP_MODE>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</VPHAL_GAMUT_PARAMS>\n"));
//Sample information
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<!-- Sample information -->\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_FORMAT>%s</VPHAL_FORMAT>\n", GetWholeFormatStr(pSrc->Format)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_SURFACE_TYPE>%s</VPHAL_SURFACE_TYPE>\n", GetSurfaceTypeStr(pSrc->SurfType)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_SAMPLE_TYPE>%s</VPHAL_SAMPLE_TYPE>\n", GetSampleTypeStr(pSrc->SampleType)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_SCALING_MODE>%s</VPHAL_SCALING_MODE>\n", GetScalingModeStr(pSrc->ScalingMode)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_ROTATION_MODE>%s</VPHAL_ROTATION_MODE>\n", GetRotationModeStr(pSrc->Rotation)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<RCSRC>%d,%d,%d,%d</RCSRC>\n", pSrc->rcSrc.left, pSrc->rcSrc.top, pSrc->rcSrc.right, pSrc->rcSrc.bottom));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<RCDST>%d,%d,%d,%d</RCDST>\n", pSrc->rcDst.left, pSrc->rcDst.top, pSrc->rcDst.right, pSrc->rcDst.bottom));
//Basic information
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<!-- Basic information -->\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_TILE_TYPE>%s</VPHAL_TILE_TYPE>\n", GetTileTypeStr(pSrc->TileType)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<WIDTH>%d</WIDTH>\n", pSrc->dwWidth));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<HEIGHT>%d</HEIGHT>\n", pSrc->dwHeight));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<PITCH>%d</PITCH>\n", pSrc->dwPitch));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<SIZE>%d</SIZE>\n", pSrc->dwPitch * pSrc->dwHeight));
//Surface content initialization
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<!-- Surface content initialization -->\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<DATA>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<DEFAULT_COLOR type=\"integer\">0x000000FF</DEFAULT_COLOR>\n"));
if (pcOutputPath)
{
memset(sSurfaceFilePath, 0, MAX_PATH);
memset(sOsSurfaceFilePath, 0, MAX_PATH);
MOS_SecureStringPrint(sSurfaceFilePath, MAX_PATH, MAX_PATH, "%s%csurfdump_loc[preALL]_lyr[%d]_f[%03d]_w[%d]_h[%d]_p[%d].%s",
pcOutputPath, MOS_DIR_SEPERATOR, index, uiFrameCounter, pSrc->dwWidth, pSrc->dwHeight, pSrc->dwPitch, VphalDumperTool::GetFormatStr(pSrc->Format));
VphalDumperTool::GetOsFilePath(sSurfaceFilePath, sOsSurfaceFilePath);
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<FILE>%s</FILE>\n", sOsSurfaceFilePath));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</DATA>\n"));
// get backward reference
if (pSrc->pBwdRef)
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<BACKREFDATA>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<DEFAULT_COLOR type=\"integer\">0x000000FF</DEFAULT_COLOR>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<Num>%d</Num>\n", pSrc->uBwdRefCount));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<FILE></FILE>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</BACKREFDATA>\n"));
}
// get forward reference
if (pSrc->pFwdRef)
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<FWDREFDATA>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<Num>%d</Num>\n", pSrc->uFwdRefCount));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</FWDREFDATA>\n"));
}
}
finish:
return eStatus;
}
MOS_STATUS VphalParameterDumper::DumpTargetSurface(
uint32_t uiFrameCounter,
char *pcOutputPath,
PVPHAL_SURFACE pTarget,
uint32_t index,
char* &pcOutContents)
{
MOS_STATUS eStatus;
eStatus = MOS_STATUS_SUCCESS;
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<VPHAL_FORMAT>%s</VPHAL_FORMAT>\n", VphalParameterDumper::GetWholeFormatStr(pTarget->Format)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<VPHAL_SURFACE_TYPE>%s</VPHAL_SURFACE_TYPE>\n", VphalParameterDumper::GetSurfaceTypeStr(pTarget->SurfType)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<VPHAL_SAMPLE_TYPE>%s</VPHAL_SAMPLE_TYPE>\n", GetSampleTypeStr(pTarget->SampleType)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<VPHAL_CSPACE>%s</VPHAL_CSPACE>\n", GetColorSpaceStr(pTarget->ColorSpace)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<VPHAL_SCALING_MODE>%s</VPHAL_SCALING_MODE>\n", GetScalingModeStr(pTarget->ScalingMode)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<VPHAL_TILE_TYPE>%s</VPHAL_TILE_TYPE>\n", GetTileTypeStr(pTarget->TileType)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<WIDTH>%d</WIDTH>\n", pTarget->dwWidth));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<HEIGHT>%d</HEIGHT>\n", pTarget->dwHeight));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<PITCH>%d</PITCH>\n", pTarget->dwPitch));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<SIZE>%d</SIZE>\n", pTarget->dwPitch*pTarget->dwHeight));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<RCSRC>%d,%d,%d,%d</RCSRC>\n", pTarget->rcSrc.left, pTarget->rcSrc.top, pTarget->rcSrc.right, pTarget->rcSrc.bottom));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<RCDST>%d,%d,%d,%d</RCDST>\n", pTarget->rcDst.left, pTarget->rcDst.top, pTarget->rcDst.right, pTarget->rcDst.bottom));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<DATA>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t\t<DEFAULT_COLOR type=\"integer\">0x000000FF</DEFAULT_COLOR>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t\t<FILE></FILE>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t</DATA>\n"));
finish:
return eStatus;
}
MOS_STATUS VphalParameterDumper::DumpRenderParameter(
uint32_t uiFrameCounter,
char *pcOutputPath,
PVPHAL_RENDER_PARAMS pRenderParams,
char* &pcOutContents)
{
MOS_STATUS eStatus;
eStatus = MOS_STATUS_SUCCESS;
if (pRenderParams->pTarget[0])
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_SURFACE_TARGET>\n"));
VPHAL_DEBUG_CHK_STATUS(DumpTargetSurface(
uiFrameCounter,
pcOutputPath,
pRenderParams->pTarget[0],
0,
pcOutContents));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</VPHAL_SURFACE_TARGET>\n"));
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<SRC_COUNT>%d</SRC_COUNT>\n", pRenderParams->uSrcCount));
//Color fill
if (pRenderParams->pColorFillParams)
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_COLORFILL_PARAMS>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<bYCbCr>%d</bYCbCr>\n", pRenderParams->pColorFillParams->bYCbCr));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<COLOR type=\"integer\">%08x</COLOR>\n", pRenderParams->pColorFillParams->Color));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t\t<CSPACE>%s</CSPACE>\n", GetColorSpaceStr(pRenderParams->pColorFillParams->CSpace)));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t</VPHAL_COLORFILL_PARAMS>\n"));
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t\t<VPHAL_COMPONENT>%s</VPHAL_COMPONENT>\n", GetComponentStr(pRenderParams->Component)));
finish:
return eStatus;
}
MOS_STATUS VphalParameterDumper::DumpToXML(
uint32_t uiFrameCounter,
char *pcOutputPath,
PVPHAL_RENDER_PARAMS pRenderParams)
{
char sPath[MAX_PATH] = { 0 }, sOsPath[MAX_PATH] = { 0 };
MOS_STATUS eStatus;
char* pcOutContents;
uint32_t dwStrLen = 0;
FILE *fpOutXML;
char* pCurFrameFileName;
char* pBwdFrameFileName;
VPHAL_DBG_PARAMS_DUMP_SPEC *pParamsDumpSpec = &m_dumpSpec;
eStatus = MOS_STATUS_SUCCESS;
dwStrLen = 0;
pcOutContents = nullptr;
fpOutXML = nullptr;
pCurFrameFileName = nullptr;
pBwdFrameFileName = nullptr;
VPHAL_DEBUG_CHK_NULL(pRenderParams);
VPHAL_DEBUG_CHK_NULL(pParamsDumpSpec);
if ((pParamsDumpSpec->uiEndFrame < pParamsDumpSpec->uiStartFrame) || strlen(pParamsDumpSpec->outFileLocation) == 0)
goto finish;
// Create a processing instruction element.
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(true, &pcOutContents, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\n"));
// Create the root element.
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "<VPHAL_SCENARIO>\n"));
// General infomation
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t<ID>%d</ID>\n", MOS_GetPid()));
VPHAL_DEBUG_CHK_NULL(pRenderParams->pSrc[0]);
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t<DESCRIPTION>%d</DESCRIPTION>\n", pRenderParams->pSrc[0]->FrameID));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t<!-- Number of frames to render -->\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t<FRAME_COUNT type = \"integer\">1</FRAME_COUNT>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t<!-- 60i or 30p BLT -->\n"));
if ((pRenderParams->uSrcCount > 0) &&
(pRenderParams->pSrc[0]->SampleType != SAMPLE_PROGRESSIVE))
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t<BLT_TYPE>60i</BLT_TYPE>\n"));
}
else
{
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t<BLT_TYPE>30p</BLT_TYPE>\n"));
}
// Surface
for (uint32_t i = 0; i < pRenderParams->uSrcCount; i++)
{
if (pRenderParams->pSrc[i] == nullptr)
continue;
//surface infomation
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t<!-- Input surface definitions -->\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t<VPHAL_SURFACE>\n"));
VPHAL_DEBUG_CHK_STATUS(DumpSourceSurface(
uiFrameCounter,
pcOutputPath,
pRenderParams->pSrc[i],
i,
pcOutContents));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t</VPHAL_SURFACE>\n"));
}
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t<!-- Rendering parameters -->\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t<VPHAL_RENDER_PARAMS>\n"));
VPHAL_DEBUG_CHK_STATUS(DumpRenderParameter(
uiFrameCounter,
pcOutputPath,
pRenderParams,
pcOutContents));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "\t</VPHAL_RENDER_PARAMS>\n"));
VPHAL_DEBUG_CHK_STATUS(VphalDumperTool::AppendString(false, &pcOutContents, "</VPHAL_SCENARIO>\n"));
MOS_SecureStringPrint(sPath, MAX_PATH, MAX_PATH, "%s%cparam_dump[%d].xml", pParamsDumpSpec->outFileLocation, MOS_DIR_SEPERATOR, uiFrameCounter);
VphalDumperTool::GetOsFilePath(sPath, sOsPath);
VPHAL_DEBUG_CHK_STATUS(MOS_WriteFileFromPtr(sOsPath, pcOutContents, strlen(pcOutContents)));
finish:
if (pcOutContents)
{
MOS_FreeMemory(pcOutContents);
pcOutContents = nullptr;
}
return eStatus;
}
VphalParameterDumper::~VphalParameterDumper()
{
}
const char * VphalDumperTool::GetFormatStr(MOS_FORMAT format)
{
switch (format)
{
case Format_A8R8G8B8 : return _T("argb");
case Format_X8R8G8B8 : return _T("xrgb");
case Format_A8B8G8R8 : return _T("abgr");
case Format_X8B8G8R8 : return _T("xbgr");
case Format_A16R16G16B16: return _T("argb16");
case Format_A16B16G16R16: return _T("abgr16");
case Format_R5G6B5 : return _T("rgb16");
case Format_R8G8B8 : return _T("rgb24");
case Format_R32U : return _T("r32u");
case Format_RGBP : return _T("rgbp");
case Format_BGRP : return _T("bgrp");
case Format_R32F : return _T("r32f");
case Format_YUY2 : return _T("yuy2");
case Format_YUYV : return _T("yuyv");
case Format_YVYU : return _T("yvyu");
case Format_UYVY : return _T("uyvy");
case Format_VYUY : return _T("vyuy");
case Format_Y416 : return _T("y416");
case Format_AYUV : return _T("ayuv");
case Format_AUYV : return _T("auyv");
case Format_NV12 : return _T("nv12");
case Format_NV11 : return _T("nv11");
case Format_P208 : return _T("p208");
case Format_IMC1 : return _T("imc1");
case Format_IMC2 : return _T("imc2");
case Format_IMC3 : return _T("imc3");
case Format_IMC4 : return _T("imc4");
case Format_422H : return _T("422h");
case Format_422V : return _T("422v");
case Format_444P : return _T("444p");
case Format_411P : return _T("411p");
case Format_411R : return _T("411r");
case Format_400P : return _T("400p");
case Format_I420 : return _T("i420");
case Format_IYUV : return _T("iyuv");
case Format_YV12 : return _T("yv12");
case Format_YVU9 : return _T("yvu9");
case Format_AI44 : return _T("ai44");
case Format_IA44 : return _T("ia44");
case Format_P8 : return _T("P8");
case Format_STMM : return _T("stmm");
case Format_Buffer : return _T("buff");
case Format_RAW : return _T("buff");
case Format_PAL : return _T("pal");
case Format_A8P8 : return _T("a8p8");
case Format_A8 : return _T("a8");
case Format_L8 : return _T("l8");
case Format_A4L4 : return _T("a4l4");
case Format_A8L8 : return _T("a8l8");
case Format_V8U8 : return _T("v8u8");
case Format_IRW0 : return _T("irw0");
case Format_IRW1 : return _T("irw1");
case Format_IRW2 : return _T("irw2");
case Format_IRW3 : return _T("irw3");
case Format_R10G10B10A2 : return _T("r10g10b10a2");
case Format_B10G10R10A2 : return _T("b10g10r10a2");
case Format_P010 : return _T("p010");
case Format_P016 : return _T("p016");
case Format_R16F : return _T("r16f");
case Format_Y210 : return _T("y210");
case Format_Y216 : return _T("y216");
case Format_Y410 : return _T("y410");
case Format_P210 : return _T("p210");
case Format_P216 : return _T("p216");
default : return _T("Err");
}
return nullptr;
}
MOS_STATUS VphalDumperTool::GetSurfaceSize(
PVPHAL_SURFACE pSurface,
uint32_t iBpp,
uint32_t* piWidthInBytes,
uint32_t* piHeightInRows)
{
MOS_STATUS eStatus;
uint32_t iWidthInBytes;
uint32_t iHeightInRows;
//-------------------------------------------
VPHAL_DEBUG_ASSERT(pSurface->dwWidth >= 1);
VPHAL_DEBUG_ASSERT(pSurface->dwHeight >= 1);
VPHAL_DEBUG_ASSERT(pSurface->dwPitch >= 1);
//-------------------------------------------
eStatus = MOS_STATUS_SUCCESS;
switch (pSurface->Format)
{
// Packed Formats
case Format_A8R8G8B8:
case Format_X8R8G8B8:
case Format_A8B8G8R8:
case Format_X8B8G8R8:
case Format_R5G6B5:
case Format_R8G8B8:
case Format_R32U:
case Format_R32F:
case Format_AYUV:
case Format_YUY2:
case Format_YUYV:
case Format_YVYU:
case Format_UYVY:
case Format_VYUY:
case Format_AI44:
case Format_IA44:
case Format_P8:
case Format_A8P8:
case Format_A8:
case Format_L8:
case Format_A4L4:
case Format_A8L8:
case Format_V8U8:
case Format_R10G10B10A2:
case Format_B10G10R10A2:
case Format_Y210:
case Format_Y216:
case Format_Y410:
case Format_Y416:
iWidthInBytes = pSurface->dwWidth * iBpp / 8;
iHeightInRows = pSurface->dwHeight;
break;
// 4:2:0 (12-bits per pixel)
// IMC1 // IMC3
// -----------------> // ----------------->
// ________________________ // ________________________
//|Y0|Y1| | //|Y0|Y1| |
//|__|__| | //|__|__| |
//| | //| |
//| | //| |
//| | //| |
//| | //| |
//| | //| |
//|________________________| //|________________________|
//|V0|V1| | | //|U0|U1| | |
//|__|__| | | //|__|__| | |
//| | | //| | |
//|____________| PAD | //|____________| PAD |
//|U0|U1| | | //|V0|V1| | |
//|__|__| | | //|__|__| | |
//| | | //| | |
//|____________|___________| //|____________|___________|
case Format_IMC1:
case Format_IMC3:
iWidthInBytes = pSurface->dwWidth;
iHeightInRows = pSurface->dwHeight * 2;
break;
// 4:0:0 (8-bits per pixel)
// 400P
// ----------------->
// ________________________
//|Y0|Y1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
case Format_400P:
case Format_Buffer:
case Format_RAW:
iWidthInBytes = pSurface->dwWidth;
iHeightInRows = pSurface->dwHeight;
break;
// 4:1:1 (12-bits per pixel) // 4:2:2 (16-bits per pixel)
// 411P // 422H
// -----------------> // ----------------->
// ________________________ // ________________________
//|Y0|Y1| | //|Y0|Y1| |
//|__|__| | //|__|__| |
//| | //| |
//| | //| |
//| | //| |
//| | //| |
//| | //| |
//|________________________| //|________________________|
//|U0|U1|| | //|U0|U1| | |
//|__|__|| | //|__|__| | |
//| | | //| | |
//| | PAD | //| | PAD |
//| | | //| | |
//| | | //| | |
//| | | //| | |
//|______|_________________| //|____________|___________|
//|V0|V1|| | //|V0|V1| | |
//|__|__|| | //|__|__| | |
//| | | //| | |
//| | PAD | //| | PAD |
//| | | //| | |
//| | | //| | |
//| | | //| | |
//|______|_________________| //|____________|___________|
// 4:4:4 (24-bits per pixel)
// 444P
// ----------------->
// ________________________
//|Y0|Y1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
//|U0|U1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
//|V0|V1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
// 4:4:4 (24-bits per pixel)
// RGBP
// ----------------->
// ________________________
//|R0|R1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
//|G0|G1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
//|B0|B1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
case Format_RGBP:
// 4:4:4 (24-bits per pixel)
// BGRP
// ----------------->
// ________________________
//|B0|B1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
//|G0|G1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
//|R0|R1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
case Format_BGRP:
case Format_411P:
case Format_422H:
case Format_444P:
iWidthInBytes = pSurface->dwWidth;
iHeightInRows = pSurface->dwHeight * 3;
break;
// 4:1:1 (12-bits per pixel)
// 411R
// ----------------->
// ________________________
//|Y0|Y1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
//|U0|U1| |
//|__|__| |
//|________________________|
//|V0|V1| |
//|__|__| |
//|________________________|
case Format_411R:
iWidthInBytes = pSurface->dwWidth;
iHeightInRows = (pSurface->dwHeight * 3) / 2;
break;
// 4:2:2V (16-bits per pixel)
// 422V
// ----------------->
// ________________________
//|Y0|Y1| |
//|__|__| |
//| |
//| |
//| |
//| |
//| |
//|________________________|
//|U0|U1| |
//|__|__| |
//| |
//|________________________|
//|V0|V1| |
//|__|__| |
//| |
//|________________________|
case Format_422V:
iWidthInBytes = pSurface->dwWidth;
iHeightInRows = pSurface->dwHeight * 2;
break;
// 4:2:0 (12-bits per pixel)
// IMC2 // IMC4
// -----------------> // ----------------->
// ________________________ // ________________________
//|Y0|Y1| | //|Y0|Y1| |
//|__|__| | //|__|__| |
//| | //| |
//| | //| |
//| | //| |
//| | //| |
//| | //| |
//|________________________| //|________________________|
//|V0|V1| |U0|U1| | //|U0|U1| |V0|V1| |
//|__|__| |__|__| | //|__|__| |__|__| |
//| | | //| | |
//|____________|___________| //|____________|___________|
// NV12 // YV12
// -----------------> // ----------------->
// ________________________ // ________________________
//|Y0|Y1| | //|Y0|Y1| |
//|__|__| | //|__|__| |
//| | //| |
//| | //| |
//| | //| |
//| | //| |
//| | //| |
//|________________________| //|________________________|
//|U0|V0|U1|V1| | //|V0|V1| |
//|__|__|__|__| | //|__|__|__________________|
//| | //|U0|U1| |
//|________________________| //|__|__|__________________|
case Format_IMC2:
case Format_IMC4:
case Format_NV12:
case Format_YV12:
case Format_I420:
case Format_IYUV:
case Format_YVU9:
iWidthInBytes = pSurface->dwWidth;
iHeightInRows = pSurface->dwHeight * iBpp / 8;
break;
case Format_P010:
case Format_P016:
iWidthInBytes = pSurface->dwWidth * 2;
iHeightInRows = pSurface->dwHeight * 3 / 2;
break;
case Format_A16R16G16B16:
case Format_A16B16G16R16:
iWidthInBytes = pSurface->dwWidth * 8;
iHeightInRows = pSurface->dwHeight;
break;
case Format_P210:
case Format_P216:
iWidthInBytes = pSurface->dwWidth * 2;
iHeightInRows = pSurface->dwHeight * 2;
default:
VPHAL_DEBUG_ASSERTMESSAGE("Format %d not supported.", pSurface->Format);
eStatus = MOS_STATUS_UNKNOWN;
goto finish;
}
*piWidthInBytes = iWidthInBytes;
*piHeightInRows = iHeightInRows;
finish:
return eStatus;
}
MOS_STATUS VphalDumperTool::AppendString(
bool bFirst,
char* *ppcBigString,
PCCHAR pcToAppendFmt,
...)
{
static size_t stTotalStrLen = 0;
static size_t stTotalAlloc = 0;
MOS_STATUS eStatus;
size_t stStrLenOld;
size_t stStrLenToAppend;
char* pcToAppend;
char* pcTmpPtr;
va_list argList;
eStatus = MOS_STATUS_SUCCESS;
stStrLenToAppend = 0;
stStrLenOld = 0;
pcTmpPtr = nullptr;
pcToAppend = (char*)MOS_AllocAndZeroMemory(sizeof(char) * ALLOC_GRANULARITY);
if (bFirst)
{
stTotalStrLen = 0;
stTotalAlloc = 0;
}
stStrLenOld = stTotalStrLen;
if (ppcBigString == nullptr || pcToAppendFmt == nullptr || (int)strlen(pcToAppendFmt) < 0)
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
goto finish;
}
va_start(argList, pcToAppendFmt);
MOS_SecureVStringPrint(pcToAppend, ALLOC_GRANULARITY, ALLOC_GRANULARITY, pcToAppendFmt, argList);
va_end(argList);
stStrLenToAppend = strlen(pcToAppend);
if (*ppcBigString == nullptr)
{
stTotalStrLen = stStrLenToAppend + 1;
stTotalAlloc = MOS_ALIGN_CEIL(stStrLenToAppend, ALLOC_GRANULARITY);
*ppcBigString = (char*)MOS_AllocAndZeroMemory(stTotalAlloc);
VPHAL_DEBUG_CHK_NULL(*ppcBigString);
*ppcBigString[0] = '\0';
stStrLenOld++;
}
else
{
stTotalStrLen += stStrLenToAppend;
if (stTotalStrLen >= stTotalAlloc)
{
stTotalAlloc = MOS_ALIGN_CEIL(stTotalStrLen, ALLOC_GRANULARITY);
// Below should be equivalent to *ppcBigString = (char*)realloc(*ppcBigString, stTotalAlloc);
pcTmpPtr = *ppcBigString;
*ppcBigString = (char*)MOS_AllocAndZeroMemory(stTotalAlloc);
VPHAL_DEBUG_CHK_NULL(*ppcBigString);
MOS_SecureStringPrint(*ppcBigString, stTotalAlloc, stTotalAlloc, "%s", pcTmpPtr);
MOS_FreeMemory(pcTmpPtr);
}
}
MOS_SecureMemcpy(
(char*)(((uintptr_t)(*ppcBigString)) + stStrLenOld - 1),
stStrLenToAppend + 1,
pcToAppend,
stStrLenToAppend + 1);
finish:
MOS_FreeMemory(pcToAppend);
return eStatus;
}
void VphalDumperTool::WriteFrame(
PMOS_INTERFACE pOsInterface,
PVPHAL_SURFACE pSurface,
PCCHAR fileName,
uint64_t iCounter)
{
uint8_t* pData;
char sPath[MAX_PATH];
char sOsPath[MAX_PATH];
uint8_t* pDst;
uint8_t* pTmpDst;
uint8_t* pTmpSrc;
uint32_t iWidthInBytes;
uint32_t iHeightInRows;
uint32_t iBpp;
uint32_t iSize;
uint32_t iY;
MOS_LOCK_PARAMS LockFlags;
pDst = nullptr;
MOS_ZeroMemory(sPath, MAX_PATH);
MOS_ZeroMemory(sOsPath, MAX_PATH);
// get bits per pixel for the format
pOsInterface->pfnGetBitsPerPixel(pOsInterface, pSurface->Format, &iBpp);
VphalDumperTool::GetSurfaceSize(
pSurface,
iBpp,
&iWidthInBytes,
&iHeightInRows);
iSize = iWidthInBytes * iHeightInRows;
// Write original image to file
MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
LockFlags.ReadOnly = 1;
pData = (uint8_t*)pOsInterface->pfnLockResource(
pOsInterface,
&pSurface->OsResource,
&LockFlags);
MOS_SecureStringPrint(
sPath,
MAX_PATH,
sizeof(sPath),
"c:\\dump\\f[%08I64x]_%s_w[%d]_h[%d]_p[%d].%s",
iCounter,
fileName,
pSurface->dwWidth,
pSurface->dwHeight,
pSurface->dwPitch,
VphalDumperTool::GetFormatStr(pSurface->Format));
MOS_SecureMemcpy(sOsPath, MAX_PATH, sPath, strlen(sPath));
// Write the data to file
if (pSurface->dwPitch == iWidthInBytes)
{
MOS_WriteFileFromPtr((const char *)sOsPath, pData, iSize);
}
else
{
pDst = (uint8_t*)MOS_AllocAndZeroMemory(iSize);
pTmpSrc = pData;
pTmpDst = pDst;
for (iY = 0; iY < iHeightInRows; iY++)
{
MOS_SecureMemcpy(pTmpDst, iSize, pTmpSrc, iWidthInBytes);
pTmpSrc += pSurface->dwPitch;
pTmpDst += iWidthInBytes;
}
MOS_WriteFileFromPtr((const char *)sOsPath, pDst, iSize);
}
if (pDst)
{
MOS_FreeMemory(pDst);
}
pOsInterface->pfnUnlockResource(
pOsInterface,
&pSurface->OsResource);
}
const char * VphalParameterDumper::GetComponentStr(MOS_COMPONENT component)
{
switch (component)
{
case COMPONENT_UNKNOWN: return _T("COMPONENT_UNKNOWN");
case COMPONENT_LibVA: return _T("COMPONENT_LibVA");
case COMPONENT_VPreP: return _T("COMPONENT_VPreP");
case COMPONENT_EMULATION: return _T("COMPONENT_EMULATION");
case COMPONENT_CM: return _T("COMPONENT_CM");
case COMPONENT_Encode: return _T("COMPONENT_Encode");
case COMPONENT_Decode: return _T("COMPONENT_Decode");
default: return _T("Err");
}
return nullptr;
}
const char * VphalParameterDumper::GetWholeFormatStr(MOS_FORMAT format)
{
switch (format)
{
case Format_Invalid: return _T("Format_Invalid");
case Format_Source: return _T("Format_Source");
case Format_420O: return _T("Format_420O");
case Format_RGB_Swap: return _T("Format_RGB_Swap");
case Format_RGB_No_Swap: return _T("Format_RGB_No_Swap");
case Format_RGB: return _T("Format_RGB");
case Format_RGB32: return _T("Format_RGB32");
case Format_PA: return _T("Format_PA");
case Format_PL2: return _T("Format_PL2");
case Format_PL2_UnAligned: return _T("Format_PL2_UnAligned");
case Format_PL3: return _T("Format_PL3");
case Format_PL3_RGB: return _T("Format_PL3_RGB");
case Format_PAL: return _T("Format_PA_T(");
case Format_None: return _T("Format_None");
case Format_Any: return _T("Format_Any");
case Format_A8R8G8B8: return _T("Format_A8R8G8B8");
case Format_X8R8G8B8: return _T("Format_X8R8G8B8");
case Format_A8B8G8R8: return _T("Format_A8B8G8R8");
case Format_X8B8G8R8: return _T("Format_X8B8G8R8");
case Format_A16B16G16R16: return _T("Format_A16B16G16R16");
case Format_A16R16G16B16: return _T("Format_A16R16G16B16");
case Format_R5G6B5: return _T("Format_R5G6B5");
case Format_R8G8B8: return _T("Format_R8G8B8");
case Format_R32U: return _T("Format_R32U");
case Format_R32F: return _T("Format_R32F");
case Format_RGBP: return _T("Format_RGBP");
case Format_BGRP: return _T("Format_BGRP");
case Format_YUY2: return _T("Format_YUY2");
case Format_YUYV: return _T("Format_YUYV");
case Format_YVYU: return _T("Format_YVYU");
case Format_UYVY: return _T("Format_UYVY");
case Format_VYUY: return _T("Format_VYUY");
case Format_Y416: return _T("Format_Y416");
case Format_AYUV: return _T("Format_AYUV");
case Format_AUYV: return _T("Format_AUYV");
case Format_400P: return _T("Format_400P");
case Format_NV12: return _T("Format_NV12");
case Format_NV12_UnAligned: return _T("Format_NV12_UnAligned");
case Format_NV21: return _T("Format_NV21");
case Format_NV11: return _T("Format_NV11");
case Format_NV11_UnAligned: return _T("Format_NV11_UnAligned");
case Format_P208: return _T("Format_P208");
case Format_P208_UnAligned: return _T("Format_P208_UnAligned");
case Format_IMC1: return _T("Format_IMC1");
case Format_IMC2: return _T("Format_IMC2");
case Format_IMC3: return _T("Format_IMC3");
case Format_IMC4: return _T("Format_IMC4");
case Format_422H: return _T("Format_422H");
case Format_422V: return _T("Format_422V");
case Format_444P: return _T("Format_444P");
case Format_411P: return _T("Format_411P");
case Format_411R: return _T("Format_411R");
case Format_I420: return _T("Format_I420");
case Format_IYUV: return _T("Format_IYUV");
case Format_YV12: return _T("Format_YV12");
case Format_YVU9: return _T("Format_YVU9");
case Format_AI44: return _T("Format_AI44");
case Format_IA44: return _T("Format_IA44");
case Format_P8: return _T("Format_P8");
case Format_A8P8: return _T("Format_A8P8");
case Format_A8: return _T("Format_A8");
case Format_L8: return _T("Format_L8");
case Format_A4L4: return _T("Format_A4L4");
case Format_A8L8: return _T("Format_A8L8");
case Format_IRW0: return _T("Format_IRW0");
case Format_IRW1: return _T("Format_IRW1");
case Format_IRW2: return _T("Format_IRW2");
case Format_IRW3: return _T("Format_IRW3");
case Format_IRW4: return _T("Format_IRW4");
case Format_IRW5: return _T("Format_IRW5");
case Format_IRW6: return _T("Format_IRW6");
case Format_IRW7: return _T("Format_IRW7");
case Format_STMM: return _T("Format_STMM");
case Format_Buffer: return _T("Format_Buffer");
case Format_Buffer_2D: return _T("Format_Buffer_2D");
case Format_V8U8: return _T("Format_V8U8");
case Format_R32S: return _T("Format_R32S");
case Format_R8U: return _T("Format_R8U");
case Format_R8G8UN: return _T("Format_R8G8UN");
case Format_R8G8SN: return _T("Format_R8G8SN");
case Format_G8R8_G8B8: return _T("Format_G8R8_G8B8");
case Format_R16U: return _T("Format_R16U");
case Format_R16S: return _T("Format_R16S");
case Format_R16UN: return _T("Format_R16UN");
case Format_RAW: return _T("Format_RAW");
case Format_Y8: return _T("Format_Y8");
case Format_Y1: return _T("Format_Y1");
case Format_Y16U: return _T("Format_Y16U");
case Format_Y16S: return _T("Format_Y16S");
case Format_L16: return _T("Format_L16");
case Format_D16: return _T("Format_D16");
case Format_R10G10B10A2: return _T("Format_R10G10B10A2");
case Format_B10G10R10A2: return _T("Format_B10G10R10A2");
case Format_P016: return _T("Format_P016");
case Format_P010: return _T("Format_P010");
case Format_Y210: return _T("Format_Y210");
case Format_Y216: return _T("Fomrat_Y216");
case Format_Y410: return _T("Format_Y410");
case Format_YV12_Planar: return _T("Format_YV12_Planar");
case Format_P210: return _T("Format_P210");
case Format_P216: return _T("Format_P216");
case Format_Count: return _T("Format_Count");
default: return _T("Err");
}
return nullptr;
}
const char * VphalParameterDumper::GetTileTypeStr(MOS_TILE_TYPE tile_type)
{
switch (tile_type)
{
case MOS_TILE_X: return _T("MOS_TILE_X");
case MOS_TILE_Y: return _T("MOS_TILE_Y");
case MOS_TILE_LINEAR: return _T("MOS_TILE_LINEAR");
case MOS_TILE_INVALID: return _T("MOS_TILE_INVALID");
default: return _T("Err");
}
return nullptr;
}
const char * VphalParameterDumper::GetSurfaceTypeStr(VPHAL_SURFACE_TYPE surface_type)
{
switch (surface_type)
{
case SURF_NONE: return _T("SURF_NONE");
case SURF_IN_BACKGROUND: return _T("SURF_IN_BACKGROUND");
case SURF_IN_PRIMARY: return _T("SURF_IN_PRIMARY");
case SURF_IN_SUBSTREAM: return _T("SURF_IN_SUBSTREAM");
case SURF_IN_REFERENCE: return _T("SURF_IN_REFERENCE");
case SURF_OUT_RENDERTARGET: return _T("SURF_OUT_RENDERTARGET");
case SURF_TYPE_COUNT: return _T("SURF_TYPE_COUNT");
default: return _T("Err");
}
return nullptr;
}
const char * VphalParameterDumper::GetSampleTypeStr(VPHAL_SAMPLE_TYPE sample_type)
{
switch (sample_type)
{
case SAMPLE_PROGRESSIVE: return _T("SAMPLE_PROGRESSIVE");
case SAMPLE_SINGLE_TOP_FIELD: return _T("SAMPLE_SINGLE_TOP_FIELD");
case SAMPLE_SINGLE_BOTTOM_FIELD: return _T("SAMPLE_SINGLE_BOTTOM_FIELD");
case SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD: return _T("SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD");
case SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD: return _T("SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD");
case SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD: return _T("SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD");
case SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD: return _T("SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD");
case SAMPLE_INVALID: return _T("SAMPLE_INVALID");
default: return _T("Err");
}
return nullptr;
}
const char * VphalParameterDumper::GetColorSpaceStr(VPHAL_CSPACE color_space)
{
switch (color_space)
{
case CSpace_None: return _T("CSpace_None");
case CSpace_Source: return _T("CSpace_Source");
case CSpace_RGB: return _T("CSpace_RGB");
case CSpace_YUV: return _T("CSpace_YUV");
case CSpace_Gray: return _T("CSpace_Gray");
case CSpace_Any: return _T("CSpace_Any");
case CSpace_sRGB: return _T("CSpace_sRGB");
case CSpace_stRGB: return _T("CSpace_stRGB");
case CSpace_BT601: return _T("CSpace_BT601");
case CSpace_BT601_FullRange: return _T("CSpace_BT601_FullRange");
case CSpace_BT709: return _T("CSpace_BT709");
case CSpace_BT709_FullRange: return _T("CSpace_BT709_FullRange");
case CSpace_xvYCC601: return _T("CSpace_xvYCC601");
case CSpace_xvYCC709: return _T("CSpace_xvYCC709");
case CSpace_BT601Gray: return _T("CSpace_BT601Gray");
case CSpace_BT601Gray_FullRange: return _T("CSpace_BT601Gray_FullRange");
case CSpace_BT2020: return _T("CSpace_BT2020");
case CSpace_BT2020_FullRange: return _T("CSpace_BT2020_FullRange");
case CSpace_BT2020_RGB: return _T("CSpace_BT2020_RGB");
case CSpace_BT2020_stRGB: return _T("CSpace_BT2020_stRGB");
case CSpace_Count: return _T("CSpace_Count");
default: return _T("Err");
}
return nullptr;
}
const char * VphalParameterDumper::GetBlendTypeStr(VPHAL_BLEND_TYPE blend_type)
{
switch (blend_type)
{
case BLEND_NONE: return _T("BLEND_NONE");
case BLEND_SOURCE: return _T("BLEND_SOURCE");
case BLEND_PARTIAL: return _T("BLEND_PARTIAL");
case BLEND_CONSTANT: return _T("BLEND_CONSTANT");
case BLEND_CONSTANT_SOURCE: return _T("BLEND_CONSTANT_SOURCE");
case BLEND_CONSTANT_PARTIAL: return _T("BLEND_CONSTANT_PARTIAL");
default: return _T("Err");
}
return nullptr;
}
const char * VphalParameterDumper::GetPaletteTypeStr(VPHAL_PALETTE_TYPE palette_type)
{
switch (palette_type)
{
case VPHAL_PALETTE_NONE: return _T("VPHAL_PALETTE_NONE");
case VPHAL_PALETTE_YCbCr_8: return _T("VPHAL_PALETTE_YCbCr_8");
case VPHAL_PALETTE_ARGB_8: return _T("VPHAL_PALETTE_ARGB_8");
case VPHAL_PALETTE_AVYU_8: return _T("VPHAL_PALETTE_AVYU_8");
default: return _T("Err");
}
return nullptr;
}
const char * VphalParameterDumper::GetScalingModeStr(VPHAL_SCALING_MODE scaling_mode)
{
switch (scaling_mode)
{
case VPHAL_SCALING_NEAREST: return _T("VPHAL_SCALING_NEAREST");
case VPHAL_SCALING_BILINEAR: return _T("VPHAL_SCALING_BILINEAR");
case VPHAL_SCALING_AVS: return _T("VPHAL_SCALING_AVS");
default: return _T("Err");
}
return nullptr;
}
const char * VphalParameterDumper::GetRotationModeStr(VPHAL_ROTATION rotation_mode)
{
switch (rotation_mode)
{
case VPHAL_ROTATION_IDENTITY: return _T("VPHAL_ROTATION_IDENTITY");
case VPHAL_ROTATION_90: return _T("VPHAL_ROTATION_90");
case VPHAL_ROTATION_180: return _T("VPHAL_ROTATION_180");
case VPHAL_ROTATION_270: return _T("VPHAL_ROTATION_270");
case VPHAL_MIRROR_HORIZONTAL: return _T("VPHAL_MIRROR_HORIZONTAL");
case VPHAL_MIRROR_VERTICAL: return _T("VPHAL_MIRROR_VERTICAL");
case VPHAL_ROTATE_90_MIRROR_VERTICAL: return _T("VPHAL_ROTATE_90_MIRROR_VERTICAL");
case VPHAL_ROTATE_90_MIRROR_HORIZONTAL: return _T("VPHAL_ROTATE_90_MIRROR_HORIZONTAL");
default: return _T("Err");
}
return nullptr;
}
const char * VphalParameterDumper::GetDIModeStr(VPHAL_DI_MODE di_mode)
{
switch (di_mode)
{
case DI_MODE_BOB: return _T("DI_MODE_BOB");
case DI_MODE_ADI: return _T("DI_MODE_ADI");
default: return _T("Err");
}
return nullptr;
}
const char * VphalParameterDumper::GetDenoiseModeStr(VPHAL_NOISELEVEL noise_level)
{
switch (noise_level)
{
case NOISELEVEL_DEFAULT: return _T("NOISELEVEL_DEFAULT");
case NOISELEVEL_VC1_HD: return _T("NOISELEVEL_VC1_HD");
default: return _T("Err");
}
return nullptr;
}
char *VphalParameterDumper::GetDumpSpecLocation()
{
return m_dumpSpec.outFileLocation;
}
bool VphalParameterDumper::GetDumpSpecSkuWaDumpEnable()
{
return m_dumpSpec.enableSkuWaDump;
}
#endif // (_DEBUG || _RELEASE_INTERNAL)