1 /* ****************************************************************************** *\
2
3 Copyright (C) 2012-2020 Intel Corporation. All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
7 - Redistributions of source code must retain the above copyright notice,
8 this list of conditions and the following disclaimer.
9 - Redistributions in binary form must reproduce the above copyright notice,
10 this list of conditions and the following disclaimer in the documentation
11 and/or other materials provided with the distribution.
12 - Neither the name of Intel Corporation nor the names of its contributors
13 may be used to endorse or promote products derived from this software
14 without specific prior written permission.
15
16 THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY EXPRESS OR
17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 IN NO EVENT SHALL INTEL CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT,
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
27 File Name: dump_mfxstructures.cpp
28
29 \* ****************************************************************************** */
30
31 #include "dump.h"
32 #include "../loggers/log.h"
33
dump(const std::string structName,const mfxDecodeStat & decodeStat)34 std::string DumpContext::dump(const std::string structName, const mfxDecodeStat &decodeStat)
35 {
36 std::string str;
37 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(decodeStat.reserved) + "\n";
38 str += structName + ".NumFrame=" + ToString(decodeStat.NumFrame) + "\n";
39 str += structName + ".NumSkippedFrame=" + ToString(decodeStat.NumSkippedFrame) + "\n";
40 str += structName + ".NumError=" + ToString(decodeStat.NumError) + "\n";
41 str += structName + ".NumCachedFrame=" + ToString(decodeStat.NumCachedFrame);
42 return str;
43 }
44
dump(const std::string structName,const mfxEncodeCtrl & EncodeCtrl)45 std::string DumpContext::dump(const std::string structName, const mfxEncodeCtrl &EncodeCtrl)
46 {
47 std::string str;
48 str += dump(structName + ".Header", EncodeCtrl.Header) + "\n";
49 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(EncodeCtrl.reserved) + "\n";
50 #if (MFX_VERSION >= 1025)
51 str += structName + ".reserved1=" + ToString(EncodeCtrl.reserved1) + "\n";
52 str += structName + ".MfxNalUnitType=" + ToString(EncodeCtrl.MfxNalUnitType) + "\n";
53 #endif
54 str += structName + ".SkipFrame=" + ToString(EncodeCtrl.SkipFrame) + "\n";
55 str += structName + ".QP=" + ToString(EncodeCtrl.QP) + "\n";
56 str += structName + ".FrameType=" + ToString(EncodeCtrl.FrameType) + "\n";
57 str += structName + ".NumPayload=" + ToString(EncodeCtrl.NumPayload) + "\n";
58 str += structName + ".reserved2=" + ToString(EncodeCtrl.reserved2) + "\n";
59 str += dump_mfxExtParams(structName, EncodeCtrl) + "\n";
60 str += structName + ".Payload=" + ToString(EncodeCtrl.Payload);
61 return str;
62 }
63
dump(const std::string structName,const mfxEncodeStat & encodeStat)64 std::string DumpContext::dump(const std::string structName, const mfxEncodeStat &encodeStat)
65 {
66 std::string str;
67 str += structName + ".NumBit=" + ToString(encodeStat.NumBit) + "\n";
68 str += structName + ".NumCachedFrame=" + ToString(encodeStat.NumCachedFrame) + "\n";
69 str += structName + ".NumFrame=" + ToString(encodeStat.NumFrame) + "\n";
70 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(encodeStat.reserved) + "\n";
71 return str;
72 }
73
dump(const std::string structName,const mfxExtCodingOption & _struct)74 std::string DumpContext::dump(const std::string structName, const mfxExtCodingOption &_struct)
75 {
76 std::string str;
77 str += dump(structName + ".Header", _struct.Header) + "\n";
78 str += structName + ".reserved1=" + ToString(_struct.reserved1) + "\n";
79 str += structName + ".RateDistortionOpt=" + ToString(_struct.RateDistortionOpt) + "\n";
80 str += structName + ".MECostType=" + ToString(_struct.MECostType) + "\n";
81 str += structName + ".MESearchType=" + ToString(_struct.MESearchType) + "\n";
82 str += structName + ".MVSearchWindow.x=" + ToString(_struct.MVSearchWindow.x) + "\n";
83 str += structName + ".MVSearchWindow.y=" + ToString(_struct.MVSearchWindow.y) + "\n";
84
85 str += structName + ".EndOfSequence=" + ToString(_struct.EndOfSequence) + "\n";
86 str += structName + ".FramePicture=" + ToString(_struct.FramePicture) + "\n";
87
88 str += structName + ".CAVLC=" + ToString(_struct.CAVLC) + "\n";
89 str += structName + ".reserved2[]=" + DUMP_RESERVED_ARRAY(_struct.reserved2) + "\n";
90 str += structName + ".RecoveryPointSEI=" + ToString(_struct.RecoveryPointSEI) + "\n";
91 str += structName + ".ViewOutput=" + ToString(_struct.ViewOutput) + "\n";
92 str += structName + ".NalHrdConformance=" + ToString(_struct.NalHrdConformance) + "\n";
93 str += structName + ".SingleSeiNalUnit=" + ToString(_struct.SingleSeiNalUnit) + "\n";
94 str += structName + ".VuiVclHrdParameters=" + ToString(_struct.VuiVclHrdParameters) + "\n";
95
96 str += structName + ".RefPicListReordering=" + ToString(_struct.RefPicListReordering) + "\n";
97 str += structName + ".ResetRefList=" + ToString(_struct.ResetRefList) + "\n";
98 str += structName + ".RefPicMarkRep=" + ToString(_struct.RefPicMarkRep) + "\n";
99 str += structName + ".FieldOutput=" + ToString(_struct.FieldOutput) + "\n";
100
101 str += structName + ".IntraPredBlockSize=" + ToString(_struct.IntraPredBlockSize) + "\n";
102 str += structName + ".InterPredBlockSize=" + ToString(_struct.InterPredBlockSize) + "\n";
103 str += structName + ".MVPrecision=" + ToString(_struct.MVPrecision) + "\n";
104 str += structName + ".MaxDecFrameBuffering=" + ToString(_struct.MaxDecFrameBuffering) + "\n";
105
106 str += structName + ".AUDelimiter=" + ToString(_struct.AUDelimiter) + "\n";
107 str += structName + ".EndOfStream=" + ToString(_struct.EndOfStream) + "\n";
108 str += structName + ".PicTimingSEI=" + ToString(_struct.PicTimingSEI) + "\n";
109 str += structName + ".VuiNalHrdParameters=" + ToString(_struct.VuiNalHrdParameters) + "\n";
110 return str;
111 }
112
dump(const std::string structName,const mfxExtCodingOption2 & _struct)113 std::string DumpContext::dump(const std::string structName, const mfxExtCodingOption2 &_struct)
114 {
115 std::string str;
116 str += dump(structName + ".Header", _struct.Header) + "\n";
117 DUMP_FIELD(IntRefType);
118 DUMP_FIELD(IntRefCycleSize);
119 DUMP_FIELD(IntRefQPDelta);
120
121 DUMP_FIELD(MaxFrameSize);
122 DUMP_FIELD(MaxSliceSize);
123
124 DUMP_FIELD(BitrateLimit);
125 DUMP_FIELD(MBBRC);
126 DUMP_FIELD(ExtBRC);
127 DUMP_FIELD(LookAheadDepth);
128 DUMP_FIELD(Trellis);
129 DUMP_FIELD(RepeatPPS);
130 DUMP_FIELD(BRefType);
131 DUMP_FIELD(AdaptiveI);
132 DUMP_FIELD(AdaptiveB);
133 DUMP_FIELD(LookAheadDS);
134 DUMP_FIELD(NumMbPerSlice);
135 DUMP_FIELD(SkipFrame);
136 DUMP_FIELD(MinQPI);
137 DUMP_FIELD(MaxQPI);
138 DUMP_FIELD(MinQPP);
139 DUMP_FIELD(MaxQPP);
140 DUMP_FIELD(MinQPB);
141 DUMP_FIELD(MaxQPB);
142 DUMP_FIELD(FixedFrameRate);
143 DUMP_FIELD(DisableDeblockingIdc);
144 DUMP_FIELD(DisableVUI);
145 DUMP_FIELD(BufferingPeriodSEI);
146 DUMP_FIELD(EnableMAD);
147 DUMP_FIELD(UseRawRef);
148
149 return str;
150 }
151
dump(const std::string structName,const mfxExtCodingOption3 & _struct)152 std::string DumpContext::dump(const std::string structName, const mfxExtCodingOption3 &_struct)
153 {
154 std::string str;
155 str += dump(structName + ".Header", _struct.Header) + "\n";
156 DUMP_FIELD(NumSliceI);
157 DUMP_FIELD(NumSliceP);
158 DUMP_FIELD(NumSliceB);
159
160 DUMP_FIELD(WinBRCMaxAvgKbps);
161 DUMP_FIELD(WinBRCSize);
162
163 DUMP_FIELD(QVBRQuality);
164 DUMP_FIELD(EnableMBQP);
165 DUMP_FIELD(IntRefCycleDist);
166 DUMP_FIELD(DirectBiasAdjustment); /* tri-state option */
167 DUMP_FIELD(GlobalMotionBiasAdjustment); /* tri-state option */
168 DUMP_FIELD(MVCostScalingFactor);
169 DUMP_FIELD(MBDisableSkipMap); /* tri-state option */
170 DUMP_FIELD(WeightedPred);
171 DUMP_FIELD(WeightedBiPred);
172 DUMP_FIELD(AspectRatioInfoPresent);
173 DUMP_FIELD(OverscanInfoPresent);
174 DUMP_FIELD(OverscanAppropriate);
175 DUMP_FIELD(TimingInfoPresent);
176 DUMP_FIELD(BitstreamRestriction);
177 DUMP_FIELD(LowDelayHrd); /* tri-state option */
178 DUMP_FIELD(MotionVectorsOverPicBoundaries); /* tri-state option */
179 #if (MFX_VERSION >= MFX_VERSION_NEXT)
180 DUMP_FIELD(Log2MaxMvLengthHorizontal); /* 0..16 */
181 DUMP_FIELD(Log2MaxMvLengthVertical); /* 0..16 */
182 #else
183 DUMP_FIELD_RESERVED(reserved1);
184 #endif
185
186 DUMP_FIELD(ScenarioInfo);
187 DUMP_FIELD(ContentInfo);
188 DUMP_FIELD(PRefType);
189 DUMP_FIELD(FadeDetection);
190 #if (MFX_VERSION >= MFX_VERSION_NEXT)
191 DUMP_FIELD(DeblockingAlphaTcOffset);
192 DUMP_FIELD(DeblockingBetaOffset);
193 #else
194 DUMP_FIELD_RESERVED(reserved2);
195 #endif
196 DUMP_FIELD(GPB);
197 DUMP_FIELD(MaxFrameSizeI);
198 DUMP_FIELD(MaxFrameSizeP);
199 DUMP_FIELD(EnableQPOffset);
200 DUMP_FIELD_RESERVED(QPOffset);
201 DUMP_FIELD_RESERVED(NumRefActiveP);
202 DUMP_FIELD_RESERVED(NumRefActiveBL0);
203 DUMP_FIELD_RESERVED(NumRefActiveBL1);
204 DUMP_FIELD(BRCPanicMode);
205 #if (MFX_VERSION >= MFX_VERSION_NEXT)
206 DUMP_FIELD(ConstrainedIntraPredFlag);
207 #endif
208 #if (MFX_VERSION >= 1026)
209 DUMP_FIELD(TransformSkip);
210 #endif
211 #if (MFX_VERSION >= 1027)
212 DUMP_FIELD(TargetChromaFormatPlus1); /* Minus 1 specifies target encoding chroma format (see ColorFormat enum). May differ from input one. */
213 DUMP_FIELD(TargetBitDepthLuma); /* Target encoding bit depth for luma samples. May differ from input one. */
214 DUMP_FIELD(TargetBitDepthChroma); /* Target encoding bit depth for chroma samples. May differ from input one. */
215 #else
216 DUMP_FIELD_RESERVED(reserved4);
217 #endif
218 DUMP_FIELD(EnableMBForceIntra);
219 DUMP_FIELD(AdaptiveMaxFrameSize);
220 DUMP_FIELD(RepartitionCheckEnable);
221 #if (MFX_VERSION >= MFX_VERSION_NEXT)
222 DUMP_FIELD(QuantScaleType);
223 DUMP_FIELD(IntraVLCFormat);
224 DUMP_FIELD(ScanType);
225 #endif
226 #if ((MFX_VERSION < MFX_VERSION_NEXT) && (MFX_VERSION >= 1025))
227 DUMP_FIELD_RESERVED(reserved5);
228 #endif
229 #if (MFX_VERSION >= 1025)
230 DUMP_FIELD(EncodedUnitsInfo);
231 DUMP_FIELD(EnableNalUnitType);
232 #endif
233 #if (MFX_VERSION >= 1026)
234 DUMP_FIELD(ExtBrcAdaptiveLTR)
235 #endif
236 DUMP_FIELD_RESERVED(reserved);
237 return str;
238 }
239
dump(const std::string structName,const mfxExtEncoderResetOption & _struct)240 std::string DumpContext::dump(const std::string structName, const mfxExtEncoderResetOption &_struct)
241 {
242 std::string str;
243 str += dump(structName + ".Header", _struct.Header) + "\n";
244 DUMP_FIELD(StartNewSequence);
245 DUMP_FIELD_RESERVED(reserved);
246 return str;
247 }
248
dump(const std::string structName,const mfxExtVPPDoNotUse & _struct)249 std::string DumpContext::dump(const std::string structName, const mfxExtVPPDoNotUse &_struct)
250 {
251 std::string str;
252 str += dump(structName + ".Header", _struct.Header) + "\n";
253 // TODO dump list of algs
254 DUMP_FIELD(NumAlg);
255 DUMP_FIELD(AlgList);
256 return str;
257 }
258
dump(const std::string structName,const mfxExtVppAuxData & extVppAuxData)259 std::string DumpContext::dump(const std::string structName, const mfxExtVppAuxData &extVppAuxData)
260 {
261 std::string str;
262 str += dump(structName + ".Header", extVppAuxData.Header) + "\n";
263 str += structName + ".SpatialComplexity=" + ToString(extVppAuxData.SpatialComplexity) + "\n";
264 str += structName + ".TemporalComplexity=" + ToString(extVppAuxData.TemporalComplexity) + "\n";
265 str += structName + ".PicStruct=" + ToString(extVppAuxData.PicStruct) + "\n";
266 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(extVppAuxData.reserved) + "\n";
267 str += structName + ".SceneChangeRate=" + ToString(extVppAuxData.SceneChangeRate) + "\n";
268 str += structName + ".RepeatedFrame=" + ToString(extVppAuxData.RepeatedFrame);
269 return str;
270 }
271
dump(const std::string structName,const mfxFrameAllocRequest & frameAllocRequest)272 std::string DumpContext::dump(const std::string structName, const mfxFrameAllocRequest &frameAllocRequest)
273 {
274 std::string str;
275 str += structName + ".AllocId=" + ToString(frameAllocRequest.AllocId) + "\n";
276 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(frameAllocRequest.reserved) + "\n";
277 str += structName + ".reserved3[]=" + DUMP_RESERVED_ARRAY(frameAllocRequest.reserved3) + "\n";
278 str += dump(structName+".Info", frameAllocRequest.Info) + "\n";
279 str += structName + ".Type=" + ToString(frameAllocRequest.Type) + "\n";
280 str += structName + ".NumFrameMin=" + ToString(frameAllocRequest.NumFrameMin) + "\n";
281 str += structName + ".NumFrameSuggested=" + ToString(frameAllocRequest.NumFrameSuggested) + "\n";
282 str += structName + ".reserved2=" + ToString(frameAllocRequest.reserved2);
283 return str;
284 }
285
dump(const std::string structName,const mfxFrameAllocResponse & frameAllocResponse)286 std::string DumpContext::dump(const std::string structName, const mfxFrameAllocResponse &frameAllocResponse)
287 {
288 std::string str;
289 str += structName + ".AllocId=" + ToString(frameAllocResponse.AllocId) + "\n";
290 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(frameAllocResponse.reserved) + "\n";
291 if (frameAllocResponse.mids)
292 str += structName + ".mids=" + ToString(frameAllocResponse.mids) + "\n";
293 else
294 str += structName + ".mids=" + "NULL" + "\n";
295 str += structName + ".NumFrameActual=" + ToString(frameAllocResponse.NumFrameActual) + "\n";
296 #if (MFX_VERSION >= MFX_VERSION_NEXT)
297 str += structName + ".MemType=" + ToString(frameAllocResponse.MemType) + "\n";
298 #else
299 str += structName + ".reserved2=" + ToString(frameAllocResponse.reserved2) + "\n";
300 #endif
301 return str;
302 }
303
dump(const std::string structName,const mfxFrameData & frameData)304 std::string DumpContext::dump(const std::string structName, const mfxFrameData &frameData)
305 {
306 std::string str;
307 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(frameData.reserved) + "\n";
308 str += structName + ".PitchHigh=" + ToString(frameData.PitchHigh) + "\n";
309 str += structName + ".TimeStamp=" + ToString(frameData.TimeStamp) + "\n";
310 str += structName + ".FrameOrder=" + ToString(frameData.FrameOrder) + "\n";
311 str += structName + ".Locked=" + ToString(frameData.Locked) + "\n";
312 str += structName + ".Pitch=" + ToString(frameData.Pitch) + "\n";
313 str += structName + ".PitchLow=" + ToString(frameData.PitchLow) + "\n";
314 if (Log::GetLogLevel() == LOG_LEVEL_FULL) {
315 str += structName + ".Y=" + ToHexFormatString(frameData.Y) + "\n";
316 str += structName + ".R=" + ToHexFormatString(frameData.R) + "\n";
317 str += structName + ".UV=" + ToHexFormatString(frameData.UV) + "\n";
318 str += structName + ".VU=" + ToHexFormatString(frameData.VU) + "\n";
319 str += structName + ".CbCr=" + ToHexFormatString(frameData.CbCr) + "\n";
320 str += structName + ".CrCb=" + ToHexFormatString(frameData.CrCb) + "\n";
321 str += structName + ".Cb=" + ToHexFormatString(frameData.Cb) + "\n";
322 str += structName + ".U=" + ToHexFormatString(frameData.U) + "\n";
323 str += structName + ".G=" + ToHexFormatString(frameData.G) + "\n";
324 #if (MFX_VERSION >= 1027)
325 str += structName + ".Y410=" + ToHexFormatString(frameData.Y410) + "\n";
326 #endif
327 str += structName + ".Cr=" + ToHexFormatString(frameData.Cr) + "\n";
328 str += structName + ".V=" + ToHexFormatString(frameData.V) + "\n";
329 str += structName + ".B=" + ToHexFormatString(frameData.B) + "\n";
330 str += structName + ".A=" + ToHexFormatString(frameData.A) + "\n";
331 #if (MFX_VERSION >= 1025)
332 str += structName + ".A2RGB10=" + ToString(frameData.A2RGB10) + "\n";
333 #endif
334 }
335 str += structName + ".MemId=" + ToString(frameData.MemId) + "\n";
336 str += structName + ".Corrupted=" + ToString(frameData.Corrupted) + "\n";
337 str += structName + ".DataFlag=" + ToString(frameData.DataFlag) + "\n";
338 str += dump_mfxExtParams(structName, frameData);
339 return str;
340 }
341
dump(const std::string structName,const mfxFrameId & frame)342 std::string DumpContext::dump(const std::string structName, const mfxFrameId &frame)
343 {
344 std::string str;
345 str += structName + ".TemporalId=" + ToString(frame.TemporalId) + "\n";
346 str += structName + ".PriorityId=" + ToString(frame.PriorityId) + "\n";
347 str += structName + ".DependencyId=" + ToString(frame.DependencyId) + "\n";
348 str += structName + ".QualityId=" + ToString(frame.QualityId) + "\n";
349 str += structName + ".ViewId=" + ToString(frame.ViewId);
350 return str;
351 }
352
dump(const std::string structName,const mfxFrameInfo & info)353 std::string DumpContext::dump(const std::string structName, const mfxFrameInfo &info)
354 {
355 std::string str;
356 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(info.reserved) + "\n";
357 str += structName + ".reserved4=" + ToString(info.reserved4) + "\n";
358 str += structName + ".BitDepthLuma=" + ToString(info.BitDepthLuma) + "\n";
359 str += structName + ".BitDepthChroma=" + ToString(info.BitDepthChroma) + "\n";
360 str += structName + ".Shift=" + ToString(info.Shift) + "\n";
361 str += dump(structName + ".mfxFrameId", info.FrameId) + "\n";
362 str += structName + ".FourCC=" + GetFourCC(info.FourCC) + "\n";
363 str += structName + ".Width=" + ToString(info.Width) + "\n";
364 str += structName + ".Height=" + ToString(info.Height) + "\n";
365 str += structName + ".CropX=" + ToString(info.CropX) + "\n";
366 str += structName + ".CropY=" + ToString(info.CropY) + "\n";
367 str += structName + ".CropW=" + ToString(info.CropW) + "\n";
368 str += structName + ".CropH=" + ToString(info.CropH) + "\n";
369 str += structName + ".BufferSize=" + ToString(info.BufferSize) + "\n";
370 str += structName + ".reserved5=" + ToString(info.reserved5) + "\n";
371 str += structName + ".FrameRateExtN=" + ToString(info.FrameRateExtN) + "\n";
372 str += structName + ".FrameRateExtD=" + ToString(info.FrameRateExtD) + "\n";
373 str += structName + ".reserved3=" + ToString(info.reserved3) + "\n";
374 str += structName + ".AspectRatioW=" + ToString(info.AspectRatioW) + "\n";
375 str += structName + ".AspectRatioH=" + ToString(info.AspectRatioH) + "\n";
376 str += structName + ".PicStruct=" + ToString(info.PicStruct) + "\n";
377 str += structName + ".ChromaFormat=" + ToString(info.ChromaFormat) + "\n";
378 str += structName + ".reserved2=" + ToString(info.reserved2);
379 return str;
380 }
381
dump(const std::string structName,const mfxFrameSurface1 & frameSurface1)382 std::string DumpContext::dump(const std::string structName, const mfxFrameSurface1 &frameSurface1)
383 {
384 std::string str;
385 str += dump(structName + ".Data", frameSurface1.Data) + "\n";
386 str += dump(structName + ".Info", frameSurface1.Info) + "\n";
387 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(frameSurface1.reserved) + "\n";
388 return str;
389 }
390
dump(const std::string structName,const mfxHandleType & handleType)391 std::string DumpContext::dump(const std::string structName, const mfxHandleType &handleType)
392 {
393 return std::string("mfxHandleType " + structName + "=" + ToString(handleType));
394 }
395
dump(const std::string structName,const mfxInfoMFX & mfx)396 std::string DumpContext::dump(const std::string structName, const mfxInfoMFX &mfx)
397 {
398 std::string str;
399 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(mfx.reserved) + "\n";
400 str += structName + ".LowPower=" + ToString(mfx.LowPower) + "\n";
401 str += structName + ".BRCParamMultiplier=" + ToString(mfx.BRCParamMultiplier) + "\n";
402 str += dump(structName + ".FrameInfo", mfx.FrameInfo) + "\n";
403 str += structName + ".CodecId=" + GetCodecIdString(mfx.CodecId) + "\n";
404 str += structName + ".CodecProfile=" + ToString(mfx.CodecProfile) + "\n";
405 str += structName + ".CodecLevel=" + ToString(mfx.CodecLevel) + "\n";
406 str += structName + ".NumThread=" + ToString(mfx.NumThread) + "\n";
407 str += structName + ".TargetUsage=" + ToString(mfx.TargetUsage) + "\n";
408 str += structName + ".GopPicSize=" + ToString(mfx.GopPicSize) + "\n";
409 str += structName + ".GopRefDist=" + ToString(mfx.GopRefDist) + "\n";
410 str += structName + ".GopOptFlag=" + ToString(mfx.GopOptFlag) + "\n";
411 str += structName + ".IdrInterval=" + ToString(mfx.IdrInterval) + "\n";
412 str += structName + ".RateControlMethod=" + ToString(mfx.RateControlMethod) + "\n";
413 str += structName + ".InitialDelayInKB=" + ToString(mfx.InitialDelayInKB) + "\n";
414 str += structName + ".QPI=" + ToString(mfx.QPI) + "\n";
415 str += structName + ".Accuracy=" + ToString(mfx.Accuracy) + "\n";
416 str += structName + ".BufferSizeInKB=" + ToString(mfx.BufferSizeInKB) + "\n";
417 str += structName + ".TargetKbps=" + ToString(mfx.TargetKbps) + "\n";
418 str += structName + ".QPP=" + ToString(mfx.QPP) + "\n";
419 str += structName + ".ICQQuality=" + ToString(mfx.ICQQuality) + "\n";
420 str += structName + ".MaxKbps=" + ToString(mfx.MaxKbps) + "\n";
421 str += structName + ".QPB=" + ToString(mfx.QPB) + "\n";
422 str += structName + ".Convergence=" + ToString(mfx.Convergence) + "\n";
423 str += structName + ".NumSlice=" + ToString(mfx.NumSlice) + "\n";
424 str += structName + ".NumRefFrame=" + ToString(mfx.NumRefFrame) + "\n";
425 str += structName + ".EncodedOrder=" + ToString(mfx.EncodedOrder) + "\n";
426 str += structName + ".DecodedOrder=" + ToString(mfx.DecodedOrder) + "\n";
427 str += structName + ".ExtendedPicStruct=" + ToString(mfx.ExtendedPicStruct) + "\n";
428 str += structName + ".TimeStampCalc=" + ToString(mfx.TimeStampCalc) + "\n";
429 str += structName + ".SliceGroupsPresent=" + ToString(mfx.SliceGroupsPresent) + "\n";
430 str += structName + ".MaxDecFrameBuffering=" + ToString(mfx.MaxDecFrameBuffering) + "\n";
431 str += structName + ".EnableReallocRequest=" + ToString(mfx.EnableReallocRequest) + "\n";
432 #if (MFX_VERSION >= 1034)
433 str += structName + ".IgnoreLevelConstrain=" + ToString(mfx.IgnoreLevelConstrain) + "\n";
434 #endif
435 str += structName + ".reserved2[]=" + DUMP_RESERVED_ARRAY(mfx.reserved2) + "\n";
436 str += structName + ".JPEGChromaFormat=" + ToString(mfx.JPEGChromaFormat) + "\n";
437 str += structName + ".Rotation=" + ToString(mfx.Rotation) + "\n";
438 str += structName + ".JPEGColorFormat=" + ToString(mfx.JPEGColorFormat) + "\n";
439 str += structName + ".InterleavedDec=" + ToString(mfx.InterleavedDec) + "\n";
440 str += structName + ".reserved3[]=" + DUMP_RESERVED_ARRAY(mfx.reserved3) + "\n";
441 str += structName + ".Interleaved=" + ToString(mfx.Interleaved) + "\n";
442 str += structName + ".Quality=" + ToString(mfx.Quality) + "\n";
443 str += structName + ".RestartInterval=" + ToString(mfx.RestartInterval) + "\n";
444 str += structName + ".reserved5[]=" + DUMP_RESERVED_ARRAY(mfx.reserved5) + "\n";
445 return str;
446 }
447
dump(const std::string structName,const mfxInfoVPP & vpp)448 std::string DumpContext::dump(const std::string structName, const mfxInfoVPP &vpp)
449 {
450 std::string str;
451 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(vpp.reserved) + "\n";
452 str += dump(structName + ".In", vpp.In) + "\n" +
453 str += dump(structName + ".Out", vpp.Out);
454 return str;
455 }
456
dump(const std::string structName,const mfxPayload & payload)457 std::string DumpContext::dump(const std::string structName, const mfxPayload &payload)
458 {
459 std::string str;
460 str += structName + ".CtrlFlags=" + ToString(payload.CtrlFlags) + "\n";
461 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(payload.reserved) + "\n";
462 str += structName + ".Data=" + ToString(payload.Data) + "\n";
463 str += structName + ".NumBit=" + ToString(payload.NumBit) + "\n";
464 str += structName + ".Type=" + ToString(payload.Type) + "\n";
465 str += structName + ".BufSize=" + ToString(payload.BufSize);
466 return str;
467 }
468
dump(const std::string structName,const mfxSkipMode & skipMode)469 std::string DumpContext::dump(const std::string structName, const mfxSkipMode &skipMode)
470 {
471 return std::string("mfxSkipMode " + structName + "=" + ToString(skipMode));
472 }
473
dump(const std::string structName,const mfxVideoParam & videoParam)474 std::string DumpContext::dump(const std::string structName, const mfxVideoParam& videoParam)
475 {
476 std::string str;
477 str += structName + ".AllocId=" + ToString(videoParam.AllocId) + "\n";
478 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(videoParam.reserved) + "\n";
479 str += structName + ".AsyncDepth=" + ToString(videoParam.AsyncDepth) + "\n";
480 if(context == DUMPCONTEXT_MFX)
481 str += dump(structName + ".mfx", videoParam.mfx) + "\n";
482 else if(context == DUMPCONTEXT_VPP)
483 str += dump(structName + ".vpp", videoParam.vpp) + "\n";
484 else if(context == DUMPCONTEXT_ALL){
485 str += dump(structName + ".mfx", videoParam.mfx) + "\n";
486 str += dump(structName + ".vpp", videoParam.vpp) + "\n";
487 }
488 str += structName + ".Protected=" + ToString(videoParam.Protected) + "\n";
489 str += structName + ".IOPattern=" + GetIOPattern(videoParam.IOPattern) + "\n";
490 str += dump_mfxExtParams(structName, videoParam) + "\n";
491 str += structName + ".reserved2=" + ToString(videoParam.reserved2);
492 return str;
493 }
494
dump(const std::string structName,const mfxVPPStat & vppStat)495 std::string DumpContext::dump(const std::string structName, const mfxVPPStat &vppStat)
496 {
497 std::string str;
498 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(vppStat.reserved) + "\n";
499 str += structName + ".NumFrame=" + ToString(vppStat.NumFrame) + "\n";
500 str += structName + ".NumCachedFrame=" + ToString(vppStat.NumCachedFrame);
501 return str;
502 }
503
dump(const std::string structName,const mfxExtDecodedFrameInfo & ExtDecodedFrameInfo)504 std::string DumpContext::dump(const std::string structName, const mfxExtDecodedFrameInfo &ExtDecodedFrameInfo)
505 {
506 std::string str;
507 str += dump(structName + ".Header", ExtDecodedFrameInfo.Header) + "\n";
508 str += structName + ".FrameType=" + ToString(ExtDecodedFrameInfo.FrameType) + "\n";
509 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtDecodedFrameInfo.reserved) + "\n";
510 return str;
511 }
512
513 #if (MFX_VERSION >= 1025)
dump(const std::string structName,const mfxExtDecodeErrorReport & ExtDecodeErrorReport)514 std::string DumpContext::dump(const std::string structName, const mfxExtDecodeErrorReport &ExtDecodeErrorReport)
515 {
516 std::string str;
517 str += dump(structName + ".Header", ExtDecodeErrorReport.Header) + "\n";
518 str += structName + ".ErrorTypes=" + toString(ExtDecodeErrorReport.ErrorTypes, DUMP_HEX) + "\n";
519 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtDecodeErrorReport.reserved) + "\n";
520 return str;
521 }
522 #endif
523
dump(const std::string structName,const mfxExtTimeCode & ExtTimeCode)524 std::string DumpContext::dump(const std::string structName, const mfxExtTimeCode &ExtTimeCode)
525 {
526 std::string str;
527 str += dump(structName + ".Header", ExtTimeCode.Header) + "\n";
528 str += structName + ".DropFrameFlag=" + ToString(ExtTimeCode.DropFrameFlag) + "\n";
529 str += structName + ".TimeCodeHours=" + ToString(ExtTimeCode.TimeCodeHours) + "\n";
530 str += structName + ".TimeCodeMinutes=" + ToString(ExtTimeCode.TimeCodeMinutes) + "\n";
531 str += structName + ".TimeCodeSeconds=" + ToString(ExtTimeCode.TimeCodeSeconds) + "\n";
532 str += structName + ".TimeCodePictures=" + ToString(ExtTimeCode.TimeCodePictures) + "\n";
533 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtTimeCode.reserved) + "\n";
534 return str;
535 }
536
dump(const std::string structName,const mfxExtEncoderCapability & ExtEncoderCapability)537 std::string DumpContext::dump(const std::string structName, const mfxExtEncoderCapability &ExtEncoderCapability)
538 {
539 std::string str;
540 str += dump(structName + ".Header", ExtEncoderCapability.Header) + "\n";
541 str += structName + ".MBPerSec=" + ToString(ExtEncoderCapability.MBPerSec) + "\n";
542 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtEncoderCapability.reserved) + "\n";
543 return str;
544 }
545
dump(const std::string structName,const mfxExtDirtyRect & ExtDirtyRect)546 std::string DumpContext::dump(const std::string structName, const mfxExtDirtyRect &ExtDirtyRect)
547 {
548 std::string str;
549 str += dump(structName + ".Header", ExtDirtyRect.Header) + "\n";
550 str += structName + ".NumRect=" + ToString(ExtDirtyRect.NumRect) + "\n";
551 str += structName + ".reserved1[]=" + DUMP_RESERVED_ARRAY(ExtDirtyRect.reserved1) + "\n";
552 str += structName + ".Rect=" + ToString(ExtDirtyRect.Rect) + "\n";
553 return str;
554 }
555
dump(const std::string structName,const mfxExtMoveRect & ExtMoveRect)556 std::string DumpContext::dump(const std::string structName, const mfxExtMoveRect &ExtMoveRect)
557 {
558 std::string str;
559 str += dump(structName + ".Header", ExtMoveRect.Header) + "\n";
560 str += structName + ".NumRect=" + ToString(ExtMoveRect.NumRect) + "\n";
561 str += structName + ".reserved1[]=" + DUMP_RESERVED_ARRAY(ExtMoveRect.reserved1) + "\n";
562 str += structName + ".Rect=" + ToString(ExtMoveRect.Rect) + "\n";
563 return str;
564 }
565
566 //camera
dump(const std::string structName,const mfxExtCamGammaCorrection & CamGammaCorrection)567 std::string DumpContext::dump(const std::string structName, const mfxExtCamGammaCorrection &CamGammaCorrection)
568 {
569 std::string str;
570 str += dump(structName + ".Header", CamGammaCorrection.Header) + "\n";
571 str += structName + ".Mode=" + ToString(CamGammaCorrection.Mode) + "\n";
572 str += structName + ".reserved1=" + ToString(CamGammaCorrection.reserved1) + "\n";
573 str += structName + ".GammaValue=" + ToString(CamGammaCorrection.GammaValue) + "\n";
574 str += structName + ".reserved2[]=" + DUMP_RESERVED_ARRAY(CamGammaCorrection.reserved2) + "\n";
575 str += structName + ".NumPoints=" + ToString(CamGammaCorrection.NumPoints) + "\n";
576 str += structName + ".GammaPoint=" + ToString(CamGammaCorrection.GammaPoint) + "\n";
577 str += structName + ".GammaCorrected=" + ToString(CamGammaCorrection.GammaCorrected) + "\n";
578 str += structName + ".reserved3[]=" + DUMP_RESERVED_ARRAY(CamGammaCorrection.reserved3) + "\n";
579 return str;
580 }
581
dump(const std::string structName,const mfxExtCamWhiteBalance & CamWhiteBalance)582 std::string DumpContext::dump(const std::string structName, const mfxExtCamWhiteBalance &CamWhiteBalance)
583 {
584 std::string str;
585 str += dump(structName + ".Header", CamWhiteBalance.Header) + "\n";
586 str += structName + ".Mode=" + ToString(CamWhiteBalance.Mode) + "\n";
587 str += structName + ".R=" + ToString(CamWhiteBalance.R) + "\n";
588 str += structName + ".G0=" + ToString(CamWhiteBalance.G0) + "\n";
589 str += structName + ".B=" + ToString(CamWhiteBalance.B) + "\n";
590 str += structName + ".G1=" + ToString(CamWhiteBalance.G1) + "\n";
591 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(CamWhiteBalance.reserved) + "\n";
592 return str;
593 }
594
dump(const std::string structName,const mfxExtCamHotPixelRemoval & CamHotPixelRemoval)595 std::string DumpContext::dump(const std::string structName, const mfxExtCamHotPixelRemoval &CamHotPixelRemoval)
596 {
597 std::string str;
598 str += dump(structName + ".Header", CamHotPixelRemoval.Header) + "\n";
599 str += structName + ".PixelThresholdDifference=" + ToString(CamHotPixelRemoval.PixelThresholdDifference) + "\n";
600 str += structName + ".PixelCountThreshold=" + ToString(CamHotPixelRemoval.PixelCountThreshold) + "\n";
601 return str;
602 }
603
dump(const std::string structName,const mfxExtCamBlackLevelCorrection & CamBlackLevelCorrection)604 std::string DumpContext::dump(const std::string structName, const mfxExtCamBlackLevelCorrection &CamBlackLevelCorrection)
605 {
606 std::string str;
607 str += dump(structName + ".Header", CamBlackLevelCorrection.Header) + "\n";
608 str += structName + ".R=" + ToString(CamBlackLevelCorrection.R) + "\n";
609 str += structName + ".G0=" + ToString(CamBlackLevelCorrection.G0) + "\n";
610 str += structName + ".B=" + ToString(CamBlackLevelCorrection.B) + "\n";
611 str += structName + ".G1=" + ToString(CamBlackLevelCorrection.G1) + "\n";
612 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(CamBlackLevelCorrection.reserved) + "\n";
613 return str;
614 }
615
dump(const std::string structName,const mfxCamVignetteCorrectionParam & VignetteCorrectionParams)616 std::string DumpContext::dump(const std::string structName, const mfxCamVignetteCorrectionParam &VignetteCorrectionParams)
617 {
618 std::string str;
619 //need to clarify SKL HW alignment with VPG
620 str += structName + ".R=" + ToString(VignetteCorrectionParams.R.integer)+"."+ToString(VignetteCorrectionParams.R.mantissa) + "\n";
621 str += structName + ".G0=" + ToString(VignetteCorrectionParams.G0.integer)+"."+ToString(VignetteCorrectionParams.G0.mantissa) + "\n";
622 str += structName + ".B=" + ToString(VignetteCorrectionParams.G1.integer)+"."+ToString(VignetteCorrectionParams.G1.mantissa) + "\n";
623 str += structName + ".G1=" + ToString(VignetteCorrectionParams.B.integer)+"."+ToString(VignetteCorrectionParams.B.mantissa) + "\n";
624 return str;
625 }
626
dump(const std::string structName,const mfxExtCamVignetteCorrection & CamVignetteCorrection)627 std::string DumpContext::dump(const std::string structName, const mfxExtCamVignetteCorrection &CamVignetteCorrection)
628 {
629 std::string str;
630 str += dump(structName + ".Header", CamVignetteCorrection.Header) + "\n";
631 str += structName + ".Width=" + ToString(CamVignetteCorrection.Width) + "\n";
632 str += structName + ".Height=" + ToString(CamVignetteCorrection.Height) + "\n";
633 str += structName + ".Pitch=" + ToString(CamVignetteCorrection.Pitch) + "\n";
634 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(CamVignetteCorrection.reserved) + "\n";
635 if (CamVignetteCorrection.CorrectionMap)
636 {
637 str += dump(structName + ".CorrectionMap", *(CamVignetteCorrection.CorrectionMap)) + "\n";
638 }
639 return str;
640 }
641
dump(const std::string structName,const mfxExtCamBayerDenoise & CamBayerDenoise)642 std::string DumpContext::dump(const std::string structName, const mfxExtCamBayerDenoise &CamBayerDenoise)
643 {
644 std::string str;
645 str += dump(structName + ".Header", CamBayerDenoise.Header) + "\n";
646 str += structName + ".Threshold=" + ToString(CamBayerDenoise.Threshold) + "\n";
647 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(CamBayerDenoise.reserved) + "\n";
648 return str;
649 }
650
dump(const std::string structName,const mfxExtCamColorCorrection3x3 & CamColorCorrection3x3)651 std::string DumpContext::dump(const std::string structName, const mfxExtCamColorCorrection3x3 &CamColorCorrection3x3)
652 {
653 std::string str;
654 str += dump(structName + ".Header", CamColorCorrection3x3.Header) + "\n";
655 str += structName + ".CCM=" + ToString(CamColorCorrection3x3.CCM) + "\n";
656 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(CamColorCorrection3x3.reserved) + "\n";
657 return str;
658 }
659
dump(const std::string structName,const mfxExtCamPadding & CamPadding)660 std::string DumpContext::dump(const std::string structName, const mfxExtCamPadding &CamPadding)
661 {
662 std::string str;
663 str += dump(structName + ".Header", CamPadding.Header) + "\n";
664 str += structName + ".Top=" + ToString(CamPadding.Top) + "\n";
665 str += structName + ".Bottom=" + ToString(CamPadding.Bottom) + "\n";
666 str += structName + ".Left=" + ToString(CamPadding.Left) + "\n";
667 str += structName + ".Right=" + ToString(CamPadding.Right) + "\n";
668 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(CamPadding.reserved) + "\n";
669 return str;
670 }
671
dump(const std::string structName,const mfxExtCamPipeControl & CamPipeControl)672 std::string DumpContext::dump(const std::string structName, const mfxExtCamPipeControl &CamPipeControl)
673 {
674 std::string str;
675 str += dump(structName + ".Header", CamPipeControl.Header) + "\n";
676 str += structName + ".RawFormat=" + ToString(CamPipeControl.RawFormat) + "\n";
677 str += structName + ".reserved1=" + ToString(CamPipeControl.reserved1) + "\n";
678 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(CamPipeControl.reserved) + "\n";
679 return str;
680 }
681
dump(const std::string structName,const mfxCamFwdGammaSegment & CamFwrGammaSegment)682 std::string DumpContext::dump(const std::string structName, const mfxCamFwdGammaSegment &CamFwrGammaSegment)
683 {
684 std::string str;
685 str += structName + ".Pixel=" + ToString(CamFwrGammaSegment.Pixel) + "\n";
686 str += structName + ".Red=" + ToString(CamFwrGammaSegment.Red) + "\n";
687 str += structName + ".Green=" + ToString(CamFwrGammaSegment.Green) + "\n";
688 str += structName + ".Blue=" + ToString(CamFwrGammaSegment.Blue) + "\n";
689 return str;
690 }
691
dump(const std::string structName,const mfxExtCamFwdGamma & CamFwrGamma)692 std::string DumpContext::dump(const std::string structName, const mfxExtCamFwdGamma &CamFwrGamma)
693 {
694 std::string str;
695 str += dump(structName + ".Header", CamFwrGamma.Header) + "\n";
696 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(CamFwrGamma.reserved) + "\n";
697 str += structName + ".NumSegments=" + ToString(CamFwrGamma.NumSegments) + "\n";
698 if (CamFwrGamma.Segment)
699 {
700 for (int i = 0; i < CamFwrGamma.NumSegments; i++)
701 {
702 str += dump((structName + ".Segment[" + ToString(i) + "]"), CamFwrGamma.Segment[i]) + "\n";
703 }
704 }
705 return str;
706 }
707
708
dump(const std::string structName,const mfxExtCamLensGeomDistCorrection & CamLensGeomDistCorrection)709 std::string DumpContext::dump(const std::string structName, const mfxExtCamLensGeomDistCorrection &CamLensGeomDistCorrection)
710 {
711 std::string str;
712 str += dump(structName + ".Header", CamLensGeomDistCorrection.Header) + "\n";
713 for (int i = 0; i < 3; i++)
714 str += structName + ".a[" + ToString(i) + "]=" + ToString(CamLensGeomDistCorrection.a[i]) + "\n";
715 for (int i = 0; i < 3; i++)
716 str += structName + ".b[" + ToString(i) + "]=" + ToString(CamLensGeomDistCorrection.b[i]) + "\n";
717 for (int i = 0; i < 3; i++)
718 str += structName + ".c[" + ToString(i) + "]=" + ToString(CamLensGeomDistCorrection.c[i]) + "\n";
719 for (int i = 0; i < 3; i++)
720 str += structName + ".d[" + ToString(i) + "]=" + ToString(CamLensGeomDistCorrection.d[i]) + "\n";
721 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(CamLensGeomDistCorrection.reserved) + "\n";
722 return str;
723 }
724
dump(const std::string structName,const mfxExtCamTotalColorControl & _struct)725 std::string DumpContext::dump(const std::string structName, const mfxExtCamTotalColorControl &_struct)
726 {
727 std::string str;
728 str += dump(structName + ".Header", _struct.Header) + "\n";
729 DUMP_FIELD(R);
730 DUMP_FIELD(G);
731 DUMP_FIELD(B);
732
733 DUMP_FIELD(C);
734 DUMP_FIELD(M);
735 DUMP_FIELD(Y);
736
737 DUMP_FIELD_RESERVED(reserved);
738 return str;
739 }
740
dump(const std::string structName,const mfxExtCamCscYuvRgb & _struct)741 std::string DumpContext::dump(const std::string structName, const mfxExtCamCscYuvRgb &_struct)
742 {
743 std::string str;
744 str += dump(structName + ".Header", _struct.Header) + "\n";
745 str += structName + ".PreOffset=" + ToString(_struct.PreOffset) + "\n";
746 str += structName + ".Matrix=" + ToString(_struct.Matrix) + "\n";
747 str += structName + ".PreOffset=" + ToString(_struct.PostOffset) + "\n";
748
749 DUMP_FIELD_RESERVED(reserved);
750 return str;
751 }
752
dump(const std::string structName,const mfxExtAVCRefListCtrl & ExtAVCRefListCtrl)753 std::string DumpContext::dump(const std::string structName, const mfxExtAVCRefListCtrl &ExtAVCRefListCtrl)
754 {
755 std::string str;
756 str += dump(structName + ".Header", ExtAVCRefListCtrl.Header) + "\n";
757 str += structName + ".NumRefIdxL0Active=" + ToString(ExtAVCRefListCtrl.NumRefIdxL0Active) + "\n";
758 str += structName + ".NumRefIdxL1Active=" + ToString(ExtAVCRefListCtrl.NumRefIdxL1Active) + "\n";
759 str += structName + ".PreferredRefList=" + ToString(ExtAVCRefListCtrl.PreferredRefList) + "\n";
760 str += structName + ".RejectedRefList=" + ToString(ExtAVCRefListCtrl.RejectedRefList) + "\n";
761 str += structName + ".LongTermRefList=" + ToString(ExtAVCRefListCtrl.LongTermRefList) + "\n";
762 str += structName + ".ApplyLongTermIdx=" + ToString(ExtAVCRefListCtrl.ApplyLongTermIdx) + "\n";
763 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtAVCRefListCtrl.reserved) + "\n";
764 return str;
765 }
766
dump(const std::string structName,const mfxExtAvcTemporalLayers & ExtAvcTemporalLayers)767 std::string DumpContext::dump(const std::string structName, const mfxExtAvcTemporalLayers &ExtAvcTemporalLayers)
768 {
769 std::string str;
770 str += dump(structName + ".Header", ExtAvcTemporalLayers.Header) + "\n";
771 str += structName + ".reserved1[]=" + DUMP_RESERVED_ARRAY(ExtAvcTemporalLayers.reserved1) + "\n";
772 str += structName + ".reserved2=" + ToString(ExtAvcTemporalLayers.reserved2) + "\n";
773 str += structName + ".BaseLayerPID=" + ToString(ExtAvcTemporalLayers.BaseLayerPID) + "\n";
774 str += structName + ".Layer=" + ToString(ExtAvcTemporalLayers.Layer) + "\n";
775 return str;
776 }
777
dump(const std::string structName,const mfxExtAVCEncodedFrameInfo & ExtAVCEncodedFrameInfo)778 std::string DumpContext::dump(const std::string structName, const mfxExtAVCEncodedFrameInfo &ExtAVCEncodedFrameInfo)
779 {
780 std::string str;
781 str += dump(structName + ".Header", ExtAVCEncodedFrameInfo.Header) + "\n";
782 str += structName + ".FrameOrder=" + ToString(ExtAVCEncodedFrameInfo.FrameOrder) + "\n";
783 str += structName + ".PicStruct=" + ToString(ExtAVCEncodedFrameInfo.PicStruct) + "\n";
784 str += structName + ".LongTermIdx=" + ToString(ExtAVCEncodedFrameInfo.LongTermIdx) + "\n";
785 str += structName + ".MAD=" + ToString(ExtAVCEncodedFrameInfo.MAD) + "\n";
786 str += structName + ".BRCPanicMode=" + ToString(ExtAVCEncodedFrameInfo.BRCPanicMode) + "\n";
787 str += structName + ".QP=" + ToString(ExtAVCEncodedFrameInfo.QP) + "\n";
788 str += structName + ".SecondFieldOffset=" + ToString(ExtAVCEncodedFrameInfo.SecondFieldOffset) + "\n";
789 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtAVCEncodedFrameInfo.reserved) + "\n";
790 str += structName + ".UsedRefListL0=" + ToHexFormatString(ExtAVCEncodedFrameInfo.UsedRefListL0) + "\n";
791 str += structName + ".UsedRefListL1=" + ToHexFormatString(ExtAVCEncodedFrameInfo.UsedRefListL1) + "\n";
792 return str;
793 }
794
dump(const std::string structName,const mfxExtAVCRefLists & ExtAVCRefLists)795 std::string DumpContext::dump(const std::string structName, const mfxExtAVCRefLists &ExtAVCRefLists)
796 {
797 std::string str;
798 str += dump(structName + ".Header", ExtAVCRefLists.Header) + "\n";
799 str += structName + ".NumRefIdxL0Active=" + ToString(ExtAVCRefLists.NumRefIdxL0Active) + "\n";
800 str += structName + ".NumRefIdxL1Active=" + ToString(ExtAVCRefLists.NumRefIdxL1Active) + "\n";
801 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtAVCRefLists.reserved) + "\n";
802 str += structName + ".RefPicList0=" + ToString(ExtAVCRefLists.RefPicList0) + "\n";
803 str += structName + ".RefPicList1=" + ToString(ExtAVCRefLists.RefPicList1) + "\n";
804 return str;
805 }
806
dump(const std::string structName,const mfxExtVPPMirroring & ExtVPPMirroring)807 std::string DumpContext::dump(const std::string structName, const mfxExtVPPMirroring &ExtVPPMirroring)
808 {
809 std::string str;
810 str += dump(structName + ".Header", ExtVPPMirroring.Header) + "\n";
811 str += structName + ".Type=" + ToString(ExtVPPMirroring.Type) + "\n";
812 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtVPPMirroring.reserved) + "\n";
813 return str;
814 }
815
dump(const std::string structName,const mfxExtMVOverPicBoundaries & ExtMVOverPicBoundaries)816 std::string DumpContext::dump(const std::string structName, const mfxExtMVOverPicBoundaries &ExtMVOverPicBoundaries)
817 {
818 std::string str;
819 str += dump(structName + ".Header", ExtMVOverPicBoundaries.Header) + "\n";
820 str += structName + ".StickTop=" + ToString(ExtMVOverPicBoundaries.StickTop) + "\n";
821 str += structName + ".StickBottom=" + ToString(ExtMVOverPicBoundaries.StickBottom) + "\n";
822 str += structName + ".StickLeft=" + ToString(ExtMVOverPicBoundaries.StickLeft) + "\n";
823 str += structName + ".StickRight=" + ToString(ExtMVOverPicBoundaries.StickRight) + "\n";
824 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtMVOverPicBoundaries.reserved) + "\n";
825 return str;
826 }
827
dump(const std::string structName,const mfxExtVPPColorFill & ExtVPPColorFill)828 std::string DumpContext::dump(const std::string structName, const mfxExtVPPColorFill &ExtVPPColorFill)
829 {
830 std::string str;
831 str += dump(structName + ".Header", ExtVPPColorFill.Header) + "\n";
832 str += structName + ".Enable=" + ToString(ExtVPPColorFill.Enable) + "\n";
833 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtVPPColorFill.reserved) + "\n";
834 return str;
835 }
836
837 //mfxjpeg
dump(const std::string structName,const mfxExtJPEGQuantTables & ExtJPEGQuantTables)838 std::string DumpContext::dump(const std::string structName, const mfxExtJPEGQuantTables &ExtJPEGQuantTables)
839 {
840 std::string str;
841 str += dump(structName + ".Header", ExtJPEGQuantTables.Header) + "\n";
842 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtJPEGQuantTables.reserved) + "\n";
843 str += structName + ".NumTable=" + ToString(ExtJPEGQuantTables.NumTable) + "\n";
844 for (int i = 0; i < 4; i++)
845 {
846 str += structName + ".Qm[" + ToString(i) + "][]=" + DUMP_RESERVED_ARRAY(ExtJPEGQuantTables.Qm[i]) + "\n";
847 }
848 return str;
849 }
850
dump(const std::string structName,const mfxExtJPEGHuffmanTables & ExtJPEGHuffmanTables)851 std::string DumpContext::dump(const std::string structName, const mfxExtJPEGHuffmanTables &ExtJPEGHuffmanTables)
852 {
853 std::string str;
854 str += dump(structName + ".Header", ExtJPEGHuffmanTables.Header) + "\n";
855 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtJPEGHuffmanTables.reserved) + "\n";
856 str += structName + ".NumDCTable=" + ToString(ExtJPEGHuffmanTables.NumDCTable) + "\n";
857 str += structName + ".NumACTable=" + ToString(ExtJPEGHuffmanTables.NumACTable) + "\n";
858 for (int i = 0; i < 4; i++)
859 {
860 str += structName + ".DCTables[" + ToString(i) + "].Bits[]=" + DUMP_RESERVED_ARRAY(ExtJPEGHuffmanTables.DCTables[i].Bits) + "\n";
861 str += structName + ".DCTables[" + ToString(i) + "].Values[]=" + DUMP_RESERVED_ARRAY(ExtJPEGHuffmanTables.DCTables[i].Values) + "\n";
862 }
863 for (int i = 0; i < 4; i++)
864 {
865 str += structName + ".ACTables[" + ToString(i) + "].Bits[]=" + DUMP_RESERVED_ARRAY(ExtJPEGHuffmanTables.ACTables[i].Bits) + "\n";
866 str += structName + ".ACTables[" + ToString(i) + "].Values[]=" + DUMP_RESERVED_ARRAY(ExtJPEGHuffmanTables.ACTables[i].Values) + "\n";
867 }
868 return str;
869 }
870
871 //mfxmvc
dump(const std::string structName,const mfxMVCViewDependency & MVCViewDependency)872 std::string DumpContext::dump(const std::string structName, const mfxMVCViewDependency &MVCViewDependency)
873 {
874 std::string str;
875 str += structName + ".ViewId=" + ToString(MVCViewDependency.ViewId) + "\n";
876 str += structName + ".NumAnchorRefsL0=" + ToString(MVCViewDependency.NumAnchorRefsL0) + "\n";
877 str += structName + ".NumAnchorRefsL1=" + ToString(MVCViewDependency.NumAnchorRefsL1) + "\n";
878 str += structName + ".AnchorRefL0[]=" + DUMP_RESERVED_ARRAY(MVCViewDependency.AnchorRefL0) + "\n";
879 str += structName + ".AnchorRefL1[]=" + DUMP_RESERVED_ARRAY(MVCViewDependency.AnchorRefL1) + "\n";
880 str += structName + ".NumNonAnchorRefsL0=" + ToString(MVCViewDependency.NumNonAnchorRefsL0) + "\n";
881 str += structName + ".NumNonAnchorRefsL1=" + ToString(MVCViewDependency.NumNonAnchorRefsL1) + "\n";
882 str += structName + ".NonAnchorRefL0[]=" + DUMP_RESERVED_ARRAY(MVCViewDependency.NonAnchorRefL0) + "\n";
883 str += structName + ".NonAnchorRefL1[]=" + DUMP_RESERVED_ARRAY(MVCViewDependency.NonAnchorRefL1) + "\n";
884 return str;
885 }
886
dump(const std::string structName,const mfxMVCOperationPoint & MVCOperationPoint)887 std::string DumpContext::dump(const std::string structName, const mfxMVCOperationPoint &MVCOperationPoint)
888 {
889 std::string str;
890 str += structName + ".TemporalId=" + ToString(MVCOperationPoint.TemporalId) + "\n";
891 str += structName + ".LevelIdc=" + ToString(MVCOperationPoint.LevelIdc) + "\n";
892 str += structName + ".NumViews=" + ToString(MVCOperationPoint.NumViews) + "\n";
893 str += structName + ".NumTargetViews=" + ToString(MVCOperationPoint.NumTargetViews) + "\n";
894 str += structName + ".TargetViewId=" + ToHexFormatString(MVCOperationPoint.TargetViewId) + "\n";
895 return str;
896 }
897
dump(const std::string structName,const mfxExtMVCSeqDesc & ExtMVCSeqDesc)898 std::string DumpContext::dump(const std::string structName, const mfxExtMVCSeqDesc &ExtMVCSeqDesc)
899 {
900 std::string str;
901 str += dump(structName + ".Header", ExtMVCSeqDesc.Header) + "\n";
902 str += structName + ".NumView=" + ToString(ExtMVCSeqDesc.NumView) + "\n";
903 if (ExtMVCSeqDesc.View)
904 {
905 str += dump(structName + ".View", *(ExtMVCSeqDesc.View)) + "\n";
906 }
907 str += structName + ".NumViewId=" + ToString(ExtMVCSeqDesc.NumViewId) + "\n";
908 str += structName + ".NumViewIdAlloc=" + ToString(ExtMVCSeqDesc.NumViewIdAlloc) + "\n";
909 str += structName + ".ViewId=" + ToString(ExtMVCSeqDesc.ViewId) + "\n";
910 str += structName + ".NumOP=" + ToString(ExtMVCSeqDesc.NumOP) + "\n";
911 str += structName + ".NumOPAlloc=" + ToString(ExtMVCSeqDesc.NumOPAlloc) + "\n";
912 if (ExtMVCSeqDesc.OP)
913 {
914 str += dump(structName + ".OP", *(ExtMVCSeqDesc.OP)) + "\n";
915 }
916 str += structName + ".NumRefsTotal=" + ToString(ExtMVCSeqDesc.NumRefsTotal) + "\n";
917 str += structName + ".Reserved[]=" + DUMP_RESERVED_ARRAY(ExtMVCSeqDesc.Reserved) + "\n";
918 return str;
919 }
920
dump(const std::string structName,const mfxExtMVCTargetViews & ExtMVCTargetViews)921 std::string DumpContext::dump(const std::string structName, const mfxExtMVCTargetViews &ExtMVCTargetViews)
922 {
923 std::string str;
924 str += dump(structName + ".Header", ExtMVCTargetViews.Header) + "\n";
925 str += structName + ".TemporalId=" + ToString(ExtMVCTargetViews.TemporalId) + "\n";
926 str += structName + ".NumView=" + ToString(ExtMVCTargetViews.NumView) + "\n";
927 str += structName + ".ViewId[]=" + DUMP_RESERVED_ARRAY(ExtMVCTargetViews.ViewId) + "\n";
928 return str;
929 }
930
dump(const std::string structName,const mfxExtOpaqueSurfaceAlloc & ExtOpaqueSurfaceAlloc)931 std::string DumpContext::dump(const std::string structName, const mfxExtOpaqueSurfaceAlloc &ExtOpaqueSurfaceAlloc)
932 {
933 std::string str;
934 str += dump(structName + ".Header", ExtOpaqueSurfaceAlloc.Header) + "\n";
935 str += structName + ".reserved1[]=" + DUMP_RESERVED_ARRAY(ExtOpaqueSurfaceAlloc.reserved1) + "\n";
936 str += structName + ".In.NumSurface=" + ToString(ExtOpaqueSurfaceAlloc.In.NumSurface) + "\n";
937 str += structName + ".In.Surfaces=" + ToHexFormatString(ExtOpaqueSurfaceAlloc.In.Surfaces) + "\n";
938 str += structName + ".In.Type=" + ToString(ExtOpaqueSurfaceAlloc.In.Type) + "\n";
939 str += structName + ".In.reserved2[]=" + DUMP_RESERVED_ARRAY(ExtOpaqueSurfaceAlloc.In.reserved2) + "\n";
940 str += structName + ".Out.NumSurface=" + ToString(ExtOpaqueSurfaceAlloc.Out.NumSurface) + "\n";
941 str += structName + ".Out.Surfaces=" + ToHexFormatString(ExtOpaqueSurfaceAlloc.Out.Surfaces) + "\n";
942 str += structName + ".Out.Type=" + ToString(ExtOpaqueSurfaceAlloc.Out.Type) + "\n";
943 str += structName + ".Out.reserved2[]=" + DUMP_RESERVED_ARRAY(ExtOpaqueSurfaceAlloc.Out.reserved2) + "\n";
944 return str;
945 }
946
947 //mfxvpp
dump(const std::string structName,const mfxExtVPPDenoise & ExtVPPDenoise)948 std::string DumpContext::dump(const std::string structName, const mfxExtVPPDenoise &ExtVPPDenoise)
949 {
950 std::string str;
951 str += dump(structName + ".Header", ExtVPPDenoise.Header) + "\n";
952 str += structName + ".DenoiseFactor=" + ToString(ExtVPPDenoise.DenoiseFactor) + "\n";
953 return str;
954 }
955
dump(const std::string structName,const mfxExtVPPDetail & ExtVPPDetail)956 std::string DumpContext::dump(const std::string structName, const mfxExtVPPDetail &ExtVPPDetail)
957 {
958 std::string str;
959 str += dump(structName + ".Header", ExtVPPDetail.Header) + "\n";
960 str += structName + ".DetailFactor=" + ToString(ExtVPPDetail.DetailFactor) + "\n";
961 return str;
962 }
963
dump(const std::string structName,const mfxExtVPPProcAmp & ExtVPPProcAmp)964 std::string DumpContext::dump(const std::string structName, const mfxExtVPPProcAmp &ExtVPPProcAmp)
965 {
966 std::string str;
967 str += dump(structName + ".Header", ExtVPPProcAmp.Header) + "\n";
968 str += structName + ".Brightness=" + ToString(ExtVPPProcAmp.Brightness) + "\n";
969 str += structName + ".Contrast=" + ToString(ExtVPPProcAmp.Contrast) + "\n";
970 str += structName + ".Hue=" + ToString(ExtVPPProcAmp.Hue) + "\n";
971 str += structName + ".Saturation=" + ToString(ExtVPPProcAmp.Saturation) + "\n";
972 return str;
973 }
974
dump(const std::string structName,const mfxExtCodingOptionSPSPPS & ExtCodingOptionSPSPPS)975 std::string DumpContext::dump(const std::string structName, const mfxExtCodingOptionSPSPPS &ExtCodingOptionSPSPPS)
976 {
977 std::string str;
978 str += dump(structName + ".Header", ExtCodingOptionSPSPPS.Header) + "\n";
979 str += structName + ".SPSBuffer=" + ToHexFormatString(ExtCodingOptionSPSPPS.SPSBuffer) + "\n";
980 str += structName + ".PPSBuffer=" + ToHexFormatString(ExtCodingOptionSPSPPS.PPSBuffer) + "\n";
981 str += structName + ".SPSBufSize=" + ToString(ExtCodingOptionSPSPPS.SPSBufSize) + "\n";
982 str += structName + ".PPSBufSize=" + ToString(ExtCodingOptionSPSPPS.PPSBufSize) + "\n";
983 str += structName + ".SPSId=" + ToString(ExtCodingOptionSPSPPS.SPSId) + "\n";
984 str += structName + ".PPSId=" + ToString(ExtCodingOptionSPSPPS.PPSId) + "\n";
985 return str;
986 }
987
dump(const std::string structName,const mfxExtCodingOptionVPS & ExtCodingOptionVPS)988 std::string DumpContext::dump(const std::string structName, const mfxExtCodingOptionVPS &ExtCodingOptionVPS)
989 {
990 std::string str;
991 str += dump(structName + ".Header", ExtCodingOptionVPS.Header) + "\n";
992 str += structName + ".VPSBuffer=" + ToHexFormatString(ExtCodingOptionVPS.VPSBuffer) + "\n";
993 str += structName + ".reserved1=" + ToString(ExtCodingOptionVPS.reserved1) + "\n";
994 str += structName + ".VPSBufSize=" + ToString(ExtCodingOptionVPS.VPSBufSize) + "\n";
995 str += structName + ".VPSId=" + ToString(ExtCodingOptionVPS.VPSId) + "\n";
996 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtCodingOptionVPS.reserved) + "\n";
997 return str;
998 }
999
dump(const std::string structName,const mfxExtVideoSignalInfo & ExtVideoSignalInfo)1000 std::string DumpContext::dump(const std::string structName, const mfxExtVideoSignalInfo &ExtVideoSignalInfo)
1001 {
1002 std::string str;
1003 str += dump(structName + ".Header", ExtVideoSignalInfo.Header) + "\n";
1004 str += structName + ".VideoFormat=" + ToString(ExtVideoSignalInfo.VideoFormat) + "\n";
1005 str += structName + ".VideoFullRange=" + ToString(ExtVideoSignalInfo.VideoFullRange) + "\n";
1006 str += structName + ".ColourDescriptionPresent=" + ToString(ExtVideoSignalInfo.ColourDescriptionPresent) + "\n";
1007 str += structName + ".ColourPrimaries=" + ToString(ExtVideoSignalInfo.ColourPrimaries) + "\n";
1008 str += structName + ".TransferCharacteristics=" + ToString(ExtVideoSignalInfo.TransferCharacteristics) + "\n";
1009 str += structName + ".MatrixCoefficients=" + ToString(ExtVideoSignalInfo.MatrixCoefficients) + "\n";
1010 return str;
1011 }
1012
dump(const std::string structName,const mfxExtVPPDoUse & ExtVPPDoUse)1013 std::string DumpContext::dump(const std::string structName, const mfxExtVPPDoUse &ExtVPPDoUse)
1014 {
1015 std::string str;
1016 str += dump(structName + ".Header", ExtVPPDoUse.Header) + "\n";
1017 str += structName + ".NumAlg=" + ToString(ExtVPPDoUse.NumAlg) + "\n";
1018 str += structName + ".AlgList=" + ToHexFormatString(ExtVPPDoUse.AlgList) + "\n";
1019 return str;
1020 }
1021
dump(const std::string structName,const mfxVPPCompInputStream & VPPCompInputStream)1022 std::string DumpContext::dump(const std::string structName, const mfxVPPCompInputStream &VPPCompInputStream)
1023 {
1024 std::string str;
1025 str += structName + ".DstX=" + ToString(VPPCompInputStream.DstX) + "\n";
1026 str += structName + ".DstY=" + ToString(VPPCompInputStream.DstY) + "\n";
1027 str += structName + ".DstW=" + ToString(VPPCompInputStream.DstW) + "\n";
1028 str += structName + ".DstH=" + ToString(VPPCompInputStream.DstH) + "\n";
1029 str += structName + ".LumaKeyEnable=" + ToString(VPPCompInputStream.LumaKeyEnable) + "\n";
1030 str += structName + ".LumaKeyMin=" + ToString(VPPCompInputStream.LumaKeyMin) + "\n";
1031 str += structName + ".LumaKeyMax=" + ToString(VPPCompInputStream.LumaKeyMax) + "\n";
1032 str += structName + ".GlobalAlphaEnable=" + ToString(VPPCompInputStream.GlobalAlphaEnable) + "\n";
1033 str += structName + ".GlobalAlphae=" + ToString(VPPCompInputStream.GlobalAlpha) + "\n";
1034 str += structName + ".PixelAlphaEnable=" + ToString(VPPCompInputStream.PixelAlphaEnable) + "\n";
1035 str += structName + ".TileId=" + ToString(VPPCompInputStream.TileId) + "\n";
1036 str += structName + ".reserved2[]=" + DUMP_RESERVED_ARRAY(VPPCompInputStream.reserved2) + "\n";
1037 return str;
1038 }
1039
dump(const std::string structName,const mfxExtVPPComposite & ExtVPPComposite)1040 std::string DumpContext::dump(const std::string structName, const mfxExtVPPComposite &ExtVPPComposite)
1041 {
1042 std::string str;
1043 str += dump(structName + ".Header", ExtVPPComposite.Header) + "\n";
1044 str += structName + ".Y=" + ToString(ExtVPPComposite.Y) + "\n";
1045 str += structName + ".R=" + ToString(ExtVPPComposite.R) + "\n";
1046 str += structName + ".U=" + ToString(ExtVPPComposite.U) + "\n";
1047 str += structName + ".G=" + ToString(ExtVPPComposite.G) + "\n";
1048 str += structName + ".V=" + ToString(ExtVPPComposite.V) + "\n";
1049 str += structName + ".B=" + ToString(ExtVPPComposite.B) + "\n";
1050 str += structName + ".NumTiles=" + ToString(ExtVPPComposite.NumTiles) + "\n";
1051 str += structName + ".reserved1[]=" + DUMP_RESERVED_ARRAY(ExtVPPComposite.reserved1) + "\n";
1052 str += structName + ".NumInputStream=" + ToString(ExtVPPComposite.NumInputStream) + "\n";
1053 str += structName + ".InputStream=" + ToHexFormatString(ExtVPPComposite.InputStream) + "\n";
1054 return str;
1055 }
1056
dump(const std::string structName,const mfxExtVPPVideoSignalInfo & ExtVPPVideoSignalInfo)1057 std::string DumpContext::dump(const std::string structName, const mfxExtVPPVideoSignalInfo &ExtVPPVideoSignalInfo)
1058 {
1059 std::string str;
1060 str += dump(structName + ".Header", ExtVPPVideoSignalInfo.Header) + "\n";
1061 str += structName + ".reserved1[]=" + DUMP_RESERVED_ARRAY(ExtVPPVideoSignalInfo.reserved1) + "\n";
1062 str += structName + ".In.TransferMatrix=" + ToString(ExtVPPVideoSignalInfo.In.TransferMatrix) + "\n";
1063 str += structName + ".In.NominalRange=" + ToString(ExtVPPVideoSignalInfo.In.NominalRange) + "\n";
1064 str += structName + ".In.reserved2[]=" + DUMP_RESERVED_ARRAY(ExtVPPVideoSignalInfo.In.reserved2) + "\n";
1065 str += structName + ".Out.TransferMatrix=" + ToString(ExtVPPVideoSignalInfo.Out.TransferMatrix) + "\n";
1066 str += structName + ".Out.NominalRange=" + ToString(ExtVPPVideoSignalInfo.Out.NominalRange) + "\n";
1067 str += structName + ".Out.reserved2[]=" + DUMP_RESERVED_ARRAY(ExtVPPVideoSignalInfo.Out.reserved2) + "\n";
1068 str += structName + ".TransferMatrix=" + ToString(ExtVPPVideoSignalInfo.TransferMatrix) + "\n";
1069 str += structName + ".NominalRange=" + ToString(ExtVPPVideoSignalInfo.NominalRange) + "\n";
1070 str += structName + ".reserved3[]=" + DUMP_RESERVED_ARRAY(ExtVPPVideoSignalInfo.reserved3) + "\n";
1071 return str;
1072 }
1073
dump(const std::string structName,const mfxExtVPPDeinterlacing & ExtVPPDeinterlacing)1074 std::string DumpContext::dump(const std::string structName, const mfxExtVPPDeinterlacing &ExtVPPDeinterlacing)
1075 {
1076 std::string str;
1077 str += dump(structName + ".Header", ExtVPPDeinterlacing.Header) + "\n";
1078 str += structName + ".Mode=" + ToString(ExtVPPDeinterlacing.Mode) + "\n";
1079 str += structName + ".TelecinePattern=" + ToString(ExtVPPDeinterlacing.TelecinePattern) + "\n";
1080 str += structName + ".TelecineLocation=" + ToString(ExtVPPDeinterlacing.TelecineLocation) + "\n";
1081 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtVPPDeinterlacing.reserved) + "\n";
1082 return str;
1083 }
1084
1085 //mfxSEI
dump(const std::string structName,const mfxExtPictureTimingSEI & ExtPictureTimingSEI)1086 std::string DumpContext::dump(const std::string structName, const mfxExtPictureTimingSEI &ExtPictureTimingSEI)
1087 {
1088 std::string str;
1089 str += dump(structName + ".Header", ExtPictureTimingSEI.Header) + "\n";
1090 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtPictureTimingSEI.reserved) + "\n";
1091 str += structName + ".TimeStamp[0].ClockTimestampFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[0].ClockTimestampFlag) + "\n";
1092 str += structName + ".TimeStamp[0].CtType=" + ToString(ExtPictureTimingSEI.TimeStamp[0].CtType) + "\n";
1093 str += structName + ".TimeStamp[0].NuitFieldBasedFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[0].NuitFieldBasedFlag) + "\n";
1094 str += structName + ".TimeStamp[0].CountingType=" + ToString(ExtPictureTimingSEI.TimeStamp[0].CountingType) + "\n";
1095 str += structName + ".TimeStamp[0].FullTimestampFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[0].FullTimestampFlag) + "\n";
1096 str += structName + ".TimeStamp[0].DiscontinuityFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[0].DiscontinuityFlag) + "\n";
1097 str += structName + ".TimeStamp[0].CntDroppedFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[0].CntDroppedFlag) + "\n";
1098 str += structName + ".TimeStamp[0].NFrames=" + ToString(ExtPictureTimingSEI.TimeStamp[0].NFrames) + "\n";
1099 str += structName + ".TimeStamp[0].SecondsFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[0].SecondsFlag) + "\n";
1100 str += structName + ".TimeStamp[0].MinutesFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[0].MinutesFlag) + "\n";
1101 str += structName + ".TimeStamp[0].HoursFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[0].HoursFlag) + "\n";
1102 str += structName + ".TimeStamp[0].SecondsValue=" + ToString(ExtPictureTimingSEI.TimeStamp[0].SecondsValue) + "\n";
1103 str += structName + ".TimeStamp[0].MinutesValue=" + ToString(ExtPictureTimingSEI.TimeStamp[0].MinutesValue) + "\n";
1104 str += structName + ".TimeStamp[0].HoursValue=" + ToString(ExtPictureTimingSEI.TimeStamp[0].HoursValue) + "\n";
1105 str += structName + ".TimeStamp[0].TimeOffset=" + ToString(ExtPictureTimingSEI.TimeStamp[0].TimeOffset) + "\n";
1106 str += structName + ".TimeStamp[1].ClockTimestampFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[1].ClockTimestampFlag) + "\n";
1107 str += structName + ".TimeStamp[1].CtType=" + ToString(ExtPictureTimingSEI.TimeStamp[1].CtType) + "\n";
1108 str += structName + ".TimeStamp[1].NuitFieldBasedFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[1].NuitFieldBasedFlag) + "\n";
1109 str += structName + ".TimeStamp[1].CountingType=" + ToString(ExtPictureTimingSEI.TimeStamp[1].CountingType) + "\n";
1110 str += structName + ".TimeStamp[1].FullTimestampFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[1].FullTimestampFlag) + "\n";
1111 str += structName + ".TimeStamp[1].DiscontinuityFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[1].DiscontinuityFlag) + "\n";
1112 str += structName + ".TimeStamp[1].CntDroppedFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[1].CntDroppedFlag) + "\n";
1113 str += structName + ".TimeStamp[1].NFrames=" + ToString(ExtPictureTimingSEI.TimeStamp[1].NFrames) + "\n";
1114 str += structName + ".TimeStamp[1].SecondsFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[1].SecondsFlag) + "\n";
1115 str += structName + ".TimeStamp[1].MinutesFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[1].MinutesFlag) + "\n";
1116 str += structName + ".TimeStamp[1].HoursFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[1].HoursFlag) + "\n";
1117 str += structName + ".TimeStamp[1].SecondsValue=" + ToString(ExtPictureTimingSEI.TimeStamp[1].SecondsValue) + "\n";
1118 str += structName + ".TimeStamp[1].MinutesValue=" + ToString(ExtPictureTimingSEI.TimeStamp[1].MinutesValue) + "\n";
1119 str += structName + ".TimeStamp[1].HoursValue=" + ToString(ExtPictureTimingSEI.TimeStamp[1].HoursValue) + "\n";
1120 str += structName + ".TimeStamp[1].TimeOffset=" + ToString(ExtPictureTimingSEI.TimeStamp[1].TimeOffset) + "\n";
1121 str += structName + ".TimeStamp[2].ClockTimestampFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[2].ClockTimestampFlag) + "\n";
1122 str += structName + ".TimeStamp[2].CtType=" + ToString(ExtPictureTimingSEI.TimeStamp[2].CtType) + "\n";
1123 str += structName + ".TimeStamp[2].NuitFieldBasedFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[2].NuitFieldBasedFlag) + "\n";
1124 str += structName + ".TimeStamp[2].CountingType=" + ToString(ExtPictureTimingSEI.TimeStamp[2].CountingType) + "\n";
1125 str += structName + ".TimeStamp[2].FullTimestampFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[2].FullTimestampFlag) + "\n";
1126 str += structName + ".TimeStamp[2].DiscontinuityFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[2].DiscontinuityFlag) + "\n";
1127 str += structName + ".TimeStamp[2].CntDroppedFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[2].CntDroppedFlag) + "\n";
1128 str += structName + ".TimeStamp[2].NFrames=" + ToString(ExtPictureTimingSEI.TimeStamp[2].NFrames) + "\n";
1129 str += structName + ".TimeStamp[2].SecondsFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[2].SecondsFlag) + "\n";
1130 str += structName + ".TimeStamp[2].MinutesFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[2].MinutesFlag) + "\n";
1131 str += structName + ".TimeStamp[2].HoursFlag=" + ToString(ExtPictureTimingSEI.TimeStamp[2].HoursFlag) + "\n";
1132 str += structName + ".TimeStamp[2].SecondsValue=" + ToString(ExtPictureTimingSEI.TimeStamp[2].SecondsValue) + "\n";
1133 str += structName + ".TimeStamp[2].MinutesValue=" + ToString(ExtPictureTimingSEI.TimeStamp[2].MinutesValue) + "\n";
1134 str += structName + ".TimeStamp[2].HoursValue=" + ToString(ExtPictureTimingSEI.TimeStamp[2].HoursValue) + "\n";
1135 str += structName + ".TimeStamp[2].TimeOffset=" + ToString(ExtPictureTimingSEI.TimeStamp[2].TimeOffset) + "\n";
1136 return str;
1137 }
1138
1139 //mfxHEVC
dump(const std::string structName,const mfxExtHEVCTiles & ExtHEVCTiles)1140 std::string DumpContext::dump(const std::string structName, const mfxExtHEVCTiles &ExtHEVCTiles)
1141 {
1142 std::string str;
1143 str += dump(structName + ".Header", ExtHEVCTiles.Header) + "\n";
1144 str += structName + ".NumTileRows=" + ToString(ExtHEVCTiles.NumTileRows) + "\n";
1145 str += structName + ".NumTileColumns=" + ToString(ExtHEVCTiles.NumTileColumns) + "\n";
1146 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtHEVCTiles.reserved) + "\n";
1147 return str;
1148 }
1149
dump(const std::string structName,const mfxExtHEVCParam & _struct)1150 std::string DumpContext::dump(const std::string structName, const mfxExtHEVCParam &_struct)
1151 {
1152 std::string str;
1153 str += dump(structName + ".Header", _struct.Header) + "\n";
1154
1155 DUMP_FIELD(PicWidthInLumaSamples);
1156 DUMP_FIELD(PicHeightInLumaSamples);
1157 DUMP_FIELD(GeneralConstraintFlags);
1158 #if (MFX_VERSION >= 1026)
1159 DUMP_FIELD(SampleAdaptiveOffset);
1160 DUMP_FIELD(LCUSize);
1161 #endif
1162
1163 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(_struct.reserved) + "\n";
1164 return str;
1165 }
1166
dump(const std::string structName,const mfxExtHEVCRegion & ExtHEVCRegion)1167 std::string DumpContext::dump(const std::string structName, const mfxExtHEVCRegion &ExtHEVCRegion)
1168 {
1169 std::string str;
1170 str += dump(structName + ".Header", ExtHEVCRegion.Header) + "\n";
1171 str += structName + ".RegionId=" + ToString(ExtHEVCRegion.RegionId) + "\n";
1172 str += structName + ".RegionType=" + ToString(ExtHEVCRegion.RegionType) + "\n";
1173 str += structName + ".RegionEncoding=" + ToString(ExtHEVCRegion.RegionEncoding) + "\n";
1174 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtHEVCRegion.reserved) + "\n";
1175 return str;
1176 }
1177
dump(const std::string structName,const mfxExtPredWeightTable & ExtPredWeightTable)1178 std::string DumpContext::dump(const std::string structName, const mfxExtPredWeightTable &ExtPredWeightTable)
1179 {
1180 std::string str;
1181 str += dump(structName + ".Header", ExtPredWeightTable.Header) + "\n";
1182 str += structName + ".LumaLog2WeightDenom=" + ToString(ExtPredWeightTable.LumaLog2WeightDenom) + "\n";
1183 str += structName + ".ChromaLog2WeightDenom=" + ToString(ExtPredWeightTable.ChromaLog2WeightDenom) + "\n";
1184 for (int i = 0; i < 2; i++)
1185 str += structName + ".LumaWeightFlag[" + ToString(i) + "][]=" + DUMP_RESERVED_ARRAY(ExtPredWeightTable.LumaWeightFlag[i]) + "\n";
1186 for (int i = 0; i < 2; i++)
1187 str += structName + ".ChromaWeightFlag[" + ToString(i) + "][]=" + DUMP_RESERVED_ARRAY(ExtPredWeightTable.ChromaWeightFlag[i]) + "\n";
1188 for (int i = 0; i < 2; i++)
1189 for (int j = 0; j < 32; j++)
1190 for (int k = 0; k < 3; k++)
1191 str += structName + ".ChromaWeightFlag[" + ToString(i) + "][" + ToString(j) + "][" + ToString(k) + "][]=" + DUMP_RESERVED_ARRAY(ExtPredWeightTable.Weights[i][j][k]) + "\n";
1192 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtPredWeightTable.reserved) + "\n";
1193 return str;
1194 }
1195
dump(const std::string structName,const mfxExtVPPFrameRateConversion & ExtVPPFrameRateConversion)1196 std::string DumpContext::dump(const std::string structName, const mfxExtVPPFrameRateConversion &ExtVPPFrameRateConversion)
1197 {
1198 std::string str;
1199 str += dump(structName + ".Header", ExtVPPFrameRateConversion.Header) + "\n";
1200 str += structName + ".Algorithm=" + ToString(ExtVPPFrameRateConversion.Algorithm) + "\n";
1201 str += structName + ".reserved=" + ToString(ExtVPPFrameRateConversion.reserved) + "\n";
1202 str += structName + ".reserved2[]=" + DUMP_RESERVED_ARRAY(ExtVPPFrameRateConversion.reserved2) + "\n";
1203 return str;
1204 }
1205
dump(const std::string structName,const mfxExtVPPImageStab & ExtVPPImageStab)1206 std::string DumpContext::dump(const std::string structName, const mfxExtVPPImageStab &ExtVPPImageStab)
1207 {
1208 std::string str;
1209 str += dump(structName + ".Header", ExtVPPImageStab.Header) + "\n";
1210 str += structName + ".Mode=" + ToString(ExtVPPImageStab.Mode) + "\n";
1211 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtVPPImageStab.reserved) + "\n";
1212 return str;
1213 }
1214
dump(const std::string structName,const mfxExtEncoderROI & ExtEncoderROI)1215 std::string DumpContext::dump(const std::string structName, const mfxExtEncoderROI &ExtEncoderROI)
1216 {
1217 std::string str;
1218 str += dump(structName + ".Header", ExtEncoderROI.Header) + "\n";
1219 str += structName + ".NumROI=" + ToString(ExtEncoderROI.NumROI) + "\n";
1220 str += structName + ".ROIMode=" + ToString(ExtEncoderROI.ROIMode) + "\n";
1221 for (int i = 0; i < ExtEncoderROI.NumROI; i++) {
1222 str += structName + ".ROI[" + ToString(i) + "].Left=" + ToString(ExtEncoderROI.ROI[i].Left) + "\n";
1223 str += structName + ".ROI[" + ToString(i) + "].Top=" + ToString(ExtEncoderROI.ROI[i].Top) + "\n";
1224 str += structName + ".ROI[" + ToString(i) + "].Right=" + ToString(ExtEncoderROI.ROI[i].Right) + "\n";
1225 str += structName + ".ROI[" + ToString(i) + "].Bottom=" + ToString(ExtEncoderROI.ROI[i].Bottom) + "\n";
1226 if (ExtEncoderROI.ROIMode == MFX_ROI_MODE_QP_DELTA) {
1227 str += structName + ".ROI[" + ToString(i) + "].DeltaQP=" + ToString(ExtEncoderROI.ROI[i].DeltaQP) + "\n";
1228 } else {
1229 str += structName + ".ROI[" + ToString(i) + "].Priority=" + ToString(ExtEncoderROI.ROI[i].Priority) + "\n";
1230 }
1231 str += structName + ".ROI[" + ToString(i) + "].reserved2[]=" + DUMP_RESERVED_ARRAY(ExtEncoderROI.ROI[i].reserved2) + "\n";
1232 }
1233 str += structName + ".reserved1[]=" + DUMP_RESERVED_ARRAY(ExtEncoderROI.reserved1) + "\n";
1234 return str;
1235 }
1236
dump(const std::string structName,const mfxExtVPPRotation & ExtVPPRotation)1237 std::string DumpContext::dump(const std::string structName, const mfxExtVPPRotation &ExtVPPRotation)
1238 {
1239 std::string str;
1240 str += dump(structName + ".Header", ExtVPPRotation.Header) + "\n";
1241 str += structName + "Angle.=" + ToString(ExtVPPRotation.Angle) + "\n";
1242 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtVPPRotation.reserved) + "\n";
1243 return str;
1244 }
1245
dump(const std::string structName,const mfxExtEncodedSlicesInfo & ExtEncodedSlicesInfo)1246 std::string DumpContext::dump(const std::string structName, const mfxExtEncodedSlicesInfo &ExtEncodedSlicesInfo)
1247 {
1248 std::string str;
1249 str += dump(structName + ".Header", ExtEncodedSlicesInfo.Header) + "\n";
1250 str += structName + "SliceSizeOverflow.=" + ToString(ExtEncodedSlicesInfo.SliceSizeOverflow) + "\n";
1251 str += structName + "NumSliceNonCopliant.=" + ToString(ExtEncodedSlicesInfo.NumSliceNonCopliant) + "\n";
1252 str += structName + "NumEncodedSlice.=" + ToString(ExtEncodedSlicesInfo.NumEncodedSlice) + "\n";
1253 str += structName + "NumSliceSizeAlloc.=" + ToString(ExtEncodedSlicesInfo.NumSliceSizeAlloc) + "\n";
1254 str += structName + "SliceSize.=" + ToHexFormatString(ExtEncodedSlicesInfo.SliceSize) + "\n";
1255 str += structName + "reserved1.=" + ToString(ExtEncodedSlicesInfo.reserved1) + "\n";
1256 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtEncodedSlicesInfo.reserved) + "\n";
1257 return str;
1258 }
1259
dump(const std::string structName,const mfxExtVPPScaling & ExtVPPScaling)1260 std::string DumpContext::dump(const std::string structName, const mfxExtVPPScaling &ExtVPPScaling)
1261 {
1262 std::string str;
1263 str += dump(structName + ".Header", ExtVPPScaling.Header) + "\n";
1264 str += structName + "ScalingMode.=" + ToString(ExtVPPScaling.ScalingMode) + "\n";
1265 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtVPPScaling.reserved) + "\n";
1266 return str;
1267 }
1268
dump(const std::string structName,const mfxExtDecVideoProcessing & ExtDecVideoProcessing)1269 std::string DumpContext::dump(const std::string structName, const mfxExtDecVideoProcessing &ExtDecVideoProcessing)
1270 {
1271 std::string str;
1272 /* IN structures */
1273 str += dump(structName + ".Header", ExtDecVideoProcessing.Header) + "\n";
1274 str += structName + "In.CropX=" + ToString(ExtDecVideoProcessing.In.CropX) + "\n";
1275 str += structName + "In.CropY=" + ToString(ExtDecVideoProcessing.In.CropY) + "\n";
1276 str += structName + "In.CropW=" + ToString(ExtDecVideoProcessing.In.CropW) + "\n";
1277 str += structName + "In.CropH=" + ToString(ExtDecVideoProcessing.In.CropH) + "\n";
1278 str += structName + "In.reserved[]=" + DUMP_RESERVED_ARRAY(ExtDecVideoProcessing.In.reserved) + "\n";
1279 /* Out structures */
1280 str += structName + "Out.FourCC=" + ToString(ExtDecVideoProcessing.Out.FourCC) + "\n";
1281 str += structName + "Out.ChromaFormat=" + ToString(ExtDecVideoProcessing.Out.ChromaFormat) + "\n";
1282 str += structName + "Out.reserved1=" + ToString(ExtDecVideoProcessing.Out.reserved1) + "\n";
1283 str += structName + "Out.Width=" + ToString(ExtDecVideoProcessing.Out.Width) + "\n";
1284 str += structName + "Out.Height=" + ToString(ExtDecVideoProcessing.Out.Height) + "\n";
1285 str += structName + "OutCropX.=" + ToString(ExtDecVideoProcessing.Out.CropX) + "\n";
1286 str += structName + "OutCropY.=" + ToString(ExtDecVideoProcessing.Out.CropY) + "\n";
1287 str += structName + "OutCropW.=" + ToString(ExtDecVideoProcessing.Out.CropW) + "\n";
1288 str += structName + "OutCropH.=" + ToString(ExtDecVideoProcessing.Out.CropH) + "\n";
1289 str += structName + "Out.reserved[]=" + DUMP_RESERVED_ARRAY(ExtDecVideoProcessing.Out.reserved) + "\n";
1290
1291 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtDecVideoProcessing.reserved) + "\n";
1292
1293 return str;
1294 }
1295
dump(const std::string structName,const mfxExtMBQP & ExtMBQP)1296 std::string DumpContext::dump(const std::string structName, const mfxExtMBQP &ExtMBQP)
1297 {
1298 std::string str;
1299 str += dump(structName + ".Header", ExtMBQP.Header) + "\n";
1300 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtMBQP.reserved) + "\n";
1301 str += structName + ".Mode=" + ToString(ExtMBQP.Mode) + "\n";
1302 str += structName + ".BlockSize=" + ToString(ExtMBQP.BlockSize) + "\n";
1303 str += structName + ".NumQPAlloc=" + ToString(ExtMBQP.NumQPAlloc) + "\n";
1304 str += structName + ".QP=" + ToString(ExtMBQP.QP) + "\n";
1305 str += structName + ".DeltaQP=" + ToString(ExtMBQP.DeltaQP) + "\n";
1306 str += structName + "reserverd2=" + ToString(ExtMBQP.reserved2) + "\n";
1307 return str;
1308 }
1309
dump(const std::string structName,const mfxExtEncoderIPCMArea & ExtEncoderIPCMArea)1310 std::string DumpContext::dump(const std::string structName, const mfxExtEncoderIPCMArea &ExtEncoderIPCMArea)
1311 {
1312 std::string str;
1313 str += dump(structName + ".Header", ExtEncoderIPCMArea.Header) + "\n";
1314 str += structName + ".reserve1[]=" + DUMP_RESERVED_ARRAY(ExtEncoderIPCMArea.reserve1) + "\n";
1315 str += structName + ".NumArea=" + ToString(ExtEncoderIPCMArea.NumArea) + "\n";
1316 // dump Area
1317 if (ExtEncoderIPCMArea.Areas == nullptr)
1318 {
1319 str += structName + ".Areas = nullptr \n";
1320 return str;
1321 }
1322
1323 for (mfxU16 i = 0; i < ExtEncoderIPCMArea.NumArea; i++) {
1324 str += structName + ".Areas[" + ToString(i) + "].Left=" + ToString(ExtEncoderIPCMArea.Areas[i].Left) + "\n";
1325 str += structName + ".Areas[" + ToString(i) + "].Top=" + ToString(ExtEncoderIPCMArea.Areas[i].Top) + "\n";
1326 str += structName + ".Areas[" + ToString(i) + "].Right=" + ToString(ExtEncoderIPCMArea.Areas[i].Right) + "\n";
1327 str += structName + ".Areas[" + ToString(i) + "].Bottom=" + ToString(ExtEncoderIPCMArea.Areas[i].Bottom) + "\n";
1328 str += structName + ".Areas[" + ToString(i) + "].reserved2=" + DUMP_RESERVED_ARRAY(ExtEncoderIPCMArea.Areas[i].reserved2) + "\n";
1329 }
1330 return str;
1331 }
1332
dump(const std::string structName,const mfxExtInsertHeaders & ExtInsertHeaders)1333 std::string DumpContext::dump(const std::string structName, const mfxExtInsertHeaders& ExtInsertHeaders)
1334 {
1335 std::string str;
1336 str += dump(structName + ".Header", ExtInsertHeaders.Header) + "\n";
1337 str += structName + ".SPS=" + ToString(ExtInsertHeaders.SPS) + "\n";
1338 str += structName + ".PPS=" + ToString(ExtInsertHeaders.PPS) + "\n";
1339 return str;
1340 }
1341
1342 #if (MFX_VERSION >= 1025)
dump(const std::string structName,const mfxExtMasteringDisplayColourVolume & _struct)1343 std::string DumpContext::dump(const std::string structName, const mfxExtMasteringDisplayColourVolume &_struct) {
1344 std::string str;
1345 str += dump(structName + ".Header", _struct.Header) + "\n";
1346 str += structName + ".InsertPayloadToggle=" + ToString(_struct.InsertPayloadToggle) + "\n";
1347 for (int i = 0; i < 3; i++) {
1348 str += structName + ".DisplayPrimariesX[" + ToString(i) + "]=" + ToString(_struct.DisplayPrimariesX[i]) + "\n";
1349 str += structName + ".DisplayPrimariesY[" + ToString(i) + "]=" + ToString(_struct.DisplayPrimariesY[i]) + "\n";
1350 }
1351 str += structName + ".WhitePointX=" + ToString(_struct.WhitePointX) + "\n";
1352 str += structName + ".WhitePointY=" + ToString(_struct.WhitePointY) + "\n";
1353 str += structName + ".MaxDisplayMasteringLuminance=" + ToString(_struct.MaxDisplayMasteringLuminance) + "\n";
1354 str += structName + ".MinDisplayMasteringLuminance=" + ToString(_struct.MinDisplayMasteringLuminance) + "\n";
1355
1356 DUMP_FIELD_RESERVED(reserved);
1357 return str;
1358 }
1359
dump(const std::string structName,const mfxExtContentLightLevelInfo & _struct)1360 std::string DumpContext::dump(const std::string structName, const mfxExtContentLightLevelInfo &_struct) {
1361 std::string str;
1362 str += dump(structName + ".Header", _struct.Header) + "\n";
1363 str += structName + ".InsertPayloadToggle=" + ToString(_struct.InsertPayloadToggle) + "\n";
1364 str += structName + ".MaxContentLightLevel=" + ToString(_struct.MaxContentLightLevel) + "\n";
1365 str += structName + ".MaxPicAverageLightLevel=" + ToString(_struct.MaxPicAverageLightLevel) + "\n";
1366
1367 DUMP_FIELD_RESERVED(reserved);
1368 return str;
1369 }
1370
dump(const std::string structName,const mfxExtMultiFrameParam & _struct)1371 std::string DumpContext::dump(const std::string structName, const mfxExtMultiFrameParam &_struct) {
1372 std::string str;
1373 str += dump(structName + ".Header", _struct.Header) + "\n";
1374 str += structName + ".MFMode=" + ToString(_struct.MFMode) + "\n";
1375 str += structName + ".MaxNumFrames=" + ToString(_struct.MaxNumFrames) + "\n";
1376
1377 DUMP_FIELD_RESERVED(reserved);
1378 return str;
1379 }
1380
dump(const std::string structName,const mfxExtMultiFrameControl & _struct)1381 std::string DumpContext::dump(const std::string structName, const mfxExtMultiFrameControl &_struct) {
1382 std::string str;
1383 str += dump(structName + ".Header", _struct.Header) + "\n";
1384 str += structName + ".Timeout=" + ToString(_struct.Timeout) + "\n";
1385 str += structName + ".Flush=" + ToString(_struct.Flush) + "\n";
1386
1387 DUMP_FIELD_RESERVED(reserved);
1388 return str;
1389 }
1390
dump(const std::string structName,const mfxExtEncodedUnitsInfo & _struct)1391 std::string DumpContext::dump(const std::string structName, const mfxExtEncodedUnitsInfo &_struct) {
1392 std::string str;
1393 str += dump(structName + ".Header", _struct.Header) + "\n";
1394 str += structName + ".NumUnitsAlloc=" + ToString(_struct.NumUnitsAlloc) + "\n";
1395 str += structName + ".NumUnitsEncoded=" + ToString(_struct.NumUnitsEncoded) + "\n";
1396
1397 if (_struct.UnitInfo != NULL)
1398 {
1399 int count = min(_struct.NumUnitsEncoded, _struct.NumUnitsAlloc);
1400 for (int i = 0; i < count; i++)
1401 {
1402 str += structName + ".UnitInfo[" + ToString(i) + "].Type=" + ToString(_struct.UnitInfo[i].Type) + "\n";
1403 str += structName + ".UnitInfo[" + ToString(i) + "].Offset=" + ToString(_struct.UnitInfo[i].Offset) + "\n";
1404 str += structName + ".UnitInfo[" + ToString(i) + "].Size=" + ToString(_struct.UnitInfo[i].Size) + "\n";
1405 }
1406 }
1407 else
1408 {
1409 str += structName + ".UnitInfo=NULL\n";
1410 }
1411
1412 DUMP_FIELD_RESERVED(reserved);
1413 return str;
1414 }
1415
dump(const std::string structName,const mfxExtColorConversion & ExtColorConversion)1416 std::string DumpContext::dump(const std::string structName, const mfxExtColorConversion &ExtColorConversion) {
1417 std::string str;
1418 str += dump(structName + ".Header", ExtColorConversion.Header) + "\n";
1419 str += structName + ".ChromaSiting=" + ToString(ExtColorConversion.ChromaSiting) + "\n";
1420 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(ExtColorConversion.reserved) + "\n";
1421 return str;
1422 }
1423
1424 #endif
1425
1426 #if (MFX_VERSION >= 1026)
dump(const std::string structName,const mfxExtVppMctf & _struct)1427 std::string DumpContext::dump(const std::string structName, const mfxExtVppMctf &_struct) {
1428 std::string str;
1429 str += dump(structName + ".Header", _struct.Header) + "\n";
1430 str += structName + ".FilterStrength=" + ToString(_struct.FilterStrength) + "\n";
1431 #if (MFX_VERSION >= MFX_VERSION_NEXT)
1432 str += structName + ".Overlap=" + ToString(_struct.Overlap) + "\n";
1433 str += structName + ".BitsPerPixelx100k=" + ToString(_struct.BitsPerPixelx100k) + "\n";
1434 str += structName + ".Deblocking=" + ToString(_struct.Deblocking) + "\n";
1435 str += structName + ".TemporalMode=" + ToString(_struct.TemporalMode) + "\n";
1436 str += structName + ".MVPrecision=" + ToString(_struct.MVPrecision) + "\n";
1437 #endif
1438 DUMP_FIELD_RESERVED(reserved);
1439 return str;
1440 }
1441
1442 #endif
1443
1444 #if (MFX_VERSION >= 1026)
1445
dump(const std::string structName,const mfxVP9SegmentParam & _struct)1446 std::string DumpContext::dump(const std::string structName, const mfxVP9SegmentParam &_struct)
1447 {
1448 std::string str;
1449 DUMP_FIELD(FeatureEnabled);
1450 DUMP_FIELD(QIndexDelta);
1451 DUMP_FIELD(LoopFilterLevelDelta);
1452 DUMP_FIELD(ReferenceFrame);
1453 return str;
1454 }
1455
1456
dump(const std::string structName,const mfxExtVP9Segmentation & _struct)1457 std::string DumpContext::dump(const std::string structName, const mfxExtVP9Segmentation &_struct)
1458 {
1459 std::string str;
1460 str += dump(structName + ".Header", _struct.Header) + "\n";
1461 DUMP_FIELD(NumSegments);
1462
1463 for (mfxU16 i = 0; i < 8 && i < _struct.NumSegments; i++)
1464 {
1465 str += dump(structName + ".Segment[" + ToString(i) + "]", _struct.Segment[i]) + "\n";
1466 }
1467
1468 DUMP_FIELD(SegmentIdBlockSize);
1469 DUMP_FIELD(NumSegmentIdAlloc);
1470
1471 if (_struct.SegmentId)
1472 {
1473 str += dump_array_with_cast<mfxU8, mfxU16>(_struct.SegmentId, _struct.NumSegmentIdAlloc);
1474 }
1475 else
1476 {
1477 DUMP_FIELD(SegmentId);
1478 }
1479
1480 return str;
1481 }
1482
dump(const std::string structName,const mfxVP9TemporalLayer & _struct)1483 std::string DumpContext::dump(const std::string structName, const mfxVP9TemporalLayer &_struct)
1484 {
1485 std::string str;
1486 DUMP_FIELD(FrameRateScale);
1487 DUMP_FIELD(TargetKbps);
1488 return str;
1489 }
1490
dump(const std::string structName,const mfxExtVP9TemporalLayers & _struct)1491 std::string DumpContext::dump(const std::string structName, const mfxExtVP9TemporalLayers &_struct)
1492 {
1493 std::string str;
1494 str += dump(structName + ".Header", _struct.Header) + "\n";
1495
1496 for (mfxU16 i = 0; i < 8; i++)
1497 {
1498 str += dump(structName + ".Layer[" + ToString(i) + "]", _struct.Layer[i]) + "\n";
1499 }
1500
1501 return str;
1502 }
1503
dump(const std::string structName,const mfxExtVP9Param & _struct)1504 std::string DumpContext::dump(const std::string structName, const mfxExtVP9Param &_struct)
1505 {
1506 std::string str;
1507 str += dump(structName + ".Header", _struct.Header) + "\n";
1508
1509 DUMP_FIELD(FrameWidth);
1510 DUMP_FIELD(FrameHeight);
1511 DUMP_FIELD(WriteIVFHeaders);
1512 #if (MFX_VERSION >= MFX_VERSION_NEXT)
1513 str += structName + ".LoopFilterRefDelta[4]=" + DUMP_RESERVED_ARRAY(_struct.LoopFilterRefDelta) + "\n";
1514 str += structName + ".LoopFilterModeDelta[2]=" + DUMP_RESERVED_ARRAY(_struct.LoopFilterModeDelta) + "\n";
1515 #endif
1516 DUMP_FIELD(QIndexDeltaLumaDC);
1517 DUMP_FIELD(QIndexDeltaChromaAC);
1518 DUMP_FIELD(QIndexDeltaChromaDC);
1519 #if (MFX_VERSION >= 1029)
1520 DUMP_FIELD(NumTileRows);
1521 DUMP_FIELD(NumTileColumns);
1522 #endif
1523 return str;
1524 }
1525
1526 #endif
1527
1528 #if (MFX_VERSION >= 1034)
dump(const std::string structName,const mfxExtAV1FilmGrainParam & _struct)1529 std::string DumpContext::dump(const std::string structName, const mfxExtAV1FilmGrainParam &_struct)
1530 {
1531 std::string str;
1532 str += dump(structName + ".Header", _struct.Header) + "\n";
1533 DUMP_FIELD(FilmGrainFlags);
1534 DUMP_FIELD(GrainSeed);
1535 DUMP_FIELD(RefIdx);
1536 DUMP_FIELD(NumYPoints);
1537 DUMP_FIELD(NumCbPoints);
1538 DUMP_FIELD(NumCrPoints);
1539
1540 for (mfxU16 i = 0; i < 14 && i < _struct.NumYPoints; i++)
1541 {
1542 str += dump(structName + ".PointY[" + ToString(i) + "].Value", _struct.PointY[i].Value) + "\n";
1543 str += dump(structName + ".PointY[" + ToString(i) + "].Scaling", _struct.PointY[i].Scaling) + "\n";
1544 }
1545
1546 for (mfxU16 i = 0; i < 10 && i < _struct.NumCbPoints; i++)
1547 {
1548 str += dump(structName + ".PointCb[" + ToString(i) + "].Value", _struct.PointCb[i].Value) + "\n";
1549 str += dump(structName + ".PointCb[" + ToString(i) + "].Scaling", _struct.PointCb[i].Scaling) + "\n";
1550 }
1551
1552 for (mfxU16 i = 0; i < 10 && i < _struct.NumCrPoints; i++)
1553 {
1554 str += dump(structName + ".PointCr[" + ToString(i) + "].Value", _struct.PointCr[i].Value) + "\n";
1555 str += dump(structName + ".PointCr[" + ToString(i) + "].Scaling", _struct.PointCr[i].Scaling) + "\n";
1556 }
1557
1558 DUMP_FIELD(GrainScalingMinus8);
1559 DUMP_FIELD(ArCoeffLag);
1560
1561 for (mfxU16 i = 0; i < 24; i++)
1562 {
1563 str += dump(structName + ".ArCoeffsYPlus128[" + ToString(i) + "]", _struct.ArCoeffsYPlus128[i]) + "\n";
1564 }
1565
1566 for (mfxU16 i = 0; i < 25; i++)
1567 {
1568 str += dump(structName + ".ArCoeffsCbPlus128[" + ToString(i) + "]", _struct.ArCoeffsCbPlus128[i]) + "\n";
1569 str += dump(structName + ".ArCoeffsCrPlus128[" + ToString(i) + "]", _struct.ArCoeffsCrPlus128[i]) + "\n";
1570 }
1571
1572 DUMP_FIELD(ArCoeffShiftMinus6);
1573 DUMP_FIELD(GrainScaleShift);
1574 DUMP_FIELD(CbMult);
1575 DUMP_FIELD(CbLumaMult);
1576 DUMP_FIELD(CbOffset);
1577 DUMP_FIELD(CrMult);
1578 DUMP_FIELD(CrLumaMult);
1579 DUMP_FIELD(CrOffset);
1580
1581 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(_struct.reserved) + "\n";
1582
1583 return str;
1584 }
1585 #endif
1586
1587 #if (MFX_VERSION >= MFX_VERSION_NEXT)
dump(const std::string structName,const mfxExtAVCScalingMatrix & _struct)1588 std::string DumpContext::dump(const std::string structName, const mfxExtAVCScalingMatrix &_struct)
1589 {
1590 std::string str;
1591 str += dump(structName + ".Header", _struct.Header) + "\n";
1592 DUMP_FIELD(Type);
1593
1594 for (mfxU8 i = 0; i < 12; ++i)
1595 {
1596 str += dump(structName + ".ScalingListPresent[" + ToString(i) + "]", _struct.ScalingListPresent[i]) + "\n";
1597 }
1598
1599 for (mfxU8 i = 0; i < 6; ++i)
1600 {
1601 for(mfxU8 y = 0; y < 4; ++y)
1602 for (mfxU8 x = 0; x < 4; ++x)
1603 {
1604 str += dump(structName + ".ScalingList4x4[" + ToString(i) + "][" + ToString(y) + "][" + ToString(x) + "]", _struct.ScalingList4x4[i][y * 4+x]) + "\n";
1605 }
1606 }
1607
1608 for (mfxU8 i = 0; i < 6; ++i)
1609 {
1610 for (mfxU8 y = 0; y < 8; ++y)
1611 for (mfxU8 x = 0; x < 8; ++x)
1612 {
1613 str += dump(structName + ".ScalingList8x8[" + ToString(i) + "][" + ToString(y) + "][" + ToString(x) + "]", _struct.ScalingList8x8[i][y * 4 + x]) + "\n";
1614 }
1615 }
1616
1617 return str;
1618 }
1619 #endif
1620
1621 #if (MFX_VERSION >= MFX_VERSION_NEXT)
dump(const std::string structName,const mfxExtPartialBitstreamParam & _struct)1622 std::string DumpContext::dump(const std::string structName, const mfxExtPartialBitstreamParam &_struct)
1623 {
1624 std::string str;
1625 str += dump(structName + ".Header", _struct.Header) + "\n";
1626 DUMP_FIELD(BlockSize);
1627 DUMP_FIELD(Granularity);
1628
1629 str += structName + ".reserved[]=" + DUMP_RESERVED_ARRAY(_struct.reserved) + "\n";
1630
1631 return str;
1632 }
1633 #endif
1634