Debian Codegraph @

media_driver/agnostic/common/cm/cm_wrapper.h

raw
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_