Debian Codegraph @

media_driver/agnostic/gen8_bdw/hw/vdbox/mhw_vdbox_mfx_g8_bdw.cpp

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 mhw_vdbox_mfx_g8_bdw.cpp
24 //! \brief Defines functions for constructing Vdbox MFX commands on BDW
25 //!
26
27 #include "mhw_vdbox_mfx_g8_bdw.h"
28 #include "mos_os_cp_interface_specific.h"
29
30 MOS_STATUS MhwVdboxMfxInterfaceG8Bdw::AddMfxPipeBufAddrCmd(
31 PMOS_COMMAND_BUFFER cmdBuffer,
32 PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params)
33 {
34 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
35
36 MHW_FUNCTION_ENTER;
37
38 MHW_MI_CHK_NULL(m_osInterface);
39 MHW_MI_CHK_NULL(cmdBuffer);
40 MHW_MI_CHK_NULL(params);
41
42 MHW_RESOURCE_PARAMS resourceParams;
43 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
44 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
45 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
46
47 mhw_vdbox_mfx_g8_bdw::MFX_PIPE_BUF_ADDR_STATE_CMD cmd;
48
49 // Encoding uses both surfaces regardless of deblocking status
50 if (params->psPreDeblockSurface != nullptr)
51 {
52 cmd.DW3.MemoryObjectControlState =
53 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC].Value;
54
55 resourceParams.presResource = &(params->psPreDeblockSurface->OsResource);
56 resourceParams.dwOffset = params->psPreDeblockSurface->dwOffset;
57 resourceParams.pdwCmd = &(cmd.DW1.Value);
58 resourceParams.dwLocationInCmd = 1;
59 resourceParams.bIsWritable = true;
60
61 MHW_MI_CHK_STATUS(AddResourceToCmd(
62 m_osInterface,
63 cmdBuffer,
64 &resourceParams));
65 }
66
67 if (params->psPostDeblockSurface != nullptr)
68 {
69 cmd.DW6.MemoryObjectControlState =
70 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_POST_DEBLOCKING_CODEC].Value;
71
72 resourceParams.presResource = &(params->psPostDeblockSurface->OsResource);
73 resourceParams.dwOffset = params->psPostDeblockSurface->dwOffset;
74 resourceParams.pdwCmd = &(cmd.DW4.Value);
75 resourceParams.dwLocationInCmd = 4;
76 resourceParams.bIsWritable = true;
77
78 MHW_MI_CHK_STATUS(AddResourceToCmd(
79 m_osInterface,
80 cmdBuffer,
81 &resourceParams));
82 }
83
84 if (params->psRawSurface != nullptr)
85 {
86 if (!m_decodeInUse)
87 {
88 cmd.DW9.MemoryObjectControlState =
89 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value;
90 }
91 else
92 {
93 cmd.DW9.MemoryObjectControlState =
94 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_DECODE].Value;
95 }
96
97 resourceParams.presResource = &params->psRawSurface->OsResource;
98 resourceParams.dwOffset = params->psRawSurface->dwOffset;
99 resourceParams.pdwCmd = &(cmd.DW7.Value);
100 resourceParams.dwLocationInCmd = 7;
101 resourceParams.bIsWritable = false;
102
103 MHW_MI_CHK_STATUS(AddResourceToCmd(
104 m_osInterface,
105 cmdBuffer,
106 &resourceParams));
107 }
108
109 if (params->presStreamOutBuffer != nullptr)
110 {
111 cmd.DW12.MemoryObjectControlState =
112 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
113
114 resourceParams.presResource = params->presStreamOutBuffer;
115 resourceParams.dwOffset = 0;
116 resourceParams.pdwCmd = &(cmd.DW10.Value);
117 resourceParams.dwLocationInCmd = 10;
118 resourceParams.bIsWritable = true;
119
120 MHW_MI_CHK_STATUS(AddResourceToCmd(
121 m_osInterface,
122 cmdBuffer,
123 &resourceParams));
124
125 if (!m_decodeInUse)
126 {
127 cmd.DW54.MemoryObjectControlState =
128 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
129
130 resourceParams.presResource = params->presStreamOutBuffer;
131 resourceParams.dwOffset = 0;
132 resourceParams.pdwCmd = &(cmd.DW52.Value);
133 resourceParams.dwLocationInCmd = 52;
134 resourceParams.bIsWritable = true;
135
136 MHW_MI_CHK_STATUS(AddResourceToCmd(
137 m_osInterface,
138 cmdBuffer,
139 &resourceParams));
140 }
141 }
142
143 if (params->presMfdIntraRowStoreScratchBuffer != nullptr)
144 {
145 cmd.DW15.MemoryObjectControlState =
146 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
147
148 resourceParams.presResource = params->presMfdIntraRowStoreScratchBuffer;
149 resourceParams.dwOffset = 0;
150 resourceParams.pdwCmd = &(cmd.DW13.Value);
151 resourceParams.dwLocationInCmd = 13;
152 resourceParams.bIsWritable = true;
153
154 MHW_MI_CHK_STATUS(AddResourceToCmd(
155 m_osInterface,
156 cmdBuffer,
157 &resourceParams));
158 }
159
160 if (params->presMfdDeblockingFilterRowStoreScratchBuffer != nullptr)
161 {
162 cmd.DW18.MemoryObjectControlState =
163 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
164
165 resourceParams.presResource = params->presMfdDeblockingFilterRowStoreScratchBuffer;
166 resourceParams.dwOffset = 0;
167 resourceParams.pdwCmd = &(cmd.DW16.Value);
168 resourceParams.dwLocationInCmd = 16;
169 resourceParams.bIsWritable = true;
170
171 MHW_MI_CHK_STATUS(AddResourceToCmd(
172 m_osInterface,
173 cmdBuffer,
174 &resourceParams));
175 }
176
177 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
178 {
179 if (params->presReferences[i] != nullptr)
180 {
181 MOS_SURFACE details;
182 MOS_ZeroMemory(&details, sizeof(details));
183 details.Format = Format_Invalid;
184 MHW_MI_CHK_STATUS(m_osInterface->pfnGetResourceInfo(m_osInterface, params->presReferences[i], &details));
185
186 resourceParams.presResource = params->presReferences[i];
187 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
188 resourceParams.pdwCmd = &(cmd.Refpicbaseaddr[i].DW0_1.Value[0]);
189 resourceParams.dwLocationInCmd = (i * 2) + 19; // * 2 to account for QW rather than DW
190 resourceParams.bIsWritable = false;
191
192 resourceParams.dwSharedMocsOffset = 51 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW51
193
194 MHW_MI_CHK_STATUS(AddResourceToCmd(
195 m_osInterface,
196 cmdBuffer,
197 &resourceParams));
198 }
199 }
200
201 // there is only one control DW51 for all references
202 cmd.DW51.MemoryObjectControlState =
203 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
204
205 // Reset dwSharedMocsOffset
206 resourceParams.dwSharedMocsOffset = 0;
207
208 if (params->presMacroblockIldbStreamOutBuffer1 != nullptr)
209 {
210 resourceParams.presResource = params->presMacroblockIldbStreamOutBuffer1;
211 resourceParams.dwOffset = 0;
212 resourceParams.pdwCmd = &(cmd.DW55.Value);
213 resourceParams.dwLocationInCmd = 55;
214 resourceParams.bIsWritable = true;
215
216 MHW_MI_CHK_STATUS(AddResourceToCmd(
217 m_osInterface,
218 cmdBuffer,
219 &resourceParams));
220 }
221
222 if (params->presMacroblockIldbStreamOutBuffer2 != nullptr)
223 {
224 resourceParams.presResource = params->presMacroblockIldbStreamOutBuffer2;
225 resourceParams.dwOffset = 0;
226 resourceParams.pdwCmd = &(cmd.DW58.Value);
227 resourceParams.dwLocationInCmd = 58;
228 resourceParams.bIsWritable = true;
229
230 MHW_MI_CHK_STATUS(AddResourceToCmd(
231 m_osInterface,
232 cmdBuffer,
233 &resourceParams));
234 }
235
236 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
237
238 return eStatus;
239 }
240
241 MOS_STATUS MhwVdboxMfxInterfaceG8Bdw::AddMfxBspBufBaseAddrCmd(
242 PMOS_COMMAND_BUFFER cmdBuffer,
243 PMHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS params)
244 {
245 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
246
247 MHW_FUNCTION_ENTER;
248
249 MHW_MI_CHK_NULL(m_osInterface);
250 MHW_MI_CHK_NULL(cmdBuffer);
251 MHW_MI_CHK_NULL(params);
252
253 MHW_RESOURCE_PARAMS resourceParams;
254 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
255 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
256 resourceParams.HwCommandType = MOS_MFX_BSP_BUF_BASE_ADDR;
257
258 mhw_vdbox_mfx_g8_bdw::MFX_BSP_BUF_BASE_ADDR_STATE_CMD cmd;
259
260 if (params->presBsdMpcRowStoreScratchBuffer)
261 {
262 cmd.DW3.MemoryObjectControlState =
263 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_BSDMPC_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
264
265 resourceParams.presResource = params->presBsdMpcRowStoreScratchBuffer;
266 resourceParams.dwOffset = 0;
267 resourceParams.pdwCmd = &(cmd.DW1.Value);
268 resourceParams.dwLocationInCmd = 1;
269 resourceParams.bIsWritable = true;
270
271 MHW_MI_CHK_STATUS(AddResourceToCmd(
272 m_osInterface,
273 cmdBuffer,
274 &resourceParams));
275 }
276
277 if (params->presMprRowStoreScratchBuffer)
278 {
279 cmd.DW6.MemoryObjectControlState =
280 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MPR_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
281
282 resourceParams.presResource = params->presMprRowStoreScratchBuffer;
283 resourceParams.dwOffset = 0;
284 resourceParams.pdwCmd = &(cmd.DW4.Value);
285 resourceParams.dwLocationInCmd = 4;
286 resourceParams.bIsWritable = true;
287
288 MHW_MI_CHK_STATUS(AddResourceToCmd(
289 m_osInterface,
290 cmdBuffer,
291 &resourceParams));
292 }
293
294 if (params->presBitplaneBuffer)
295 {
296 cmd.DW9.MemoryObjectControlState =
297 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_BITPLANE_READ_CODEC].Value;
298
299 resourceParams.presResource = params->presBitplaneBuffer;
300 resourceParams.dwOffset = 0;
301 resourceParams.pdwCmd = &(cmd.DW7.Value);
302 resourceParams.dwLocationInCmd = 7;
303 resourceParams.bIsWritable = false;
304
305 MHW_MI_CHK_STATUS(AddResourceToCmd(
306 m_osInterface,
307 cmdBuffer,
308 &resourceParams));
309 }
310
311 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
312
313 return eStatus;
314 }
315
316 MOS_STATUS MhwVdboxMfxInterfaceG8Bdw::AddMfxJpegPicCmd(
317 PMOS_COMMAND_BUFFER cmdBuffer,
318 PMHW_VDBOX_JPEG_PIC_STATE params)
319 {
320 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
321
322 MHW_FUNCTION_ENTER;
323
324 MHW_MI_CHK_NULL(m_osInterface);
325 MHW_MI_CHK_NULL(cmdBuffer);
326 MHW_MI_CHK_NULL(params);
327 MHW_MI_CHK_NULL(params->pJpegPicParams);
328
329 mhw_vdbox_mfx_g8_bdw::MFX_JPEG_PIC_STATE_CMD cmd;
330 auto picParams = params->pJpegPicParams;
331
332 if (picParams->m_chromaType == jpegRGB || picParams->m_chromaType == jpegBGR)
333 {
334 cmd.DW1.InputFormatYuv = jpegYUV444;
335 }
336 else
337 {
338 cmd.DW1.InputFormatYuv = picParams->m_chromaType;
339 }
340
341 cmd.DW1.Rotation = picParams->m_rotation;
342 cmd.DW1.OutputFormatYuv = GetJpegDecodeFormat((MOS_FORMAT)params->dwOutputFormat);
343
344 if (params->dwOutputFormat == Format_NV12)
345 {
346 if (picParams->m_chromaType == jpegYUV422H2Y ||
347 picParams->m_chromaType == jpegYUV422H4Y)
348 {
349 cmd.DW1.VerticalDownSamplingEnable = 1;
350 }
351 else if (picParams->m_chromaType == jpegYUV422V2Y ||
352 picParams->m_chromaType == jpegYUV422V4Y)
353 {
354 cmd.DW1.HorizontalDownSamplingEnable = 1;
355 }
356 }
357 else if (params->dwOutputFormat == Format_UYVY ||
358 params->dwOutputFormat == Format_YUY2)
359 {
360 if (picParams->m_chromaType == jpegYUV420)
361 {
362 cmd.DW1.VerticalUpSamplingEnable = 1;
363 }
364 }
365
366 cmd.DW2.FrameWidthInBlocksMinus1 = params->dwWidthInBlocks;
367 cmd.DW2.FrameHeightInBlocksMinus1 = params->dwHeightInBlocks;
368
369 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
370
371 return eStatus;
372 }
373
374 MOS_STATUS MhwVdboxMfxInterfaceG8Bdw::AddMfxDecodeVp8PicCmd(
375 PMOS_COMMAND_BUFFER cmdBuffer,
376 PMHW_VDBOX_VP8_PIC_STATE params)
377 {
378 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
379
380 MHW_FUNCTION_ENTER;
381
382 MHW_MI_CHK_NULL(m_osInterface);
383 MHW_MI_CHK_NULL(cmdBuffer);
384 MHW_MI_CHK_NULL(params);
385
386 mhw_vdbox_mfx_g8_bdw::MFX_VP8_PIC_STATE_CMD cmd;
387 auto vp8PicParams = params->pVp8PicParams;
388 auto vp8IqMatrixParams = params->pVp8IqMatrixParams;
389
390 cmd.DW1.FrameWidthMinus1 = vp8PicParams->wFrameWidthInMbsMinus1;
391 cmd.DW1.FrameHeightMinus1 = vp8PicParams->wFrameHeightInMbsMinus1;
392 cmd.DW2.McFilterSelect = (vp8PicParams->version != 0);
393 cmd.DW2.ChromaFullPixelMcFilterMode = (vp8PicParams->version == 3);
394 cmd.DW2.Dblkfiltertype = vp8PicParams->filter_type;
395 cmd.DW2.Skeyframeflag = vp8PicParams->key_frame;
396 cmd.DW2.SegmentationIdStreamoutEnable =
397 (vp8PicParams->segmentation_enabled) && (vp8PicParams->update_mb_segmentation_map);
398 cmd.DW2.SegmentationIdStreaminEnable =
399 (vp8PicParams->segmentation_enabled) && !(vp8PicParams->update_mb_segmentation_map);
400 cmd.DW2.SegmentEnableFlag = vp8PicParams->segmentation_enabled;
401 cmd.DW2.UpdateMbsegmentMapFlag =
402 (vp8PicParams->segmentation_enabled) ? vp8PicParams->update_mb_segmentation_map : 0;
403 cmd.DW2.MbNocoeffSkipflag = vp8PicParams->mb_no_coeff_skip;
404 cmd.DW2.ModeReferenceLoopFilterDeltaEnabled = vp8PicParams->loop_filter_adj_enable;
405 cmd.DW2.GoldenRefPictureMvSignbiasFlag = vp8PicParams->sign_bias_golden;
406 cmd.DW2.AlternateRefPicMvSignbiasFlag = vp8PicParams->sign_bias_alternate;
407 cmd.DW2.DeblockSharpnessLevel = vp8PicParams->ucSharpnessLevel;
408 cmd.DW3.DblkfilterlevelForSegment3 = vp8PicParams->ucLoopFilterLevel[3];
409 cmd.DW3.DblkfilterlevelForSegment2 = vp8PicParams->ucLoopFilterLevel[2];
410 cmd.DW3.DblkfilterlevelForSegment1 = vp8PicParams->ucLoopFilterLevel[1];
411 cmd.DW3.DblkfilterlevelForSegment0 = vp8PicParams->ucLoopFilterLevel[0];
412
413 uint32_t i = 0;
414 uint32_t j = 0;
415 cmd.DW4.QuantizerValue0Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j];
416 cmd.DW4.QuantizerValue0Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
417
418 i = 0;
419 j = 2;
420 cmd.DW5.QuantizerValue0Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j];
421 cmd.DW5.QuantizerValue0Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1];
422
423 i = 0;
424 j = 4;
425 cmd.DW6.QuantizerValue0Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j];
426 cmd.DW6.QuantizerValue0Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
427
428 i = 1;
429 j = 0;
430 cmd.DW7.QuantizerValue1Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j];
431 cmd.DW7.QuantizerValue1Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
432
433 i = 1;
434 j = 2;
435 cmd.DW8.QuantizerValue1Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j];
436 cmd.DW8.QuantizerValue1Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1];
437
438 i = 1;
439 j = 4;
440 cmd.DW9.QuantizerValue1Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j];
441 cmd.DW9.QuantizerValue1Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
442
443 i = 2;
444 j = 0;
445 cmd.DW10.QuantizerValue2Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j];
446 cmd.DW10.QuantizerValue2Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
447
448 i = 2;
449 j = 2;
450 cmd.DW11.QuantizerValue2Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j];
451 cmd.DW11.QuantizerValue2Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1];
452
453 i = 2;
454 j = 4;
455 cmd.DW12.QuantizerValue2Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j];
456 cmd.DW12.QuantizerValue2Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
457
458 i = 3;
459 j = 0;
460 cmd.DW13.QuantizerValue3Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j];
461 cmd.DW13.QuantizerValue3Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
462
463 i = 3;
464 j = 2;
465 cmd.DW14.QuantizerValue3Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j];
466 cmd.DW14.QuantizerValue3Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1];
467
468 i = 3;
469 j = 4;
470 cmd.DW15.QuantizerValue3Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j];
471 cmd.DW15.QuantizerValue3Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
472
473 cmd.DW19.Mbsegmentidtreeprobs2 = vp8PicParams->cMbSegmentTreeProbs[2];
474 cmd.DW19.Mbsegmentidtreeprobs1 = vp8PicParams->cMbSegmentTreeProbs[1];
475 cmd.DW19.Mbsegmentidtreeprobs0 = vp8PicParams->cMbSegmentTreeProbs[0];
476 cmd.DW20.Mbnocoeffskipfalseprob = vp8PicParams->ucProbSkipFalse;
477 cmd.DW20.Intrambprob = vp8PicParams->ucProbIntra;
478 cmd.DW20.Interpredfromlastrefprob = vp8PicParams->ucProbLast;
479 cmd.DW20.Interpredfromgrefrefprob = vp8PicParams->ucProbGolden;
480 cmd.DW21.Ymodeprob3 = vp8PicParams->ucYModeProbs[3];
481 cmd.DW21.Ymodeprob2 = vp8PicParams->ucYModeProbs[2];
482 cmd.DW21.Ymodeprob1 = vp8PicParams->ucYModeProbs[1];
483 cmd.DW21.Ymodeprob0 = vp8PicParams->ucYModeProbs[0];
484 cmd.DW22.Uvmodeprob2 = vp8PicParams->ucUvModeProbs[2];
485 cmd.DW22.Uvmodeprob1 = vp8PicParams->ucUvModeProbs[1];
486 cmd.DW22.Uvmodeprob0 = vp8PicParams->ucUvModeProbs[0];
487
488 i = 0;
489 j = 0;
490 cmd.DW23.Mvupdateprobs00 = vp8PicParams->ucMvUpdateProb[i][j];
491 cmd.DW23.Mvupdateprobs01 = vp8PicParams->ucMvUpdateProb[i][j + 1];
492 cmd.DW23.Mvupdateprobs02 = vp8PicParams->ucMvUpdateProb[i][j + 2];
493 cmd.DW23.Mvupdateprobs03 = vp8PicParams->ucMvUpdateProb[i][j + 3];
494
495 i = 0;
496 j = 4;
497 cmd.DW24.Mvupdateprobs04 = vp8PicParams->ucMvUpdateProb[i][j];
498 cmd.DW24.Mvupdateprobs05 = vp8PicParams->ucMvUpdateProb[i][j + 1];
499 cmd.DW24.Mvupdateprobs06 = vp8PicParams->ucMvUpdateProb[i][j + 2];
500 cmd.DW24.Mvupdateprobs07 = vp8PicParams->ucMvUpdateProb[i][j + 3];
501
502 i = 0;
503 j = 8;
504 cmd.DW25.Mvupdateprobs08 = vp8PicParams->ucMvUpdateProb[i][j];
505 cmd.DW25.Mvupdateprobs09 = vp8PicParams->ucMvUpdateProb[i][j + 1];
506 cmd.DW25.Mvupdateprobs010 = vp8PicParams->ucMvUpdateProb[i][j + 2];
507 cmd.DW25.Mvupdateprobs011 = vp8PicParams->ucMvUpdateProb[i][j + 3];
508
509 i = 0;
510 j = 12;
511 cmd.DW26.Mvupdateprobs012 = vp8PicParams->ucMvUpdateProb[i][j];
512 cmd.DW26.Mvupdateprobs013 = vp8PicParams->ucMvUpdateProb[i][j + 1];
513 cmd.DW26.Mvupdateprobs014 = vp8PicParams->ucMvUpdateProb[i][j + 2];
514 cmd.DW26.Mvupdateprobs015 = vp8PicParams->ucMvUpdateProb[i][j + 3];
515
516 i = 0;
517 j = 16;
518 cmd.DW27.Mvupdateprobs016 = vp8PicParams->ucMvUpdateProb[i][j];
519 cmd.DW27.Mvupdateprobs017 = vp8PicParams->ucMvUpdateProb[i][j + 1];
520 cmd.DW27.Mvupdateprobs018 = vp8PicParams->ucMvUpdateProb[i][j + 2];
521
522 i = 1;
523 j = 0;
524 cmd.DW28.Mvupdateprobs10 = vp8PicParams->ucMvUpdateProb[i][j];
525 cmd.DW28.Mvupdateprobs11 = vp8PicParams->ucMvUpdateProb[i][j + 1];
526 cmd.DW28.Mvupdateprobs12 = vp8PicParams->ucMvUpdateProb[i][j + 2];
527 cmd.DW28.Mvupdateprobs13 = vp8PicParams->ucMvUpdateProb[i][j + 3];
528
529 i = 1;
530 j = 4;
531 cmd.DW29.Mvupdateprobs14 = vp8PicParams->ucMvUpdateProb[i][j];
532 cmd.DW29.Mvupdateprobs15 = vp8PicParams->ucMvUpdateProb[i][j + 1];
533 cmd.DW29.Mvupdateprobs16 = vp8PicParams->ucMvUpdateProb[i][j + 2];
534 cmd.DW29.Mvupdateprobs17 = vp8PicParams->ucMvUpdateProb[i][j + 3];
535
536 i = 1;
537 j = 8;
538 cmd.DW30.Mvupdateprobs18 = vp8PicParams->ucMvUpdateProb[i][j];
539 cmd.DW30.Mvupdateprobs19 = vp8PicParams->ucMvUpdateProb[i][j + 1];
540 cmd.DW30.Mvupdateprobs110 = vp8PicParams->ucMvUpdateProb[i][j + 2];
541 cmd.DW30.Mvupdateprobs111 = vp8PicParams->ucMvUpdateProb[i][j + 3];
542
543 i = 1;
544 j = 12;
545 cmd.DW31.Mvupdateprobs112 = vp8PicParams->ucMvUpdateProb[i][j];
546 cmd.DW31.Mvupdateprobs113 = vp8PicParams->ucMvUpdateProb[i][j + 1];
547 cmd.DW31.Mvupdateprobs114 = vp8PicParams->ucMvUpdateProb[i][j + 2];
548 cmd.DW31.Mvupdateprobs115 = vp8PicParams->ucMvUpdateProb[i][j + 3];
549
550 i = 1;
551 j = 16;
552 cmd.DW32.Mvupdateprobs116 = vp8PicParams->ucMvUpdateProb[i][j];
553 cmd.DW32.Mvupdateprobs117 = vp8PicParams->ucMvUpdateProb[i][j + 1];
554 cmd.DW32.Mvupdateprobs118 = vp8PicParams->ucMvUpdateProb[i][j + 2];
555
556 cmd.DW33.Reflfdelta0ForIntraFrame = vp8PicParams->cRefLfDelta[0];
557 cmd.DW33.Reflfdelta1ForLastFrame = vp8PicParams->cRefLfDelta[1];
558 cmd.DW33.Reflfdelta2ForGoldenFrame = vp8PicParams->cRefLfDelta[2];
559 cmd.DW33.Reflfdelta3ForAltrefFrame = vp8PicParams->cRefLfDelta[3];
560 cmd.DW34.Modelfdelta0ForBPredMode = vp8PicParams->cModeLfDelta[0];
561 cmd.DW34.Modelfdelta1ForZeromvMode = vp8PicParams->cModeLfDelta[1];
562 cmd.DW34.Modelfdelta2ForNearestNearAndNewMode = vp8PicParams->cModeLfDelta[2];
563 cmd.DW34.Modelfdelta3ForSplitmvMode = vp8PicParams->cModeLfDelta[3];
564
565 MHW_RESOURCE_PARAMS resourceParams;
566 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
567 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
568 resourceParams.HwCommandType = MOS_MFX_VP8_PIC;
569
570 resourceParams.presResource = params->presCoefProbBuffer;
571 resourceParams.dwOffset = params->dwCoefProbTableOffset;
572 resourceParams.pdwCmd = &(cmd.DW16.Value);
573 resourceParams.dwLocationInCmd = 16;
574 resourceParams.bIsWritable = false;
575
576 MHW_MI_CHK_STATUS(AddResourceToCmd(
577 m_osInterface,
578 cmdBuffer,
579 &resourceParams));
580
581 if (vp8PicParams->segmentation_enabled)
582 {
583 resourceParams.presResource = params->presSegmentationIdStreamBuffer;
584 resourceParams.dwOffset = 0;
585 resourceParams.pdwCmd = &(cmd.DW35.Value);
586 resourceParams.dwLocationInCmd = 35;
587 resourceParams.bIsWritable = true;
588
589 MHW_MI_CHK_STATUS(AddResourceToCmd(
590 m_osInterface,
591 cmdBuffer,
592 &resourceParams));
593 }
594
595 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
596
597 return eStatus;
598 }