Debian Codegraph @

media_softlet/agnostic/common/codec/hal/enc/av1/features/encode_av1_aqm.cpp

raw
1 /*
2 * Copyright (c) 2021-2024, 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,Av1EncodeTile
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_av1_aqm.cpp
24 //! \brief Defines the common interface for av1 aqm
25 //!
26
27 #include "encode_av1_aqm.h"
28 #include "encode_av1_vdenc_feature_manager.h"
29 #include "encode_av1_basic_feature.h"
30 #include "encode_av1_fastpass.h"
31
32 namespace encode
33 {
34 Av1EncodeAqm::Av1EncodeAqm(MediaFeatureManager *featureManager,
35 EncodeAllocator * allocator,
36 CodechalHwInterfaceNext * hwInterface,
37 void * constSettings) : EncodeAqmFeature(featureManager, allocator, hwInterface, constSettings)
38 {
39 auto encFeatureManager = dynamic_cast<EncodeAv1VdencFeatureManager *>(featureManager);
40 ENCODE_CHK_NULL_NO_STATUS_RETURN(encFeatureManager);
41
42 m_basicFeature = dynamic_cast<EncodeBasicFeature *>(encFeatureManager->GetFeature(Av1FeatureIDs::basicFeature));
43 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_basicFeature);
44 };
45
46 MOS_STATUS Av1EncodeAqm::Update(void *params)
47 {
48 ENCODE_FUNC_CALL();
49 auto basicFeature = dynamic_cast<Av1BasicFeature *>(m_basicFeature);
50 ENCODE_CHK_NULL_RETURN(basicFeature);
51
52 auto fastPassFeature = dynamic_cast<Av1FastPass *>(m_featureManager->GetFeature(Av1FeatureIDs::av1FastPass));
53 if (fastPassFeature && fastPassFeature->IsEnabled())
54 {
55 m_useFastPass = true;
56 m_dsWidth = fastPassFeature->GetFastPassDsWidth();
57 m_dsHeight = fastPassFeature->GetFastPassDsHeight();
58 }
59
60 if (basicFeature->m_av1PicParams->QualityInfoSupportFlags.fields.enable_frame
61 || basicFeature->m_av1PicParams->QualityInfoSupportFlags.fields.enable_block)
62 {
63 m_enabled = true;
64 }
65
66 m_numTiles = basicFeature->m_av1PicParams->tile_rows * basicFeature->m_av1PicParams->tile_cols;
67 m_tileBasedEngine = m_numTiles > 1 ? true : false;
68 if (m_useFastPass && m_numTiles == 1)
69 {
70 m_tile_width[0] = (uint16_t)m_dsWidth;
71 m_tile_height[0] = (uint16_t)m_dsHeight;
72 }
73 else
74 {
75 for (uint32_t tileIdx = 0; tileIdx < m_numTiles && tileIdx < ENCODE_VDENC_MAX_TILE_NUM; tileIdx++)
76 {
77 EncodeTileData tileData = {};
78 RUN_FEATURE_INTERFACE_RETURN(Av1EncodeTile, Av1FeatureIDs::encodeTile, GetTileByIndex, tileData, tileIdx);
79 m_tile_width[tileIdx] = (tileData.tileWidthInMinCbMinus1 + 1) * av1MinBlockWidth;
80 m_tile_height[tileIdx] = (tileData.tileHeightInMinCbMinus1 + 1) * av1MinBlockWidth;
81 }
82 }
83
84 #if USE_CODECHAL_DEBUG_TOOL
85 auto displayOrderInSeq = basicFeature->m_ref.GetFrameDisplayOrder();
86 m_frameIdxQueue.push(displayOrderInSeq);
87 #endif
88 ENCODE_CHK_STATUS_RETURN(EncodeAqmFeature::Update(params));
89 return MOS_STATUS_SUCCESS;
90 }
91
92 MHW_SETPAR_DECL_SRC(AQM_PIC_STATE, Av1EncodeAqm)
93 {
94 ENCODE_FUNC_CALL();
95 ENCODE_CHK_STATUS_RETURN(EncodeAqmFeature::MHW_SETPAR_F(AQM_PIC_STATE)(params));
96
97 params.lcuSize = LCU_SIZE_64X64;
98 params.codectype = CODECTYPE_AV1;
99
100 return MOS_STATUS_SUCCESS;
101 }
102
103 MHW_SETPAR_DECL_SRC(AVP_PIC_STATE, Av1EncodeAqm)
104 {
105 ENCODE_FUNC_CALL();
106
107 params.VdaqmEnable = m_enabled;
108
109 return MOS_STATUS_SUCCESS;
110 }
111
112 MHW_SETPAR_DECL_SRC(AQM_TILE_CODING, Av1EncodeAqm)
113 {
114 ENCODE_FUNC_CALL();
115 auto encFeatureManager = dynamic_cast<EncodeAv1VdencFeatureManager *>(m_featureManager);
116 ENCODE_CHK_NULL_RETURN(encFeatureManager);
117
118 auto av1Tile = dynamic_cast<Av1EncodeTile *>(encFeatureManager->GetFeature(Av1FeatureIDs::encodeTile));
119 ENCODE_CHK_NULL_RETURN(av1Tile);
120
121 Av1TileInfo av1TileInfo;
122
123 av1Tile->GetTileInfo(&av1TileInfo);
124
125 params.tileId = av1TileInfo.tileId;
126 params.tileColPositionInSb = av1TileInfo.tileColPositionInSb;
127 params.tileRowPositionInSb = av1TileInfo.tileRowPositionInSb;
128 params.tileWidthInSbMinus1 = m_useFastPass ? (MOS_ROUNDUP_DIVIDE(m_dsWidth, av1SuperBlockWidth) - 1): av1TileInfo.tileWidthInSbMinus1;
129 params.tileHeightInSbMinus1 = m_useFastPass ? (MOS_ROUNDUP_DIVIDE(m_dsHeight, av1SuperBlockHeight) - 1) : av1TileInfo.tileHeightInSbMinus1;
130 params.tileNum = av1TileInfo.tileId;
131 params.tileGroupId = av1TileInfo.tileGroupId;
132
133 return MOS_STATUS_SUCCESS;
134 }
135
136 MHW_SETPAR_DECL_SRC(AQM_SLICE_STATE, Av1EncodeAqm)
137 {
138 ENCODE_FUNC_CALL();
139 auto encFeatureManager = dynamic_cast<EncodeAv1VdencFeatureManager *>(m_featureManager);
140 ENCODE_CHK_NULL_RETURN(encFeatureManager);
141
142 auto av1Tile = dynamic_cast<Av1EncodeTile *>(encFeatureManager->GetFeature(Av1FeatureIDs::encodeTile));
143 ENCODE_CHK_NULL_RETURN(av1Tile);
144
145 Av1TileInfo av1TileInfo;
146
147 av1Tile->GetTileInfo(&av1TileInfo);
148
149 params.tileSliceStartLcuMbX = av1TileInfo.tileStartXInLCU;
150 params.tileSliceStartLcuMbY = av1TileInfo.tileStartYInLCU;
151 params.nextTileSliceStartLcuMbX = m_useFastPass ? ((m_dsWidth + (av1SuperBlockWidth - 1)) / av1SuperBlockWidth) : av1TileInfo.tileEndXInLCU;
152 params.nextTileSliceStartLcuMbY = m_useFastPass ? ((m_dsHeight + (av1SuperBlockHeight - 1)) / av1SuperBlockHeight) : av1TileInfo.tileEndYInLCU;
153
154 return MOS_STATUS_SUCCESS;
155 }
156
157 MHW_SETPAR_DECL_SRC(VD_PIPELINE_FLUSH, Av1EncodeAqm)
158 {
159 ENCODE_FUNC_CALL();
160 auto av1BasicFeature = dynamic_cast<Av1BasicFeature *>(m_basicFeature);
161 ENCODE_CHK_NULL_RETURN(av1BasicFeature);
162
163 if (av1BasicFeature->m_flushCmd == Av1BasicFeature::waitVdenc && m_enabled)
164 {
165 params.flushVDAQM = true;
166 params.waitDoneVDAQM = true;
167 }
168
169 return MOS_STATUS_SUCCESS;
170 }
171
172 MHW_SETPAR_DECL_SRC(AQM_PIPE_BUF_ADDR_STATE, Av1EncodeAqm)
173 {
174 ENCODE_FUNC_CALL();
175 auto aqmFeature = dynamic_cast<Av1EncodeAqm*>(m_featureManager->GetFeature(Av1FeatureIDs::av1Aqm));
176 ENCODE_CHK_NULL_RETURN(aqmFeature);
177
178 auto basicFeature = dynamic_cast<Av1BasicFeature*>(m_basicFeature);
179 ENCODE_CHK_NULL_RETURN(basicFeature);
180
181 bool mmcEnabled = basicFeature->m_mmcState ? basicFeature->m_mmcState->IsMmcEnabled() : false;
182 if (m_enabled)
183 {
184 auto bIdx = m_basicFeature->m_currOriginalPic.FrameIdx;
185
186 for (uint8_t index = 0; index < AQM_INDEX; index++)
187 params.AqmPipeBufAddrStatePar0[index] = EncodeAqmFeatureMember0[index];
188
189 params.AqmPipeBufAddrStatePar4[0] = nullptr;
190 params.AqmPipeBufAddrStatePar4[1] = m_basicFeature->m_recycleBuf->GetBuffer(RecycleResId::VdaqmBuffer1, bIdx);
191 params.AqmPipeBufAddrStatePar4[2] = m_basicFeature->m_recycleBuf->GetBuffer(RecycleResId::VdaqmBuffer2, bIdx);
192 params.AqmPipeBufAddrStatePar4[3] = m_basicFeature->m_recycleBuf->GetBuffer(RecycleResId::VdaqmBuffer3, bIdx);
193 params.AqmPipeBufAddrStatePar4[4] = m_basicFeature->m_recycleBuf->GetBuffer(RecycleResId::VdaqmBuffer4, bIdx);
194 params.AqmPipeBufAddrStatePar2 = m_basicFeature->m_recycleBuf->GetBuffer(RecycleResId::VdaqmBuffer0, bIdx);
195
196 if (m_aqmMode)
197 {
198 params.surfaceRawBuffer = &m_basicFeature->m_rawSurfaceToEnc->OsResource;
199 params.surfaceReconBuffer = &(&m_basicFeature->m_reconSurface)->OsResource;
200
201 if (mmcEnabled)
202 {
203 ENCODE_CHK_STATUS_RETURN(basicFeature->m_mmcState->GetSurfaceMmcState(const_cast<PMOS_SURFACE>(&m_basicFeature->m_rawSurface), &params.mmcStateRawSurf));
204 ENCODE_CHK_STATUS_RETURN(basicFeature->m_mmcState->GetSurfaceMmcState(const_cast<PMOS_SURFACE>(&m_basicFeature->m_reconSurface), &params.mmcStateReconSurf));
205 ENCODE_CHK_STATUS_RETURN(basicFeature->m_mmcState->GetSurfaceMmcFormat(const_cast<PMOS_SURFACE>(m_basicFeature->m_rawSurfaceToEnc), &params.compressionFormat));
206 }
207 else
208 {
209 params.mmcStateRawSurf = MOS_MEMCOMP_DISABLED;
210 params.mmcStateReconSurf = MOS_MEMCOMP_DISABLED;
211 params.compressionFormat = GMM_FORMAT_INVALID;
212 }
213 }
214 }
215
216 return MOS_STATUS_SUCCESS;
217 }
218
219 MHW_SETPAR_DECL_SRC(AQM_SURFACE_STATE, Av1EncodeAqm)
220 {
221 ENCODE_FUNC_CALL();
222 auto basicFeature = dynamic_cast<Av1BasicFeature*>(m_basicFeature);
223 ENCODE_CHK_NULL_RETURN(basicFeature);
224
225 if (m_enabled && m_aqmMode)
226 {
227 // format
228 if (!m_basicFeature->m_is10Bit)
229 {
230 params.surfaceFormat = mhw::vdbox::aqm::AQM_SURFACE_FORMAT::SURFACE_FORMAT_PLANAR4208;
231 }
232 else
233 {
234 if (params.surfaceStateId == srcInputPic)
235 {
236 params.surfaceFormat = mhw::vdbox::aqm::AQM_SURFACE_FORMAT::SURFACE_FORMAT_P010;
237 }
238 else
239 {
240 params.surfaceFormat = mhw::vdbox::aqm::AQM_SURFACE_FORMAT::SURFACE_FORMAT_P010VARIANT;
241 }
242 }
243
244 switch (params.surfaceStateId)
245 {
246 case srcInputPic:
247 params.pitch = m_basicFeature->m_rawSurfaceToEnc->dwPitch;
248 params.uOffset = m_basicFeature->m_rawSurfaceToEnc->YoffsetForUplane;
249 params.vOffset = m_basicFeature->m_rawSurfaceToEnc->YoffsetForVplane;
250 basicFeature->GetSurfaceMmcInfo(m_basicFeature->m_rawSurfaceToEnc, params.mmcStateRawSurf, params.compressionFormat);
251 break;
252 case reconPic:
253 params.pitch = m_basicFeature->m_reconSurface.dwPitch;
254 params.uOffset = m_basicFeature->m_reconSurface.YoffsetForUplane;
255 params.vOffset = m_basicFeature->m_reconSurface.YoffsetForVplane;
256 basicFeature->GetSurfaceMmcInfo(const_cast<PMOS_SURFACE>(&m_basicFeature->m_reconSurface), params.mmcStateRawSurf, params.compressionFormat);
257 break;
258 }
259 }
260
261 return MOS_STATUS_SUCCESS;
262 }
263 } // namespace encode