Debian Codegraph @

media_softlet/agnostic/common/codec/hal/enc/shared/packet/encode_preenc_packet.h

raw
1 /*
2 * Copyright (c) 2020-2022, 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_preenc_packet.h
24 //! \brief Defines the interface to adapt to preenc pipeline
25 //!
26
27 #ifndef __CODECHAL_PREENC_PACKET_H__
28 #define __CODECHAL_PREENC_PACKET_H__
29
30 #include "media_cmd_packet.h"
31 #include "encode_pipeline.h"
32 #include "encode_utils.h"
33 #include "encode_preenc_basic_feature.h"
34 #include "encode_status_report.h"
35 #include "mhw_vdbox_vdenc_itf.h"
36 #include "mhw_vdbox_hcp_itf.h"
37 #include "media_sfc_interface.h"
38
39 namespace encode
40 {
41 class EncodePreEncPacket : public CmdPacket, public MediaStatusReportObserver, public mhw::vdbox::vdenc::Itf::ParSetting, public mhw::vdbox::hcp::Itf::ParSetting
42 {
43 public:
44 enum FlushCmd
45 {
46 waitHevc = 0,
47 waitVdenc,
48 waitHevcVdenc
49 };
50 EncodePreEncPacket(MediaPipeline* pipeline, MediaTask* task, CodechalHwInterfaceNext* hwInterface) : CmdPacket(task),
51 m_pipeline(dynamic_cast<EncodePipeline*>(pipeline)),
52 m_hwInterface(dynamic_cast<CodechalHwInterfaceNext*>(hwInterface))
53 {
54 ENCODE_CHK_NULL_NO_STATUS_RETURN(hwInterface);
55 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_pipeline);
56 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_hwInterface);
57
58 m_osInterface = hwInterface->GetOsInterface();
59 m_statusReport = m_pipeline->GetStatusReportInstance();
60
61 m_featureManager = m_pipeline->GetPacketLevelFeatureManager(EncodePipeline::encodePreEncPacket);
62 m_vdencItf = std::static_pointer_cast<mhw::vdbox::vdenc::Itf>(hwInterface->GetVdencInterfaceNext());
63
64 m_hcpItf = std::static_pointer_cast<mhw::vdbox::hcp::Itf>(m_hwInterface->GetHcpInterfaceNext());
65 m_miItf = m_hwInterface->GetMiInterfaceNext();
66 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_miItf);
67
68 m_sfcItf = m_hwInterface->GetMediaSfcInterface();
69 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_sfcItf);
70
71 MEDIA_SFC_INTERFACE_MODE sfcMode = {};
72 sfcMode.vdboxSfcEnabled = false;
73 sfcMode.veboxSfcEnabled = true;
74 m_sfcItf->Initialize(sfcMode);
75 }
76 virtual ~EncodePreEncPacket() {}
77
78 virtual MOS_STATUS Init() override;
79
80 virtual MOS_STATUS Prepare() override;
81
82 virtual MOS_STATUS Destroy() override;
83
84 virtual MOS_STATUS Submit(MOS_COMMAND_BUFFER* commandBuffer, uint8_t packetPhase = otherPacket) override;
85
86 virtual MOS_STATUS Completed(void* mfxStatus, void* rcsStatus, void* statusReport) override;
87
88 virtual MOS_STATUS CalculatePictureStateCommandSize();
89
90 virtual MOS_STATUS GetVdencStateCommandsDataSize(uint32_t& vdencPictureStatesSize, uint32_t& vdencPicturePatchListSize);
91
92 virtual MOS_STATUS PrepareRawSurface();
93
94 MOS_STATUS CalculateCommandSize(
95 uint32_t& commandBufferSize,
96 uint32_t& requestedPatchListSize) override;
97
98 MOS_STATUS RawSurfaceDownScaling(const PMOS_SURFACE inSurf, PMOS_SURFACE outSurf);
99
100 virtual std::string GetPacketName() override
101 {
102 return "VDENC_PASS" + std::to_string((uint32_t)m_pipeline->GetCurrentPass());
103 }
104
105 protected:
106
107 virtual MOS_STATUS GetHxxPrimitiveCommandSize();
108
109 virtual uint32_t CalculateCommandBufferSize();
110
111 virtual uint32_t CalculatePatchListSize();
112
113 virtual MOS_STATUS StartStatusReport(
114 uint32_t srType,
115 MOS_COMMAND_BUFFER* cmdBuffer) override;
116
117 virtual MOS_STATUS EndStatusReport(
118 uint32_t srType,
119 MOS_COMMAND_BUFFER* cmdBuffer) override;
120
121 MOS_STATUS ReadHcpStatus(
122 MHW_VDBOX_NODE_IND vdboxIndex,
123 MediaStatusReport* statusReport,
124 MOS_COMMAND_BUFFER& cmdBuffer);
125
126 virtual MOS_STATUS AllocateResources();
127
128 virtual MOS_STATUS AddPicStateWithNoTile(
129 MOS_COMMAND_BUFFER& cmdBuffer);
130
131 virtual MOS_STATUS SendHwSliceEncodeCommand(
132 MOS_COMMAND_BUFFER& cmdBuffer);
133
134 virtual MOS_STATUS AddHcpPipeModeSelect(
135 MOS_COMMAND_BUFFER& cmdBuffer);
136
137 void SetPerfTag(uint16_t type, uint16_t mode, uint16_t picCodingType);
138
139 MOS_STATUS SendPrologCmds(
140 MOS_COMMAND_BUFFER& cmdBuffer);
141
142 MOS_STATUS AddForceWakeup(MOS_COMMAND_BUFFER& cmdBuffer);
143
144 MHW_SETPAR_DECL_HDR(VDENC_PIPE_MODE_SELECT);
145
146 MHW_SETPAR_DECL_HDR(VDENC_HEVC_VP9_TILE_SLICE_STATE);
147
148 MHW_SETPAR_DECL_HDR(VDENC_PIPE_BUF_ADDR_STATE);
149
150 MHW_SETPAR_DECL_HDR(VD_PIPELINE_FLUSH);
151
152 MHW_SETPAR_DECL_HDR(HCP_PIPE_BUF_ADDR_STATE);
153
154 MHW_SETPAR_DECL_HDR(HCP_PIPE_MODE_SELECT);
155
156 MHW_SETPAR_DECL_HDR(HCP_SURFACE_STATE);
157
158 MHW_SETPAR_DECL_HDR(HCP_IND_OBJ_BASE_ADDR_STATE);
159
160 MHW_SETPAR_DECL_HDR(HCP_SLICE_STATE);
161
162 MOS_STATUS AddHcpSurfaceStateCmds(PMOS_COMMAND_BUFFER cmdBuffer) const;
163
164 MOS_STATUS AddHcpFqmStateCmds(PMOS_COMMAND_BUFFER cmdBuffer) const;
165
166 MOS_STATUS AddHcpQMStateCmds(PMOS_COMMAND_BUFFER cmdBuffer) const;
167
168 MOS_STATUS AddHcpPakInsertObjectCmds(PMOS_COMMAND_BUFFER cmdBuffer) const;
169
170 MOS_STATUS AddHcpRefIdxStateCmds(PMOS_COMMAND_BUFFER cmdBuffer) const;
171
172 MOS_STATUS AddHcpBSliceRefIdxStateCmds(PMOS_COMMAND_BUFFER cmdBuffer) const;
173
174 MOS_STATUS SubmitPictureLevel(MOS_COMMAND_BUFFER *commandBuffer, uint8_t packetPhase);
175
176 MOS_STATUS PatchSliceLevelCommands(MOS_COMMAND_BUFFER &cmdBuffer, uint8_t packetPhase);
177
178 MOS_STATUS AddPictureHcpCommands(MOS_COMMAND_BUFFER &cmdBuffer);
179
180 MOS_STATUS AddPictureVdencCommands(MOS_COMMAND_BUFFER &cmdBuffer);
181
182 MOS_STATUS PatchPictureLevelCommands(const uint8_t &packetPhase, MOS_COMMAND_BUFFER &cmdBuffer);
183
184 MOS_STATUS EnsureAllCommandsExecuted(MOS_COMMAND_BUFFER &cmdBuffer);
185
186 #if USE_CODECHAL_DEBUG_TOOL
187 MOS_STATUS DumpResources(
188 EncodeStatusMfx* encodeStatusMfx,
189 EncodeStatusReportData* statusReportData);
190 #endif
191 EncodePipeline *m_pipeline = nullptr;
192
193 // Interfaces
194 EncodeAllocator * m_allocator = nullptr;
195 CodechalHwInterfaceNext * m_hwInterface = nullptr;
196 PreEncBasicFeature * m_basicFeature = nullptr; //!< Encode parameters used in each frame
197 EncodeMemComp * m_mmcState = nullptr;
198
199 std::shared_ptr<mhw::vdbox::vdenc::Itf> m_vdencItf = nullptr;
200 std::shared_ptr<mhw::vdbox::hcp::Itf> m_hcpItf = nullptr;
201 std::shared_ptr<MediaSfcInterface> m_sfcItf = nullptr;
202 std::shared_ptr<MediaFeatureManager::ManagerLite> m_featureManager = nullptr;
203
204 mutable uint8_t m_curHcpSurfStateId = 0;
205
206 // Parameters passed from application
207 const CODECHAL_HEVC_IQ_MATRIX_PARAMS* m_hevcIqMatrixParams = nullptr; //!< Pointer to IQ matrix parameter
208 const PCODECHAL_NAL_UNIT_PARAMS* m_nalUnitParams = nullptr; //!< Pointer to NAL unit parameters
209
210 // PAK resources
211 PMOS_RESOURCE m_resMetadataLineBuffer = nullptr; //!< Metadata line data buffer
212 PMOS_RESOURCE m_resMetadataTileLineBuffer = nullptr; //!< Metadata tile line data buffer
213 PMOS_RESOURCE m_resMetadataTileColumnBuffer = nullptr; //!< Metadata tile column data buffer
214
215 PMOS_RESOURCE m_vdencTileRowStoreBuffer = nullptr; //!< Tile row store buffer
216
217 uint32_t m_sliceStatesSize = 0; //!< Slice states size
218
219 PMOS_RESOURCE m_vdencIntraRowStoreScratch = nullptr;
220
221 bool m_usePatchList = 0; //!< Use Ptach List or not
222 uint32_t m_defaultPictureStatesSize = 0; //!< Picture state command size
223 uint32_t m_pictureStatesSize = 0; //!< Picture states size
224 uint32_t m_defaultSliceStatesSize = 0; //!< Slice state command size
225 uint32_t m_defaultPicturePatchListSize = 0; //!< Picture state patch list size
226 uint32_t m_picturePatchListSize = 0; //!< Picture patch list size
227 uint32_t m_defaultSlicePatchListSize = 0; //!< Slice state patch list size
228 uint32_t m_slicePatchListSize = 0; //!< Slice patch list size
229
230 FlushCmd m_flushCmd = waitHevc;
231 uint32_t m_encodeMode = 0;
232
233 bool m_enablePreEncStatusReport = false;
234
235 MEDIA_CLASS_DEFINE_END(encode__EncodePreEncPacket)
236 };
237
238 } // namespace encode
239 #endif