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