Debian Codegraph @

media_driver/agnostic/common/hw/mhw_render_generic.h

raw
1 /*
2 * Copyright (c) 2014-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 mhw_render_generic.h
24 //! \brief MHW interface templates for render engine commands
25 //! \details Impelements shared HW command construction functions across all platforms as templates
26 //!
27
28 #ifndef __MHW_RENDER_GENERIC_H__
29 #define __MHW_RENDER_GENERIC_H__
30
31 #include "mhw_render_legacy.h"
32
33 template <class TRenderCmds>
34 class MhwRenderInterfaceGeneric : public MhwRenderInterface
35 {
36 protected:
37 MhwRenderInterfaceGeneric(
38 MhwMiInterface *miInterface,
39 PMOS_INTERFACE osInterface,
40 MEDIA_SYSTEM_INFO *gtSystemInfo,
41 uint8_t newStateHeapManagerRequested) :
42 MhwRenderInterface(miInterface, osInterface, gtSystemInfo, newStateHeapManagerRequested){}
43
44 public:
45 virtual ~MhwRenderInterfaceGeneric() { MHW_FUNCTION_ENTER; }
46
47 MOS_STATUS AddPipelineSelectCmd(
48 PMOS_COMMAND_BUFFER cmdBuffer,
49 bool gpGpuPipe)
50 {
51 MHW_FUNCTION_ENTER;
52
53 MHW_MI_CHK_NULL(m_osInterface);
54 MHW_MI_CHK_NULL(cmdBuffer);
55
56 typename TRenderCmds::PIPELINE_SELECT_CMD cmd;
57 cmd.DW0.PipelineSelection = (gpGpuPipe) ? cmd.PIPELINE_SELECTION_GPGPU : cmd.PIPELINE_SELECTION_MEDIA;
58
59 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
60
61 return MOS_STATUS_SUCCESS;
62 }
63
64 MOS_STATUS AddStateBaseAddrCmd(
65 PMOS_COMMAND_BUFFER cmdBuffer,
66 PMHW_STATE_BASE_ADDR_PARAMS params)
67 {
68 MHW_FUNCTION_ENTER;
69
70 MHW_MI_CHK_NULL(m_osInterface);
71 MHW_MI_CHK_NULL(cmdBuffer);
72 MHW_MI_CHK_NULL(params);
73
74 MHW_RESOURCE_PARAMS resourceParams;
75 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
76 resourceParams.dwLsbNum = MHW_RENDER_ENGINE_STATE_BASE_ADDRESS_SHIFT;
77 resourceParams.HwCommandType = MOS_STATE_BASE_ADDR;
78
79 typename TRenderCmds::STATE_BASE_ADDRESS_CMD cmd;
80
81 if (params->presGeneralState)
82 {
83 cmd.DW1_2.GeneralStateBaseAddressModifyEnable = true;
84 cmd.DW12.GeneralStateBufferSizeModifyEnable = true;
85 resourceParams.presResource = params->presGeneralState;
86 resourceParams.dwOffset = 0;
87 resourceParams.pdwCmd = cmd.DW1_2.Value;
88 resourceParams.dwLocationInCmd = 1;
89
90 // upper bound of the allocated resource will not be set
91 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
92
93 InitMocsParams(resourceParams, &cmd.DW1_2.Value[0], 5, 10);
94
95 MHW_MI_CHK_STATUS(AddResourceToCmd(
96 m_osInterface,
97 cmdBuffer,
98 &resourceParams));
99
100 if (params->mocs4GeneralState != 0)
101 {
102 cmd.DW1_2.GeneralStateMemoryObjectControlState = params->mocs4GeneralState;
103 }
104
105 cmd.DW12.GeneralStateBufferSize = (params->dwGeneralStateSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
106 }
107
108 if (m_osInterface->bNoParsingAssistanceInKmd)
109 {
110 uint32_t indirectStateOffset, indirectStateSize;
111 MHW_MI_CHK_STATUS(m_osInterface->pfnGetIndirectState(m_osInterface, &indirectStateOffset, &indirectStateSize));
112
113 // When KMD parsing assistance is not used,
114 // UMD is required to set up the SSH
115 // in the STATE_BASE_ADDRESS command.
116 // All addresses used in the STATE_BASE_ADDRESS
117 // command need to have the modify
118 // bit associated with it set to 1.
119 cmd.DW4_5.SurfaceStateBaseAddressModifyEnable = true;
120 resourceParams.presResource = &cmdBuffer->OsResource;
121 resourceParams.dwOffset = indirectStateOffset;
122 resourceParams.pdwCmd = cmd.DW4_5.Value;
123 resourceParams.dwLocationInCmd = 4;
124
125 // upper bound of the allocated resource will not be set
126 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
127
128 InitMocsParams(resourceParams, &cmd.DW4_5.Value[0], 5, 10);
129
130 MHW_MI_CHK_STATUS(AddResourceToCmd(
131 m_osInterface,
132 cmdBuffer,
133 &resourceParams));
134
135 if (params->mocs4SurfaceState != 0)
136 {
137 cmd.DW4_5.SurfaceStateMemoryObjectControlState = params->mocs4SurfaceState;
138 }
139 }
140
141 if (params->presDynamicState)
142 {
143 cmd.DW6_7.DynamicStateBaseAddressModifyEnable = true;
144 cmd.DW13.DynamicStateBufferSizeModifyEnable = true;
145 resourceParams.presResource = params->presDynamicState;
146 resourceParams.dwOffset = 0;
147 resourceParams.pdwCmd = cmd.DW6_7.Value;
148 resourceParams.dwLocationInCmd = 6;
149 resourceParams.bIsWritable = params->bDynamicStateRenderTarget;
150
151 // upper bound of the allocated resource will not be set
152 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
153
154 InitMocsParams(resourceParams, &cmd.DW6_7.Value[0], 5, 10);
155
156 MHW_MI_CHK_STATUS(AddResourceToCmd(
157 m_osInterface,
158 cmdBuffer,
159 &resourceParams));
160
161 if (params->mocs4DynamicState != 0)
162 {
163 cmd.DW6_7.DynamicStateMemoryObjectControlState = params->mocs4DynamicState;
164 }
165
166 cmd.DW13.DynamicStateBufferSize = (params->dwDynamicStateSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
167
168 //Reset bRenderTarget as it should be enabled only for Dynamic State
169 resourceParams.bIsWritable = false;
170 }
171
172 if (params->presIndirectObjectBuffer)
173 {
174 cmd.DW8_9.IndirectObjectBaseAddressModifyEnable = true;
175 cmd.DW14.IndirectObjectBufferSizeModifyEnable = true;
176 resourceParams.presResource = params->presIndirectObjectBuffer;
177 resourceParams.dwOffset = 0;
178 resourceParams.pdwCmd = cmd.DW8_9.Value;
179 resourceParams.dwLocationInCmd = 8;
180
181 // upper bound of the allocated resource will not be set
182 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
183
184 InitMocsParams(resourceParams, &cmd.DW8_9.Value[0], 5, 10);
185
186 MHW_MI_CHK_STATUS(AddResourceToCmd(
187 m_osInterface,
188 cmdBuffer,
189 &resourceParams));
190
191 if (params->mocs4IndirectObjectBuffer != 0)
192 {
193 cmd.DW8_9.IndirectObjectMemoryObjectControlState = params->mocs4IndirectObjectBuffer;
194 }
195
196 cmd.DW14.IndirectObjectBufferSize = (params->dwIndirectObjectBufferSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
197 }
198
199 if (params->presInstructionBuffer)
200 {
201 cmd.DW10_11.InstructionBaseAddressModifyEnable = true;
202 cmd.DW15.InstructionBufferSizeModifyEnable = true;
203 resourceParams.presResource = params->presInstructionBuffer;
204 resourceParams.dwOffset = 0;
205 resourceParams.pdwCmd = cmd.DW10_11.Value;
206 resourceParams.dwLocationInCmd = 10;
207
208 // upper bound of the allocated resource will not be set
209 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
210
211 InitMocsParams(resourceParams, &cmd.DW10_11.Value[0], 5, 10);
212
213 MHW_MI_CHK_STATUS(AddResourceToCmd(
214 m_osInterface,
215 cmdBuffer,
216 &resourceParams));
217
218 if (params->mocs4InstructionCache != 0)
219 {
220 cmd.DW10_11.InstructionMemoryObjectControlState = params->mocs4InstructionCache;
221 }
222
223 cmd.DW15.InstructionBufferSize = (params->dwInstructionBufferSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE;
224 }
225
226 // stateless dataport access
227 cmd.DW3.StatelessDataPortAccessMemoryObjectControlState = params->mocs4StatelessDataport;
228
229 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
230
231 return MOS_STATUS_SUCCESS;
232 }
233
234 MOS_STATUS AddMediaVfeCmd(
235 PMOS_COMMAND_BUFFER cmdBuffer,
236 PMHW_VFE_PARAMS params)
237 {
238 MHW_FUNCTION_ENTER;
239
240 MHW_MI_CHK_NULL(m_osInterface);
241 MHW_MI_CHK_NULL(cmdBuffer);
242 MHW_MI_CHK_NULL(params);
243
244 typename TRenderCmds::MEDIA_VFE_STATE_CMD cmd;
245
246 if (params->pKernelState)
247 {
248 MHW_MI_CHK_NULL(params->pKernelState);
249
250 cmd.DW3.MaximumNumberOfThreads = (params->dwMaximumNumberofThreads) ?
251 params->dwMaximumNumberofThreads - 1 : params->pKernelState->KernelParams.iThreadCount - 1;
252 cmd.DW5.CurbeAllocationSize =
253 MOS_ROUNDUP_SHIFT(params->pKernelState->KernelParams.iCurbeLength, 5);
254 cmd.DW5.UrbEntryAllocationSize = MOS_MAX(1,
255 MOS_ROUNDUP_SHIFT(params->pKernelState->KernelParams.iInlineDataLength, 5));
256
257 uint32_t numberofURBEntries =
258 (m_hwCaps.dwMaxURBSize -
259 cmd.DW5.CurbeAllocationSize -
260 params->pKernelState->KernelParams.iIdCount) /
261 cmd.DW5.UrbEntryAllocationSize;
262 numberofURBEntries = MOS_CLAMP_MIN_MAX(numberofURBEntries, 1, 64);
263 cmd.DW3.NumberOfUrbEntries = numberofURBEntries;
264 }
265 else
266 {
267 if (params->dwNumberofURBEntries == 0)
268 {
269 MHW_ASSERTMESSAGE("Parameter dwNumberofURBEntries is 0 will cause divided by zero.");
270 return MOS_STATUS_INVALID_PARAMETER;
271 }
272
273 if (params->dwPerThreadScratchSpace)
274 {
275 cmd.DW1.PerThreadScratchSpace = params->dwPerThreadScratchSpace;
276 cmd.DW1.ScratchSpaceBasePointer = params->dwScratchSpaceBasePointer >> 10;
277 cmd.DW2.ScratchSpaceBasePointerHigh = 0;
278 }
279 cmd.DW3.MaximumNumberOfThreads = (params->dwMaximumNumberofThreads) ?
280 params->dwMaximumNumberofThreads - 1 : m_hwCaps.dwMaxThreads - 1;
281 cmd.DW3.NumberOfUrbEntries = params->dwNumberofURBEntries;
282 cmd.DW5.CurbeAllocationSize = params->dwCURBEAllocationSize >> 5;
283 cmd.DW5.UrbEntryAllocationSize = (params->dwURBEntryAllocationSize) ?
284 params->dwURBEntryAllocationSize :
285 (m_hwCaps.dwMaxURBSize -
286 cmd.DW5.CurbeAllocationSize -
287 m_hwCaps.dwMaxInterfaceDescriptorEntries) /
288 params->dwNumberofURBEntries;
289 }
290
291 if ((cmd.DW3.NumberOfUrbEntries > m_hwCaps.dwMaxURBEntries) ||
292 (cmd.DW5.CurbeAllocationSize > m_hwCaps.dwMaxCURBEAllocationSize) ||
293 (cmd.DW5.UrbEntryAllocationSize > m_hwCaps.dwMaxURBEntryAllocationSize) ||
294 (cmd.DW3.NumberOfUrbEntries * cmd.DW5.UrbEntryAllocationSize +
295 cmd.DW5.CurbeAllocationSize +
296 m_hwCaps.dwMaxInterfaceDescriptorEntries > m_hwCaps.dwMaxURBSize))
297 {
298 MHW_ASSERTMESSAGE("Parameters requested exceed maximum supported by HW.");
299 return MOS_STATUS_INVALID_PARAMETER;
300 }
301
302 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
303
304 return MOS_STATUS_SUCCESS;
305 }
306
307 MOS_STATUS AddMediaCurbeLoadCmd(
308 PMOS_COMMAND_BUFFER cmdBuffer,
309 PMHW_CURBE_LOAD_PARAMS params)
310 {
311 MHW_FUNCTION_ENTER;
312
313 MHW_MI_CHK_NULL(m_osInterface);
314 MHW_MI_CHK_NULL(cmdBuffer);
315 MHW_MI_CHK_NULL(params);
316
317 typename TRenderCmds::MEDIA_CURBE_LOAD_CMD cmd;
318
319 if (params->pKernelState)
320 {
321 MHW_MI_CHK_NULL(m_stateHeapInterface->pStateHeapInterface);
322
323 auto kernelState = params->pKernelState;
324
325 cmd.DW2.CurbeTotalDataLength = (uint32_t)MOS_ALIGN_CEIL(
326 kernelState->KernelParams.iCurbeLength,
327 m_stateHeapInterface->pStateHeapInterface->GetCurbeAlignment());
328 cmd.DW3.CurbeDataStartAddress = MOS_ALIGN_CEIL(
329 (kernelState->m_dshRegion.GetOffset() +
330 kernelState->dwCurbeOffset),
331 m_stateHeapInterface->pStateHeapInterface->GetCurbeAlignment());
332 }
333 else
334 {
335 cmd.DW2.CurbeTotalDataLength = params->dwCURBETotalDataLength;
336 cmd.DW3.CurbeDataStartAddress = params->dwCURBEDataStartAddress;
337 }
338
339 // Send the command only if there is data to load
340 if (cmd.DW2.CurbeTotalDataLength)
341 {
342 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
343 }
344 else
345 {
346 MHW_NORMALMESSAGE("MEDIA_CURBE_LOAD must load data. Command skipped.");
347 }
348
349 return MOS_STATUS_SUCCESS;
350 }
351
352 MOS_STATUS AddMediaIDLoadCmd(
353 PMOS_COMMAND_BUFFER cmdBuffer,
354 PMHW_ID_LOAD_PARAMS params)
355 {
356 MHW_FUNCTION_ENTER;
357
358 MHW_MI_CHK_NULL(m_osInterface);
359 MHW_MI_CHK_NULL(cmdBuffer);
360 MHW_MI_CHK_NULL(params);
361 MHW_MI_CHK_NULL(m_stateHeapInterface->pStateHeapInterface);
362
363 typename TRenderCmds::MEDIA_INTERFACE_DESCRIPTOR_LOAD_CMD cmd;
364
365 if (params->pKernelState)
366 {
367 auto kernelState = params->pKernelState;
368
369 cmd.DW2.InterfaceDescriptorTotalLength =
370 m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData() * params->dwNumKernelsLoaded;
371 cmd.DW3.InterfaceDescriptorDataStartAddress = MOS_ALIGN_CEIL(
372 kernelState->m_dshRegion.GetOffset() +
373 kernelState->dwIdOffset +
374 (params->dwIdIdx * m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData()),
375 m_stateHeapInterface->pStateHeapInterface->GetIdAlignment());
376 }
377 // Client managed MediaIDs
378 else if (params->dwInterfaceDescriptorLength)
379 {
380 cmd.DW2.InterfaceDescriptorTotalLength = params->dwInterfaceDescriptorLength;
381 cmd.DW3.InterfaceDescriptorDataStartAddress = params->dwInterfaceDescriptorStartOffset;
382 }
383
384 if (cmd.DW2.InterfaceDescriptorTotalLength > 0)
385 {
386 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
387 }
388 else
389 {
390 MHW_NORMALMESSAGE("MEDIA_INTERFACE_DESCRIPTOR_LOAD must load data. Command skipped.");
391 }
392
393 return MOS_STATUS_SUCCESS;
394 }
395
396 MOS_STATUS AddMediaObject(
397 PMOS_COMMAND_BUFFER cmdBuffer,
398 PMHW_BATCH_BUFFER batchBuffer,
399 PMHW_MEDIA_OBJECT_PARAMS params)
400 {
401 MHW_FUNCTION_ENTER;
402
403 MHW_MI_CHK_NULL(params);
404
405 if (cmdBuffer == nullptr && batchBuffer == nullptr)
406 {
407 MHW_ASSERTMESSAGE("No valid buffer to add the command to!");
408 return MOS_STATUS_INVALID_PARAMETER;
409 }
410
411 typename TRenderCmds::MEDIA_OBJECT_CMD cmd;
412
413 if (params->dwInlineDataSize > 0)
414 {
415 cmd.DW0.DwordLength =
416 TRenderCmds::GetOpLength(((params->dwInlineDataSize / sizeof(uint32_t)) + cmd.dwSize));
417 }
418
419 cmd.DW1.InterfaceDescriptorOffset = params->dwInterfaceDescriptorOffset;
420 cmd.DW2.IndirectDataLength = params->dwIndirectLoadLength;
421 cmd.DW2.SubsliceDestinationSelect = params->dwHalfSliceDestinationSelect;
422 cmd.DW2.SliceDestinationSelect = params->dwSliceDestinationSelect;
423 cmd.DW2.ForceDestination = params->bForceDestination;
424 cmd.DW3.IndirectDataStartAddress = params->dwIndirectDataStartAddress;
425
426 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(
427 m_osInterface,
428 cmdBuffer,
429 batchBuffer,
430 &cmd,
431 cmd.byteSize));
432
433 if (params->pInlineData && params->dwInlineDataSize > 0)
434 {
435 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(
436 m_osInterface,
437 cmdBuffer,
438 batchBuffer,
439 params->pInlineData,
440 params->dwInlineDataSize));
441 }
442
443 return MOS_STATUS_SUCCESS;
444 }
445
446 MOS_STATUS AddMediaObjectWalkerCmd(
447 PMOS_COMMAND_BUFFER cmdBuffer,
448 PMHW_WALKER_PARAMS params)
449 {
450 MHW_FUNCTION_ENTER;
451
452 MHW_MI_CHK_NULL(m_osInterface);
453 MHW_MI_CHK_NULL(cmdBuffer);
454 MHW_MI_CHK_NULL(params);
455
456 typename TRenderCmds::MEDIA_OBJECT_WALKER_CMD cmd;
457
458 if (params->pInlineData)
459 {
460 cmd.DW0.DwordLength =
461 TRenderCmds::GetOpLength(cmd.dwSize + params->InlineDataLength / sizeof(uint32_t));
462 }
463
464 cmd.DW1.InterfaceDescriptorOffset = params->InterfaceDescriptorOffset;
465 cmd.DW5.GroupIdLoopSelect = params->GroupIdLoopSelect;
466 cmd.DW6.ColorCountMinusOne = params->ColorCountMinusOne;
467 cmd.DW6.MiddleLoopExtraSteps = params->MiddleLoopExtraSteps;
468 cmd.DW6.MidLoopUnitX = params->MidLoopUnitX;
469 cmd.DW6.LocalMidLoopUnitY = params->MidLoopUnitY;
470 cmd.DW7.LocalLoopExecCount = params->dwLocalLoopExecCount;
471 cmd.DW7.GlobalLoopExecCount = params->dwGlobalLoopExecCount;
472 cmd.DW8.BlockResolutionX = params->BlockResolution.x;
473 cmd.DW8.BlockResolutionY = params->BlockResolution.y;
474 cmd.DW9.LocalStartX = params->LocalStart.x;
475 cmd.DW9.LocalStartY = params->LocalStart.y;
476 cmd.DW11.LocalOuterLoopStrideX = params->LocalOutLoopStride.x;
477 cmd.DW11.LocalOuterLoopStrideY = params->LocalOutLoopStride.y;
478 cmd.DW12.LocalInnerLoopUnitX = params->LocalInnerLoopUnit.x;
479 cmd.DW12.LocalInnerLoopUnitY = params->LocalInnerLoopUnit.y;
480 cmd.DW13.GlobalResolutionX = params->GlobalResolution.x;
481 cmd.DW13.GlobalResolutionY = params->GlobalResolution.y;
482 cmd.DW14.GlobalStartX = params->GlobalStart.x;
483 cmd.DW14.GlobalStartY = params->GlobalStart.y;
484 cmd.DW15.GlobalOuterLoopStrideX = params->GlobalOutlerLoopStride.x;
485 cmd.DW15.GlobalOuterLoopStrideY = params->GlobalOutlerLoopStride.y;
486 cmd.DW16.GlobalInnerLoopUnitX = params->GlobalInnerLoopUnit.x;
487 cmd.DW16.GlobalInnerLoopUnitY = params->GlobalInnerLoopUnit.y;
488
489 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
490
491 if (params->pInlineData)
492 {
493 if (params->InlineDataLength > 0)
494 {
495 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(
496 cmdBuffer,
497 params->pInlineData,
498 params->InlineDataLength));
499 }
500 else
501 {
502 MHW_NORMALMESSAGE("Inline data indicated, however cannot insert without valid length.");
503 }
504 }
505
506 return MOS_STATUS_SUCCESS;
507 }
508
509 MOS_STATUS AddGpGpuWalkerStateCmd(
510 PMOS_COMMAND_BUFFER cmdBuffer,
511 PMHW_GPGPU_WALKER_PARAMS params)
512 {
513 MHW_FUNCTION_ENTER;
514
515 MHW_MI_CHK_NULL(m_osInterface);
516 MHW_MI_CHK_NULL(cmdBuffer);
517 MHW_MI_CHK_NULL(params);
518
519 if (params->ThreadDepth == 0)
520 {
521 params->ThreadDepth = 1;
522 }
523 if (params->GroupDepth == 0)
524 {
525 params->GroupDepth = 1;
526 }
527
528 typename TRenderCmds::GPGPU_WALKER_CMD cmd;
529 cmd.DW1.InterfaceDescriptorOffset = params->InterfaceDescriptorOffset;
530 cmd.DW4.SimdSize = 2; // SIMD32
531 cmd.DW4.ThreadWidthCounterMaximum = params->ThreadWidth - 1;
532 cmd.DW4.ThreadHeightCounterMaximum = params->ThreadHeight - 1;
533 cmd.DW4.ThreadDepthCounterMaximum = params->ThreadDepth - 1;
534 cmd.DW5.ThreadGroupIdStartingX = 0;
535 cmd.DW7.ThreadGroupIdXDimension = params->GroupWidth;
536 cmd.DW8.ThreadGroupIdStartingY = 0;
537 cmd.DW10.ThreadGroupIdYDimension = params->GroupHeight;
538 cmd.DW11.ThreadGroupIdStartingResumeZ = 0;
539 cmd.DW12.ThreadGroupIdZDimension = params->GroupDepth;
540 cmd.DW13.RightExecutionMask = 0xffffffff;
541 cmd.DW14.BottomExecutionMask = 0xffffffff;
542
543 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
544
545 return MOS_STATUS_SUCCESS;
546 }
547 MOS_STATUS AddChromaKeyCmd(
548 PMOS_COMMAND_BUFFER cmdBuffer,
549 PMHW_CHROMAKEY_PARAMS params)
550 {
551 MHW_FUNCTION_ENTER;
552
553 MHW_MI_CHK_NULL(m_osInterface);
554 MHW_MI_CHK_NULL(cmdBuffer);
555 MHW_MI_CHK_NULL(params);
556
557 typename TRenderCmds::_3DSTATE_CHROMA_KEY_CMD cmd;
558 cmd.DW1.ChromakeyTableIndex = params->dwIndex;
559 cmd.DW2.ChromakeyLowValue = params->dwLow;
560 cmd.DW3.ChromakeyHighValue = params->dwHigh;
561
562 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
563
564 return MOS_STATUS_SUCCESS;
565 }
566
567 MOS_STATUS AddSipStateCmd(
568 PMOS_COMMAND_BUFFER cmdBuffer,
569 PMHW_SIP_STATE_PARAMS params)
570 {
571 MHW_FUNCTION_ENTER;
572
573 MHW_MI_CHK_NULL(m_osInterface);
574 MHW_MI_CHK_NULL(cmdBuffer);
575 MHW_MI_CHK_NULL(params);
576
577 typename TRenderCmds::STATE_SIP_CMD cmd;
578 cmd.DW1_2.SystemInstructionPointer = (uint64_t)(params->dwSipBase >> 4);
579
580 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize))
581
582 return MOS_STATUS_SUCCESS;
583 }
584
585 inline uint32_t GetMediaObjectCmdSize()
586 {
587 return TRenderCmds::MEDIA_OBJECT_CMD::byteSize;
588 }
589 };
590
591 #endif // __MHW_RENDER_GENERIC_H__