1 /* 2 * Copyright (c) 2018-2023, Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included 12 * in all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 */ 22 #ifndef __VP_UTILS_H__ 23 #define __VP_UTILS_H__ 24 25 #include "mos_util_debug.h" 26 #include "vp_common.h" 27 28 using MosFormatArray = std::vector<MOS_FORMAT>; 29 30 #define VP_UNUSED(param) (void)(param) 31 //------------------------------------------------------------------------------ 32 // Macros specific to MOS_VP_SUBCOMP_ENCODE sub-comp 33 //------------------------------------------------------------------------------ 34 #define VP_HW_ASSERT(_expr) \ 35 MOS_ASSERT(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_HW, _expr) 36 37 #define VP_HW_ASSERTMESSAGE(_message, ...) \ 38 MOS_ASSERTMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_HW, _message, ##__VA_ARGS__) 39 40 #define VP_HW_NORMALMESSAGE(_message, ...) \ 41 MOS_NORMALMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_HW, _message, ##__VA_ARGS__) 42 43 #define VP_HW_VERBOSEMESSAGE(_message, ...) \ 44 MOS_VERBOSEMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_HW, _message, ##__VA_ARGS__) 45 46 #define VP_HW_FUNCTION_ENTER \ 47 MOS_FUNCTION_ENTER(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_HW) 48 49 #define VP_HW_CHK_STATUS(_stmt) \ 50 MOS_CHK_STATUS(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_HW, _stmt) 51 52 #define VP_HW_CHK_NULL(_ptr) \ 53 MOS_CHK_NULL(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_HW, _ptr) 54 55 #define VP_HW_CHK_NULL_RETURN(_ptr) \ 56 MOS_CHK_NULL_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _ptr) 57 58 #define VP_HW_CHK_NULL_NO_STATUS(_ptr) \ 59 MOS_CHK_NULL_NO_STATUS(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_HW, _ptr) 60 61 //------------------------------------------------------------------------------ 62 // Macros specific to MOS_VP_SUBCOMP_PUBLIC sub-comp 63 //------------------------------------------------------------------------------ 64 #define VP_PUBLIC_ASSERT(_expr) \ 65 MOS_ASSERT(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _expr) 66 67 #define VP_PUBLIC_ASSERTMESSAGE(_message, ...) \ 68 MOS_ASSERTMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _message, ##__VA_ARGS__) 69 70 #define VP_PUBLIC_NORMALMESSAGE(_message, ...) \ 71 MOS_NORMALMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _message, ##__VA_ARGS__) 72 73 #define VP_PUBLIC_VERBOSEMESSAGE(_message, ...) \ 74 MOS_VERBOSEMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _message, ##__VA_ARGS__) 75 76 #define VP_PUBLIC_FUNCTION_ENTER \ 77 MOS_FUNCTION_ENTER(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC) 78 79 #define VP_PUBLIC_CHK_STATUS(_stmt) \ 80 MOS_CHK_STATUS(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _stmt) 81 82 #define VP_PUBLIC_CHK_STATUS_RETURN(_stmt) \ 83 MOS_CHK_STATUS_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _stmt) 84 85 #define VP_PUBLIC_CHK_VALUE_RETURN(_value, _expect_value) \ 86 MOS_CHK_STATUS_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, \ 87 ((_value) == (_expect_value)) ? MOS_STATUS_SUCCESS : MOS_STATUS_INVALID_PARAMETER) 88 89 #define VP_PUBLIC_CHK_NULL(_ptr) \ 90 MOS_CHK_NULL(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _ptr) 91 92 #define VP_PUBLIC_CHK_NULL_RETURN(_ptr) \ 93 MOS_CHK_NULL_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _ptr) 94 95 #define VP_PUBLIC_CHK_NULL_NO_STATUS(_ptr) \ 96 MOS_CHK_NULL_NO_STATUS(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _ptr) 97 98 #define VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(_ptr) \ 99 MOS_CHK_NULL_NO_STATUS_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _ptr) 100 101 #define VP_CHK_SPACE_NULL_RETURN(_ptr) \ 102 { \ 103 if ((_ptr) == nullptr) \ 104 { \ 105 MOS_ASSERTMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, "Invalid (nullptr) Pointer."); \ 106 return MOS_STATUS_NO_SPACE; \ 107 } \ 108 } 109 110 #define VP_PUBLIC_CHK_NOT_FOUND_RETURN(_handle, _group) \ 111 { \ 112 if (_handle == (_group)->end()) \ 113 { \ 114 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_NULL_POINTER); \ 115 } \ 116 } 117 //------------------------------------------------------------------------------ 118 // Macros specific to MOS_VP_SUBCOMP_DEBUG sub-comp 119 //------------------------------------------------------------------------------ 120 #define VP_DEBUG_ASSERT(_expr) \ 121 MOS_ASSERT(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DEBUG, _expr) 122 123 #define VP_DEBUG_ASSERTMESSAGE(_message, ...) \ 124 MOS_ASSERTMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DEBUG, _message, ##__VA_ARGS__) 125 126 #define VP_DEBUG_NORMALMESSAGE(_message, ...) \ 127 MOS_NORMALMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DEBUG, _message, ##__VA_ARGS__) 128 129 #define VP_DEBUG_VERBOSEMESSAGE(_message, ...) \ 130 MOS_VERBOSEMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DEBUG, _message, ##__VA_ARGS__) 131 132 #define VP_FUNCTION_VERBOSEMESSAGE(_message, ...) \ 133 MOS_DEBUGMESSAGE(MOS_MESSAGE_LVL_FUNCTION_ENTRY_VERBOSE, MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DEBUG, _message, ##__VA_ARGS__) 134 135 #define VP_DEBUG_FUNCTION_ENTER \ 136 MOS_FUNCTION_ENTER(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DEBUG) 137 138 #define VP_DEBUG_CHK_STATUS(_stmt) \ 139 MOS_CHK_STATUS(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DEBUG, _stmt) 140 141 #define VP_DEBUG_CHK_STATUS_RETURN(_stmt) \ 142 MOS_CHK_STATUS_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DEBUG, _stmt) 143 144 #define VP_DEBUG_CHK_NULL(_ptr) \ 145 MOS_CHK_NULL(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DEBUG, _ptr) 146 147 #define VP_DEBUG_CHK_NULL_RETURN(_ptr) \ 148 MOS_CHK_NULL_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _ptr) 149 150 #define VP_DEBUG_CHK_NULL_NO_STATUS(_ptr) \ 151 MOS_CHK_NULL_NO_STATUS(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DEBUG, _ptr) 152 153 //------------------------------------------------------------------------------ 154 // Macros specific to MOS_VP_SUBCOMP_RENDER sub-comp 155 //------------------------------------------------------------------------------ 156 #define VP_RENDER_ASSERT(_expr) \ 157 MOS_ASSERT(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER, _expr) 158 159 #define VP_RENDER_ASSERTMESSAGE(_message, ...) \ 160 MOS_ASSERTMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER, _message, ##__VA_ARGS__) 161 162 #define VP_RENDER_NORMALMESSAGE(_message, ...) \ 163 MOS_NORMALMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER, _message, ##__VA_ARGS__) 164 165 #define VP_RENDER_VERBOSEMESSAGE(_message, ...) \ 166 MOS_VERBOSEMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER, _message, ##__VA_ARGS__) 167 168 #define VP_RENDER_FUNCTION_ENTER \ 169 MOS_FUNCTION_ENTER(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER) 170 171 #define VP_RENDER_EXITMESSAGE(_message, ...) \ 172 MOS_DEBUGMESSAGE(MOS_MESSAGE_LVL_FUNCTION_EXIT, MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER, _message, ##__VA_ARGS__) 173 174 #define VP_RENDER_CHK_STATUS(_stmt) \ 175 MOS_CHK_STATUS(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER, _stmt) 176 177 #define VP_RENDER_CHK_STATUS_RETURN(_stmt) \ 178 MOS_CHK_STATUS_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER, _stmt) 179 180 #define VP_RENDER_CHK_STATUS_MESSAGE(_stmt, _message, ...) \ 181 MOS_CHK_STATUS_MESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER, _stmt, _message, ##__VA_ARGS__) 182 183 #define VP_RENDER_CHK_NULL(_ptr) \ 184 MOS_CHK_NULL(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER, _ptr) 185 186 #define VP_RENDER_CHK_NULL_RETURN(_ptr) \ 187 MOS_CHK_NULL_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER, _ptr) 188 189 #define VP_RENDER_CHK_NULL_NO_STATUS(_ptr) \ 190 MOS_CHK_NULL_NO_STATUS(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_RENDER, _ptr) 191 192 //------------------------------------------------------------------------------ 193 // Macros specific to MOS_VP_SUBCOMP_DDI sub-comp 194 //------------------------------------------------------------------------------ 195 #define VP_DDI_ASSERT(_expr) \ 196 MOS_ASSERT(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DDI, _expr) 197 198 #define VP_DDI_ASSERTMESSAGE(_message, ...) \ 199 MOS_ASSERTMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DDI, _message, ##__VA_ARGS__) 200 201 #define VP_DDI_NORMALMESSAGE(_message, ...) \ 202 MOS_NORMALMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DDI, _message, ##__VA_ARGS__) 203 204 #define VP_DDI_VERBOSEMESSAGE(_message, ...) \ 205 MOS_VERBOSEMESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DDI, _message, ##__VA_ARGS__) 206 207 #define VP_DDI_FUNCTION_ENTER \ 208 MOS_FUNCTION_ENTER(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DDI) 209 210 #define VP_DDI_CHK_STATUS(_stmt) \ 211 MOS_CHK_STATUS(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DDI, _stmt) 212 213 #define VP_DDI_CHK_STATUS_MESSAGE(_stmt, _message, ...) \ 214 MOS_CHK_STATUS_MESSAGE(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DDI, _stmt, _message, ##__VA_ARGS__) 215 216 #define VP_DDI_CHK_NULL(_ptr) \ 217 MOS_CHK_NULL(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DDI, _ptr) 218 219 #define VP_DDI_CHK_NULL_RETURN(_ptr) \ 220 MOS_CHK_NULL_RETURN(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_PUBLIC, _ptr) 221 222 #define VP_DDI_CHK_NULL_NO_STATUS(_ptr) \ 223 MOS_CHK_NULL_NO_STATUS(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DDI, _ptr) 224 225 #define VPHAL_DDI_CHK_HR(_ptr) \ 226 MOS_CHK_HR(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DDI, _ptr) 227 228 #define VPHAL_DDI_CHK_NULL_WITH_HR(_ptr) \ 229 MOS_CHK_NULL_WITH_HR(MOS_COMPONENT_VP, MOS_VP_SUBCOMP_DDI, _ptr) 230 namespace vp 231 { 232 class Trace 233 { 234 public: Trace(const char * name)235 Trace(const char* name) : m_name(name) 236 { 237 if (g_perfutility && (g_perfutility->dwPerfUtilityIsEnabled & VP_HAL)) 238 { 239 g_perfutility->startTick(name); 240 m_enablePerfMeasure = true; 241 } 242 else // Always bypass function trace for perf measurement case. 243 { 244 VP_FUNCTION_VERBOSEMESSAGE("Enter function:%s\r\n", name); 245 } 246 } 247 ~Trace()248 ~Trace() 249 { 250 if (m_enablePerfMeasure && g_perfutility) 251 { 252 g_perfutility->stopTick(m_name); 253 } 254 else 255 { 256 VP_FUNCTION_VERBOSEMESSAGE("Exit function:%s\r\n", m_name); 257 } 258 } 259 260 protected: 261 const char* m_name = nullptr; 262 bool m_enablePerfMeasure = false; 263 }; 264 } 265 266 #if MOS_MESSAGES_ENABLED 267 // Function trace for vp hal layer. 268 #define VP_FUNC_CALL() vp::Trace trace(__FUNCTION__); 269 #else 270 #define VP_FUNC_CALL() 271 #endif 272 273 #define __VPHAL_VEBOX_OUTPUTPIPE_MODE "VPOutputPipe Mode" 274 #define __VPHAL_VEBOX_FEATURE_INUSE "VeBox Feature In use" 275 #define __VPHAL_VEBOX_DISABLE_SFC "Disable SFC" 276 #define __MEDIA_USER_FEATURE_VALUE_SFC_OUTPUT_DTR_DISABLE "Disable SFC DTR" 277 #define __MEDIA_USER_FEATURE_VALUE_SFC_OUTPUT_CENTERING_DISABLE "SFC Output Centering Disable" 278 #define __VPHAL_BYPASS_COMPOSITION "Bypass Composition" 279 #define __MEDIA_USER_FEATURE_VALUE_VEBOX_TGNE_ENABLE_VP "Enable Vebox GNE" 280 281 #define __VPHAL_RNDR_SSD_CONTROL "SSD Control" 282 #define __MEDIA_USER_FEATURE_VALUE_CSC_COEFF_PATCH_MODE_DISABLE "CSC Patch Mode Disable" 283 #define __MEDIA_USER_FEATURE_VALUE_DISABLE_DN "Disable Dn" 284 #define __MEDIA_USER_FEATURE_VALUE_DISABLE_PACKET_REUSE "Disable PacketReuse" 285 #define __MEDIA_USER_FEATURE_VALUE_ENABLE_PACKET_REUSE_TEAMS_ALWAYS "Enable PacketReuse Teams mode Always" 286 #define __MEDIA_USER_FEATURE_VALUE_FORCE_ENABLE_VEBOX_OUTPUT_SURF "Force Enable Vebox Output Surf" 287 288 #define __VPHAL_HDR_LUT_MODE "HDR Lut Mode" 289 #define __VPHAL_HDR_GPU_GENERTATE_3DLUT "HDR GPU generate 3DLUT" 290 #define __VPHAL_HDR_DISABLE_AUTO_MODE "Disable HDR Auto Mode" 291 #define __VPHAL_HDR_SPLIT_FRAME_PORTIONS "VPHAL HDR Split Frame Portions" 292 #define __MEDIA_USER_FEATURE_VALUE_VPP_APOGEIOS_ENABLE "VP Apogeios Enabled" 293 #define __VPHAL_PRIMARY_MMC_COMPRESSMODE "VP Primary Surface Compress Mode" 294 #define __VPHAL_RT_MMC_COMPRESSMODE "VP RT Compress Mode" 295 #define __VPHAL_RT_Cache_Setting "VP RT Cache Setting" 296 297 #if (_DEBUG || _RELEASE_INTERNAL) 298 #define __VPHAL_RT_Old_Cache_Setting "VP RT Old Cache Setting" 299 #define __VPHAL_ENABLE_COMPUTE_CONTEXT "VP Enable Compute Context" 300 #define __VPHAL_RNDR_SCOREBOARD_CONTROL "SCOREBOARD Control" 301 #define __VPHAL_RNDR_CMFC_CONTROL "CMFC Control" 302 #define __VPHAL_ENABLE_1K_1DLUT "Enable 1K 1DLUT" 303 #define __VPHAL_FORCE_3DLUT_INTERPOLATION "VPHAL Force 3DLUT Interpolation" 304 #define __VPHAL_VEBOX_HDR_MODE "VeboxHDRMode" 305 #define __VPHAL_HDR_ENABLE_QUALITY_TUNING "VPHAL HDR Enable Quality Tuning" 306 #define __VPHAL_HDR_ENABLE_KERNEL_DUMP "VPHAL HDR Enable Kernel Dump" 307 #define __VPHAL_HDR_H2S_RGB_TM "VPHAL H2S TM RGB Based" 308 #define __VPHAL_HDR_3DLUT_CPU_PATH "HDR 3DLut Table Use CPU Caculate" 309 #define __VPHAL_FORCE_VP_3DLUT_KERNEL_ONLY "Force VP 3DLut Kernel Only" 310 311 // Compression 312 #define __VPHAL_MMC_ENABLE "VP MMC In Use" 313 #define __VPHAL_RT_MMC_COMPRESSIBLE "VP RT Compressible" 314 #define __VPHAL_PRIMARY_MMC_COMPRESSIBLE "VP Primary Surface Compressible" 315 316 #define __VPHAL_RNDR_FORCE_VP_DECOMPRESSED_OUTPUT "FORCE VP DECOMPRESSED OUTPUT" 317 #define __VPHAL_COMP_8TAP_ADAPTIVE_ENABLE "8-TAP Enable" 318 #define __VPHAL_VEBOX_FORCE_VP_MEMCOPY_OUTPUTCOMPRESSED "Force VP Memorycopy Outputcompressed" 319 #define __VPHAL_ENABLE_SFC_NV12_P010_LINEAR_OUTPUT "Enable SFC NV12 P010 Linear Output" 320 #define __VPHAL_ENABLE_SFC_RGBP_RGB24_OUTPUT "Enable SFC RGBP RGB24 Output" 321 322 #define __VPHAL_DBG_PARAM_DUMP_OUTFILE_KEY_NAME "outxmlLocation" 323 #define __VPHAL_DBG_PARAM_DUMP_START_FRAME_KEY_NAME "startxmlFrame" 324 #define __VPHAL_DBG_PARAM_DUMP_END_FRAME_KEY_NAME "endxmlFrame" 325 #define __VPHAL_DBG_DUMP_OUTPUT_DIRECTORY "Vphal Debug Dump Output Directory" 326 #define __VPHAL_DBG_PARA_DUMP_ENABLE_SKUWA_DUMP "enableSkuWaDump" 327 328 #define __MEDIA_USER_FEATURE_VALUE_INTER_FRAME_MEMORY_NINJA_START_COUNTER "InterFrameNinjaStartCounter" 329 #define __MEDIA_USER_FEATURE_VALUE_INTER_FRAME_MEMORY_NINJA_END_COUNTER "InterFrameNinjaEndCounter" 330 #define __MEDIA_USER_FEATURE_VALUE_ENABLE_IFNCC "EnableIFNCC" 331 // For L0 3DLut 332 #define __MEDIA_USER_FEATURE_VALUE_ENABLE_VP_L0_3DLUT "Enable L0 3DLUT" 333 #define __MEDIA_USER_FEATURE_VALUE_VP_L0_3DLUT_ENABLED "L0 3DLUT Enabled" 334 335 // For L0 FC 336 #define __MEDIA_USER_FEATURE_VALUE_ENABLE_VP_L0_FC "Enable L0 FC" 337 #define __MEDIA_USER_FEATURE_VALUE_DISABLE_VP_L0_FC_FP "Disable L0 FC FP" 338 #define __MEDIA_USER_FEATURE_VALUE_VP_L0_FC_ENABLED "L0 FC Enabled" 339 #define __MEDIA_USER_FEATURE_VALUE_VP_L0_FC_REPORT "L0 FC Diff Report" 340 341 #define __MEDIA_USER_FEATURE_VALUE_ENABLE_VESFC_LINEAR_OUTPUT_BY_TILECONVERT "Enable VESFC Linearoutput By TileConvert" 342 #endif //(_DEBUG || _RELEASE_INTERNAL) 343 344 class VpUtils 345 { 346 public: 347 //! 348 //! \brief Allocates the Surface 349 //! \details Allocates the Surface 350 //! - if the surface is not already allocated OR 351 //! - resource dimenisions OR format changed 352 //! \param [in] pOsInterface 353 //! Pointer to MOS_INTERFACE 354 //! \param [in,out] pSurface 355 //! Pointer to VPHAL_SURFACE 356 //! \param [in] pSurfaceName 357 //! Pointer to surface name 358 //! \param [in] format 359 //! Expected MOS_FORMAT 360 //! \param [in] DefaultResType 361 //! Expected Resource Type 362 //! \param [in] DefaultTileType 363 //! Expected Surface Tile Type 364 //! \param [in] dwWidth 365 //! Expected Surface Width 366 //! \param [in] dwHeight 367 //! Expected Surface Height 368 //! \param [in] bCompressible 369 //! Surface being compressible or not 370 //! \param [in] CompressionMode 371 //! Compression Mode 372 //! \param [out] pbAllocated 373 //! true if allocated, false for not 374 //! \param [in] resUsageType 375 //! resource usage type for caching 376 //! \param [in] tileModeByForce 377 //! Forced tile mode 378 //! \param [in] memType 379 //! vidoe memory location 380 //! \param [in] isNotLockable 381 //! Flag to indicate whether resource being not lockable 382 //! \return MOS_STATUS 383 //! MOS_STATUS_SUCCESS if success. Error code otherwise 384 //! 385 static MOS_STATUS ReAllocateSurface( 386 PMOS_INTERFACE osInterface, 387 PVPHAL_SURFACE surface, 388 PCCHAR surfaceName, 389 MOS_FORMAT format, 390 MOS_GFXRES_TYPE defaultResType, 391 MOS_TILE_TYPE defaultTileType, 392 uint32_t dwWidth, 393 uint32_t dwHeight, 394 bool bCompressible, 395 MOS_RESOURCE_MMC_MODE compressionMode, 396 bool *bAllocated, 397 MOS_HW_RESOURCE_DEF resUsageType = MOS_HW_RESOURCE_DEF_MAX, 398 MOS_TILE_MODE_GMM tileModeByForce = MOS_TILE_UNSET_GMM, 399 Mos_MemPool memType = MOS_MEMPOOL_VIDEOMEMORY, 400 bool isNotLockable = false); 401 402 //! 403 //! \brief 404 //! \details Get CSC matrix in a form usable by Vebox, SFC and IECP kernels 405 //! \param [in] SrcCspace 406 //! Source Cspace 407 //! \param [in] DstCspace 408 //! Destination Cspace 409 //! \param [out] pfCscCoeff 410 //! [3x3] Coefficients matrix 411 //! \param [out] pfCscInOffset 412 //! [3x1] Input Offset matrix 413 //! \param [out] pfCscOutOffset 414 //! [3x1] Output Offset matrix 415 //! \return void 416 //! 417 static void GetCscMatrixForVeSfc8Bit( 418 VPHAL_CSPACE srcCspace, 419 VPHAL_CSPACE dstCspace, 420 float *fCscCoeff, 421 float *fCscInOffset, 422 float *fCscOutOffset); 423 424 //! 425 //! \brief Performs Color Space Convert for Sample 8 bit 426 //! \details Performs Color Space Convert from Src Color Spase to Dst Color Spase 427 //! \param [out] pOutput 428 //! Pointer to VPHAL_COLOR_SAMPLE_8 429 //! \param [in] pInput 430 //! Pointer to VPHAL_COLOR_SAMPLE_8 431 //! \param [in] srcCspace 432 //! Source Color Space 433 //! \param [in] dstCspace 434 //! Dest Color Space 435 //! \return bool 436 //! Return true if successful, otherwise false 437 //! 438 static bool GetCscMatrixForRender8Bit( 439 VPHAL_COLOR_SAMPLE_8 *output, 440 VPHAL_COLOR_SAMPLE_8 *input, 441 VPHAL_CSPACE srcCspace, 442 VPHAL_CSPACE dstCspace); 443 444 static bool IsSyncFreeNeededForMMCSurface(PVPHAL_SURFACE surface, PMOS_INTERFACE osInterface); 445 446 static bool IsVerticalRotation(VPHAL_ROTATION rotation); 447 448 private: 449 //! 450 //! \brief Performs Color Space Convert for Sample 8 bit Using Specified Coeff Matrix 451 //! \details Performs Color Space Convert from Src Color Spase to Dst Color Spase 452 // Using Secified input CSC Coeff Matrix 453 //! \param [out] output 454 //! Pointer to VPHAL_COLOR_SAMPLE_8 455 //! \param [in] input 456 //! Pointer to VPHAL_COLOR_SAMPLE_8 457 //! \param [in] srcCspace 458 //! Source Color Space 459 //! \param [in] dstCspace 460 //! Dest Color Space 461 //! \param [in] iCscMatrix 462 //! input CSC coeff Matrxi 463 //! \return bool 464 //! Return true if successful, otherwise false 465 //! 466 static bool GetCscMatrixForRender8BitWithCoeff( 467 VPHAL_COLOR_SAMPLE_8 *output, 468 VPHAL_COLOR_SAMPLE_8 *input, 469 VPHAL_CSPACE srcCspace, 470 VPHAL_CSPACE dstCspace, 471 int32_t *iCscMatrix); 472 473 MEDIA_CLASS_DEFINE_END(VpUtils) 474 }; 475 476 #endif // !__VP_UTILS_H__ 477