1 /* 2 * Copyright (c) 2017, 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 //! 23 //! \file cm_wrapper.h 24 //! \brief Contains declarations of various OS-agnostic data structures and 25 //! functions for executing commands from cmrtlib. 26 //! 27 28 #ifndef MEDIADRIVER_AGNOSTIC_COMMON_CM_CMWRAPPER_H_ 29 #define MEDIADRIVER_AGNOSTIC_COMMON_CM_CMWRAPPER_H_ 30 31 #include "cm_wrapper_os.h" 32 #include "cm_device.h" 33 34 #define CM_BOUNDARY_PIXEL_MODE GFX3DSTATE_MEDIA_BOUNDARY_PIXEL_MODE 35 36 #define CM_SURFACE_2D(pSurf) static_cast<CmSurface2DRT*>((CmSurface2D *)(pSurf)) 37 38 typedef struct _CM_DESTROYCMDEVICE_PARAM 39 { 40 void *deviceHandle; // [in/out] pointer to CmDevice object 41 int32_t returnValue; // [out] the return value from CMRT@UMD 42 }CM_DESTROYCMDEVICE_PARAM, *PCM_DESTROYCMDEVICE_PARAM; 43 44 typedef struct _CM_DESTROYBUFFER_PARAM 45 { 46 void *bufferHandle; // [in/out] pointer to CmBuffer object 47 int32_t returnValue; // [out] the return value from CMRT@UMD 48 }CM_DESTROYBUFFER_PARAM, *PCM_DESTROYBUFFER_PARAM; 49 50 typedef struct _CM_DESTROYSURFACE2D_PARAM 51 { 52 void *surface2DHandle; // [in/out] pointer to CmSurface2D object 53 int32_t returnValue; // [out] the return value from CMRT@UMD 54 }CM_DESTROYSURFACE2D_PARAM, *PCM_DESTROYSURFACE2D_PARAM; 55 56 typedef struct _CM_DESTROYSURFACE2DUP_PARAM 57 { 58 void *surface2DUPHandle; // [in/out] pointer to CmSurface2D object 59 int32_t returnValue; // [out] the return value from CMRT@UMD 60 }CM_DESTROYSURFACE2DUP_PARAM, *PCM_DESTROYSURFACE2DUP_PARAM; 61 62 typedef struct _CM_LOADPROGRAM_PARAM 63 { 64 void *cisaCode; // [in] pointer to the CISA code buffer 65 uint32_t cisaCodeSize; // [in] size of CISA code 66 char* options; // [in] additonal options for LoadProgram 67 void *programHandle; // [out] pointer to CmProgram object used by CMRT@UMD 68 uint32_t indexInArray; // [out] index in m_ProgramArray of CMRT@UMD 69 int32_t returnValue; // [out] the return value from CMRT@UMD 70 }CM_LOADPROGRAM_PARAM, *PCM_LOADPROGRAM_PARAM; 71 72 typedef struct _CM_DESTROYPROGRAM_PARAM 73 { 74 void *programHandle; // [IN] pointer to CmProgram object used by CMRT@UMD 75 int32_t returnValue; // [out] the return value from CMRT@UMD 76 }CM_DESTROYPROGRAM_PARAM, *PCM_DESTROYPROGRAM_PARAM; 77 78 typedef struct _CM_CREATEKERNEL_PARAM 79 { 80 void *programHandle; // [in] pointer to CmProgram used in driver 81 char* kernelName; // [in] pointer to the kernel name string 82 char* options; // [in] pointer to the kernel creation options 83 void *kernelHandle; // [out] pointer to new created CmKernel used in driver 84 uint32_t indexKernelArray; // [out] index in m_KernelArray 85 int32_t returnValue; // [out] the return value from driver 86 }CM_CREATEKERNEL_PARAM, *PCM_CREATEKERNEL_PARAM; 87 88 typedef struct _CM_DESTROYKERNEL_PARAM 89 { 90 void *kernelHandle; // [in/out] pointer to new created CmKernel used in driver 91 int32_t returnValue; // [out] the return value from driver 92 }CM_DESTROYKERNEL_PARAM, *PCM_DESTROYKERNEL_PARAM; 93 94 typedef struct _CM_SETSURFACEMEMORYOBJECTCTRL_PARAM 95 { 96 void *surfaceHandle; // [in] 97 MEMORY_OBJECT_CONTROL memCtrl; // [in] 98 MEMORY_TYPE memType; // [in] 99 uint32_t age; // [in] 100 int32_t returnValue; // [out] 101 }CM_SETSURFACEMEMORYOBJECTCTRL_PARAM, *PCM_SETSURFACEMEMORYOBJECTCTRL_PARAM; 102 103 typedef struct _CM_CREATETASK_PARAM 104 { 105 void *taskHandle; // [out] pointer to new created CmTask used in driver 106 uint32_t taskIndex; // [out] index of task i 107 int32_t returnValue; // [out] the return value from driver 108 }CM_CREATETASK_PARAM, *PCM_CREATETASK_PARAM; 109 110 typedef struct _CM_DESTROYTASK_PARAM 111 { 112 void *taskHandle; // [in/out] pointer to CmTask used in driver 113 int32_t returnValue; // [out] the return value from driver 114 }CM_DESTROYTASK_PARAM, *PCM_DESTROYTASK_PARAM; 115 116 struct CM_CREATEQUEUE_PARAM 117 { 118 CM_QUEUE_CREATE_OPTION createOption; // [in/out] 119 void *queueHandle; // [out] 120 int32_t returnValue; // [out] 121 }; 122 123 typedef struct _CM_ENQUEUE_PARAM 124 { 125 void *queueHandle; // [in] 126 void *taskHandle; // [in] 127 void *threadSpaceHandle; // [in] 128 void *eventHandle; // [out] 129 uint32_t eventIndex; // [out] index of pCmEventHandle in m_EventArray 130 int32_t returnValue; // [out] 131 }CM_ENQUEUE_PARAM, *PCM_ENQUEUE_PARAM; 132 133 typedef struct _CM_ENQUEUEHINTS_PARAM 134 { 135 void *queueHandle; // [in] 136 void *taskHandle; // [in] 137 void *eventHandle; // [in] 138 uint32_t hints; // [in] 139 uint32_t eventIndex; // [out] index of pCmEventHandle in m_EventArray 140 int32_t returnValue; // [out] 141 }CM_ENQUEUEHINTS_PARAM, *PCM_ENQUEUEHINTS_PARAM; 142 143 typedef struct _CM_DESTROYEVENT_PARAM 144 { 145 void *queueHandle; // [in] 146 void *eventHandle; // [in] 147 int32_t returnValue; // [out] 148 }CM_DESTROYEVENT_PARAM, *PCM_DESTROYEVENT_PARAM; 149 150 typedef struct _CM_CREATETHREADSPACE_PARAM 151 { 152 uint32_t threadSpaceWidth; // [in] 153 uint32_t threadSpaceHeight; // [in] 154 void *threadSpaceHandle; // [out] 155 uint32_t indexInTSArray; // [out] 156 int32_t returnValue; // [out] 157 }CM_CREATETHREADSPACE_PARAM, *PCM_CREATETHREADSPACE_PARAM; 158 159 typedef struct _CM_DESTROYTHREADSPACE_PARAM 160 { 161 void *threadSpaceHandle; // [in] 162 int32_t returnValue; // [out] 163 }CM_DESTROYTHREADSPACE_PARAM, *PCM_DESTROYTHREADSPACE_PARAM; 164 165 typedef struct _CM_DESTROYVMESURFACE_PARAM 166 { 167 void *vmeSurfIndexHandle; // [in] 168 int32_t returnValue; // [out] 169 }CM_DESTROYVMESURFACE_PARAM, *PCM_DESTROYVMESURFACE_PARAM; 170 171 typedef struct _CM_CONFIGVMESURFACEDIMENSION_PARAM 172 { 173 void *vmeSurfHandle; // [in] 174 CM_VME_SURFACE_STATE_PARAM *surfDimensionPara; // [in] 175 int32_t returnValue; // [out] 176 }CM_CONFIGVMESURFACEDIMENSION_PARAM, *PCM_CONFIGVMESURFACEDIMENSION_PARAM; 177 178 typedef struct _CM_CREATEVMESURFACE_PARAM 179 { 180 void *curSurfHandle; // [in] 181 void *forwardSurfArray; // [in] 182 void *backwardSurfArray; // [in] 183 uint32_t forwardSurfCount; // [in] 184 uint32_t backwardSurfCount; // [in] 185 void *vmeSurfIndexHandle; // [out] 186 int32_t returnValue; // [out] 187 }CM_CREATEVMESURFACE_PARAM, *PCM_CREATEVMESURFACE_PARAM; 188 189 typedef struct _CM_CREATESAMPLER_PARAM 190 { 191 CM_SAMPLER_STATE sampleState; // [in] 192 void *samplerHandle; // [out] 193 void *samplerIndexHandle; // [out] 194 int32_t returnValue; // [out] 195 }CM_CREATESAMPLER_PARAM, *PCM_CREATESAMPLER_PARAM; 196 197 typedef struct _CM_CREATESAMPLER_PARAM_EX 198 { 199 CM_SAMPLER_STATE_EX sampleState; // [in] 200 void *samplerHandle; // [out] 201 void *samplerIndexHandle; // [out] 202 int32_t returnValue; // [out] 203 }CM_CREATESAMPLER_PARAM_EX, *PCM_CREATESAMPLER_PARAM_EX; 204 205 typedef struct _CM_DESTROYSAMPLER_PARAM 206 { 207 void *samplerHandle; // [in] 208 int32_t returnValue; // [out] 209 }CM_DESTROYSAMPLER_PARAM, *PCM_DESTROYSAMPLER_PARAM; 210 211 typedef struct _CM_ENQUEUEGROUP_PARAM 212 { 213 void *queueHandle; // [in] 214 void *taskHandle; // [in] 215 void *threadGroupSpaceHandle; // [in] 216 void *eventHandle; // [out] 217 uint32_t eventIndex; // [out] index of pCmEventHandle in m_EventArray 218 int32_t returnValue; // [out] 219 }CM_ENQUEUEGROUP_PARAM, *PCM_ENQUEUEGROUP_PARAM; 220 221 typedef struct _CM_CREATETGROUPSPACE_PARAM 222 { 223 uint32_t thrdSpaceWidth; // [in] 224 uint32_t thrdSpaceHeight; // [in] 225 uint32_t thrdSpaceDepth; // [in] 226 uint32_t grpSpaceWidth; // [in] 227 uint32_t grpSpaceHeight; // [in] 228 uint32_t grpSpaceDepth; // [in] 229 void *groupSpaceHandle; // [out] 230 uint32_t threadGroupSpaceIndex; // [out] 231 int32_t returnValue; // [out] 232 }CM_CREATETGROUPSPACE_PARAM, *PCM_CREATETGROUPSPACE_PARAM; 233 234 typedef struct _CM_DESTROYTGROPUSPACE_PARAM 235 { 236 void *groupSpaceHandle; // [in] 237 int32_t returnValue; // [out] 238 }CM_DESTROYTGROPUSPACE_PARAM, *PCM_DESTROYTGROPUSPACE_PARAM; 239 240 typedef struct _CM_GETCAPS_PARAM 241 { 242 CM_DEVICE_CAP_NAME capName; //[in] 243 uint32_t capValueSize; //[in] 244 void *capValue; //[in/out] 245 uint32_t returnValue; //[out] Return value 246 }CM_GETCAPS_PARAM, *PCM_GETCAPS_PARAM; 247 248 typedef struct _CM_ENQUEUE_GPUCOPY_V2V_PARAM 249 { 250 void *queueHandle; // [in] 251 void *srcSurface2d; // [in] 252 void *dstSurface2d; // [in] 253 uint32_t option; // [in] 254 void *eventHandle; // [out] 255 uint32_t eventIndex; // [out] index of pCmEventHandle in m_EventArray 256 int32_t returnValue; // [out] 257 }CM_ENQUEUE_GPUCOPY_V2V_PARAM, *PCM_ENQUEUE_GPUCOPY_V2V_PARAM; 258 259 typedef struct _CM_ENQUEUE_GPUCOPY_L2L_PARAM 260 { 261 void *queueHandle; // [in] 262 void *srcSysMem; // [in] 263 void *dstSysMem; // [in] 264 uint32_t copySize; // [in] 265 uint32_t option; // [in] 266 void *eventHandle; // [out] 267 uint32_t eventIndex; // [out] index of pCmEventHandle in m_EventArray 268 int32_t returnValue; // [out] 269 }CM_ENQUEUE_GPUCOPY_L2L_PARAM, *PCM_ENQUEUE_GPUCOPY_L2L_PARAM; 270 271 typedef struct _CM_ENQUEUE_COPY_BUFFER_PARAM 272 { 273 void* cmQueueHandle; // [in] 274 void* buffer; // [in] 275 void* sysMem; // [in] 276 uint32_t offset; // [in] 277 uint64_t copySize; // [in] 278 uint32_t copyDir; // [in] 279 void* wait_event; // [in] 280 void* cmEventHandle; // [out] 281 uint32_t option; // [in] 282 uint32_t eventIndex; // [out] index of Event in m_EventArray 283 int32_t returnValue; // [out] 284 }CM_ENQUEUE_COPY_BUFFER_PARAM, * PCM_ENQUEUE_COPY_BUFFER_PARAM; 285 286 typedef struct _CM_DESTROY_SURFACE3D_PARAM 287 { 288 void *surface3DHandle; // [in] pointer of CmSurface3D used in driver 289 int32_t returnValue; // [out] the return value from driver 290 }CM_DESTROY_SURFACE3D_PARAM, *PCM_DESTROY_SURFACE3D_PARAM; 291 292 typedef struct _CM_CREATESAMPLER2D_PARAM 293 { 294 void *surface2DHandle; // [in] pointer to CmSurface2D object used by CMRT@UMD 295 void *samplerSurfIndexHandle; // [out] pointer of SurfaceIndex used in driver 296 int32_t returnValue; // [out] the return value from CMRT@UMD 297 }CM_CREATESAMPLER2D_PARAM, *PCM_CREATESAMPLER2D_PARAM; 298 299 typedef struct _CM_CREATESAMPLER2DUP_PARAM 300 { 301 void *surface2DUPHandle; // [in] pointer to CmSurface2DUP object used by CMRT@UMD 302 void *samplerSurfIndexHandle; // [out] pointer of SurfaceIndex used in driver 303 int32_t returnValue; // [out] the return value from CMRT@UMD 304 }CM_CREATESAMPLER2DUP_PARAM, *PCM_CREATESAMPLER2DUP_PARAM; 305 306 typedef struct _CM_CREATESAMPLER3D_PARAM 307 { 308 void *surface3DHandle; // [in] pointer to CmSurface3D object used by CMRT@UMD 309 void *samplerSurfIndexHandle; // [out] pointer of SurfaceIndex used in driver 310 int32_t returnValue; // [out] the return value from CMRT@UMD 311 }CM_CREATESAMPLER3D_PARAM, *PCM_CREATESAMPLER3D_PARAM; 312 313 typedef struct _CM_DESTROYSAMPLERSURF_PARAM 314 { 315 void *samplerSurfIndexHandle; // [in] pointer of SamplerSurfaceIndex used in driver 316 int32_t returnValue; // [out] the return value from CMRT@UMD 317 }CM_DESTROYSAMPLERSURF_PARAM, *PCM_DESTROYSAMPLERSURF_PARAM; 318 319 typedef struct _CM_DEVICE_SETCAP_PARAM 320 { 321 CM_DEVICE_CAP_NAME capName; // [in] Cap Type 322 size_t capValueSize; // [in] Value Size 323 void *capValue; // [in] Pointer to value 324 int32_t returnValue; // [out] the return value from CMRT@UMD 325 }CM_DEVICE_SETCAP_PARAM, *PCM_DEVICE_SETCAP_PARAM; 326 327 typedef struct _CM_DEVICE_SETSUGGESTEDL3_PARAM 328 { 329 L3_SUGGEST_CONFIG l3SuggestConfig; // [in] Cap Type 330 int32_t returnValue; // [out] the return value from CMRT@UMD 331 }CM_DEVICE_SETSUGGESTEDL3_PARAM, *PCM_DEVICE_SETSUGGESTEDL3_PARAM; 332 333 using CMRT_UMD::SamplerIndex; 334 typedef struct _CM_CREATESAMPLER8x8_PARAM 335 { 336 CM_SAMPLER_8X8_DESCR sample8x8Desc; // [in] 337 void *sampler8x8Handle; // [out] 338 SamplerIndex* samplerIndexHandle; // [out] 339 int32_t returnValue; // [out] 340 }CM_CREATESAMPLER8x8_PARAM, *PCM_CREATESAMPLER8x8_PARAM; 341 342 typedef struct _CM_DESTROYSAMPLER8x8_PARAM 343 { 344 void *sampler8x8Handle; // [in] 345 int32_t returnValue; // [out] 346 }CM_DESTROYSAMPLER8x8_PARAM, *PCM_DESTROYSAMPLER8x8_PARAM; 347 348 using CMRT_UMD::SurfaceIndex; 349 typedef struct _CM_CREATESAMPLER8x8SURF_PARAM 350 { 351 void *surf2DHandle; // [in] 352 CM_SAMPLER8x8_SURFACE sampler8x8Type; // [in] 353 CM_SURFACE_ADDRESS_CONTROL_MODE sampler8x8Mode; // [in] 354 SurfaceIndex* surfIndexHandle; // [out] 355 int32_t returnValue; // [out] 356 }CM_CREATESAMPLER8x8SURF_PARAM, *PCM_CREATESAMPLER8x8SURF_PARAM; 357 358 typedef struct _CM_CREATESAMPLER8x8SURFEX_PARAM 359 { 360 void *surf2DHandle; // [in] 361 CM_SAMPLER8x8_SURFACE sampler8x8Type; // [in] 362 CM_SURFACE_ADDRESS_CONTROL_MODE sampler8x8Mode; // [in] 363 CM_FLAG* flag; // [in] 364 SurfaceIndex* surfIndexHandle; // [out] 365 int32_t returnValue; // [out] 366 }CM_CREATESAMPLER8x8SURFEX_PARAM, *PCM_CREATESAMPLER8x8SURFEX_PARAM; 367 368 typedef struct _CM_CREATESAMPLER2DEX_PARAM 369 { 370 void *surface2DHandle; // [in] 371 CM_FLAG* flag; // [in] 372 void *samplerSurfIndexHandle; // [out] 373 int32_t returnValue; // [out] 374 }CM_CREATESAMPLER2DEX_PARAM, *PCM_CREATESAMPLER2DEX_PARAM; 375 376 typedef struct _CM_DESTROYSAMPLER8x8SURF_PARAM 377 { 378 SurfaceIndex* surfIndexHandle; // [in] 379 int32_t returnValue; // [out] 380 }CM_DESTROYSAMPLER8x8SURF_PARAM, *PCM_DESTROYSAMPLER8x8SURF_PARAM; 381 382 typedef struct _CM_ENQUEUE_2DINIT_PARAM 383 { 384 void *queueHandle; // [in] handle of Queue 385 void *surface2d; // [in] handle of surface 2d 386 uint32_t initValue; // [in] init value 387 void *eventHandle; // [out] event's handle 388 uint32_t eventIndex; // [out] event's index 389 int32_t returnValue; // [out] return value 390 }CM_ENQUEUE_2DINIT_PARAM, *PCM_ENQUEUE_2DINIT_PARAM; 391 392 typedef struct _CM_DEVICE_INIT_PRINT_BUFFER_PARAM 393 { 394 uint32_t printBufferSize; //[in] print buffer's size 395 void *printBufferMem; //[out] print buffer's memory 396 int32_t returnValue; //[out] return value 397 }CM_DEVICE_INIT_PRINT_BUFFER_PARAM, *PCM_DEVICE_INIT_PRINT_BUFFER_PARAM; 398 399 typedef struct _CM_DEVICE_FLUSH_PRINT_BUFFER_PARAM 400 { 401 const char *fileName; //[in] target file name 402 int32_t returnValue; //[out] return value 403 }CM_DEVICE_FLUSH_PRINT_BUFFER_PARAM, *PCM_DEVICE_FLUSH_PRINT_BUFFER_PARAM; 404 405 typedef struct _CM_CREATEVEBOX_PARAM 406 { 407 void *veboxHandle; // [out] CmVeboxG75's handle 408 uint32_t indexInVeboxArray; // [out] index in m_VeboxArray 409 int32_t returnValue; // [out] return value 410 }CM_CREATEVEBOX_PARAM, *PCM_CREATEVEBOX_PARAM; 411 412 typedef struct _CM_DESTROYVEBOX_PARAM 413 { 414 void *veboxHandle; // [IN] CmVeboxG75's handle 415 int32_t returnValue; // [out] return value 416 }CM_DESTROYVEBOX_PARAM, *PCM_DESTROYVEBOX_PARAM; 417 418 typedef struct _CM_DEVICE_CREATE_SURF2D_ALIAS_PARAM 419 { 420 void *surface2DHandle; // [IN] pointer to CMSurface2D 421 void *surfaceIndexHandle; // [OUT] pointer of SurfaceIndex 422 int32_t returnValue; // [OUT] return value 423 } CM_DEVICE_CREATE_SURF2D_ALIAS_PARAM, *PCM_DEVICE_CREATE_SURF2D_ALIAS_PARAM; 424 425 typedef struct _CM_DEVICE_CREATE_BUFFER_ALIAS_PARAM 426 { 427 void *bufferHandle; // [IN] pointer to CmBuffer object 428 void *surfaceIndexHandle; // [OUT] ponter of SurfaceIndex 429 int32_t returnValue; // [OUT] return value 430 } CM_DEVICE_CREATE_BUFFER_ALIAS_PARAM, *PCM_DEVICE_CREATE_BUFFER_ALIAS_PARAM; 431 432 typedef struct _CM_CLONE_KERNEL_PARAM 433 { 434 void *kernelHandleSrc; // [IN] source kernel 435 void *kernelHandleDest; // [OUT] dest kernel 436 int32_t returnValue; // [OUT] return value 437 }CM_CLONE_KERNEL_PARAM, *PCM_CLONE_KERNEL_PARAM; 438 439 typedef struct _CM_ENQUEUE_VEBOX_PARAM 440 { 441 void *queueHandle; // [IN] 442 void *veboxHandle; // [IN] CmVeboxG75's handle 443 void *eventHandle; // [out] event's handle 444 uint32_t eventIndex; // [out] event's index 445 int32_t returnValue; // [out] return value 446 }CM_ENQUEUE_VEBOX_PARAM, *PCM_ENQUEUE_VEBOX_PARAM; 447 448 struct CM_GET_VISA_VERSION_PARAM 449 { 450 uint32_t majorVersion; // [OUT] the major version of jitter 451 uint32_t minorVersion; // [OUT] the minor version of jitter 452 int32_t returnValue; // [OUT] return value 453 }; 454 455 //*----------------------------------------------------------------------------- 456 //| CM extension Function Codes 457 //*----------------------------------------------------------------------------- 458 enum CM_FUNCTION_ID 459 { 460 CM_FN_RT_ULT = 0x900, 461 CM_FN_RT_ULT_INFO = 0x902, 462 463 CM_FN_CREATECMDEVICE = 0x1000, 464 CM_FN_DESTROYCMDEVICE = 0x1001, 465 466 CM_FN_CMDEVICE_CREATEBUFFER = 0x1100, 467 CM_FN_CMDEVICE_DESTROYBUFFER = 0x1101, 468 CM_FN_CMDEVICE_CREATEBUFFERUP = 0x1102, 469 CM_FN_CMDEVICE_DESTROYBUFFERUP = 0x1103, 470 CM_FN_CMDEVICE_CREATESURFACE2D = 0x1104, 471 CM_FN_CMDEVICE_DESTROYSURFACE2D = 0x1105, 472 CM_FN_CMDEVICE_CREATESURFACE2DUP = 0x1106, 473 CM_FN_CMDEVICE_DESTROYSURFACE2DUP = 0x1107, 474 CM_FN_CMDEVICE_GETSURFACE2DINFO = 0x1108, 475 CM_FN_CMDEVICE_CREATESURFACE3D = 0x1109, 476 CM_FN_CMDEVICE_DESTROYSURFACE3D = 0x110A, 477 CM_FN_CMDEVICE_CREATEQUEUE = 0x110B, 478 CM_FN_CMDEVICE_LOADPROGRAM = 0x110C, 479 CM_FN_CMDEVICE_DESTROYPROGRAM = 0x110D, 480 CM_FN_CMDEVICE_CREATEKERNEL = 0x110E, 481 CM_FN_CMDEVICE_DESTROYKERNEL = 0x110F, 482 CM_FN_CMDEVICE_CREATETASK = 0x1110, 483 CM_FN_CMDEVICE_DESTROYTASK = 0x1111, 484 CM_FN_CMDEVICE_GETCAPS = 0x1112, 485 CM_FN_CMDEVICE_SETCAPS = 0x1113, 486 CM_FN_CMDEVICE_CREATETHREADSPACE = 0x1114, 487 CM_FN_CMDEVICE_DESTROYTHREADSPACE = 0x1115, 488 CM_FN_CMDEVICE_CREATETHREADGROUPSPACE = 0x1116, 489 CM_FN_CMDEVICE_DESTROYTHREADGROUPSPACE = 0x1117, 490 CM_FN_CMDEVICE_SETL3CONFIG = 0x1118, 491 CM_FN_CMDEVICE_SETSUGGESTEDL3CONFIG = 0x1119, 492 CM_FN_CMDEVICE_CREATESAMPLER = 0x111A, 493 CM_FN_CMDEVICE_DESTROYSAMPLER = 0x111B, 494 CM_FN_CMDEVICE_CREATESAMPLER8X8 = 0x111C, 495 CM_FN_CMDEVICE_DESTROYSAMPLER8X8 = 0x111D, 496 CM_FN_CMDEVICE_CREATESAMPLER8X8SURFACE = 0x111E, 497 CM_FN_CMDEVICE_DESTROYSAMPLER8X8SURFACE = 0x111F, 498 CM_FN_CMDEVICE_DESTROYVMESURFACE = 0x1123, 499 CM_FN_CMDEVICE_CREATEVMESURFACEG7_5 = 0x1124, 500 CM_FN_CMDEVICE_DESTROYVMESURFACEG7_5 = 0x1125, 501 CM_FN_CMDEVICE_CREATESAMPLERSURFACE2D = 0x1126, 502 CM_FN_CMDEVICE_CREATESAMPLERSURFACE3D = 0x1127, 503 CM_FN_CMDEVICE_DESTROYSAMPLERSURFACE = 0x1128, 504 CM_FN_CMDEVICE_ENABLE_GTPIN = 0X112A, 505 CM_FN_CMDEVICE_INIT_PRINT_BUFFER = 0x112C, 506 CM_FN_CMDEVICE_CREATEVEBOX = 0x112D, 507 CM_FN_CMDEVICE_DESTROYVEBOX = 0x112E, 508 CM_FN_CMDEVICE_CREATEBUFFERSVM = 0x1131, 509 CM_FN_CMDEVICE_DESTROYBUFFERSVM = 0x1132, 510 CM_FN_CMDEVICE_CREATESAMPLERSURFACE2DUP = 0x1133, 511 CM_FN_CMDEVICE_REGISTER_GTPIN_MARKERS = 0x1136, 512 CM_FN_CMDEVICE_CLONEKERNEL = 0x1137, 513 CM_FN_CMDEVICE_CREATESURFACE2D_ALIAS = 0x1138, 514 CM_FN_CMDEVICE_CREATESAMPLER_EX = 0x1139, 515 516 CM_FN_CMDEVICE_CREATESAMPLER8X8SURFACE_EX = 0x113A, 517 CM_FN_CMDEVICE_CREATESAMPLERSURFACE2D_EX = 0x113B, 518 CM_FN_CMDEVICE_CREATESURFACE2D_EX = 0x113C, 519 CM_FN_CMDEVICE_CREATEBUFFER_ALIAS = 0x113D, 520 CM_FN_CMDEVICE_CONFIGVMESURFACEDIMENSION = 0x113E, 521 CM_FN_CMDEVICE_CREATEHEVCVMESURFACEG10 = 0x113F, 522 CM_FN_CMDEVICE_GETVISAVERSION = 0x1140, 523 CM_FN_CMDEVICE_CREATEQUEUEEX = 0x1141, 524 CM_FN_CMDEVICE_FLUSH_PRINT_BUFFER = 0x1142, 525 CM_FN_CMDEVICE_DESTROYBUFFERSTATELESS = 0x1143, 526 527 CM_FN_CMQUEUE_ENQUEUE = 0x1500, 528 CM_FN_CMQUEUE_DESTROYEVENT = 0x1501, 529 CM_FN_CMQUEUE_ENQUEUECOPY = 0x1502, 530 CM_FN_CMQUEUE_ENQUEUEWITHGROUP = 0x1504, 531 CM_FN_CMQUEUE_ENQUEUESURF2DINIT = 0x1505, 532 CM_FN_CMQUEUE_ENQUEUECOPY_V2V = 0x1506, 533 CM_FN_CMQUEUE_ENQUEUECOPY_L2L = 0x1507, 534 CM_FN_CMQUEUE_ENQUEUEVEBOX = 0x1508, 535 CM_FN_CMQUEUE_ENQUEUEWITHHINTS = 0x1509, 536 CM_FN_CMQUEUE_ENQUEUEFAST = 0x150a, 537 CM_FN_CMQUEUE_DESTROYEVENTFAST = 0x150b, 538 CM_FN_CMQUEUE_ENQUEUEWITHGROUPFAST = 0x150c, 539 CM_FN_CMQUEUE_ENQUEUECOPY_BUFFER = 0x150d, 540 }; 541 542 //*----------------------------------------------------------------------------- 543 //| Purpose: CMRT thin layer library supported function execution 544 //| Return: CM_SUCCESS if successful 545 //*----------------------------------------------------------------------------- 546 using CMRT_UMD::CmDevice; 547 int32_t CmThinExecuteInternal(CmDevice *device, 548 CM_FUNCTION_ID cmFunctionID, 549 void *inputData, 550 uint32_t inputDataLen); 551 552 namespace CMRT_UMD 553 { 554 // class of CmWrapperEx for functionality extention in cm wrapper 555 class CmWrapperEx 556 { 557 public: CmWrapperEx()558 CmWrapperEx(){} ~CmWrapperEx()559 virtual ~CmWrapperEx(){} 560 561 virtual void Initialize(void *context); 562 virtual int Execute( 563 CmDevice *device, 564 CM_FUNCTION_ID cmFunctionID, 565 void *inputData, 566 uint32_t inputDataLen); 567 }; 568 }; 569 #endif // #ifndef MEDIADRIVER_AGNOSTIC_COMMON_CM_CMWRAPPER_H_ 570