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