1 /*############################################################################
2 # Copyright Intel Corporation
3 #
4 # SPDX-License-Identifier: MIT
5 ############################################################################*/
6
7 #pragma once
8
9 #include <iostream>
10 #include <string>
11 #include <utility>
12 #include <vector>
13
14 #include "vpl/preview/defs.hpp"
15 #include "vpl/mfxstructures.h"
16
17 namespace oneapi {
18 namespace vpl {
19 namespace detail {
20
21 constexpr unsigned int INTENT = 4;
22
23 template <typename T>
space(int space,std::ostream & out,const T & arg)24 const T& space(int space, std::ostream& out, const T& arg) {
25 for (int i = 0; i < space; i++) {
26 out << ' ';
27 }
28 return arg;
29 }
30
Boolean2String(uint16_t code)31 inline std::string Boolean2String(uint16_t code) {
32 if (0 == code) {
33 return ("False");
34 }
35 return (std::string("True"));
36 }
37
FourCC2String(uint32_t code)38 inline std::string FourCC2String(uint32_t code) {
39 if (0 != code) {
40 const char* b = (const char*)&code;
41 return (std::string(b, 4));
42 }
43 return (std::string("Unset"));
44 }
45
NotSpecifyed0(uint16_t code)46 inline std::string NotSpecifyed0(uint16_t code) {
47 if (0 == code) {
48 return (std::string("Not Specifyed"));
49 }
50 return (std::to_string(code));
51 }
52
IOPattern2String(uint16_t code)53 inline std::string IOPattern2String(uint16_t code) {
54 std::string iop;
55 bool carry = false;
56 bool isset = false;
57 if (0 == code) {
58 return (std::string("Unset"));
59 }
60 if (code & MFX_IOPATTERN_IN_VIDEO_MEMORY) {
61 iop += "In Video";
62 carry = true;
63 isset = true;
64 }
65 if (code & MFX_IOPATTERN_IN_SYSTEM_MEMORY) {
66 if (carry) {
67 iop += " & ";
68 }
69 iop += "In System";
70 carry = true;
71 isset = true;
72 }
73 if (code & MFX_IOPATTERN_OUT_VIDEO_MEMORY) {
74 if (carry) {
75 iop += " & ";
76 }
77 iop += "Out Video";
78 carry = true;
79 isset = true;
80 }
81 if (code & MFX_IOPATTERN_OUT_SYSTEM_MEMORY) {
82 if (carry) {
83 iop += " & ";
84 }
85 iop += "Out Syatem";
86 isset = true;
87 }
88 if (isset) {
89 iop += " Memory";
90 }
91 return (iop);
92 }
93
TriState2String(uint16_t code)94 inline std::string TriState2String(uint16_t code) {
95 switch (code) {
96 case MFX_CODINGOPTION_ON:
97 return (std::string("ON"));
98 case MFX_CODINGOPTION_OFF:
99 return (std::string("OFF"));
100 case MFX_CODINGOPTION_ADAPTIVE:
101 return (std::string("Adaptive"));
102 default:
103 return (std::string("Unset"));
104 }
105 return (std::string("Unset"));
106 }
107
PicStruct2String(uint16_t code)108 inline std::string PicStruct2String(uint16_t code) {
109 switch (code) {
110 case MFX_PICSTRUCT_PROGRESSIVE:
111 return (std::string("Progressive Picture"));
112 case MFX_PICSTRUCT_FIELD_TFF:
113 return (std::string("Top field"));
114 case MFX_PICSTRUCT_FIELD_BFF:
115 return (std::string("Bottom field"));
116 case MFX_PICSTRUCT_FIELD_REPEATED:
117 return (std::string("First field repeated"));
118 case MFX_PICSTRUCT_FRAME_DOUBLING:
119 return (std::string("Double the frame"));
120 case MFX_PICSTRUCT_FRAME_TRIPLING:
121 return (std::string("Triple the frame"));
122 case MFX_PICSTRUCT_FIELD_SINGLE:
123 return (std::string("Single field"));
124 case MFX_PICSTRUCT_FIELD_TOP:
125 return (std::string("Top field in a picture"));
126 case MFX_PICSTRUCT_FIELD_BOTTOM:
127 return (std::string("Bottom field in a picture"));
128 case MFX_PICSTRUCT_FIELD_PAIRED_PREV:
129 return (std::string("Paired with previouse field"));
130 case MFX_PICSTRUCT_FIELD_PAIRED_NEXT:
131 return (std::string("Paired with nect field"));
132 case MFX_PICSTRUCT_UNKNOWN:
133 default:
134 return (std::string("Unset"));
135 }
136 return (std::string("Unset"));
137 }
138
ChromaFormat2String(uint16_t code)139 inline std::string ChromaFormat2String(uint16_t code) {
140 switch (code) {
141 case MFX_CHROMAFORMAT_MONOCHROME:
142 return (std::string("Monochrome"));
143 case MFX_CHROMAFORMAT_YUV420:
144 return (std::string("4:2:0"));
145 case MFX_CHROMAFORMAT_YUV422:
146 return (std::string("4:2:2"));
147 case MFX_CHROMAFORMAT_YUV444:
148 return (std::string("4:4:4"));
149 case MFX_CHROMAFORMAT_YUV411:
150 return (std::string("4:1:1"));
151 case MFX_CHROMAFORMAT_YUV422V:
152 return (std::string("4:2:2 vertical"));
153 default:
154 return (std::string("Unset"));
155 }
156 return (std::string("Unset"));
157 }
158
TimeStampCalc2String(uint16_t code)159 inline std::string TimeStampCalc2String(uint16_t code) {
160 switch (code) {
161 case MFX_TIMESTAMPCALC_TELECINE:
162 return (std::string("Telecine"));
163 default:
164 return (std::string("Not specifyed"));
165 }
166 return (std::string("Not specifyed"));
167 }
168
GopOptFlag2String(uint16_t code)169 inline std::string GopOptFlag2String(uint16_t code) {
170 switch (code) {
171 case MFX_GOP_CLOSED:
172 return (std::string("Closed"));
173 case MFX_GOP_STRICT:
174 return (std::string("Strict"));
175 }
176 return (std::string("Value is out of possible values"));
177 }
178
RateControlMethod2String(uint16_t code)179 inline std::string RateControlMethod2String(uint16_t code) {
180 switch (code) {
181 case MFX_RATECONTROL_CBR:
182 return (std::string("CBR"));
183 case MFX_RATECONTROL_VBR:
184 return (std::string("VBR"));
185 case MFX_RATECONTROL_CQP:
186 return (std::string("CQP"));
187 case MFX_RATECONTROL_AVBR:
188 return (std::string("AVBR"));
189 case MFX_RATECONTROL_LA:
190 return (std::string("LA"));
191 case MFX_RATECONTROL_ICQ:
192 return (std::string("ICQ"));
193 case MFX_RATECONTROL_VCM:
194 return (std::string("VCM"));
195 case MFX_RATECONTROL_LA_ICQ:
196 return (std::string("LA ICQ"));
197 case MFX_RATECONTROL_LA_HRD:
198 return (std::string("LA HRD"));
199 case MFX_RATECONTROL_QVBR:
200 return (std::string("QVBR"));
201 default:
202 return (std::string("Unknown"));
203 }
204 return (std::string("Not specifyed"));
205 }
206
MemType2String(uint16_t code)207 inline std::string MemType2String(uint16_t code) {
208 std::string res;
209 bool carry = false;
210 if (code & MFX_MEMTYPE_INTERNAL_FRAME) {
211 res += "Internal frame";
212 carry = true;
213 }
214 else if (code & MFX_MEMTYPE_EXTERNAL_FRAME) {
215 res += "External frame";
216 carry = true;
217 }
218 else if (code & MFX_MEMTYPE_EXPORT_FRAME) {
219 res += "Export frame";
220 carry = true;
221 }
222
223 if (code & MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET) {
224 res += carry ? " " : "";
225 res += "in dec video memory target";
226 }
227 else if (code & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) {
228 res += carry ? " " : "";
229 res += "in VPP video memory target";
230 }
231 else if (code & MFX_MEMTYPE_SYSTEM_MEMORY) {
232 res += carry ? " " : "";
233 res += "in system memory";
234 }
235 else if (code & MFX_MEMTYPE_VIDEO_MEMORY_ENCODER_TARGET) {
236 res += carry ? " " : "";
237 res += "in enc video memory target";
238 }
239 else {
240 carry = false;
241 }
242
243 if (code & MFX_MEMTYPE_FROM_ENCODE) {
244 res += carry ? " " : "";
245 res += "alocated by enc";
246 }
247 else if (code & MFX_MEMTYPE_FROM_DECODE) {
248 res += carry ? " " : "";
249 res += "alocated by dec";
250 }
251 else if (code & MFX_MEMTYPE_FROM_VPPIN) {
252 res += carry ? " " : "";
253 res += "alocated by vpp for in";
254 }
255 else if (code & MFX_MEMTYPE_FROM_VPPOUT) {
256 res += carry ? " " : "";
257 res += "alocated by vpp for out";
258 }
259 if (res.size() == 0)
260 return (std::string("Invalid"));
261 return (res);
262 }
263
TimeStamp2String(uint64_t tms)264 inline std::string TimeStamp2String(uint64_t tms) {
265 if (tms == (uint64_t)MFX_TIMESTAMP_UNKNOWN)
266 return (std::string("Unknown"));
267 return (std::to_string(tms));
268 }
269
TimeStamp2String(int64_t tms)270 inline std::string TimeStamp2String(int64_t tms) {
271 if (tms == (int64_t)MFX_TIMESTAMP_UNKNOWN)
272 return (std::string("Unknown"));
273 return (std::to_string(tms));
274 }
275
TimeStamp2String(uint16_t code)276 inline std::string TimeStamp2String(uint16_t code) {
277 if (code == MFX_FRAMEDATA_ORIGINAL_TIMESTAMP)
278 return (std::string("Original timestamp."));
279 return ("Calculated timestamp");
280 }
281
Corruption2String(uint16_t code)282 inline std::string Corruption2String(uint16_t code) {
283 switch (code) {
284 case MFX_CORRUPTION_MINOR:
285 return (std::string("Minor"));
286 case MFX_CORRUPTION_MAJOR:
287 return (std::string("Major"));
288 case MFX_CORRUPTION_ABSENT_TOP_FIELD:
289 return (std::string("Top field corrupted"));
290 case MFX_CORRUPTION_ABSENT_BOTTOM_FIELD:
291 return (std::string("Bottom field corrupted"));
292 case MFX_CORRUPTION_REFERENCE_FRAME:
293 return (std::string("Corrupted reference frame"));
294 case MFX_CORRUPTION_REFERENCE_LIST:
295 return (std::string("corrupted reference list"));
296 default:
297 return (std::string("No corruption"));
298 }
299 return (std::string("Not specifyed"));
300 }
301
ResourceType2String(mfxResourceType code)302 inline std::string ResourceType2String(mfxResourceType code) {
303 switch (code) {
304 case MFX_RESOURCE_SYSTEM_SURFACE:
305 return (std::string("System buffer"));
306 case MFX_RESOURCE_VA_SURFACE_PTR:
307 // same value as MFX_RESOURCE_VA_SURFACE (API >= 2.5)
308 return (std::string("VA Surface pointer"));
309 case MFX_RESOURCE_VA_BUFFER_PTR:
310 // same value as MFX_RESOURCE_VA_BUFFER (API >= 2.5)
311 return (std::string("VA buffer pointer"));
312 case MFX_RESOURCE_DX9_SURFACE:
313 return (std::string("DX9 Surface"));
314 case MFX_RESOURCE_DX11_TEXTURE:
315 return (std::string("DX11 Texture"));
316 case MFX_RESOURCE_DX12_RESOURCE:
317 return (std::string("DX12 Resource"));
318 case MFX_RESOURCE_DMA_RESOURCE:
319 return (std::string("DMA buffer"));
320 default:
321 return (std::string("Unknown resource type"));
322 }
323 return (std::string("Not specifyed"));
324 }
325
ImplType2String(mfxImplType code)326 inline std::string ImplType2String(mfxImplType code) {
327 switch (code) {
328 case MFX_IMPL_TYPE_SOFTWARE:
329 return (std::string("Software"));
330 case MFX_IMPL_TYPE_HARDWARE:
331 return (std::string("Hardware"));
332 default:
333 return (std::string("Unknown type"));
334 }
335 return (std::string("Not specifyed"));
336 }
337
AccelerationMode2String(mfxAccelerationMode code)338 inline std::string AccelerationMode2String(mfxAccelerationMode code) {
339 switch (code) {
340 case MFX_ACCEL_MODE_NA:
341 return (std::string("No HW acceleration"));
342 case MFX_ACCEL_MODE_VIA_D3D9:
343 return (std::string("HW acceleration via Microsoft* Direct3D9*"));
344 case MFX_ACCEL_MODE_VIA_D3D11:
345 return (std::string("HW acceleration via Microsoft* Direct3D11*"));
346 case MFX_ACCEL_MODE_VIA_VAAPI:
347 return (std::string("HW acceleration via Linux* VA-API"));
348 default:
349 return (std::string("Unknown resource type"));
350 }
351 return (std::string("Not specifyed"));
352 }
353
component2String(component c)354 inline std::string component2String(component c) {
355 switch (c) {
356 case component::decoder:
357 return (std::string("Decoder"));
358 case component::encoder:
359 return (std::string("Encoder"));
360 case component::vpp:
361 return (std::string("VPP"));
362 case component::decoder_vpp:
363 return (std::string("Decoder+VPP"));
364 default:
365 return (std::string("Unknown component"));
366 }
367 return (std::string("Unknown component"));
368 }
369
status2Str(status s)370 inline std::string status2Str(status s) {
371 switch (s) {
372 case status::Ok:
373 return (std::string("Ok"));
374 break;
375 case status::ExecutionInProgress:
376 return (std::string("ExecutionInProgress"));
377 break;
378 case status::DeviceBusy:
379 return (std::string("DeviceBusy"));
380 break;
381 case status::VideoParamChanged:
382 return (std::string("VideoParamChanged"));
383 break;
384 case status::PartialAcceleration:
385 return (std::string("PartialAcceleration"));
386 break;
387 case status::IncompartibleVideoParam:
388 return (std::string("IncompartibleVideoParam"));
389 break;
390 case status::ValueNotChanged:
391 return (std::string("ValueNotChanged"));
392 break;
393 case status::OutOfRange:
394 return (std::string("OutOfRange"));
395 break;
396 case status::TaskWorking:
397 return (std::string("TaskWorking"));
398 break;
399 case status::TaskBusy:
400 return (std::string("TaskBusy"));
401 break;
402 case status::FilterSkipped:
403 return (std::string("FilterSkipped"));
404 break;
405 case status::PartialOutput:
406 return (std::string("PartialOutput"));
407 break;
408 case status::NotEnoughData:
409 return (std::string("NotEnoughData"));
410 break;
411 case status::NotEnoughSurface:
412 return (std::string("NotEnoughSurface"));
413 break;
414 case status::NotEnoughBuffer:
415 return (std::string("NotEnoughBuffer"));
416 break;
417 case status::EndOfStreamReached:
418 return (std::string("EndOfStreamReached"));
419 break;
420 case status::Unknown:
421 default:
422 return (std::string("Unknown"));
423 break;
424 }
425 }
426
427 /// @brief Write value in human readable form to a stream
428 /// @param[in] out destination stream
429 /// @param[in] value value
430 template<typename... Ts>
operator <<(std::ostream & out,std::pair<Ts...> const & value)431 std::ostream& operator<<(std::ostream& out, std::pair<Ts...> const& value)
432 {
433 out << '(';
434 out << value.first;
435 out << ", ";
436 out << value.second;
437 out << ')';
438 return out;
439 }
440
441 /// @brief Write value in human readable form to a stream
442 /// @param[in] out destination stream
443 /// @param[in] value value
444 template<typename T>
operator <<(std::ostream & out,std::vector<T> const & value)445 std::ostream& operator<<(std::ostream& out, std::vector<T> const& value)
446 {
447 out << '[';
448 bool first = true;
449 for(auto& v : value){
450 if(first){
451 first = false;
452 out << v;
453 } else {
454 out << ", " << v;
455 }
456 }
457 out << ']';
458 return out;
459 }
460
operator <<(std::ostream & out,const mfxRange32U & v)461 inline std::ostream& operator<<(std::ostream& out, const mfxRange32U& v) {
462 out << "{" << v.Min << ", " << v.Max << "," << v.Step << "}";
463 return out;
464 }
465
466
467 } // namespace detail
468 } // namespace vpl
469 } // namespace oneapi
470