| 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: |
| 558 |
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_ |