Debian Codegraph @

media_softlet/agnostic/common/codec/hal/enc/hevc/features/encode_hevc_tile.cpp

raw
1 /*
2 * Copyright (c) 2019-2020, 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 encode_hevc_tile.cpp
24 //! \brief Defines the common interface for hevc tile
25 //!
26
27 #include "encode_hevc_tile.h"
28 #include "encode_hevc_basic_feature.h"
29 #include "codec_def_common.h"
30 #include "encode_hevc_vdenc_feature_manager.h"
31 #include "encode_pipeline.h"
32
33 namespace encode
34 {
35 HevcEncodeTile::HevcEncodeTile(
36 MediaFeatureManager *featureManager,
37 EncodeAllocator *allocator,
38 CodechalHwInterfaceNext *hwInterface,
39 void *constSettings) :
40 EncodeTile(featureManager, allocator, hwInterface, constSettings)
41 {
42 ENCODE_CHK_NULL_NO_STATUS_RETURN(hwInterface);
43 m_mosCtx = hwInterface->GetOsInterface()->pOsContext;
44
45 auto encFeatureManager = dynamic_cast<EncodeHevcVdencFeatureManager *>(featureManager);
46 ENCODE_CHK_NULL_NO_STATUS_RETURN(encFeatureManager);
47
48 m_basicFeature = dynamic_cast<EncodeBasicFeature *>(encFeatureManager->GetFeature(FeatureIDs::basicFeature));
49 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_basicFeature);
50
51 m_hcpItf = std::static_pointer_cast<mhw::vdbox::hcp::Itf>(hwInterface->GetHcpInterfaceNext());
52 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_hcpItf);
53 }
54
55 MOS_STATUS HevcEncodeTile::Init(void* settings)
56 {
57 ENCODE_FUNC_CALL();
58 ENCODE_CHK_NULL_RETURN(settings);
59
60 ENCODE_CHK_STATUS_RETURN(EncodeTile::Init(settings));
61
62 #if (_DEBUG || _RELEASE_INTERNAL)
63 // Tile Replay Enable should be passed from DDI, will change later when DDI is ready
64 MediaUserSetting::Value outValue;
65 ReadUserSetting(
66 m_userSettingPtr,
67 outValue,
68 "HEVC VDEnc TileReplay Enable",
69 MediaUserSetting::Group::Sequence);
70 m_enableTileReplay = outValue.Get<bool>();
71 #else
72 m_enableTileReplay = false;
73 #endif
74
75 return MOS_STATUS_SUCCESS;
76 }
77
78 MOS_STATUS HevcEncodeTile::Update(void *params)
79 {
80 ENCODE_FUNC_CALL();
81 ENCODE_CHK_NULL_RETURN(params);
82
83 EncoderParams* encodeParams = (EncoderParams*)params;;
84 ENCODE_CHK_NULL_RETURN(encodeParams);
85
86 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams =
87 static_cast<PCODEC_HEVC_ENCODE_PICTURE_PARAMS>(encodeParams->pPicParams);
88 ENCODE_CHK_NULL_RETURN(hevcPicParams);
89
90 m_enabled = hevcPicParams->tiles_enabled_flag ? true : false;
91
92
93 m_maxTileNumber = CODECHAL_GET_WIDTH_IN_BLOCKS(m_basicFeature->m_frameWidth, CODECHAL_HEVC_MIN_TILE_SIZE) *
94 CODECHAL_GET_HEIGHT_IN_BLOCKS(m_basicFeature->m_frameHeight, CODECHAL_HEVC_MIN_TILE_SIZE);
95
96 ENCODE_CHK_STATUS_RETURN(EncodeTile::Update(params));
97
98 return MOS_STATUS_SUCCESS;
99 }
100
101 bool HevcEncodeTile::IsLcuInTile(
102 uint32_t lcuX,
103 uint32_t lcuY,
104 EncodeTileData *currentTile)
105 {
106 ENCODE_FUNC_CALL();
107
108 if (m_basicFeature == nullptr)
109 {
110 ENCODE_ASSERTMESSAGE("Null basic feature, unexpected!");
111 return false;
112 }
113 auto hevcBasicFeature = dynamic_cast<HevcBasicFeature *>(m_basicFeature);
114 if (hevcBasicFeature == nullptr)
115 {
116 ENCODE_ASSERTMESSAGE("Null hevc basic feature, unexpected!");
117 return false;
118 }
119 auto hevcSeqParams = hevcBasicFeature->m_hevcSeqParams;
120 if (hevcSeqParams == nullptr)
121 {
122 ENCODE_ASSERTMESSAGE("Null seq parameters, unexpected!");
123 return false;
124 }
125
126 uint32_t shift = hevcSeqParams->log2_max_coding_block_size_minus3 - hevcSeqParams->log2_min_coding_block_size_minus3;
127 uint32_t residual = (1 << shift) - 1;
128 uint32_t tileColumnWidth = (currentTile->tileWidthInMinCbMinus1 + 1 + residual) >> shift;
129 uint32_t tileRowHeight = (currentTile->tileHeightInMinCbMinus1 + 1 + residual) >> shift;
130
131 return (lcuX < currentTile->tileStartXInLCU ||
132 lcuY < currentTile->tileStartYInLCU ||
133 lcuX >= currentTile->tileStartXInLCU + tileColumnWidth ||
134 lcuY >= currentTile->tileStartYInLCU + tileRowHeight);
135 }
136
137 MOS_STATUS HevcEncodeTile::IsSliceInTile(
138 uint32_t sliceNumber,
139 EncodeTileData *currentTile,
140 bool * sliceInTile,
141 bool * lastSliceInTile)
142 {
143 ENCODE_FUNC_CALL();
144 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
145
146 ENCODE_CHK_NULL_RETURN(currentTile);
147 ENCODE_CHK_NULL_RETURN(sliceInTile);
148 ENCODE_CHK_NULL_RETURN(lastSliceInTile);
149 ENCODE_CHK_NULL_RETURN(m_basicFeature);
150 auto tmpHevcBasicFeature = dynamic_cast<HevcBasicFeature *>(m_basicFeature);
151 ENCODE_CHK_NULL_RETURN(tmpHevcBasicFeature);
152
153 auto hevcPicParams = tmpHevcBasicFeature->m_hevcPicParams;
154 auto hevcSeqParams = tmpHevcBasicFeature->m_hevcSeqParams;
155 auto hevcSliceParams = tmpHevcBasicFeature->m_hevcSliceParams;
156 ENCODE_CHK_NULL_RETURN(hevcPicParams);
157 ENCODE_CHK_NULL_RETURN(hevcSeqParams);
158 ENCODE_CHK_NULL_RETURN(hevcSliceParams);
159
160 if (!m_enabled)
161 {
162 *lastSliceInTile = *sliceInTile = true;
163 return eStatus;
164 }
165
166 uint32_t shift = hevcSeqParams->log2_max_coding_block_size_minus3 - hevcSeqParams->log2_min_coding_block_size_minus3;
167 uint32_t residual = (1 << shift) - 1;
168 uint32_t frameWidthInLCU = (hevcSeqParams->wFrameWidthInMinCbMinus1 + 1 + residual) >> shift;
169 uint32_t frameHeightInLCU = (hevcSeqParams->wFrameHeightInMinCbMinus1 + 1 + residual) >> shift;
170
171 uint32_t tileColumnWidth = (currentTile->tileWidthInMinCbMinus1 + 1 + residual) >> shift;
172 uint32_t tileRowHeight = (currentTile->tileHeightInMinCbMinus1 + 1 + residual) >> shift;
173
174 const CODEC_HEVC_ENCODE_SLICE_PARAMS *hevcSlcParams = &hevcSliceParams[sliceNumber];
175 uint32_t sliceStartLCU = hevcSlcParams->slice_segment_address;
176 uint32_t sliceLCUx = sliceStartLCU % frameWidthInLCU;
177 uint32_t sliceLCUy = sliceStartLCU / frameWidthInLCU;
178
179 if (IsLcuInTile(sliceLCUx, sliceLCUy, currentTile))
180 {
181 // slice start is not in the tile boundary
182 *lastSliceInTile = *sliceInTile = false;
183 return eStatus;
184 }
185
186 sliceLCUx += (hevcSlcParams->NumLCUsInSlice - 1) % tileColumnWidth;
187 sliceLCUy += (hevcSlcParams->NumLCUsInSlice - 1) / tileColumnWidth;
188
189 if (sliceLCUx >= currentTile->tileStartXInLCU + tileColumnWidth)
190 {
191 sliceLCUx -= tileColumnWidth;
192 sliceLCUy++;
193 }
194
195 if (IsLcuInTile(sliceLCUx, sliceLCUy, currentTile))
196 {
197 // last LCU of the slice is out of the tile boundary
198 *lastSliceInTile = *sliceInTile = false;
199 return eStatus;
200 }
201
202 *sliceInTile = true;
203
204 sliceLCUx++;
205 sliceLCUy++;
206
207 // the end of slice is at the boundary of tile
208 *lastSliceInTile = (sliceLCUx == currentTile->tileStartXInLCU + tileColumnWidth &&
209 sliceLCUy == currentTile->tileStartYInLCU + tileRowHeight);
210
211 return eStatus;
212 }
213
214 MOS_STATUS HevcEncodeTile::SetPipeNumber(uint32_t numPipes)
215 {
216 ENCODE_FUNC_CALL();
217
218 m_curTileCodingParams.NumberOfActiveBePipes = numPipes;
219
220 return MOS_STATUS_SUCCESS;
221 }
222
223 MOS_STATUS HevcEncodeTile::SetCurrentTileFromSliceIndex(
224 uint32_t slcCount,
225 EncodePipeline *pipeline)
226 {
227 ENCODE_FUNC_CALL();
228
229 bool lastSliceInTile = false, sliceInTile = false;
230
231 EncodeTileData curTileData = {};
232
233 // Find the tileData corresponding to this slice
234 for (uint32_t tileRow = 0; tileRow < m_numTileRows; tileRow++)
235 {
236 for (uint32_t tileCol = 0; tileCol < m_numTileColumns; tileCol++)
237 {
238 ENCODE_CHK_STATUS_RETURN(SetCurrentTile(tileRow, tileCol, pipeline));
239 ENCODE_CHK_STATUS_RETURN(GetCurrentTile(curTileData));
240 ENCODE_CHK_STATUS_RETURN(IsSliceInTile(slcCount, &curTileData, &sliceInTile, &lastSliceInTile));
241
242 if (sliceInTile)
243 {
244 break;
245 }
246 }
247 if (sliceInTile)
248 {
249 break;
250 }
251 }
252
253 return MOS_STATUS_SUCCESS;
254 }
255
256 MOS_STATUS HevcEncodeTile::CalculateNumLcuByTiles(PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams)
257 {
258 ENCODE_FUNC_CALL();
259
260 ENCODE_CHK_NULL_RETURN(hevcPicParams);
261
262 m_numLcuInPic = 0;
263 for (uint32_t numLcusInTiles = 0, i = 0; i < m_numTileRows; i++)
264 {
265 for (uint32_t j = 0; j < m_numTileColumns; j++)
266 {
267 m_numLcuInPic += hevcPicParams->tile_row_height[i] * hevcPicParams->tile_column_width[j];
268 }
269 }
270 if (m_numLcuInPic == 0)
271 {
272 ENCODE_ASSERTMESSAGE("LCU num cal by each tile is zero, sth must be wrong!");
273 return MOS_STATUS_INVALID_PARAMETER;
274 }
275 return MOS_STATUS_SUCCESS;
276 }
277
278 MOS_STATUS HevcEncodeTile::CalculateTilesBoundary(
279 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams,
280 uint32_t *rowBd,
281 uint32_t *colBd)
282 {
283 ENCODE_FUNC_CALL();
284
285 ENCODE_CHK_NULL_RETURN(hevcPicParams);
286 ENCODE_CHK_NULL_RETURN(rowBd);
287 ENCODE_CHK_NULL_RETURN(colBd);
288
289 for (uint32_t i = 0; i < m_numTileColumns; i++)
290 {
291 colBd[i + 1] = colBd[i] + hevcPicParams->tile_column_width[i];
292 }
293
294 for (uint32_t i = 0; i < m_numTileRows; i++)
295 {
296 rowBd[i + 1] = rowBd[i] + hevcPicParams->tile_row_height[i];
297 }
298
299 return MOS_STATUS_SUCCESS;
300
301 }
302
303 MOS_STATUS HevcEncodeTile::CalculateTileWidthAndHeight(
304 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams,
305 PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS hevcSeqParams,
306 uint32_t rowIndex,
307 uint32_t colIndex,
308 uint32_t *rowBd,
309 uint32_t *colBd)
310 {
311 ENCODE_FUNC_CALL();
312
313 ENCODE_CHK_NULL_RETURN(hevcPicParams);
314 ENCODE_CHK_NULL_RETURN(hevcSeqParams);
315 ENCODE_CHK_NULL_RETURN(rowBd);
316 ENCODE_CHK_NULL_RETURN(colBd);
317
318 uint32_t idx = rowIndex * m_numTileColumns + colIndex;
319 int32_t frameWidthInMinCb = hevcSeqParams->wFrameWidthInMinCbMinus1 + 1;
320 int32_t frameHeightInMinCb = hevcSeqParams->wFrameHeightInMinCbMinus1 + 1;
321 int32_t shift = hevcSeqParams->log2_max_coding_block_size_minus3 - hevcSeqParams->log2_min_coding_block_size_minus3;
322
323 if (colIndex != m_numTileColumns - 1)
324 {
325 m_tileData[idx].tileWidthInMinCbMinus1 = (hevcPicParams->tile_column_width[colIndex] << shift) - 1;
326 m_tileData[idx].isLastTileofRow = false;
327 }
328 else
329 {
330 m_tileData[idx].tileWidthInMinCbMinus1 = (frameWidthInMinCb - (colBd[colIndex] << shift)) - 1;
331 m_tileData[idx].isLastTileofRow = true;
332 }
333
334 if (rowIndex != m_numTileRows - 1)
335 {
336 m_tileData[idx].isLastTileofColumn = false;
337 m_tileData[idx].tileHeightInMinCbMinus1 = (hevcPicParams->tile_row_height[rowIndex] << shift) - 1;
338 }
339 else
340 {
341 m_tileData[idx].tileHeightInMinCbMinus1 = (frameHeightInMinCb - (rowBd[rowIndex] << shift)) - 1;
342 m_tileData[idx].isLastTileofColumn = true;
343 }
344
345 return MOS_STATUS_SUCCESS;
346 }
347
348 MOS_STATUS HevcEncodeTile::GetTileInfo(
349 uint32_t xPosition,
350 uint32_t yPosition,
351 uint32_t &tileStartLcuX,
352 uint32_t &tileEndLcuX,
353 uint32_t &tileStartLcuY,
354 uint32_t &tileEndLcuY,
355 uint32_t &tileStreaminOffset)
356 {
357 ENCODE_FUNC_CALL();
358 MOS_STATUS eStatus = MOS_STATUS_INVALID_PARAMETER;
359
360 for (uint32_t i = 0; i < m_numTiles; i++)
361 {
362 tileStartLcuX = m_tileData[i].tileStartXInLCU;
363 tileStartLcuY = m_tileData[i].tileStartYInLCU;
364 tileEndLcuX = m_tileData[i].tileEndXInLCU;
365 tileEndLcuY = m_tileData[i].tileEndYInLCU;
366
367 tileStreaminOffset = m_tileData[i].tileStreaminOffset;
368
369 if ((xPosition >= (tileStartLcuX * 2)) &&
370 (yPosition >= (tileStartLcuY * 2)) &&
371 (xPosition < (tileEndLcuX * 2)) &&
372 (yPosition < (tileEndLcuY * 2)))
373 {
374 eStatus = MOS_STATUS_SUCCESS;
375 break;
376 }
377 }
378
379 return eStatus;
380 }
381
382 MOS_STATUS HevcEncodeTile::SetTileData(void *params)
383 {
384 ENCODE_FUNC_CALL();
385
386 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
387
388 if (!m_enabled)
389 {
390 return eStatus;
391 }
392
393 ENCODE_CHK_NULL_RETURN(params);
394
395 EncoderParams* encodeParams = (EncoderParams*)params;;
396 ENCODE_CHK_NULL_RETURN(encodeParams);
397
398 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams =
399 static_cast<PCODEC_HEVC_ENCODE_PICTURE_PARAMS>(encodeParams->pPicParams);
400 ENCODE_CHK_NULL_RETURN(hevcPicParams);
401
402 PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS hevcSeqParams =
403 static_cast<PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS>(encodeParams->pSeqParams);
404 ENCODE_CHK_NULL_RETURN(hevcSeqParams);
405
406 PCODEC_HEVC_ENCODE_SLICE_PARAMS hevcSliceParams =
407 static_cast<PCODEC_HEVC_ENCODE_SLICE_PARAMS>(encodeParams->pSliceParams);
408 ENCODE_CHK_NULL_RETURN(hevcSliceParams);
409
410 m_numTileRows = hevcPicParams->num_tile_rows_minus1 + 1;
411 m_numTileColumns = hevcPicParams->num_tile_columns_minus1 + 1;
412
413 uint32_t colBd[m_maxTileBdNum] = {0};
414 uint32_t rowBd[m_maxTileBdNum] = {0};
415 ENCODE_CHK_STATUS_RETURN(CalculateTilesBoundary(hevcPicParams, &rowBd[0], &colBd[0]));
416
417 m_numTiles = m_numTileRows * m_numTileColumns;
418 if (m_numTiles > CODECHAL_GET_WIDTH_IN_BLOCKS(m_basicFeature->m_frameWidth, CODECHAL_HEVC_VDENC_MIN_TILE_WIDTH_SIZE) *
419 CODECHAL_GET_HEIGHT_IN_BLOCKS(m_basicFeature->m_frameHeight, CODECHAL_HEVC_VDENC_MIN_TILE_HEIGHT_SIZE))
420 {
421 return MOS_STATUS_INVALID_PARAMETER;
422 }
423
424 bool is10Bit = m_basicFeature->m_is10Bit;
425
426 uint32_t const numCuRecordTab[] = {1, 4, 16, 64}; //LCU: 8x8->1, 16x16->4, 32x32->16, 64x64->64
427 uint32_t numCuRecord = numCuRecordTab[MOS_MIN(3, hevcSeqParams->log2_max_coding_block_size_minus3)];
428 uint32_t maxBytePerLCU = 1 << (hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
429 maxBytePerLCU = maxBytePerLCU * maxBytePerLCU; // number of pixels per LCU
430 maxBytePerLCU = maxBytePerLCU * 3 / (is10Bit ? 1 : 2); //assume 4:2:0 format
431 uint32_t bitstreamByteOffset = 0, saoRowstoreOffset = 0, cuLevelStreamoutOffset = 0, sseRowstoreOffset = 0;
432 int32_t frameWidthInMinCb = hevcSeqParams->wFrameWidthInMinCbMinus1 + 1;
433 int32_t frameHeightInMinCb = hevcSeqParams->wFrameHeightInMinCbMinus1 + 1;
434 int32_t shift = hevcSeqParams->log2_max_coding_block_size_minus3 - hevcSeqParams->log2_min_coding_block_size_minus3;
435 uint32_t ctbSize = 1 << (hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
436 uint32_t streamInWidthinLCU = MOS_ROUNDUP_DIVIDE((frameWidthInMinCb << (hevcSeqParams->log2_min_coding_block_size_minus3 + 3)), ctbSize);
437 uint32_t tileStartLCUAddr = 0;
438
439 ENCODE_CHK_STATUS_RETURN(CalculateNumLcuByTiles(hevcPicParams));
440
441 uint64_t activeBitstreamSize = (uint64_t)m_basicFeature->m_bitstreamSize;
442 // There would be padding at the end of last tile in CBR, reserve dedicated part in the BS buf
443 if (hevcSeqParams->RateControlMethod == RATECONTROL_CBR)
444 {
445 // Assume max padding num < target frame size derived from target bit rate and frame rate
446 if (hevcSeqParams->FrameRate.Denominator == 0)
447 {
448 return MOS_STATUS_INVALID_PARAMETER;
449 }
450 uint32_t actualFrameRate = hevcSeqParams->FrameRate.Numerator / hevcSeqParams->FrameRate.Denominator;
451 uint64_t reservedPart = (uint64_t)hevcSeqParams->TargetBitRate / 8 / (uint64_t)actualFrameRate * 1024;
452
453 if (reservedPart > activeBitstreamSize)
454 {
455 ENCODE_ASSERTMESSAGE("Frame size cal from target Bit rate is larger than BS buf! Issues in CBR paras!");
456 return MOS_STATUS_INVALID_PARAMETER;
457 }
458
459 // Capping the reserved part to 1/10 of bs buf size
460 if (reservedPart > activeBitstreamSize / 10)
461 {
462 reservedPart = activeBitstreamSize / 10;
463 }
464
465 activeBitstreamSize -= reservedPart;
466 }
467
468 for (uint32_t numLcusInTiles = 0, i = 0; i < m_numTileRows; i++)
469 {
470 for (uint32_t j = 0; j < m_numTileColumns; j++)
471 {
472 uint32_t idx = i * m_numTileColumns + j;
473 uint32_t numLcuInTile = hevcPicParams->tile_row_height[i] * hevcPicParams->tile_column_width[j];
474
475 m_tileData[idx].tileStartXInLCU = colBd[j];
476 m_tileData[idx].tileStartYInLCU = rowBd[i];
477
478 m_tileData[idx].tileColumnStoreSelect = j % 2;
479 m_tileData[idx].tileRowStoreSelect = i % 2;
480
481 ENCODE_CHK_STATUS_RETURN(CalculateTileWidthAndHeight(hevcPicParams, hevcSeqParams, i, j, &rowBd[0], &colBd[0]));
482
483 m_tileData[idx].numOfTilesInFrame = m_numTiles;
484 m_tileData[idx].numOfTileColumnsInFrame = m_numTileColumns;
485 m_tileData[idx].cuRecordOffset = MOS_ALIGN_CEIL(((numCuRecord * numLcusInTiles) * m_hcpItf->GetEncCuRecordSize()),
486 CODECHAL_CACHELINE_SIZE) / CODECHAL_CACHELINE_SIZE;
487
488 m_tileData[idx].pakTileStatisticsOffset = 9 * idx;
489 m_tileData[idx].tileSizeStreamoutOffset = idx;
490 m_tileData[idx].vp9ProbabilityCounterStreamoutOffset = 0;
491
492 m_tileData[idx].cuLevelStreamoutOffset = cuLevelStreamoutOffset;
493 m_tileData[idx].sseRowstoreOffset = sseRowstoreOffset;
494 m_tileData[idx].bitstreamByteOffset = bitstreamByteOffset;
495 m_tileData[idx].saoRowstoreOffset = saoRowstoreOffset;
496
497 uint32_t tileHeightInLCU = MOS_ROUNDUP_DIVIDE(((m_tileData[idx].tileHeightInMinCbMinus1 + 1) << (hevcSeqParams->log2_min_coding_block_size_minus3 + 3)), ctbSize);
498 uint32_t tileWidthInLCU = MOS_ROUNDUP_DIVIDE(((m_tileData[idx].tileWidthInMinCbMinus1 + 1) << (hevcSeqParams->log2_min_coding_block_size_minus3 + 3)), ctbSize);
499
500 m_tileData[idx].tileEndXInLCU = m_tileData[idx].tileStartXInLCU + tileWidthInLCU;
501 m_tileData[idx].tileEndYInLCU = m_tileData[idx].tileStartYInLCU + tileHeightInLCU;
502
503 //StreamIn data is 4 CLs per LCU
504 m_tileData[idx].tileStreaminOffset = 4 * (m_tileData[idx].tileStartYInLCU * streamInWidthinLCU + m_tileData[idx].tileStartXInLCU * tileHeightInLCU);
505 m_tileData[idx].sliceSizeStreamoutOffset = tileStartLCUAddr;
506
507 tileStartLCUAddr += (tileWidthInLCU * tileHeightInLCU);
508
509 cuLevelStreamoutOffset += (m_tileData[idx].tileWidthInMinCbMinus1 + 1) * (m_tileData[idx].tileHeightInMinCbMinus1 + 1) * 16 / CODECHAL_CACHELINE_SIZE;
510 sseRowstoreOffset += ((hevcPicParams->tile_column_width[j] + 3) * ((HevcBasicFeature*)m_basicFeature)->m_sizeOfSseSrcPixelRowStoreBufferPerLcu) / CODECHAL_CACHELINE_SIZE;
511 saoRowstoreOffset += (MOS_ALIGN_CEIL(hevcPicParams->tile_column_width[j], 4) * CODECHAL_HEVC_SAO_STRMOUT_SIZE_PERLCU) / CODECHAL_CACHELINE_SIZE;
512
513 uint64_t totalSizeTemp = (uint64_t)activeBitstreamSize * (uint64_t)numLcuInTile;
514 uint32_t bitStreamSizePerTile = (uint32_t)(totalSizeTemp / (uint64_t)m_numLcuInPic) + ((totalSizeTemp % (uint64_t)m_numLcuInPic) ? 1 : 0);
515 bitstreamByteOffset += MOS_ALIGN_CEIL(bitStreamSizePerTile, CODECHAL_CACHELINE_SIZE) / CODECHAL_CACHELINE_SIZE;
516
517 numLcusInTiles += numLcuInTile;
518 }
519
520 // same row store buffer for different tile rows.
521 saoRowstoreOffset = 0;
522 sseRowstoreOffset = 0;
523 }
524
525 return eStatus;
526 }
527
528 MOS_STATUS HevcEncodeTile::AllocateTileStatistics(void *params)
529 {
530 ENCODE_FUNC_CALL();
531
532 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
533
534 ENCODE_CHK_NULL_RETURN(params);
535
536 if (!m_enabled)
537 {
538 return eStatus;
539 }
540
541 EncoderParams *encodeParams = (EncoderParams *)params;
542 ENCODE_CHK_NULL_RETURN(encodeParams);
543
544 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams =
545 static_cast<PCODEC_HEVC_ENCODE_PICTURE_PARAMS>(encodeParams->pPicParams);
546 ENCODE_CHK_NULL_RETURN(hevcPicParams);
547
548 auto num_tile_rows = hevcPicParams->num_tile_rows_minus1 + 1;
549 auto num_tile_columns = hevcPicParams->num_tile_columns_minus1 + 1;
550 auto num_tiles = num_tile_rows * num_tile_columns;
551
552 uint32_t maxLcuSize = 64;
553 if (m_numLcuInPic == 0)
554 {
555 ENCODE_ASSERTMESSAGE("LCU num cal by each tile is zero, sth must be wrong!");
556 return MOS_STATUS_INVALID_PARAMETER;
557 }
558
559 MOS_ZeroMemory(&m_hevcFrameStatsOffset, sizeof(HevcTileStatusInfo));
560 MOS_ZeroMemory(&m_hevcTileStatsOffset, sizeof(HevcTileStatusInfo));
561 MOS_ZeroMemory(&m_hevcStatsSize, sizeof(HevcTileStatusInfo));
562
563 // Set the maximum size based on frame level statistics.
564 m_hevcStatsSize.tileSizeRecord = CODECHAL_CACHELINE_SIZE;
565 m_hevcStatsSize.hevcPakStatistics = EncodeBasicFeature::m_sizeOfHcpPakFrameStats;
566 m_hevcStatsSize.vdencStatistics = CODECHAL_HEVC_VDENC_STATS_SIZE;
567 m_hevcStatsSize.hevcSliceStreamout = CODECHAL_CACHELINE_SIZE;
568
569 // Maintain the offsets to use for patching addresses in to the HuC Pak Integration kernel Aggregated Frame Statistics Output Buffer
570 // Each offset needs to be page aligned as the combined region is fed into different page aligned HuC regions
571 m_hevcFrameStatsOffset.tileSizeRecord = 0; // Tile Size Record is not present in resHuCPakAggregatedFrameStatsBuffer
572 m_hevcFrameStatsOffset.hevcPakStatistics = 0;
573 m_hevcFrameStatsOffset.vdencStatistics = MOS_ALIGN_CEIL(m_hevcFrameStatsOffset.hevcPakStatistics + m_hevcStatsSize.hevcPakStatistics, CODECHAL_PAGE_SIZE);
574 m_hevcFrameStatsOffset.hevcSliceStreamout = MOS_ALIGN_CEIL(m_hevcFrameStatsOffset.vdencStatistics + m_hevcStatsSize.vdencStatistics, CODECHAL_PAGE_SIZE);
575
576 // Frame level statistics
577 m_hwInterface->m_pakIntAggregatedFrameStatsSize = MOS_ALIGN_CEIL(m_hevcFrameStatsOffset.hevcSliceStreamout + (m_hevcStatsSize.hevcSliceStreamout * m_numLcuInPic), CODECHAL_PAGE_SIZE);
578
579 // HEVC Frame Statistics Buffer - Output from HuC PAK Integration kernel
580 if (Mos_ResourceIsNull(&m_resHuCPakAggregatedFrameStatsBuffer))
581 {
582 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
583 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
584 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
585 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
586 allocParamsForBufferLinear.Format = Format_Buffer;
587 allocParamsForBufferLinear.dwBytes = m_hwInterface->m_pakIntAggregatedFrameStatsSize;
588 allocParamsForBufferLinear.pBufName = "HCP Aggregated Frame Statistics Streamout Buffer";
589 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
590 auto resource = m_allocator->AllocateResource(allocParamsForBufferLinear, true);
591 ENCODE_CHK_NULL_RETURN(resource);
592 m_resHuCPakAggregatedFrameStatsBuffer = *resource;
593 }
594
595 // Maintain the offsets to use for patching addresses in to the Tile Based Statistics Buffer
596 // Each offset needs to be page aligned as the combined region is fed into different page aligned HuC regions
597 m_hevcTileStatsOffset.tileSizeRecord = 0; // TileRecord is a separated resource
598 m_hevcTileStatsOffset.hevcPakStatistics = 0; // PakStatistics is head of m_resTileBasedStatisticsBuffer;
599 m_hevcTileStatsOffset.vdencStatistics = MOS_ALIGN_CEIL(m_hevcTileStatsOffset.hevcPakStatistics + (m_hevcStatsSize.hevcPakStatistics * num_tiles), CODECHAL_PAGE_SIZE);
600 m_hevcTileStatsOffset.hevcSliceStreamout = MOS_ALIGN_CEIL(m_hevcTileStatsOffset.vdencStatistics + (m_hevcStatsSize.vdencStatistics * num_tiles), CODECHAL_PAGE_SIZE);
601 // Combined statistics size for all tiles
602 m_hwInterface->m_pakIntTileStatsSize = MOS_ALIGN_CEIL(m_hevcTileStatsOffset.hevcSliceStreamout + m_hevcStatsSize.hevcSliceStreamout * m_numLcuInPic, CODECHAL_PAGE_SIZE);
603
604 // Tile size record size for all tiles
605 m_hwInterface->m_tileRecordSize = m_hevcStatsSize.tileSizeRecord * num_tiles;
606
607 MOS_SURFACE surface;
608 MOS_ZeroMemory(&surface, sizeof(surface));
609 surface.OsResource = m_resTileBasedStatisticsBuffer[m_statisticsBufIndex];
610 if (!Mos_ResourceIsNull(&surface.OsResource))
611 {
612 m_allocator->GetSurfaceInfo(&surface);
613 }
614 uint32_t curPakIntTileStatsSize = surface.dwHeight * surface.dwWidth;
615
616 if (Mos_ResourceIsNull(&m_resTileBasedStatisticsBuffer[m_statisticsBufIndex]) ||
617 curPakIntTileStatsSize < m_hwInterface->m_pakIntTileStatsSize)
618 {
619 if (!Mos_ResourceIsNull(&m_resTileBasedStatisticsBuffer[m_statisticsBufIndex]))
620 {
621 m_allocator->DestroyResource(&m_resTileBasedStatisticsBuffer[m_statisticsBufIndex]);
622 }
623 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
624 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
625 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
626 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
627 allocParamsForBufferLinear.Format = Format_Buffer;
628 allocParamsForBufferLinear.dwBytes = m_hwInterface->m_pakIntTileStatsSize;
629 allocParamsForBufferLinear.pBufName = "HCP Tile Level Statistics Streamout Buffer";
630 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_NOCACHE;
631 auto resource = m_allocator->AllocateResource(allocParamsForBufferLinear, true);
632 ENCODE_CHK_NULL_RETURN(resource);
633 m_resTileBasedStatisticsBuffer[m_statisticsBufIndex] = *resource;
634 }
635
636 // Allocate the updated tile size buffer for PAK integration kernel
637 if (Mos_ResourceIsNull(&m_tileRecordBuffer[m_statisticsBufIndex]))
638 {
639 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
640 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
641 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
642 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
643 allocParamsForBufferLinear.Format = Format_Buffer;
644 allocParamsForBufferLinear.dwBytes = CODECHAL_CACHELINE_SIZE * num_tiles;
645 allocParamsForBufferLinear.pBufName = "Tile Record Buffer";
646 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_NOCACHE;
647
648 auto resource = m_allocator->AllocateResource(allocParamsForBufferLinear, true);
649 ENCODE_CHK_NULL_RETURN(resource);
650 m_tileRecordBuffer[m_statisticsBufIndex] = *resource;
651 }
652
653 return eStatus;
654 }
655
656 MOS_STATUS HevcEncodeTile::GetTileStatusInfo(
657 HevcTileStatusInfo &hevcTileStatsOffset,
658 HevcTileStatusInfo &hevcFrameStatsOffset,
659 HevcTileStatusInfo &hevcStatsSize)
660 {
661 ENCODE_FUNC_CALL();
662 if (!m_enabled)
663 {
664 return MOS_STATUS_SUCCESS;
665 }
666
667 hevcTileStatsOffset = m_hevcTileStatsOffset;
668 hevcFrameStatsOffset = m_hevcFrameStatsOffset;
669 hevcStatsSize = m_hevcStatsSize;
670
671 return MOS_STATUS_SUCCESS;
672 }
673
674 MOS_STATUS HevcEncodeTile::GetTileInfo(HevcTileInfo *hevcTileInfo) const
675 {
676 ENCODE_FUNC_CALL();
677 ENCODE_CHK_NULL_RETURN(hevcTileInfo);
678
679 if (m_enabled)
680 {
681 hevcTileInfo->tileId = static_cast<uint16_t>(m_tileIdx); // Tile number in a frame
682
683 const auto currTileData = m_tileData[m_tileIdx];
684
685 hevcTileInfo->tileColPositionInSb = static_cast<uint16_t>(currTileData.tileStartX);
686 hevcTileInfo->tileRowPositionInSb = static_cast<uint16_t>(currTileData.tileStartY);
687
688 hevcTileInfo->tileWidthInSbMinus1 = currTileData.tileEndX - currTileData.tileStartX - 1;
689 hevcTileInfo->tileHeightInSbMinus1 = currTileData.tileEndY - currTileData.tileStartY - 1;
690
691 hevcTileInfo->tileStartXInLCU = currTileData.tileStartX;
692 hevcTileInfo->tileStartYInLCU = currTileData.tileStartY;
693 hevcTileInfo->tileEndXInLCU = currTileData.tileEndX;
694 hevcTileInfo->tileEndYInLCU = currTileData.tileEndY;
695 hevcTileInfo->tileNum = static_cast<uint16_t>(m_tileIdx);
696 }
697 return MOS_STATUS_SUCCESS;
698 }
699
700 MHW_SETPAR_DECL_SRC(VDENC_PIPE_MODE_SELECT, HevcEncodeTile)
701 {
702 ENCODE_FUNC_CALL();
703 if (m_enabled)
704 {
705 params.tileBasedReplayMode = m_enableTileReplay;
706 }
707 else
708 {
709 params.tileBasedReplayMode = 0;
710 }
711 return MOS_STATUS_SUCCESS;
712 }
713
714 MHW_SETPAR_DECL_SRC(VDENC_PIPE_BUF_ADDR_STATE, HevcEncodeTile)
715 {
716 ENCODE_FUNC_CALL();
717
718 if (!m_enabled)
719 {
720 return MOS_STATUS_SUCCESS;
721 }
722
723 MOS_RESOURCE *tileStatisticsBuffer = const_cast<MOS_RESOURCE *>(& m_resTileBasedStatisticsBuffer[m_statisticsBufIndex]);
724
725 if (!Mos_ResourceIsNull(tileStatisticsBuffer))
726 {
727 params.streamOutBuffer = tileStatisticsBuffer;
728 params.streamOutOffset = m_hevcTileStatsOffset.vdencStatistics;
729 }
730
731 return MOS_STATUS_SUCCESS;
732 }
733
734 MHW_SETPAR_DECL_SRC(VDENC_WALKER_STATE, HevcEncodeTile)
735 {
736 ENCODE_FUNC_CALL();
737 auto hevcBasicFeature = dynamic_cast<HevcBasicFeature *>(m_basicFeature);
738 ENCODE_CHK_NULL_RETURN(hevcBasicFeature);
739 auto picParams = hevcBasicFeature->m_hevcPicParams;
740 ENCODE_CHK_NULL_RETURN(picParams);
741 auto seqParams = hevcBasicFeature->m_hevcSeqParams;
742 ENCODE_CHK_NULL_RETURN(seqParams);
743 auto t_sliceParams = hevcBasicFeature->m_hevcSliceParams;
744 ENCODE_CHK_NULL_RETURN(t_sliceParams);
745 CODEC_HEVC_ENCODE_SLICE_PARAMS *sliceParams = (CODEC_HEVC_ENCODE_SLICE_PARAMS *)&t_sliceParams[hevcBasicFeature->m_curNumSlices];
746
747 uint32_t ctbSize = 1 << (seqParams->log2_max_coding_block_size_minus3 + 3);
748 uint32_t widthInPix = (1 << (seqParams->log2_min_coding_block_size_minus3 + 3)) * (seqParams->wFrameWidthInMinCbMinus1 + 1);
749 uint32_t widthInCtb = (widthInPix / ctbSize) + ((widthInPix % ctbSize) ? 1 : 0); // round up
750 uint32_t heightInPix = (1 << (seqParams->log2_min_coding_block_size_minus3 + 3)) * (seqParams->wFrameHeightInMinCbMinus1 + 1);
751 uint32_t heightInCtb = (heightInPix / ctbSize) + ((heightInPix % ctbSize) ? 1 : 0); // round up
752 uint32_t shift = seqParams->log2_max_coding_block_size_minus3 - seqParams->log2_min_coding_block_size_minus3;
753
754 if (!m_enabled)
755 {
756 params.firstSuperSlice = 0;
757 // No tiling support
758 params.tileSliceStartLcuMbY = sliceParams->slice_segment_address / widthInCtb;
759 params.nextTileSliceStartLcuMbX = (sliceParams->slice_segment_address + sliceParams->NumLCUsInSlice) / heightInCtb;
760 params.nextTileSliceStartLcuMbY = (sliceParams->slice_segment_address + sliceParams->NumLCUsInSlice) / widthInCtb;
761 }
762 else
763 {
764 params.tileSliceStartLcuMbX = (&m_curTileCodingParams)->TileStartLCUX;
765 params.tileSliceStartLcuMbY = (&m_curTileCodingParams)->TileStartLCUY;
766
767 // In HEVC vdnec, always first super slice in each tile
768 params.firstSuperSlice = 1;
769
770 params.nextTileSliceStartLcuMbX = (&m_curTileCodingParams)->TileStartLCUX + ((&m_curTileCodingParams)->TileWidthInMinCbMinus1 >> shift) + 1;
771 params.nextTileSliceStartLcuMbY = (&m_curTileCodingParams)->TileStartLCUY + ((&m_curTileCodingParams)->TileHeightInMinCbMinus1 >> shift) + 1;
772 }
773
774 return MOS_STATUS_SUCCESS;
775 }
776
777 MHW_SETPAR_DECL_SRC(HCP_PIPE_MODE_SELECT, HevcEncodeTile)
778 {
779 ENCODE_FUNC_CALL();
780
781 // In single pipe mode, if TileBasedReplayMode is enabled,
782 // the bit stream for each tile will not be continuous
783 if (m_enabled)
784 {
785 params.bTileBasedReplayMode = m_enableTileReplay;
786 }
787 else
788 {
789 params.bTileBasedReplayMode = 0;
790 }
791
792 return MOS_STATUS_SUCCESS;
793 }
794
795 MHW_SETPAR_DECL_SRC(HCP_TILE_CODING, HevcEncodeTile)
796 {
797 ENCODE_FUNC_CALL();
798 if (!m_enabled)
799 {
800 return MOS_STATUS_SUCCESS;
801 }
802
803 params.numOfTileColumnsInFrame = m_curTileCodingParams.NumOfTileColumnsInFrame;
804 params.tileRowStoreSelect = m_curTileCodingParams.TileRowStoreSelect;
805 params.tileColumnStoreSelect = m_curTileCodingParams.TileColumnStoreSelect;
806 params.tileStartLCUX = m_curTileCodingParams.TileStartLCUX;
807 params.tileStartLCUY = m_curTileCodingParams.TileStartLCUY;
808 params.isLastTileofColumn = m_curTileCodingParams.IsLastTileofColumn;
809 params.isLastTileofRow = m_curTileCodingParams.IsLastTileofRow;
810 params.tileHeightInMinCbMinus1 = m_curTileCodingParams.TileHeightInMinCbMinus1;
811 params.tileWidthInMinCbMinus1 = m_curTileCodingParams.TileWidthInMinCbMinus1;
812 params.cuRecordOffset = m_curTileCodingParams.CuRecordOffset;
813 params.bitstreamByteOffset = m_curTileCodingParams.BitstreamByteOffset;
814 params.pakTileStatisticsOffset = m_curTileCodingParams.PakTileStatisticsOffset;
815 params.cuLevelStreamoutOffset = m_curTileCodingParams.CuLevelStreamoutOffset;
816 params.sliceSizeStreamoutOffset = m_curTileCodingParams.SliceSizeStreamoutOffset;
817 params.sseRowstoreOffset = m_curTileCodingParams.SseRowstoreOffset;
818 params.saoRowstoreOffset = m_curTileCodingParams.SaoRowstoreOffset;
819 params.tileSizeStreamoutOffset = m_curTileCodingParams.TileSizeStreamoutOffset;
820 params.vp9ProbabilityCounterStreamoutOffset = 0;
821 params.nonFirstPassTile = m_curTileCodingParams.bTileReplayEnable && (!m_curTileCodingParams.IsFirstPass);
822 params.bitstreamByteOffsetEnable = m_curTileCodingParams.bTileReplayEnable;
823
824 return MOS_STATUS_SUCCESS;
825 }
826
827 MHW_SETPAR_DECL_SRC(HCP_PIPE_BUF_ADDR_STATE, HevcEncodeTile)
828 {
829 ENCODE_FUNC_CALL();
830
831 if (m_enabled && m_curTileCodingParams.NumberOfActiveBePipes > 1)
832 {
833 MOS_RESOURCE *tileStatisticsBuffer = const_cast<PMOS_RESOURCE>(&m_resTileBasedStatisticsBuffer[m_statisticsBufIndex]);
834 if (!Mos_ResourceIsNull(tileStatisticsBuffer))
835 {
836 params.presLcuBaseAddressBuffer = tileStatisticsBuffer;
837 params.dwLcuStreamOutOffset = m_hevcTileStatsOffset.hevcSliceStreamout;
838 params.presFrameStatStreamOutBuffer = tileStatisticsBuffer;
839 params.dwFrameStatStreamOutOffset = m_hevcTileStatsOffset.hevcPakStatistics;
840 }
841 }
842 else
843 {
844 params.presLcuBaseAddressBuffer = m_basicFeature->m_recycleBuf->GetBuffer(LcuBaseAddressBuffer, 0);
845 params.presFrameStatStreamOutBuffer = m_basicFeature->m_recycleBuf->GetBuffer(FrameStatStreamOutBuffer, 0);
846 }
847
848 return MOS_STATUS_SUCCESS;
849 }
850
851 MHW_SETPAR_DECL_SRC(HCP_SLICE_STATE, HevcEncodeTile)
852 {
853 ENCODE_FUNC_CALL();
854
855 if (!m_enabled)
856 {
857 return MOS_STATUS_SUCCESS;
858 }
859
860 auto hevcFeature = dynamic_cast<HevcBasicFeature *>(m_basicFeature);
861 ENCODE_CHK_NULL_RETURN(hevcFeature);
862
863 params.lastSliceInTile = hevcFeature->m_lastSliceInTile;
864 params.lastSliceInTileColumn = (hevcFeature->m_lastSliceInTile & m_tileData[m_tileIdx].isLastTileofColumn) ? true : false;
865
866 return MOS_STATUS_SUCCESS;
867 }
868
869 MHW_SETPAR_DECL_SRC(HCP_IND_OBJ_BASE_ADDR_STATE, HevcEncodeTile)
870 {
871 ENCODE_FUNC_CALL();
872
873 if (!m_enabled)
874 {
875 return MOS_STATUS_SUCCESS;
876 }
877
878 MOS_RESOURCE *tileRecordBuffer = const_cast<PMOS_RESOURCE>(&m_tileRecordBuffer[m_statisticsBufIndex]);
879 if (!Mos_ResourceIsNull(tileRecordBuffer))
880 {
881 params.presPakTileSizeStasBuffer = tileRecordBuffer;
882 params.dwPakTileSizeStasBufferSize = m_hwInterface->m_tileRecordSize;
883 params.dwPakTileSizeRecordOffset = m_hevcTileStatsOffset.tileSizeRecord;
884 }
885
886 return MOS_STATUS_SUCCESS;
887 }
888
889 MHW_SETPAR_DECL_SRC(VDENC_HEVC_VP9_TILE_SLICE_STATE, HevcEncodeTile)
890 {
891 ENCODE_FUNC_CALL();
892 auto hevcBasicFeature = dynamic_cast<HevcBasicFeature *>(m_basicFeature);
893 ENCODE_CHK_NULL_RETURN(hevcBasicFeature);
894 auto picParams = hevcBasicFeature->m_hevcPicParams;
895 ENCODE_CHK_NULL_RETURN(picParams);
896 auto seqParams = hevcBasicFeature->m_hevcSeqParams;
897 ENCODE_CHK_NULL_RETURN(seqParams);
898 auto sliceParams = hevcBasicFeature->m_hevcSliceParams;
899 ENCODE_CHK_NULL_RETURN(sliceParams);
900
901 uint32_t ctbSize = 1 << (seqParams->log2_max_coding_block_size_minus3 + 3);
902 uint32_t widthInPix = (1 << (seqParams->log2_min_coding_block_size_minus3 + 3)) * (seqParams->wFrameWidthInMinCbMinus1 + 1);
903 uint32_t heightInPix = (1 << (seqParams->log2_min_coding_block_size_minus3 + 3)) * (seqParams->wFrameHeightInMinCbMinus1 + 1);
904 uint32_t minCodingBlkSize = seqParams->log2_min_coding_block_size_minus3 + 3;
905 params.ctbSize = ctbSize;
906
907 if (!m_enabled)
908 {
909 // No tiling support
910 params.tileWidth = widthInPix;
911 params.tileHeight = heightInPix;
912 }
913 else
914 {
915 params.tileStartLCUX = (&m_curTileCodingParams)->TileStartLCUX;
916 params.tileStartLCUY = (&m_curTileCodingParams)->TileStartLCUY;
917
918 params.tileWidth = (((&m_curTileCodingParams)->TileWidthInMinCbMinus1 + 1) << minCodingBlkSize);
919 params.tileHeight = (((&m_curTileCodingParams)->TileHeightInMinCbMinus1 + 1) << minCodingBlkSize);
920
921 // NumParEngine is not used by HW
922 //cmd.DW3.NumParEngine = tileSlcParams->dwNumberOfPipes;
923
924 params.tileId = m_tileIdx;
925 params.tileRowStoreSelect = (&m_curTileCodingParams)->TileRowStoreSelect;
926 params.tileEnable = 1;
927 params.tileStreamInOffset = (&m_curTileCodingParams)->TileStreaminOffset;
928
929 // PAK Object StreamOut Offset Computation
930 uint32_t tileLCUStreamOutByteOffset = 0;
931 if ((&m_curTileCodingParams)->TileStartLCUX != 0 || (&m_curTileCodingParams)->TileStartLCUY != 0)
932 {
933 uint32_t NumOfCUInLCU = (ctbSize >> 3) * (ctbSize >> 3); // Min CU size is 8
934 uint32_t ImgWidthInLCU = (widthInPix + ctbSize - 1) / ctbSize;
935 uint32_t ImgHeightInLCU = (heightInPix + ctbSize - 1) / ctbSize;
936 uint32_t NumLCUsCurLocation = (&m_curTileCodingParams)->TileStartLCUY * ImgWidthInLCU + (&m_curTileCodingParams)->TileStartLCUX *
937 (((((&m_curTileCodingParams)->TileHeightInMinCbMinus1 + 1) << minCodingBlkSize) + ctbSize - 1) / ctbSize);
938 //For PAKObject Surface
939 tileLCUStreamOutByteOffset = 2 * BYTES_PER_DWORD * NumLCUsCurLocation * (NUM_PAK_DWS_PER_LCU + NumOfCUInLCU * NUM_DWS_PER_CU);
940 //Add 1 CL for size info at the beginning of each tile
941 tileLCUStreamOutByteOffset += MHW_CACHELINE_SIZE;
942 //CL alignment at end of every tile
943 tileLCUStreamOutByteOffset = MOS_ROUNDUP_DIVIDE(tileLCUStreamOutByteOffset, MHW_CACHELINE_SIZE);
944 }
945
946 params.tileLCUStreamOutOffset = tileLCUStreamOutByteOffset;
947 params.tileRowstoreOffset = (params.tileStartLCUY == 0) ? (params.tileStartLCUX * params.ctbSize) / 32 : 0;
948 }
949
950 return MOS_STATUS_SUCCESS;
951 }
952
953 } // namespace encode