1 /*
2 * Copyright (c) 2020-2021, 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_avc_vdenc_stream_in.cpp
24 //! \brief    Defines the common interface for encode AVC VDEnc Stream-in
25 //!
26 
27 #include "encode_avc_vdenc_stream_in_feature.h"
28 #include "encode_avc_brc.h"
29 #include "media_avc_feature_defs.h"
30 #include "mos_os_cp_interface_specific.h"
31 
32 namespace encode
33 {
34 const size_t AvcVdencStreamInState::byteSize = sizeof(AvcVdencStreamInState);
35 
AvcVdencStreamInFeature(MediaFeatureManager * featureManager,EncodeAllocator * allocator,CodechalHwInterfaceNext * hwInterface,void * constSettings)36 AvcVdencStreamInFeature::AvcVdencStreamInFeature(
37     MediaFeatureManager* featureManager,
38     EncodeAllocator* allocator,
39     CodechalHwInterfaceNext *hwInterface,
40     void* constSettings) :
41     MediaFeature(constSettings),
42     m_hwInterface(hwInterface),
43     m_allocator(allocator)
44 {
45     m_featureManager = featureManager;
46     ENCODE_CHK_NULL_NO_STATUS_RETURN(m_featureManager);
47 
48     m_basicFeature = dynamic_cast<AvcBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
49     ENCODE_CHK_NULL_NO_STATUS_RETURN(m_basicFeature);
50 
51     ENCODE_CHK_NULL_NO_STATUS_RETURN(m_hwInterface);
52 }
53 
~AvcVdencStreamInFeature()54 AvcVdencStreamInFeature::~AvcVdencStreamInFeature()
55 {
56     ENCODE_FUNC_CALL();
57 }
58 
Init(void * setting)59 MOS_STATUS AvcVdencStreamInFeature::Init(void* setting)
60 {
61     ENCODE_FUNC_CALL();
62     return MOS_STATUS_SUCCESS;
63 }
64 
Update(void * setting)65 MOS_STATUS AvcVdencStreamInFeature::Update(void* setting)
66 {
67     ENCODE_FUNC_CALL();
68 
69     ENCODE_CHK_NULL_RETURN(m_allocator);
70     ENCODE_CHK_NULL_RETURN(m_basicFeature);
71     ENCODE_CHK_NULL_RETURN(m_basicFeature->m_recycleBuf);
72 
73     // Allocate buffer if it doesn't exists
74     if (!m_basicFeature->m_recycleBuf->GetBuffer(RecycleResId::StreamInBuffer, m_basicFeature->m_frameNum))
75     {
76         if (m_basicFeature->m_picWidthInMb == 0 || m_basicFeature->m_picHeightInMb == 0)
77         {
78             ENCODE_ASSERTMESSAGE("m_picWidthInMb or m_picHeightInMb is equal to zero. BasicFeature->Update() must be call before StreamIn->Update()\n");
79             return MOS_STATUS_UNINITIALIZED;
80         }
81 
82         MOS_ALLOC_GFXRES_PARAMS allocParams;
83         MOS_ZeroMemory(&allocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
84         allocParams.Type = MOS_GFXRES_BUFFER;
85         allocParams.TileType = MOS_TILE_LINEAR;
86         allocParams.Format = Format_Buffer;
87         allocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
88         allocParams.bIsPersistent = true;
89         allocParams.dwMemType = MOS_MEMPOOL_VIDEOMEMORY;
90 
91         m_widthInMb = m_basicFeature->m_picWidthInMb;
92         m_heightInMb = m_basicFeature->m_picHeightInMb;
93 
94         allocParams.dwBytes = MOS_ALIGN_CEIL(m_widthInMb * m_heightInMb * AvcVdencStreamInState::byteSize, CODECHAL_CACHELINE_SIZE);
95         allocParams.pBufName = "AVC VDEnc StreamIn Data Buffer";
96 
97         ENCODE_CHK_STATUS_RETURN(m_basicFeature->m_recycleBuf->RegisterResource(RecycleResId::StreamInBuffer, allocParams));
98     }
99 
100     m_streamInBuffer = m_basicFeature->m_recycleBuf->GetBuffer(RecycleResId::StreamInBuffer, m_basicFeature->m_frameNum);
101     ENCODE_CHK_NULL_RETURN(m_streamInBuffer);
102 
103     m_updated = true; // For check that Stream-In must be updated before other features, which will use it
104     return MOS_STATUS_SUCCESS;
105 }
106 
Enable()107 MOS_STATUS AvcVdencStreamInFeature::Enable()
108 {
109     ENCODE_FUNC_CALL();
110 
111     if (!m_updated)
112     {
113         return MOS_STATUS_UNINITIALIZED;
114     }
115 
116     m_enabled = true;
117     return MOS_STATUS_SUCCESS;
118 }
119 
Reset()120 void AvcVdencStreamInFeature::Reset()
121 {
122     ENCODE_FUNC_CALL();
123     m_updated = m_enabled = false;
124 }
125 
Clear()126 MOS_STATUS AvcVdencStreamInFeature::Clear()
127 {
128     ENCODE_FUNC_CALL();
129 
130     if (!m_enabled)
131     {
132         return MOS_STATUS_UNINITIALIZED;
133     }
134 
135     uint8_t *pData = (uint8_t*)Lock();
136     ENCODE_CHK_NULL_RETURN(pData);
137 
138     MOS_ZeroMemory(pData, m_heightInMb * m_widthInMb * AvcVdencStreamInState::byteSize);
139     return Unlock();
140 }
141 
Lock()142 AvcVdencStreamInState* AvcVdencStreamInFeature::Lock()
143 {
144     ENCODE_FUNC_CALL();
145     return m_enabled ? (AvcVdencStreamInState*)m_allocator->LockResourceForWrite(m_streamInBuffer) : nullptr;
146 }
147 
Unlock()148 MOS_STATUS AvcVdencStreamInFeature::Unlock()
149 {
150     ENCODE_FUNC_CALL();
151     return m_enabled ? m_allocator->UnLock(m_streamInBuffer) : MOS_STATUS_UNINITIALIZED;
152 }
153 
154 #if USE_CODECHAL_DEBUG_TOOL
Dump(CodechalDebugInterface * itf,const char * bufName)155 MOS_STATUS AvcVdencStreamInFeature::Dump(CodechalDebugInterface* itf, const char* bufName)
156 {
157     ENCODE_FUNC_CALL();
158     if (m_enabled)
159     {
160         return itf->DumpBuffer(
161             m_streamInBuffer,
162             CodechalDbgAttr::attrStreamIn,
163             bufName,
164             m_basicFeature->m_picWidthInMb * m_basicFeature->m_picHeightInMb * CODECHAL_CACHELINE_SIZE,
165             0,
166             CODECHAL_NUM_MEDIA_STATES);
167     }
168     return MOS_STATUS_SUCCESS;
169 }
170 #endif
171 
MHW_SETPAR_DECL_SRC(VDENC_PIPE_BUF_ADDR_STATE,AvcVdencStreamInFeature)172 MHW_SETPAR_DECL_SRC(VDENC_PIPE_BUF_ADDR_STATE, AvcVdencStreamInFeature)
173 {
174     if (m_enabled)
175     {
176         ENCODE_CHK_NULL_RETURN(m_basicFeature);
177         ENCODE_CHK_NULL_RETURN(m_basicFeature->m_trackedBuf);
178 
179         params.streamInBuffer = m_streamInBuffer;
180     }
181 
182     return MOS_STATUS_SUCCESS;
183 }
184 
MHW_SETPAR_DECL_SRC(VDENC_PIPE_MODE_SELECT,AvcVdencStreamInFeature)185 MHW_SETPAR_DECL_SRC(VDENC_PIPE_MODE_SELECT, AvcVdencStreamInFeature)
186 {
187     params.streamIn = m_enabled;
188 
189     return MOS_STATUS_SUCCESS;
190 }
191 
MHW_SETPAR_DECL_SRC(VDENC_AVC_IMG_STATE,AvcVdencStreamInFeature)192 MHW_SETPAR_DECL_SRC(VDENC_AVC_IMG_STATE, AvcVdencStreamInFeature)
193 {
194     auto picParams = m_basicFeature->m_picParam;
195 
196     auto brcFeature = dynamic_cast<AvcEncodeBRC*>(m_featureManager->GetFeature(AvcFeatureIDs::avcBrcFeature));
197     ENCODE_CHK_NULL_RETURN(brcFeature);
198 
199     params.roiEnable             = m_enabled && picParams->EnableRollingIntraRefresh == ROLLING_I_DISABLED &&
200                                     (picParams->NumDirtyROI && brcFeature->IsVdencBrcEnabled() ||
201                                      picParams->NumROI && picParams->bNativeROI ||
202                                      picParams->TargetFrameSize > 0 && !m_basicFeature->m_lookaheadDepth);  // TCBRC (for AdaptiveRegionBoost)
203 
204     params.mbLevelQpEnable      = m_enabled && picParams->EnableRollingIntraRefresh == ROLLING_I_DISABLED &&
205                                    (picParams->NumROI && !picParams->bNativeROI || m_basicFeature->m_mbQpDataEnabled);
206 
207     if (m_enabled)
208     {
209         PMOS_INTERFACE osInterface = m_hwInterface->GetOsInterface();
210         ENCODE_CHK_NULL_RETURN(osInterface);
211         MEDIA_WA_TABLE *pWaTable   = osInterface->pfnGetWaTable(osInterface);
212         ENCODE_CHK_NULL_RETURN(pWaTable);
213 
214         if (MEDIA_IS_WA(pWaTable, Wa_15013906446))
215         {
216 #if _MEDIA_RESERVED
217     params.vdencAvcImgStatePar1 = 0;
218 #else
219     params.extSettings.emplace_back(
220         [this](uint32_t *data) {
221             data[2] &= 0xffffff7f;
222             return MOS_STATUS_SUCCESS;
223         });
224 #endif  // _MEDIA_RESERVED
225         }
226     }
227 
228     return MOS_STATUS_SUCCESS;
229 }
230 
MHW_SETPAR_DECL_SRC(HUC_VIRTUAL_ADDR_STATE,AvcVdencStreamInFeature)231 MHW_SETPAR_DECL_SRC(HUC_VIRTUAL_ADDR_STATE, AvcVdencStreamInFeature)
232 {
233     if (params.function == BRC_UPDATE)
234     {
235         if (!m_enabled)
236         {
237             return MOS_STATUS_SUCCESS;
238         }
239 
240         ENCODE_CHK_NULL_RETURN(m_basicFeature);
241         ENCODE_CHK_NULL_RETURN(m_hwInterface);
242         ENCODE_CHK_NULL_RETURN(m_hwInterface->GetOsInterface());
243 
244         // Input regions
245         if (m_basicFeature->m_picParam->NumROI && !m_basicFeature->m_picParam->bNativeROI)  // Only for BRC non-native ROI
246         {
247             if (m_hwInterface->GetOsInterface()->osCpInterface != nullptr &&
248                 m_hwInterface->GetOsInterface()->osCpInterface->IsCpEnabled())
249             {
250                 ENCODE_ASSERTMESSAGE("Non-native BRC ROI doesn't supports in CP case");
251                 return MOS_STATUS_UNIMPLEMENTED;
252             }
253             params.regionParams[9].presRegion = m_streamInBuffer;
254         }
255 
256         // Output regions
257         if (m_basicFeature->m_picParam->NumROI && !m_basicFeature->m_picParam->bNativeROI)  // Only for BRC non-native ROI
258         {
259             if (m_hwInterface->GetOsInterface()->osCpInterface != nullptr &&
260                 m_hwInterface->GetOsInterface()->osCpInterface->IsCpEnabled())
261             {
262                 ENCODE_ASSERTMESSAGE("Non-native BRC ROI doesn't supports in CP case");
263                 return MOS_STATUS_UNIMPLEMENTED;
264             }
265             params.regionParams[10].presRegion = m_streamInBuffer;
266             params.regionParams[10].isWritable = true;
267         }
268     }
269 
270     return MOS_STATUS_SUCCESS;
271 }
272 
273 }  // namespace encode
274