1 /*############################################################################
2 # Copyright (C) 2005 Intel Corporation
3 #
4 # SPDX-License-Identifier: MIT
5 ############################################################################*/
6
7 #include <algorithm>
8 #include <cctype>
9 #include <fstream>
10 #include <regex>
11 #include <sstream>
12 #include <string>
13 #include "sample_vpp_utils.h"
14 #include "version.h"
15
16 #define VAL_CHECK(val) \
17 { \
18 if (val) \
19 return MFX_ERR_UNKNOWN; \
20 }
21
22 #ifndef MFX_VERSION
23 #error MFX_VERSION not defined
24 #endif
25
vppPrintHelp(const msdk_char * strAppName,const msdk_char * strErrorMessage)26 void vppPrintHelp(const msdk_char* strAppName, const msdk_char* strErrorMessage) {
27 msdk_printf(MSDK_STRING("Intel(R) Media SDK VPP Sample version %s\n"),
28 GetMSDKSampleVersion().c_str());
29 if (strErrorMessage) {
30 msdk_printf(MSDK_STRING("Error: %s\n"), strErrorMessage);
31 }
32
33 msdk_printf(MSDK_STRING("Usage: %s [Options] -i InputFile -o OutputFile\n"), strAppName);
34
35 msdk_printf(MSDK_STRING("Options: \n"));
36 msdk_printf(
37 MSDK_STRING(" [-lib type] - type of used library. sw, hw (def: sw)\n\n"));
38 #if defined(LINUX32) || defined(LINUX64)
39 msdk_printf(
40 MSDK_STRING(" [-device /path/to/device] - set graphics device for processing\n"));
41 msdk_printf(
42 MSDK_STRING(" For example: '-device /dev/dri/card0'\n"));
43 msdk_printf(MSDK_STRING(
44 " '-device /dev/dri/renderD128'\n"));
45 msdk_printf(MSDK_STRING(
46 " If not specified, defaults to the first Intel device found on the system\n\n"));
47 #endif
48 #ifdef ONEVPL_EXPERIMENTAL
49 #if (defined(_WIN64) || defined(_WIN32))
50 msdk_printf(MSDK_STRING(" [-luid HighPart:LowPart] - setup adapter by LUID \n"));
51 msdk_printf(MSDK_STRING(" For example: \"0x0:0x8a46\" \n"));
52 #endif
53 msdk_printf(MSDK_STRING(" [-pci domain:bus:device.function] - setup device with PCI \n"));
54 msdk_printf(MSDK_STRING(" For example: \"0:3:0.0\" \n"));
55 #endif
56 msdk_printf(MSDK_STRING(
57 " [-dGfx] - preffer processing on dGfx (by default system decides)\n"));
58 msdk_printf(MSDK_STRING(
59 " [-iGfx] - preffer processing on iGfx (by default system decides)\n"));
60 msdk_printf(MSDK_STRING(
61 " [-AdapterNum] - specifies adpter number for processing, starts from 0\n"));
62 msdk_printf(MSDK_STRING(
63 " [-dispatcher:fullSearch] - enable search for all available implementations in oneVPL dispatcher\n"));
64 #if defined(D3D_SURFACES_SUPPORT)
65 msdk_printf(MSDK_STRING(" [-d3d] - use d3d9 surfaces\n\n"));
66 #endif
67 #if MFX_D3D11_SUPPORT
68 msdk_printf(MSDK_STRING(" [-d3d11] - use d3d11 surfaces\n\n"));
69 #endif
70 #ifdef LIBVA_SUPPORT
71 msdk_printf(MSDK_STRING(" [-vaapi] - work with vaapi surfaces\n\n"));
72 #endif
73
74 msdk_printf(MSDK_STRING(" [-sw width] - width of src video (def: 352)\n"));
75 msdk_printf(MSDK_STRING(" [-sh height] - height of src video (def: 288)\n"));
76 msdk_printf(MSDK_STRING(" [-scrX x] - cropX of src video (def: 0)\n"));
77 msdk_printf(MSDK_STRING(" [-scrY y] - cropY of src video (def: 0)\n"));
78 msdk_printf(MSDK_STRING(" [-scrW w] - cropW of src video (def: width)\n"));
79 msdk_printf(
80 MSDK_STRING(" [-scrH h] - cropH of src video (def: height)\n"));
81 msdk_printf(
82 MSDK_STRING(" [-sf frameRate] - frame rate of src video (def: 30.0)\n"));
83 msdk_printf(MSDK_STRING(
84 " [-scc format] - format (FourCC) of src video (def: nv12. support i420|nv12|yv12|yuy2|rgb565|rgb3|rgb4|imc3|yuv400|yuv411|yuv422h|yuv422v|yuv444|uyvy|ayuv|i010|p010|y210|y410|p016|y216|y416)\n"));
85 msdk_printf(MSDK_STRING(
86 " [-sbitshift 0|1] - shift data to right or keep it the same way as in Microsoft's P010\n"));
87 msdk_printf(MSDK_STRING(
88 " [-sbitdepthluma value] - shift luma channel to right to \"16 - value\" bytes\n"));
89 msdk_printf(MSDK_STRING(
90 " [-sbitdepthchroma value] - shift chroma channel to right to \"16 - value\" bytes\n"));
91
92 msdk_printf(MSDK_STRING(" [-spic value] - picture structure of src video\n"));
93 msdk_printf(
94 MSDK_STRING(" 0 - interlaced top field first\n"));
95 msdk_printf(
96 MSDK_STRING(" 2 - interlaced bottom field first\n"));
97 msdk_printf(MSDK_STRING(" 3 - single field\n"));
98 msdk_printf(MSDK_STRING(" 1 - progressive (default)\n"));
99 msdk_printf(MSDK_STRING(" -1 - unknown\n\n"));
100
101 msdk_printf(MSDK_STRING(" [-dw width] - width of dst video (def: 352)\n"));
102 msdk_printf(MSDK_STRING(" [-dh height] - height of dst video (def: 288)\n"));
103 msdk_printf(MSDK_STRING(" [-dcrX x] - cropX of dst video (def: 0)\n"));
104 msdk_printf(MSDK_STRING(" [-dcrY y] - cropY of dst video (def: 0)\n"));
105 msdk_printf(MSDK_STRING(" [-dcrW w] - cropW of dst video (def: width)\n"));
106 msdk_printf(
107 MSDK_STRING(" [-dcrH h] - cropH of dst video (def: height)\n"));
108 msdk_printf(
109 MSDK_STRING(" [-df frameRate] - frame rate of dst video (def: 30.0)\n"));
110 msdk_printf(MSDK_STRING(
111 " [-dcc format] - format (FourCC) of dst video (def: nv12. support i420|nv12|yuy2|rgb4|rgbp|yv12|ayuv|a2rgb10|y210|y410|p016|y216|y416)\n"));
112 msdk_printf(MSDK_STRING(
113 " [-dbitshift 0|1] - shift data to right or keep it the same way as in Microsoft's P010\n"));
114 msdk_printf(MSDK_STRING(
115 " [-dbitdepthluma value] - shift luma channel to left to \"16 - value\" bytes\n"));
116 msdk_printf(MSDK_STRING(
117 " [-dbitdepthchroma value] - shift chroma channel to left to \"16 - value\" bytes\n"));
118
119 msdk_printf(MSDK_STRING(" [-dpic value] - picture structure of dst video\n"));
120 msdk_printf(
121 MSDK_STRING(" 0 - interlaced top field first\n"));
122 msdk_printf(
123 MSDK_STRING(" 2 - interlaced bottom field first\n"));
124 msdk_printf(MSDK_STRING(" 3 - single field\n"));
125 msdk_printf(MSDK_STRING(" 1 - progressive (default)\n"));
126 msdk_printf(MSDK_STRING(" -1 - unknown\n\n"));
127
128 msdk_printf(MSDK_STRING(" Video Composition\n"));
129 msdk_printf(MSDK_STRING(
130 " [-composite parameters_file] - composite several input files in one output. The syntax of the parameters file is:\n"));
131 msdk_printf(MSDK_STRING(" stream=<video file name>\n"));
132 msdk_printf(MSDK_STRING(" width=<input video width>\n"));
133 msdk_printf(MSDK_STRING(" height=<input video height>\n"));
134 msdk_printf(MSDK_STRING(" cropx=<input cropX (def: 0)>\n"));
135 msdk_printf(MSDK_STRING(" cropy=<input cropY (def: 0)>\n"));
136 msdk_printf(
137 MSDK_STRING(" cropw=<input cropW (def: width)>\n"));
138 msdk_printf(
139 MSDK_STRING(" croph=<input cropH (def: height)>\n"));
140 msdk_printf(MSDK_STRING(
141 " framerate=<input frame rate (def: 30.0)>\n"));
142 msdk_printf(MSDK_STRING(
143 " fourcc=<format (FourCC) of input video (def: nv12. support nv12|rgb4)>\n"));
144 msdk_printf(MSDK_STRING(
145 " picstruct=<picture structure of input video,\n"));
146 msdk_printf(MSDK_STRING(
147 " 0 = interlaced top field first\n"));
148 msdk_printf(MSDK_STRING(
149 " 2 = interlaced bottom field first\n"));
150 msdk_printf(MSDK_STRING(" 3 = single field\n"));
151 msdk_printf(
152 MSDK_STRING(" 1 = progressive (default)>\n"));
153 msdk_printf(MSDK_STRING(
154 " dstx=<X coordinate of input video located in the output (def: 0)>\n"));
155 msdk_printf(MSDK_STRING(
156 " dsty=<Y coordinate of input video located in the output (def: 0)>\n"));
157 msdk_printf(MSDK_STRING(
158 " dstw=<width of input video located in the output (def: width)>\n"));
159 msdk_printf(MSDK_STRING(
160 " dsth=<height of input video located in the output (def: height)>\n\n"));
161 msdk_printf(MSDK_STRING(" stream=<video file name>\n"));
162 msdk_printf(MSDK_STRING(" width=<input video width>\n"));
163 msdk_printf(MSDK_STRING(" GlobalAlphaEnable=1\n"));
164 msdk_printf(MSDK_STRING(" GlobalAlpha=<Alpha value>\n"));
165 msdk_printf(MSDK_STRING(" LumaKeyEnable=1\n"));
166 msdk_printf(MSDK_STRING(" LumaKeyMin=<Luma key min value>\n"));
167 msdk_printf(MSDK_STRING(" LumaKeyMax=<Luma key max value>\n"));
168 msdk_printf(MSDK_STRING(" ...\n"));
169 msdk_printf(MSDK_STRING(
170 " The parameters file may contain up to 64 streams.\n\n"));
171 msdk_printf(MSDK_STRING(" For example:\n"));
172 msdk_printf(MSDK_STRING(" stream=input_720x480.yuv\n"));
173 msdk_printf(MSDK_STRING(" width=720\n"));
174 msdk_printf(MSDK_STRING(" height=480\n"));
175 msdk_printf(MSDK_STRING(" cropx=0\n"));
176 msdk_printf(MSDK_STRING(" cropy=0\n"));
177 msdk_printf(MSDK_STRING(" cropw=720\n"));
178 msdk_printf(MSDK_STRING(" croph=480\n"));
179 msdk_printf(MSDK_STRING(" dstx=0\n"));
180 msdk_printf(MSDK_STRING(" dsty=0\n"));
181 msdk_printf(MSDK_STRING(" dstw=720\n"));
182 msdk_printf(MSDK_STRING(" dsth=480\n\n"));
183 msdk_printf(MSDK_STRING(" stream=input_480x320.yuv\n"));
184 msdk_printf(MSDK_STRING(" width=480\n"));
185 msdk_printf(MSDK_STRING(" height=320\n"));
186 msdk_printf(MSDK_STRING(" cropx=0\n"));
187 msdk_printf(MSDK_STRING(" cropy=0\n"));
188 msdk_printf(MSDK_STRING(" cropw=480\n"));
189 msdk_printf(MSDK_STRING(" croph=320\n"));
190 msdk_printf(MSDK_STRING(" dstx=100\n"));
191 msdk_printf(MSDK_STRING(" dsty=100\n"));
192 msdk_printf(MSDK_STRING(" dstw=320\n"));
193 msdk_printf(MSDK_STRING(" dsth=240\n"));
194 msdk_printf(MSDK_STRING(" GlobalAlphaEnable=1\n"));
195 msdk_printf(MSDK_STRING(" GlobalAlpha=128\n"));
196 msdk_printf(MSDK_STRING(" LumaKeyEnable=1\n"));
197 msdk_printf(MSDK_STRING(" LumaKeyMin=250\n"));
198 msdk_printf(MSDK_STRING(" LumaKeyMax=255\n"));
199 msdk_printf(MSDK_STRING(" [-cf_disable] disable colorfill\n"));
200
201 msdk_printf(MSDK_STRING(" Video Enhancement Algorithms\n"));
202
203 msdk_printf(MSDK_STRING(" [-di_mode (mode)] - set type of deinterlace algorithm\n"));
204 msdk_printf(
205 MSDK_STRING(" 12 - advanced with Scene Change Detection (SCD) \n"));
206 msdk_printf(MSDK_STRING(
207 " 8 - reverse telecine for a selected telecine pattern (use -tc_pattern). For PTIR plug-in\n"));
208 msdk_printf(MSDK_STRING(" 2 - advanced or motion adaptive (default)\n"));
209 msdk_printf(MSDK_STRING(" 1 - simple or BOB\n\n"));
210
211 msdk_printf(MSDK_STRING(
212 " [-deinterlace (type)] - enable deinterlace algorithm (alternative way: -spic 0 -dpic 1) \n"));
213 msdk_printf(MSDK_STRING(" type is tff (default) or bff \n"));
214
215 msdk_printf(MSDK_STRING(
216 " [-rotate (angle)] - enable rotation. Supported angles: 0, 90, 180, 270.\n"));
217
218 msdk_printf(
219 MSDK_STRING(" [-scaling_mode (mode)] - specify type of scaling to be used for resize\n"));
220 msdk_printf(MSDK_STRING(" 0 - default\n"));
221 msdk_printf(MSDK_STRING(" 1 - low power mode\n"));
222 msdk_printf(MSDK_STRING(" 2 - quality mode\n\n"));
223
224 msdk_printf(MSDK_STRING(
225 " [-interpolation_method (method)] - specify interpolation method to be used for resize\n"));
226 msdk_printf(MSDK_STRING(" 0 - default\n"));
227 msdk_printf(MSDK_STRING(" 1 - nearest neighbor\n"));
228 msdk_printf(MSDK_STRING(" 2 - bilinear\n"));
229 msdk_printf(MSDK_STRING(" 3 - advanced\n\n"));
230
231 msdk_printf(MSDK_STRING(" [-denoise (level) (mode)] - enable denoise.\n"));
232 msdk_printf(MSDK_STRING(" mode - denoise mode\n"));
233 msdk_printf(MSDK_STRING(" 0 - default\n"));
234 msdk_printf(MSDK_STRING(" 1001 - auto BD rate\n"));
235 msdk_printf(MSDK_STRING(" 1002 - auto subjective\n"));
236 msdk_printf(MSDK_STRING(" 1003 - auto adjust\n"));
237 msdk_printf(MSDK_STRING(" 1004 - manual mode for pre-processing, need level\n"));
238 msdk_printf(MSDK_STRING(" 1005 - manual mode for post-processing, need level\n"));
239 msdk_printf(MSDK_STRING(" level - range of noise level is [0, 100]\n"));
240 msdk_printf(MSDK_STRING(
241 " [-chroma_siting (vmode hmode)] - specify chroma siting mode for VPP color conversion, allowed values: vtop|vcen|vbot hleft|hcen\n"));
242 #ifdef ENABLE_MCTF
243 #if !defined ENABLE_MCTF_EXT
244 msdk_printf(MSDK_STRING(" -mctf [Strength]\n"));
245 msdk_printf(MSDK_STRING(" Strength is an optional value; it is in range [0...20]\n"));
246 msdk_printf(MSDK_STRING(" value 0 makes MCTF operates in auto mode;\n"));
247 msdk_printf(
248 MSDK_STRING(" values [1...20] makes MCTF operates with fixed-strength mode;\n"));
249 msdk_printf(MSDK_STRING(
250 " In fixed-strength mode, MCTF strength can be adjusted at framelevel;\n"));
251 msdk_printf(MSDK_STRING(" If no Strength is given, MCTF operates in auto mode.\n"));
252 #else
253 msdk_printf(MSDK_STRING(" -mctf MctfMode:BitsPerPixel:Strength:ME:Overlap:DB\n"));
254 msdk_printf(MSDK_STRING(
255 " every parameter may be missed; in this case default value is used.\n"));
256 msdk_printf(MSDK_STRING(" MctfMode: 0 - spatial filter\n"));
257 msdk_printf(MSDK_STRING(" MctfMode: 1- temporal filtering, 1 backward reference\n"));
258 msdk_printf(
259 MSDK_STRING(" MctfMode: 2- temporal filtering, 1 backward & 1 forward reference\n"));
260 msdk_printf(MSDK_STRING(
261 " MctfMode: 3- temporal filtering, 2 backward & 2 forward references\n"));
262 msdk_printf(MSDK_STRING(" MctfMode: other values: force default mode to be used\n"));
263 msdk_printf(MSDK_STRING(
264 " BitsPerPixel: float, valid range [0...12.0]; if exists, is used for automatic filter strength adaptation. Default is 0.0\n"));
265 msdk_printf(MSDK_STRING(" Strength: integer, [0...20]. Default value is 0.\n"));
266 msdk_printf(MSDK_STRING(
267 " ME: Motion Estimation precision; 0 - integer ME (default); 1 - quater-pel ME\n"));
268 msdk_printf(MSDK_STRING(
269 " Overlap: 0 - do not apply overlap ME (default); 1 - to apply overlap ME\n"));
270 msdk_printf(MSDK_STRING(
271 " DB: 0 - do not apply deblock Filter (default); 1 - to apply Deblock Filter\n"));
272 #endif //ENABLE_MCTF_EXT
273 #endif //ENABLE_MCTF
274 msdk_printf(MSDK_STRING(
275 " [-detail (level)] - enable detail enhancement algorithm. Level is optional \n"));
276 msdk_printf(MSDK_STRING(" range of detail level is [0, 100]\n\n"));
277 msdk_printf(MSDK_STRING(
278 " [-pa_hue hue] - procamp hue property. range [-180.0, 180.0] (def: 0.0)\n"));
279 msdk_printf(MSDK_STRING(
280 " [-pa_sat saturation] - procamp satursation property. range [ 0.0, 10.0] (def: 1.0)\n"));
281 msdk_printf(MSDK_STRING(
282 " [-pa_con contrast] - procamp contrast property. range [ 0.0, 10.0] (def: 1.0)\n"));
283 msdk_printf(MSDK_STRING(
284 " [-pa_bri brightness] - procamp brightness property. range [-100.0, 100.0] (def: 0.0)\n\n"));
285 #ifdef ENABLE_VPP_RUNTIME_HSBC
286 msdk_printf(MSDK_STRING(
287 " [-rt_hue num_frames hue1 hue2] - enable per-frame hue adjustment in run-time without the whole video processing pipeline reinitialization.\n"));
288 msdk_printf(MSDK_STRING(
289 " num_frames - a number of frames after which hue is changed either from hue1 to hue2 or from hue2 to hue1. \n"));
290 msdk_printf(MSDK_STRING(
291 " The first num_frames frames are initialized to hue1.\n"));
292 msdk_printf(MSDK_STRING(
293 " hue1 - the first hue value in range [-180.0, 180.0] (def: 0.0)\n"));
294 msdk_printf(MSDK_STRING(
295 " hue2 - the second hue value in range [-180.0, 180.0] (def: 0.0)\n\n"));
296 msdk_printf(MSDK_STRING(
297 " [-rt_sat num_frames sat1 sat2] - enable per-frame saturation adjustment in run-time without the whole video processing pipeline reinitialization.\n"));
298 msdk_printf(MSDK_STRING(
299 " num_frames - a number of frames after which saturation is changed either from sat1 to sat2 or from sat2 to sat1. \n"));
300 msdk_printf(MSDK_STRING(
301 " The first num_frames frames are initialized to sat1.\n"));
302 msdk_printf(MSDK_STRING(
303 " sat1 - the first saturation value in range [0.0, 10.0] (def: 1.0)\n"));
304 msdk_printf(MSDK_STRING(
305 " sat2 - the second saturation value in range [0.0, 10.0] (def: 1.0)\n\n"));
306 msdk_printf(MSDK_STRING(
307 " [-rt_con num_frames con1 con2] - enable per-frame contrast adjustment in run-time without the whole video processing pipeline reinitialization.\n"));
308 msdk_printf(MSDK_STRING(
309 " num_frames - a number of frames after which contrast is changed either from con1 to con2 or from con2 to con1. \n"));
310 msdk_printf(MSDK_STRING(
311 " The first num_frames frames are initialized to con1.\n"));
312 msdk_printf(MSDK_STRING(
313 " con1 - the first contrast value in range [0.0, 10.0] (def: 1.0)\n"));
314 msdk_printf(MSDK_STRING(
315 " con2 - the second contrast value in range [0.0, 10.0] (def: 1.0)\n\n"));
316 msdk_printf(MSDK_STRING(
317 " [-rt_bri num_frames bri1 bri2] - enable per-frame brightness adjustment in run-time without the whole video processing pipeline reinitialization.\n"));
318 msdk_printf(MSDK_STRING(
319 " num_frames - a number of frames after which brightness is changed either from bri1 to bri2 or from bri2 to bri1. \n"));
320 msdk_printf(MSDK_STRING(
321 " The first num_frames frames are initialized to bri1.\n"));
322 msdk_printf(MSDK_STRING(
323 " bri1 - the first brightness value in range [-100.0, 100.0] (def: 0.0)\n"));
324 msdk_printf(MSDK_STRING(
325 " bri2 - the second brightness value in range [-100.0, 100.0] (def: 0.0)\n\n"));
326 #endif
327 msdk_printf(MSDK_STRING(
328 " [-gamut:compression] - enable gamut compression algorithm (xvYCC->sRGB) \n"));
329 msdk_printf(MSDK_STRING(
330 " [-gamut:bt709] - enable BT.709 matrix transform (RGB->YUV conversion)(def: BT.601)\n\n"));
331 msdk_printf(
332 MSDK_STRING(" [-frc:advanced] - enable advanced FRC algorithm (based on PTS) \n"));
333 msdk_printf(MSDK_STRING(
334 " [-frc:interp] - enable FRC based on frame interpolation algorithm\n\n"));
335
336 msdk_printf(MSDK_STRING(
337 " [-tcc:red] - enable color saturation algorithm (R component) \n"));
338 msdk_printf(MSDK_STRING(
339 " [-tcc:green] - enable color saturation algorithm (G component)\n"));
340 msdk_printf(MSDK_STRING(
341 " [-tcc:blue] - enable color saturation algorithm (B component)\n"));
342 msdk_printf(MSDK_STRING(
343 " [-tcc:cyan] - enable color saturation algorithm (C component)\n"));
344 msdk_printf(MSDK_STRING(
345 " [-tcc:magenta] - enable color saturation algorithm (M component)\n"));
346 msdk_printf(MSDK_STRING(
347 " [-tcc:yellow] - enable color saturation algorithm (Y component)\n\n"));
348
349 msdk_printf(
350 MSDK_STRING(" [-ace] - enable auto contrast enhancement algorithm \n\n"));
351 msdk_printf(MSDK_STRING(
352 " [-ste (level)] - enable Skin Tone Enhancement algorithm. Level is optional \n"));
353 msdk_printf(
354 MSDK_STRING(" range of ste level is [0, 9] (def: 4)\n\n"));
355 msdk_printf(MSDK_STRING(
356 " [-istab (mode)] - enable Image Stabilization algorithm. Mode is optional \n"));
357 msdk_printf(MSDK_STRING(" mode of istab can be [1, 2] (def: 2)\n"));
358 msdk_printf(MSDK_STRING(
359 " where: 1 means upscale mode, 2 means croppping mode\n"));
360 msdk_printf(MSDK_STRING(
361 " [-view:count value] - enable Multi View preprocessing. range of views [1, 1024] (def: 1)\n\n"));
362 msdk_printf(MSDK_STRING(" id-layerId, width/height-resolution \n\n"));
363 msdk_printf(MSDK_STRING(
364 " [-ssitm (id)] - specify YUV<->RGB transfer matrix for input surface.\n"));
365 msdk_printf(MSDK_STRING(
366 " [-dsitm (id)] - specify YUV<->RGB transfer matrix for output surface.\n"));
367 msdk_printf(
368 MSDK_STRING(" [-ssinr (id)] - specify YUV nominal range for input surface.\n"));
369 msdk_printf(MSDK_STRING(
370 " [-dsinr (id)] - specify YUV nominal range for output surface.\n\n"));
371 msdk_printf(MSDK_STRING(" [-mirror (mode)] - mirror image using specified mode.\n"));
372
373 msdk_printf(MSDK_STRING(" [-n frames] - number of frames to VPP process\n\n"));
374
375 msdk_printf(MSDK_STRING(
376 " [-iopattern IN/OUT surface type] - IN/OUT surface type: sys_to_sys, sys_to_d3d, d3d_to_sys, d3d_to_d3d (def: sys_to_sys)\n"));
377 msdk_printf(
378 MSDK_STRING(" [-async n] - maximum number of asynchronious tasks. def: -async 1 \n"));
379 msdk_printf(MSDK_STRING(
380 " [-perf_opt n m] - n: number of prefetech frames. m : number of passes. In performance mode app preallocates bufer and load first n frames, def: no performace 1 \n"));
381 msdk_printf(MSDK_STRING(" [-pts_check] - checking of time stampls. Default is OFF \n"));
382 msdk_printf(MSDK_STRING(
383 " [-pts_jump ] - checking of time stamps jumps. Jump for random value since 13-th frame. Also, you can change input frame rate (via pts). Default frame_rate = sf \n"));
384 msdk_printf(MSDK_STRING(
385 " [-pts_fr ] - input frame rate which used for pts. Default frame_rate = sf \n"));
386 msdk_printf(MSDK_STRING(" [-pts_advanced] - enable FRC checking mode based on PTS \n"));
387 msdk_printf(MSDK_STRING(
388 " [-pf file for performance data] - file to save performance data. Default is off \n\n\n"));
389
390 msdk_printf(MSDK_STRING(
391 " [-roi_check mode seed1 seed2] - checking of ROI processing. Default is OFF \n"));
392 msdk_printf(MSDK_STRING(" mode - usage model of cropping\n"));
393 msdk_printf(MSDK_STRING(
394 " var_to_fix - variable input ROI and fixed output ROI\n"));
395 msdk_printf(MSDK_STRING(
396 " fix_to_var - fixed input ROI and variable output ROI\n"));
397 msdk_printf(MSDK_STRING(
398 " var_to_var - variable input ROI and variable output ROI\n"));
399 msdk_printf(MSDK_STRING(" seed1 - seed for init of rand generator for src\n"));
400 msdk_printf(MSDK_STRING(" seed2 - seed for init of rand generator for dst\n"));
401 msdk_printf(MSDK_STRING(
402 " range of seed [1, 65535]. 0 reserved for random init\n\n"));
403
404 msdk_printf(MSDK_STRING(" [-tc_pattern (pattern)] - set telecine pattern\n"));
405 msdk_printf(MSDK_STRING(
406 " 4 - provide a position inside a sequence of 5 frames where the artifacts starts. Use to -tc_pos to provide position\n"));
407 msdk_printf(MSDK_STRING(" 3 - 4:1 pattern\n"));
408 msdk_printf(MSDK_STRING(" 2 - frame repeat pattern\n"));
409 msdk_printf(MSDK_STRING(" 1 - 2:3:3:2 pattern\n"));
410 msdk_printf(MSDK_STRING(" 0 - 3:2 pattern\n\n"));
411
412 msdk_printf(MSDK_STRING(
413 " [-tc_pos (position)] - Position inside a telecine sequence of 5 frames where the artifacts starts - Value [0 - 4]\n\n"));
414
415 msdk_printf(MSDK_STRING(
416 " [-reset_start (frame number)] - after reaching this frame, encoder will be reset with new parameters, followed after this command and before -reset_end \n"));
417 msdk_printf(MSDK_STRING(
418 " [-reset_end] - specifies end of reset related options \n\n"));
419 msdk_printf(MSDK_STRING("\n"));
420
421 msdk_printf(
422 MSDK_STRING(
423 "Usage2: %s -sw 352 -sh 144 -scc rgb3 -dw 320 -dh 240 -dcc nv12 -denoise 32 -iopattern d3d_to_d3d -i in.rgb -o out.yuv -roi_check var_to_fix 7 7\n"),
424 strAppName);
425
426 msdk_printf(MSDK_STRING("\n"));
427
428 } // void vppPrintHelp(msdk_char *strAppName, msdk_char *strErrorMessage)
429
GetPicStruct(mfxI8 picStruct)430 mfxU16 GetPicStruct(mfxI8 picStruct) {
431 if (0 == picStruct) {
432 return MFX_PICSTRUCT_FIELD_TFF;
433 }
434 else if (2 == picStruct) {
435 return MFX_PICSTRUCT_FIELD_BFF;
436 }
437 else if (3 == picStruct) {
438 return MFX_PICSTRUCT_FIELD_SINGLE;
439 }
440 else if (-1 == picStruct) {
441 return MFX_PICSTRUCT_UNKNOWN;
442 }
443 else {
444 return MFX_PICSTRUCT_PROGRESSIVE;
445 }
446
447 } // mfxU16 GetPicStruct( mfxI8 picStruct )
448
Str2FourCC(msdk_char * strInput)449 mfxU32 Str2FourCC(msdk_char* strInput) {
450 mfxU32 fourcc = 0; //default
451
452 if (0 == msdk_stricmp(strInput, MSDK_STRING("yv12"))) {
453 fourcc = MFX_FOURCC_YV12;
454 }
455 else if (0 == msdk_stricmp(strInput, MSDK_STRING("rgb565"))) {
456 fourcc = MFX_FOURCC_RGB565;
457 }
458 else if (0 == msdk_stricmp(strInput, MSDK_STRING("rgb3"))) {
459 fourcc = MFX_FOURCC_RGB3;
460 }
461 else if (0 == msdk_stricmp(strInput, MSDK_STRING("rgb4"))) {
462 fourcc = MFX_FOURCC_RGB4;
463 }
464 #if !(defined(_WIN32) || defined(_WIN64))
465 else if (0 == msdk_stricmp(strInput, MSDK_STRING("rgbp"))) {
466 fourcc = MFX_FOURCC_RGBP;
467 }
468 #endif
469 else if (0 == msdk_stricmp(strInput, MSDK_STRING("yuy2"))) {
470 fourcc = MFX_FOURCC_YUY2;
471 }
472 else if (0 == msdk_stricmp(strInput, MSDK_STRING("nv12"))) {
473 fourcc = MFX_FOURCC_NV12;
474 }
475 else if (0 == msdk_stricmp(strInput, MSDK_STRING("imc3"))) {
476 fourcc = MFX_FOURCC_IMC3;
477 }
478 else if (0 == msdk_stricmp(strInput, MSDK_STRING("yuv400"))) {
479 fourcc = MFX_FOURCC_YUV400;
480 }
481 else if (0 == msdk_stricmp(strInput, MSDK_STRING("yuv411"))) {
482 fourcc = MFX_FOURCC_YUV411;
483 }
484 else if (0 == msdk_stricmp(strInput, MSDK_STRING("yuv422h"))) {
485 fourcc = MFX_FOURCC_YUV422H;
486 }
487 else if (0 == msdk_stricmp(strInput, MSDK_STRING("yuv422v"))) {
488 fourcc = MFX_FOURCC_YUV422V;
489 }
490 else if (0 == msdk_stricmp(strInput, MSDK_STRING("yuv444"))) {
491 fourcc = MFX_FOURCC_YUV444;
492 }
493 else if (0 == msdk_stricmp(strInput, MSDK_STRING("i010"))) {
494 fourcc = MFX_FOURCC_I010;
495 }
496 else if (0 == msdk_stricmp(strInput, MSDK_STRING("p010"))) {
497 fourcc = MFX_FOURCC_P010;
498 }
499 else if (0 == msdk_stricmp(strInput, MSDK_STRING("p210"))) {
500 fourcc = MFX_FOURCC_P210;
501 }
502 else if (0 == msdk_stricmp(strInput, MSDK_STRING("nv16"))) {
503 fourcc = MFX_FOURCC_NV16;
504 }
505 else if (0 == msdk_stricmp(strInput, MSDK_STRING("a2rgb10"))) {
506 fourcc = MFX_FOURCC_A2RGB10;
507 }
508 else if (0 == msdk_stricmp(strInput, MSDK_STRING("uyvy"))) {
509 fourcc = MFX_FOURCC_UYVY;
510 }
511 else if (0 == msdk_stricmp(strInput, MSDK_STRING("y210"))) {
512 fourcc = MFX_FOURCC_Y210;
513 }
514 else if (0 == msdk_stricmp(strInput, MSDK_STRING("y410"))) {
515 fourcc = MFX_FOURCC_Y410;
516 }
517 else if (0 == msdk_stricmp(strInput, MSDK_STRING("p016"))) {
518 fourcc = MFX_FOURCC_P016;
519 }
520 else if (0 == msdk_stricmp(strInput, MSDK_STRING("y216"))) {
521 fourcc = MFX_FOURCC_Y216;
522 }
523 else if (0 == msdk_stricmp(strInput, MSDK_STRING("y416"))) {
524 fourcc = MFX_FOURCC_Y416;
525 }
526 else if (0 == msdk_stricmp(strInput, MSDK_STRING("i420"))) {
527 fourcc = MFX_FOURCC_I420;
528 }
529 else if (0 == msdk_stricmp(strInput, MSDK_STRING("ayuv"))) {
530 fourcc = MFX_FOURCC_AYUV;
531 }
532
533 return fourcc;
534
535 } // mfxU32 Str2FourCC( msdk_char* strInput )
536
Str2ROIMode(msdk_char * strInput)537 eROIMode Str2ROIMode(msdk_char* strInput) {
538 eROIMode mode;
539
540 if (0 == msdk_strcmp(strInput, MSDK_STRING("var_to_fix"))) {
541 mode = ROI_VAR_TO_FIX;
542 }
543 else if (0 == msdk_strcmp(strInput, MSDK_STRING("var_to_var"))) {
544 mode = ROI_VAR_TO_VAR;
545 }
546 else if (0 == msdk_strcmp(strInput, MSDK_STRING("fix_to_var"))) {
547 mode = ROI_FIX_TO_VAR;
548 }
549 else {
550 mode = ROI_FIX_TO_FIX; // default mode
551 }
552
553 return mode;
554
555 } // eROIMode Str2ROIMode( msdk_char* strInput )
556
Str2IOpattern(msdk_char * strInput)557 static mfxU16 Str2IOpattern(msdk_char* strInput) {
558 mfxU16 IOPattern = 0;
559
560 if (0 == msdk_strcmp(strInput, MSDK_STRING("d3d_to_d3d"))) {
561 IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
562 }
563 else if (0 == msdk_strcmp(strInput, MSDK_STRING("d3d_to_sys"))) {
564 IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
565 }
566 else if (0 == msdk_strcmp(strInput, MSDK_STRING("sys_to_d3d"))) {
567 IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
568 }
569 else if (0 == msdk_strcmp(strInput, MSDK_STRING("sys_to_sys"))) {
570 IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
571 }
572 return IOPattern;
573
574 } // static mfxU16 Str2IOpattern( msdk_char* strInput )
575
576 #ifdef ENABLE_MCTF
577 // returns a pointer to start of argument with a number argn;
578 // if failes to find argn, returns NULL
ParseArgn(msdk_char * pIn,mfxU32 argn,msdk_char separator)579 msdk_char* ParseArgn(msdk_char* pIn, mfxU32 argn, msdk_char separator) {
580 msdk_char* pstr = pIn;
581 if (!argn)
582 return pIn;
583 else {
584 for (mfxU32 n = 0; n != argn; ++n) {
585 while (separator != *pstr && msdk_char('\0') != *pstr)
586 ++pstr;
587 if (msdk_char('\0') == *pstr)
588 return NULL;
589 else
590 ++pstr;
591 }
592 return pstr;
593 }
594 };
595
596 template <typename T>
ArgConvert(msdk_char * pIn,mfxU32 argn,const msdk_char * pattern,T * pArg,T ArgDefault,mfxU32 & NumOfGoodConverts)597 void ArgConvert(msdk_char* pIn,
598 mfxU32 argn,
599 const msdk_char* pattern,
600 T* pArg,
601 T ArgDefault,
602 mfxU32& NumOfGoodConverts) {
603 msdk_char* pargs = ParseArgn(pIn, argn, msdk_char(':'));
604 if (pargs) {
605 if (!msdk_sscanf(pargs, pattern, pArg))
606 *pArg = ArgDefault;
607 else
608 ++NumOfGoodConverts;
609 };
610 }
611
ParseMCTFParams(msdk_char * strInput[],mfxU8 nArgNum,mfxU8 & curArg,sInputParams * pParams,mfxU32 paramID)612 void ParseMCTFParams(msdk_char* strInput[],
613 mfxU8 nArgNum,
614 mfxU8& curArg,
615 sInputParams* pParams,
616 mfxU32 paramID) {
617 mfxU8& i = curArg;
618 if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-mctf"))) {
619 pParams->mctfParam[paramID].mode = VPP_FILTER_ENABLED_DEFAULT;
620 pParams->mctfParam[paramID].params.FilterStrength = 0;
621 #if defined ENABLE_MCTF_EXT
622 pParams->mctfParam[paramID].params.TemporalMode = MFX_MCTF_TEMPORAL_MODE_2REF; // default
623 pParams->mctfParam[paramID].params.BitsPerPixelx100k = 0;
624 pParams->mctfParam[paramID].params.Deblocking = MFX_CODINGOPTION_OFF;
625 pParams->mctfParam[paramID].params.Overlap = MFX_CODINGOPTION_OFF;
626 pParams->mctfParam[paramID].params.MVPrecision = MFX_MVPRECISION_INTEGER;
627 #endif
628
629 if (i + 1 < nArgNum) {
630 mfxU16 _strength(0);
631 mfxU32 strength_idx = 0;
632 mfxU32 ParsedArgsNumber = 0;
633
634 //the order of arguments is:
635 //Strength:ReferencesMode:BitsPerPixel:ME:Overlap:DB
636
637 ArgConvert(strInput[i + 1],
638 strength_idx,
639 MSDK_STRING("%hd:%*c"),
640 &_strength,
641 _strength,
642 ParsedArgsNumber);
643 #if defined ENABLE_MCTF_EXT
644 mfxU16 _refnum(MFX_MCTF_TEMPORAL_MODE_2REF);
645 mfxF64 _bitsperpixel(0.0);
646 mfxU16 _me_precision(0);
647 mfxU16 _overlap(0);
648 mfxU16 _deblock(0);
649
650 ArgConvert(strInput[i + 1],
651 1,
652 MSDK_STRING("%hd:%*c"),
653 &_refnum,
654 _refnum,
655 ParsedArgsNumber);
656 ArgConvert(strInput[i + 1],
657 2,
658 MSDK_STRING("%lf:%*c"),
659 &_bitsperpixel,
660 _bitsperpixel,
661 ParsedArgsNumber);
662 ArgConvert(strInput[i + 1],
663 3,
664 MSDK_STRING("%hd:%*c"),
665 &_me_precision,
666 _me_precision,
667 ParsedArgsNumber);
668 ArgConvert(strInput[i + 1],
669 4,
670 MSDK_STRING("%hd:%*c"),
671 &_overlap,
672 _overlap,
673 ParsedArgsNumber);
674 ArgConvert(strInput[i + 1],
675 5,
676 MSDK_STRING("%hd:%*c"),
677 &_deblock,
678 _deblock,
679 ParsedArgsNumber);
680 #endif
681 if (ParsedArgsNumber > 0) {
682 pParams->mctfParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
683 }
684 else {
685 pParams->mctfParam[paramID].mode = VPP_FILTER_ENABLED_DEFAULT;
686 msdk_printf(MSDK_STRING("MCTF works in default mode; no parameters are passed.\n"));
687 }
688 pParams->mctfParam[paramID].params.FilterStrength = _strength;
689 #if defined ENABLE_MCTF_EXT
690 pParams->mctfParam[paramID].params.BitsPerPixelx100k =
691 mfxU32(_bitsperpixel * MCTF_BITRATE_MULTIPLIER);
692 switch (_refnum) {
693 case 0:
694 pParams->mctfParam[paramID].params.TemporalMode =
695 MFX_MCTF_TEMPORAL_MODE_SPATIAL;
696 break;
697 case 1:
698 pParams->mctfParam[paramID].params.TemporalMode = MFX_MCTF_TEMPORAL_MODE_1REF;
699 break;
700 case 2:
701 pParams->mctfParam[paramID].params.TemporalMode = MFX_MCTF_TEMPORAL_MODE_2REF;
702 break;
703 case 3:
704 pParams->mctfParam[paramID].params.TemporalMode = MFX_MCTF_TEMPORAL_MODE_4REF;
705 break;
706 default:
707 pParams->mctfParam[paramID].params.TemporalMode =
708 MFX_MCTF_TEMPORAL_MODE_UNKNOWN;
709 };
710 switch (_deblock) {
711 case 0:
712 pParams->mctfParam[paramID].params.Deblocking = MFX_CODINGOPTION_OFF;
713 break;
714 case 1:
715 pParams->mctfParam[paramID].params.Deblocking = MFX_CODINGOPTION_ON;
716 break;
717 default:
718 pParams->mctfParam[paramID].params.Deblocking = MFX_CODINGOPTION_UNKNOWN;
719 };
720 switch (_overlap) {
721 case 0:
722 pParams->mctfParam[paramID].params.Overlap = MFX_CODINGOPTION_OFF;
723 break;
724 case 1:
725 pParams->mctfParam[paramID].params.Overlap = MFX_CODINGOPTION_ON;
726 break;
727 default:
728 pParams->mctfParam[paramID].params.Overlap = MFX_CODINGOPTION_UNKNOWN;
729 };
730 switch (_me_precision) {
731 case 0:
732 pParams->mctfParam[paramID].params.MVPrecision = MFX_MVPRECISION_INTEGER;
733 break;
734 case 1:
735 pParams->mctfParam[paramID].params.MVPrecision = MFX_MVPRECISION_QUARTERPEL;
736 break;
737 default:
738 pParams->mctfParam[paramID].params.MVPrecision = MFX_MVPRECISION_UNKNOWN;
739 };
740 #endif
741 if (ParsedArgsNumber)
742 i++;
743 }
744 else {
745 msdk_printf(MSDK_STRING("MCTF works in default mode; no parameters are passed.\n"));
746 }
747 }
748 }
749 #endif
750
vppParseResetPar(msdk_char * strInput[],mfxU8 nArgNum,mfxU8 & curArg,sInputParams * pParams,mfxU32 paramID,sFiltersParam * pDefaultFiltersParam)751 mfxStatus vppParseResetPar(msdk_char* strInput[],
752 mfxU8 nArgNum,
753 mfxU8& curArg,
754 sInputParams* pParams,
755 mfxU32 paramID,
756 sFiltersParam* pDefaultFiltersParam) {
757 MSDK_CHECK_POINTER(pParams, MFX_ERR_NULL_PTR);
758 MSDK_CHECK_POINTER(strInput, MFX_ERR_NULL_PTR);
759
760 sOwnFrameInfo info = pParams->frameInfoIn.back();
761 pParams->frameInfoIn.push_back(info);
762 info = pParams->frameInfoOut.back();
763 pParams->frameInfoOut.push_back(info);
764
765 pParams->deinterlaceParam.push_back(*pDefaultFiltersParam->pDIParam);
766 pParams->denoiseParam.push_back(*pDefaultFiltersParam->pDenoiseParam);
767 #ifdef ENABLE_MCTF
768 pParams->mctfParam.push_back(*pDefaultFiltersParam->pMctfParam);
769 #endif
770 pParams->detailParam.push_back(*pDefaultFiltersParam->pDetailParam);
771 pParams->procampParam.push_back(*pDefaultFiltersParam->pProcAmpParam);
772 pParams->frcParam.push_back(*pDefaultFiltersParam->pFRCParam);
773 pParams->multiViewParam.push_back(*pDefaultFiltersParam->pMultiViewParam);
774 pParams->gamutParam.push_back(*pDefaultFiltersParam->pGamutParam);
775 pParams->tccParam.push_back(*pDefaultFiltersParam->pClrSaturationParam);
776 pParams->aceParam.push_back(*pDefaultFiltersParam->pContrastParam);
777 pParams->steParam.push_back(*pDefaultFiltersParam->pSkinParam);
778 pParams->istabParam.push_back(*pDefaultFiltersParam->pImgStabParam);
779 pParams->videoSignalInfoParam.push_back(*pDefaultFiltersParam->pVideoSignalInfo);
780 pParams->mirroringParam.push_back(*pDefaultFiltersParam->pMirroringParam);
781 pParams->rotate.push_back(0);
782 pParams->colorfillParam.push_back(*pDefaultFiltersParam->pColorfillParam);
783
784 mfxU32 readData;
785 mfxU32 ioStatus;
786
787 for (mfxU8& i = curArg; i < nArgNum; i++) {
788 MSDK_CHECK_POINTER(strInput[i], MFX_ERR_NULL_PTR);
789 {
790 if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-o"))) {
791 VAL_CHECK(1 + i == nArgNum);
792 i++;
793
794 pParams->strDstFiles.push_back(strInput[i]);
795 pParams->isOutput = true;
796 }
797 //-----------------------------------------------------------------------------------
798 // Video Enhancement Algorithms
799 //-----------------------------------------------------------------------------------
800 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ssinr"))) {
801 VAL_CHECK(1 + i == nArgNum);
802
803 pParams->videoSignalInfoParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
804
805 i++;
806 msdk_sscanf(strInput[i],
807 MSDK_STRING("%hu"),
808 &pParams->videoSignalInfoParam[paramID].In.NominalRange);
809 }
810 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dsinr"))) {
811 VAL_CHECK(1 + i == nArgNum);
812
813 pParams->videoSignalInfoParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
814
815 i++;
816 msdk_sscanf(strInput[i],
817 MSDK_STRING("%hu"),
818 &pParams->videoSignalInfoParam[paramID].Out.NominalRange);
819 }
820 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ssitm"))) {
821 VAL_CHECK(1 + i == nArgNum);
822
823 pParams->videoSignalInfoParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
824
825 i++;
826 msdk_sscanf(strInput[i],
827 MSDK_STRING("%hu"),
828 &pParams->videoSignalInfoParam[paramID].In.TransferMatrix);
829 }
830 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dsitm"))) {
831 VAL_CHECK(1 + i == nArgNum);
832
833 pParams->videoSignalInfoParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
834
835 i++;
836 msdk_sscanf(strInput[i],
837 MSDK_STRING("%hu"),
838 &pParams->videoSignalInfoParam[paramID].Out.TransferMatrix);
839 }
840 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-mirror"))) {
841 VAL_CHECK(1 + i == nArgNum);
842
843 pParams->mirroringParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
844
845 i++;
846 msdk_sscanf(strInput[i],
847 MSDK_STRING("%hu"),
848 &pParams->mirroringParam[paramID].Type);
849 }
850 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sw"))) {
851 VAL_CHECK(1 + i == nArgNum);
852 i++;
853 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoIn.back().nWidth);
854 }
855 else if (0 == msdk_stricmp(strInput[i], MSDK_STRING("-dw"))) {
856 VAL_CHECK(1 + i == nArgNum);
857 i++;
858 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoOut.back().nWidth);
859 }
860 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sh"))) {
861 VAL_CHECK(1 + i == nArgNum);
862 i++;
863 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoIn.back().nHeight);
864 }
865 else if (0 == msdk_stricmp(strInput[i], MSDK_STRING("-dh"))) {
866 VAL_CHECK(1 + i == nArgNum);
867 i++;
868 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoOut.back().nHeight);
869 }
870 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-denoise"))) {
871 pParams->denoiseParam[paramID].mode = VPP_FILTER_ENABLED_DEFAULT;
872
873 if (i + 1 < nArgNum) {
874 ioStatus = msdk_sscanf(strInput[i + 1],
875 MSDK_STRING("%hd"),
876 reinterpret_cast<short int*>(&readData));
877 if (ioStatus > 0) {
878 pParams->denoiseParam[paramID].factor = (mfxU16)readData;
879 pParams->denoiseParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
880 i++;
881 }
882 ioStatus = msdk_sscanf(strInput[i + 1],
883 MSDK_STRING("%hd"),
884 reinterpret_cast<short int*>(&readData));
885 if (ioStatus > 0) {
886 pParams->denoiseParam[paramID].config = (mfxU16)readData;
887 pParams->denoiseParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
888 i++;
889 }
890 }
891 }
892 #ifdef ENABLE_MCTF
893 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-mctf"))) {
894 ParseMCTFParams(strInput, nArgNum, i, pParams, paramID);
895 }
896
897 #endif
898 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-di_mode"))) {
899 pParams->deinterlaceParam[paramID].mode = VPP_FILTER_ENABLED_DEFAULT;
900
901 if (i + 1 < nArgNum) {
902 ioStatus = msdk_sscanf(strInput[i + 1],
903 MSDK_STRING("%hd"),
904 reinterpret_cast<short int*>(&readData));
905 if (ioStatus > 0) {
906 pParams->deinterlaceParam[paramID].algorithm = (mfxU16)readData;
907 pParams->deinterlaceParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
908 i++;
909 }
910 }
911 }
912 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tc_pattern"))) {
913 if (i + 1 < nArgNum) {
914 ioStatus = msdk_sscanf(strInput[i + 1],
915 MSDK_STRING("%hd"),
916 reinterpret_cast<short int*>(&readData));
917 if (ioStatus > 0) {
918 pParams->deinterlaceParam[paramID].tc_pattern = (mfxU16)readData;
919 i++;
920 }
921 }
922 }
923 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tc_pos"))) {
924 //pParams->deinterlaceParam.mode = VPP_FILTER_ENABLED_DEFAULT;
925
926 if (i + 1 < nArgNum) {
927 ioStatus = msdk_sscanf(strInput[i + 1],
928 MSDK_STRING("%hd"),
929 reinterpret_cast<short int*>(&readData));
930 if (ioStatus > 0) {
931 pParams->deinterlaceParam[paramID].tc_pos = (mfxU16)readData;
932 i++;
933 }
934 }
935 }
936 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-detail"))) {
937 pParams->detailParam[paramID].mode = VPP_FILTER_ENABLED_DEFAULT;
938
939 if (i + 1 < nArgNum) {
940 ioStatus = msdk_sscanf(strInput[i + 1],
941 MSDK_STRING("%hd"),
942 reinterpret_cast<short int*>(&readData));
943 if (ioStatus > 0) {
944 pParams->detailParam[paramID].factor = (mfxU16)readData;
945 pParams->detailParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
946 i++;
947 }
948 }
949 }
950 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rotate"))) {
951 VAL_CHECK(1 + i == nArgNum);
952 i++;
953 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->rotate[paramID]);
954 }
955 // different modes of MFX FRC
956 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-frc:advanced"))) {
957 pParams->frcParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
958 pParams->frcParam[paramID].algorithm = MFX_FRCALGM_DISTRIBUTED_TIMESTAMP;
959 }
960 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-frc:interp"))) {
961 pParams->frcParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
962 pParams->frcParam[paramID].algorithm = MFX_FRCALGM_FRAME_INTERPOLATION;
963 }
964 //---------------------------------------------
965 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pa_hue"))) {
966 pParams->procampParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
967 i++;
968 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->procampParam[paramID].hue);
969 }
970 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pa_bri"))) {
971 pParams->procampParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
972 i++;
973 msdk_sscanf(strInput[i],
974 MSDK_STRING("%lf"),
975 &pParams->procampParam[paramID].brightness);
976 }
977 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pa_con"))) {
978 pParams->procampParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
979 i++;
980 msdk_sscanf(strInput[i],
981 MSDK_STRING("%lf"),
982 &pParams->procampParam[paramID].contrast);
983 }
984 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pa_sat"))) {
985 pParams->procampParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
986 i++;
987 msdk_sscanf(strInput[i],
988 MSDK_STRING("%lf"),
989 &pParams->procampParam[paramID].saturation);
990 }
991 #ifdef ENABLE_VPP_RUNTIME_HSBC
992 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rt_hue"))) {
993 VAL_CHECK(1 + i == nArgNum);
994 i++;
995 msdk_sscanf(strInput[i], MSDK_STRING("%u"), &pParams->rtHue.interval);
996 VAL_CHECK(1 + i == nArgNum);
997 i++;
998 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtHue.value1);
999 VAL_CHECK(1 + i == nArgNum);
1000 i++;
1001 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtHue.value2);
1002 pParams->rtHue.isEnabled = true;
1003 }
1004 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rt_bri"))) {
1005 VAL_CHECK(1 + i == nArgNum);
1006 i++;
1007 msdk_sscanf(strInput[i], MSDK_STRING("%u"), &pParams->rtBrightness.interval);
1008 VAL_CHECK(1 + i == nArgNum);
1009 i++;
1010 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtBrightness.value1);
1011 VAL_CHECK(1 + i == nArgNum);
1012 i++;
1013 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtBrightness.value2);
1014 pParams->rtBrightness.isEnabled = true;
1015 }
1016 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rt_con"))) {
1017 VAL_CHECK(1 + i == nArgNum);
1018 i++;
1019 msdk_sscanf(strInput[i], MSDK_STRING("%u"), &pParams->rtContrast.interval);
1020 VAL_CHECK(1 + i == nArgNum);
1021 i++;
1022 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtContrast.value1);
1023 VAL_CHECK(1 + i == nArgNum);
1024 i++;
1025 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtContrast.value2);
1026 pParams->rtContrast.isEnabled = true;
1027 }
1028 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rt_sat"))) {
1029 VAL_CHECK(1 + i == nArgNum);
1030 i++;
1031 msdk_sscanf(strInput[i], MSDK_STRING("%u"), &pParams->rtSaturation.interval);
1032 VAL_CHECK(1 + i == nArgNum);
1033 i++;
1034 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtSaturation.value1);
1035 VAL_CHECK(1 + i == nArgNum);
1036 i++;
1037 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtSaturation.value2);
1038 pParams->rtSaturation.isEnabled = true;
1039 }
1040 #endif
1041 //MSDK 3.0
1042 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gamut:compression"))) {
1043 pParams->gamutParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
1044 }
1045 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gamut:bt709"))) {
1046 pParams->gamutParam[paramID].bBT709 = true;
1047 }
1048 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-view:count"))) {
1049 VAL_CHECK(1 + i == nArgNum);
1050 i++;
1051
1052 mfxU16 viewCount;
1053 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &viewCount);
1054 if (viewCount > 1) {
1055 pParams->multiViewParam[paramID].viewCount = (mfxU16)viewCount;
1056 pParams->multiViewParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
1057 }
1058 }
1059 //---------------------------------------------
1060 // MSDK API 1.5
1061 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-istab"))) {
1062 pParams->istabParam[paramID].mode = VPP_FILTER_ENABLED_DEFAULT;
1063
1064 if (i + 1 < nArgNum) {
1065 ioStatus = msdk_sscanf(strInput[i + 1],
1066 MSDK_STRING("%hd"),
1067 reinterpret_cast<short int*>(&readData));
1068 if (ioStatus > 0) {
1069 pParams->istabParam[paramID].istabMode = (mfxU8)readData;
1070 pParams->istabParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
1071 i++;
1072
1073 if (pParams->istabParam[paramID].istabMode != 1 &&
1074 pParams->istabParam[paramID].istabMode != 2) {
1075 vppPrintHelp(strInput[0], MSDK_STRING("Invalid IStab configuration"));
1076 return MFX_ERR_UNSUPPORTED;
1077 }
1078 }
1079 }
1080 }
1081 //---------------------------------------------
1082 // IECP
1083 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ace"))) {
1084 pParams->aceParam[paramID].mode = VPP_FILTER_ENABLED_DEFAULT;
1085 }
1086 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ste"))) {
1087 pParams->steParam[paramID].mode = VPP_FILTER_ENABLED_DEFAULT;
1088
1089 if (i + 1 < nArgNum) {
1090 ioStatus = msdk_sscanf(strInput[i + 1],
1091 MSDK_STRING("%hd"),
1092 reinterpret_cast<short int*>(&readData));
1093 if (ioStatus > 0) {
1094 pParams->steParam[paramID].SkinToneFactor = (mfxU8)readData;
1095 pParams->steParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
1096 i++;
1097 }
1098 }
1099 }
1100 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:red"))) {
1101 pParams->tccParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
1102 i++;
1103 msdk_sscanf(strInput[i],
1104 MSDK_STRING("%lf"),
1105 reinterpret_cast<double*>(&pParams->tccParam[paramID].Red));
1106 }
1107 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:green"))) {
1108 pParams->tccParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
1109 i++;
1110 msdk_sscanf(strInput[i],
1111 MSDK_STRING("%lf"),
1112 reinterpret_cast<double*>(&pParams->tccParam[paramID].Green));
1113 }
1114 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:blue"))) {
1115 pParams->tccParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
1116 i++;
1117 msdk_sscanf(strInput[i],
1118 MSDK_STRING("%lf"),
1119 reinterpret_cast<double*>(&pParams->tccParam[paramID].Blue));
1120 }
1121 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:magenta"))) {
1122 pParams->tccParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
1123 i++;
1124 msdk_sscanf(strInput[i],
1125 MSDK_STRING("%lf"),
1126 reinterpret_cast<double*>(&pParams->tccParam[paramID].Magenta));
1127 }
1128 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:yellow"))) {
1129 pParams->tccParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
1130 i++;
1131 msdk_sscanf(strInput[i],
1132 MSDK_STRING("%lf"),
1133 reinterpret_cast<double*>(&pParams->tccParam[paramID].Yellow));
1134 }
1135 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:cyan"))) {
1136 pParams->tccParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
1137 i++;
1138 msdk_sscanf(strInput[i],
1139 MSDK_STRING("%lf"),
1140 reinterpret_cast<double*>(&pParams->tccParam[paramID].Cyan));
1141 }
1142 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-reset_end"))) {
1143 break;
1144 }
1145 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cf_disable"))) {
1146 pParams->colorfillParam[paramID].mode = VPP_FILTER_ENABLED_CONFIGURED;
1147 pParams->colorfillParam[paramID].Enable = MFX_CODINGOPTION_OFF;
1148 }
1149 else {
1150 msdk_printf(MSDK_STRING("Unknow reset option: %s\n"), strInput[i]);
1151
1152 return MFX_ERR_UNKNOWN;
1153 }
1154 }
1155 }
1156
1157 return MFX_ERR_NONE;
1158
1159 } // mfxStatus vppParseResetPar( ... )
1160
AdjustBitDepth(sInputParams & params)1161 void AdjustBitDepth(sInputParams& params) {
1162 if (params.frameInfoIn[0].BitDepthLuma != 0 || params.frameInfoIn[0].BitDepthChroma != 0) {
1163 if (params.frameInfoIn[0].BitDepthLuma == 0) {
1164 params.frameInfoIn[0].BitDepthLuma = params.frameInfoIn[0].BitDepthChroma;
1165 msdk_printf(
1166 MSDK_STRING(
1167 "Warning: input BitDepthLuma was defaulted to value which was set to BitDepthChroma (%d)."),
1168 params.frameInfoIn[0].BitDepthLuma);
1169 }
1170
1171 if (params.frameInfoIn[0].BitDepthChroma == 0) {
1172 params.frameInfoIn[0].BitDepthChroma = params.frameInfoIn[0].BitDepthLuma;
1173 msdk_printf(
1174 MSDK_STRING(
1175 "Warning: input BitDepthChroma was defaulted to value which was set to BitDepthLuma (%d)."),
1176 params.frameInfoIn[0].BitDepthChroma);
1177 }
1178 }
1179
1180 if (params.frameInfoOut[0].BitDepthLuma != 0 || params.frameInfoOut[0].BitDepthChroma != 0) {
1181 if (params.frameInfoOut[0].BitDepthLuma == 0) {
1182 params.frameInfoOut[0].BitDepthLuma = params.frameInfoOut[0].BitDepthChroma;
1183 msdk_printf(
1184 MSDK_STRING(
1185 "Warning: output BitDepthLuma was defaulted to value which was set to BitDepthChroma (%d)."),
1186 params.frameInfoOut[0].BitDepthLuma);
1187 }
1188
1189 if (params.frameInfoOut[0].BitDepthChroma == 0) {
1190 params.frameInfoOut[0].BitDepthChroma = params.frameInfoOut[0].BitDepthLuma;
1191 msdk_printf(
1192 MSDK_STRING(
1193 "Warning: output BitDepthChroma was defaulted to value which was set to BitDepthLuma (%d)."),
1194 params.frameInfoOut[0].BitDepthChroma);
1195 }
1196 }
1197 }
1198
vppParseInputString(msdk_char * strInput[],mfxU8 nArgNum,sInputParams * pParams,sFiltersParam * pDefaultFiltersParam)1199 mfxStatus vppParseInputString(msdk_char* strInput[],
1200 mfxU8 nArgNum,
1201 sInputParams* pParams,
1202 sFiltersParam* pDefaultFiltersParam) {
1203 MSDK_CHECK_POINTER(pParams, MFX_ERR_NULL_PTR);
1204 MSDK_CHECK_POINTER(strInput, MFX_ERR_NULL_PTR);
1205
1206 mfxU32 readData;
1207 mfxU32 ioStatus;
1208 if (nArgNum < 4) {
1209 vppPrintHelp(strInput[0], MSDK_STRING("Not enough parameters"));
1210
1211 return MFX_ERR_MORE_DATA;
1212 }
1213
1214 pParams->frameInfoIn.back().CropX = 0;
1215 pParams->frameInfoIn.back().CropY = 0;
1216 pParams->frameInfoIn.back().CropW = NOT_INIT_VALUE;
1217 pParams->frameInfoIn.back().CropH = NOT_INIT_VALUE;
1218 // zeroize destination crops
1219 pParams->frameInfoOut.back().CropX = 0;
1220 pParams->frameInfoOut.back().CropY = 0;
1221 pParams->frameInfoOut.back().CropW = NOT_INIT_VALUE;
1222 pParams->frameInfoOut.back().CropH = NOT_INIT_VALUE;
1223 pParams->numStreams = 1;
1224
1225 for (mfxU8 i = 1; i < nArgNum; i++) {
1226 MSDK_CHECK_POINTER(strInput[i], MFX_ERR_NULL_PTR);
1227 {
1228 if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ssinr"))) {
1229 VAL_CHECK(1 + i == nArgNum);
1230
1231 pParams->videoSignalInfoParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1232
1233 i++;
1234 msdk_sscanf(strInput[i],
1235 MSDK_STRING("%hu"),
1236 &pParams->videoSignalInfoParam[0].In.NominalRange);
1237 }
1238 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dsinr"))) {
1239 VAL_CHECK(1 + i == nArgNum);
1240
1241 pParams->videoSignalInfoParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1242
1243 i++;
1244 msdk_sscanf(strInput[i],
1245 MSDK_STRING("%hu"),
1246 &pParams->videoSignalInfoParam[0].Out.NominalRange);
1247 }
1248 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ssitm"))) {
1249 VAL_CHECK(1 + i == nArgNum);
1250
1251 pParams->videoSignalInfoParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1252
1253 i++;
1254 msdk_sscanf(strInput[i],
1255 MSDK_STRING("%hu"),
1256 &pParams->videoSignalInfoParam[0].In.TransferMatrix);
1257 }
1258 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dsitm"))) {
1259 VAL_CHECK(1 + i == nArgNum);
1260
1261 pParams->videoSignalInfoParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1262
1263 i++;
1264 msdk_sscanf(strInput[i],
1265 MSDK_STRING("%hu"),
1266 &pParams->videoSignalInfoParam[0].Out.TransferMatrix);
1267 }
1268 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-mirror"))) {
1269 VAL_CHECK(1 + i == nArgNum);
1270
1271 pParams->mirroringParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1272
1273 i++;
1274 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->mirroringParam[0].Type);
1275 }
1276 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sw"))) {
1277 VAL_CHECK(1 + i == nArgNum);
1278 i++;
1279 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoIn[0].nWidth);
1280 }
1281 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sh"))) {
1282 VAL_CHECK(1 + i == nArgNum);
1283 i++;
1284 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoIn[0].nHeight);
1285 }
1286 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-scrX"))) {
1287 VAL_CHECK(1 + i == nArgNum);
1288 i++;
1289 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoIn[0].CropX);
1290 }
1291 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-scrY"))) {
1292 VAL_CHECK(1 + i == nArgNum);
1293 i++;
1294 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoIn[0].CropY);
1295 }
1296 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-scrW"))) {
1297 VAL_CHECK(1 + i == nArgNum);
1298 i++;
1299 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoIn[0].CropW);
1300 }
1301 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-scrH"))) {
1302 VAL_CHECK(1 + i == nArgNum);
1303 i++;
1304 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoIn[0].CropH);
1305 }
1306 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-spic"))) {
1307 VAL_CHECK(1 + i == nArgNum);
1308 i++;
1309 mfxI16 tmp;
1310 msdk_sscanf(strInput[i], MSDK_STRING("%hd"), reinterpret_cast<short int*>(&tmp));
1311 pParams->frameInfoIn[0].PicStruct = GetPicStruct(static_cast<mfxI8>(tmp));
1312 }
1313 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sf"))) {
1314 VAL_CHECK(1 + i == nArgNum);
1315 i++;
1316 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->frameInfoIn[0].dFrameRate);
1317 }
1318 else if (0 == msdk_stricmp(strInput[i], MSDK_STRING("-dw"))) {
1319 VAL_CHECK(1 + i == nArgNum);
1320 i++;
1321 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoOut[0].nWidth);
1322 }
1323 else if (0 == msdk_stricmp(strInput[i], MSDK_STRING("-dh"))) {
1324 VAL_CHECK(1 + i == nArgNum);
1325 i++;
1326 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoOut[0].nHeight);
1327 }
1328 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dcrX"))) {
1329 VAL_CHECK(1 + i == nArgNum);
1330 i++;
1331 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoOut[0].CropX);
1332 }
1333 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dcrY"))) {
1334 VAL_CHECK(1 + i == nArgNum);
1335 i++;
1336 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoOut[0].CropY);
1337 }
1338 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dcrW"))) {
1339 VAL_CHECK(1 + i == nArgNum);
1340 i++;
1341 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoOut[0].CropW);
1342 }
1343 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dcrH"))) {
1344 VAL_CHECK(1 + i == nArgNum);
1345 i++;
1346 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoOut[0].CropH);
1347 }
1348 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dpic"))) {
1349 VAL_CHECK(1 + i == nArgNum);
1350 i++;
1351 mfxI16 tmp;
1352 msdk_sscanf(strInput[i], MSDK_STRING("%hd"), reinterpret_cast<short int*>(&tmp));
1353 pParams->frameInfoOut[0].PicStruct = GetPicStruct(static_cast<mfxI8>(tmp));
1354 }
1355 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-df"))) {
1356 VAL_CHECK(1 + i == nArgNum);
1357 i++;
1358 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->frameInfoOut[0].dFrameRate);
1359 }
1360 //-----------------------------------------------------------------------------------
1361 // Video Enhancement Algorithms
1362 //-----------------------------------------------------------------------------------
1363 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-denoise"))) {
1364 pParams->denoiseParam[0].mode = VPP_FILTER_ENABLED_DEFAULT;
1365
1366 if (i + 1 < nArgNum) {
1367 ioStatus = msdk_sscanf(strInput[i + 1],
1368 MSDK_STRING("%hd"),
1369 reinterpret_cast<short int*>(&readData));
1370 if (ioStatus > 0) {
1371 pParams->denoiseParam[0].factor = (mfxU16)readData;
1372 pParams->denoiseParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1373 i++;
1374 }
1375 ioStatus = msdk_sscanf(strInput[i + 1],
1376 MSDK_STRING("%hd"),
1377 reinterpret_cast<short int*>(&readData));
1378 if (ioStatus > 0) {
1379 pParams->denoiseParam[0].config = (mfxU16)readData;
1380 pParams->denoiseParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1381 i++;
1382 }
1383 }
1384 }
1385 #ifdef ENABLE_MCTF
1386 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-mctf"))) {
1387 ParseMCTFParams(strInput, nArgNum, i, pParams, 0);
1388 }
1389 #endif
1390
1391 // aya: altenative and simple way to enable deinterlace
1392 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-deinterlace"))) {
1393 pParams->frameInfoOut[0].PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
1394 pParams->frameInfoIn[0].PicStruct = MFX_PICSTRUCT_FIELD_TFF;
1395
1396 if (i + 1 < nArgNum) {
1397 if (0 == msdk_strcmp(strInput[i + 1], MSDK_STRING("bff"))) {
1398 pParams->frameInfoOut[0].PicStruct = MFX_PICSTRUCT_FIELD_BFF;
1399 i++;
1400 }
1401 }
1402 }
1403 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-di_mode"))) {
1404 pParams->deinterlaceParam[0].mode = VPP_FILTER_ENABLED_DEFAULT;
1405
1406 if (i + 1 < nArgNum) {
1407 ioStatus = msdk_sscanf(strInput[i + 1],
1408 MSDK_STRING("%hd"),
1409 reinterpret_cast<short int*>(&readData));
1410 if (ioStatus > 0) {
1411 pParams->deinterlaceParam[0].algorithm = (mfxU16)readData;
1412 pParams->deinterlaceParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1413 i++;
1414 }
1415 }
1416 }
1417 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tc_pattern"))) {
1418 if (i + 1 < nArgNum) {
1419 ioStatus = msdk_sscanf(strInput[i + 1],
1420 MSDK_STRING("%hd"),
1421 reinterpret_cast<short int*>(&readData));
1422 if (ioStatus > 0) {
1423 pParams->deinterlaceParam[0].tc_pattern = (mfxU16)readData;
1424 i++;
1425 }
1426 }
1427 }
1428 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tc_pos"))) {
1429 //pParams->deinterlaceParam.mode = VPP_FILTER_ENABLED_DEFAULT;
1430
1431 if (i + 1 < nArgNum) {
1432 ioStatus = msdk_sscanf(strInput[i + 1],
1433 MSDK_STRING("%hd"),
1434 reinterpret_cast<short int*>(&readData));
1435 if (ioStatus > 0) {
1436 pParams->deinterlaceParam[0].tc_pos = (mfxU16)readData;
1437 i++;
1438 }
1439 }
1440 }
1441 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-detail"))) {
1442 pParams->detailParam[0].mode = VPP_FILTER_ENABLED_DEFAULT;
1443
1444 if (i + 1 < nArgNum) {
1445 ioStatus = msdk_sscanf(strInput[i + 1],
1446 MSDK_STRING("%hd"),
1447 reinterpret_cast<short int*>(&readData));
1448 if (ioStatus > 0) {
1449 pParams->detailParam[0].factor = (mfxU16)readData;
1450 pParams->detailParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1451 i++;
1452 }
1453 }
1454 }
1455 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rotate"))) {
1456 VAL_CHECK(1 + i == nArgNum);
1457 i++;
1458 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->rotate[0]);
1459 }
1460 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-scaling_mode"))) {
1461 VAL_CHECK(1 + i == nArgNum);
1462 i++;
1463 pParams->bScaling = true;
1464 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->scalingMode);
1465 }
1466 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-interpolation_method"))) {
1467 VAL_CHECK(1 + i == nArgNum);
1468 i++;
1469 pParams->bScaling = true;
1470 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->interpolationMethod);
1471 }
1472 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-chroma_siting"))) {
1473 VAL_CHECK(2 + i == nArgNum);
1474 bool bVfound = false;
1475 bool bHfound = false;
1476 i++;
1477 for (int ii = 0; ii < 2; ii++) {
1478 /* ChromaSiting */
1479 if (msdk_strcmp(strInput[i + ii], MSDK_STRING("vtop")) == 0) {
1480 pParams->uChromaSiting |= MFX_CHROMA_SITING_VERTICAL_TOP;
1481 bVfound = true;
1482 }
1483 else if (msdk_strcmp(strInput[i + ii], MSDK_STRING("vcen")) == 0) {
1484 pParams->uChromaSiting |= MFX_CHROMA_SITING_VERTICAL_CENTER;
1485 bVfound = true;
1486 }
1487 else if (msdk_strcmp(strInput[i + ii], MSDK_STRING("vbot")) == 0) {
1488 pParams->uChromaSiting |= MFX_CHROMA_SITING_VERTICAL_BOTTOM;
1489 bVfound = true;
1490 }
1491 else if (msdk_strcmp(strInput[i + ii], MSDK_STRING("hleft")) == 0) {
1492 pParams->uChromaSiting |= MFX_CHROMA_SITING_HORIZONTAL_LEFT;
1493 bHfound = true;
1494 }
1495 else if (msdk_strcmp(strInput[i + ii], MSDK_STRING("hcen")) == 0) {
1496 pParams->uChromaSiting |= MFX_CHROMA_SITING_HORIZONTAL_CENTER;
1497 bHfound = true;
1498 }
1499 else
1500 msdk_printf(MSDK_STRING("Unknown Chroma siting flag %s"), strInput[i + ii]);
1501 }
1502 pParams->bChromaSiting = bVfound && bHfound;
1503 if (!pParams->bChromaSiting) {
1504 vppPrintHelp(strInput[0], MSDK_STRING("Invalid chroma siting flags\n"));
1505 return MFX_ERR_UNSUPPORTED;
1506 }
1507 i++;
1508 }
1509 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-composite"))) {
1510 if (i + 1 < nArgNum) {
1511 if (ParseCompositionParfile(strInput[i + 1], pParams) != MFX_ERR_NONE) {
1512 vppPrintHelp(
1513 strInput[0],
1514 MSDK_STRING(
1515 "Parfile for -composite has invalid data or cannot be opened\n"));
1516 return MFX_ERR_UNSUPPORTED;
1517 }
1518 pParams->compositionParam.mode = VPP_FILTER_ENABLED_CONFIGURED;
1519 i++;
1520 }
1521 }
1522 // different modes of MFX FRC
1523 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-frc:advanced"))) {
1524 pParams->frcParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1525 pParams->frcParam[0].algorithm = MFX_FRCALGM_DISTRIBUTED_TIMESTAMP;
1526 }
1527 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-frc:interp"))) {
1528 pParams->frcParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1529 pParams->frcParam[0].algorithm = MFX_FRCALGM_FRAME_INTERPOLATION;
1530 }
1531 //---------------------------------------------
1532 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pa_hue"))) {
1533 pParams->procampParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1534 i++;
1535 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->procampParam[0].hue);
1536 }
1537 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pa_bri"))) {
1538 pParams->procampParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1539 i++;
1540 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->procampParam[0].brightness);
1541 }
1542 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pa_con"))) {
1543 pParams->procampParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1544 i++;
1545 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->procampParam[0].contrast);
1546 }
1547 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pa_sat"))) {
1548 pParams->procampParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1549 i++;
1550 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->procampParam[0].saturation);
1551 }
1552 #ifdef ENABLE_VPP_RUNTIME_HSBC
1553 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rt_hue"))) {
1554 VAL_CHECK(1 + i == nArgNum);
1555 i++;
1556 msdk_sscanf(strInput[i], MSDK_STRING("%u"), &pParams->rtHue.interval);
1557 VAL_CHECK(1 + i == nArgNum);
1558 i++;
1559 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtHue.value1);
1560 VAL_CHECK(1 + i == nArgNum);
1561 i++;
1562 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtHue.value2);
1563 pParams->rtHue.isEnabled = true;
1564 }
1565 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rt_bri"))) {
1566 VAL_CHECK(1 + i == nArgNum);
1567 i++;
1568 msdk_sscanf(strInput[i], MSDK_STRING("%u"), &pParams->rtBrightness.interval);
1569 VAL_CHECK(1 + i == nArgNum);
1570 i++;
1571 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtBrightness.value1);
1572 VAL_CHECK(1 + i == nArgNum);
1573 i++;
1574 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtBrightness.value2);
1575 pParams->rtBrightness.isEnabled = true;
1576 }
1577 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rt_con"))) {
1578 VAL_CHECK(1 + i == nArgNum);
1579 i++;
1580 msdk_sscanf(strInput[i], MSDK_STRING("%u"), &pParams->rtContrast.interval);
1581 VAL_CHECK(1 + i == nArgNum);
1582 i++;
1583 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtContrast.value1);
1584 VAL_CHECK(1 + i == nArgNum);
1585 i++;
1586 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtContrast.value2);
1587 pParams->rtContrast.isEnabled = true;
1588 }
1589 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rt_sat"))) {
1590 VAL_CHECK(1 + i == nArgNum);
1591 i++;
1592 msdk_sscanf(strInput[i], MSDK_STRING("%u"), &pParams->rtSaturation.interval);
1593 VAL_CHECK(1 + i == nArgNum);
1594 i++;
1595 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtSaturation.value1);
1596 VAL_CHECK(1 + i == nArgNum);
1597 i++;
1598 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->rtSaturation.value2);
1599 pParams->rtSaturation.isEnabled = true;
1600 }
1601 #endif
1602
1603 //MSDK 3.0
1604 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gamut:compression"))) {
1605 pParams->gamutParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1606 }
1607 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gamut:bt709"))) {
1608 pParams->gamutParam[0].bBT709 = true;
1609 }
1610 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-view:count"))) {
1611 VAL_CHECK(1 + i == nArgNum);
1612 i++;
1613
1614 mfxU16 viewCount;
1615 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &viewCount);
1616 if (viewCount > 1) {
1617 pParams->multiViewParam[0].viewCount = (mfxU16)viewCount;
1618 pParams->multiViewParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1619 }
1620 }
1621 //---------------------------------------------
1622 // MSDK API 1.5
1623 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-istab"))) {
1624 pParams->istabParam[0].mode = VPP_FILTER_ENABLED_DEFAULT;
1625
1626 if (i + 1 < nArgNum) {
1627 ioStatus = msdk_sscanf(strInput[i + 1],
1628 MSDK_STRING("%hd"),
1629 reinterpret_cast<short int*>(&readData));
1630 if (ioStatus > 0) {
1631 pParams->istabParam[0].istabMode = (mfxU8)readData;
1632 pParams->istabParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1633 i++;
1634
1635 if (pParams->istabParam[0].istabMode != 1 &&
1636 pParams->istabParam[0].istabMode != 2) {
1637 vppPrintHelp(strInput[0], MSDK_STRING("Invalid IStab configuration"));
1638 return MFX_ERR_UNSUPPORTED;
1639 }
1640 }
1641 }
1642 }
1643 //---------------------------------------------
1644 // IECP
1645 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ace"))) {
1646 pParams->aceParam[0].mode = VPP_FILTER_ENABLED_DEFAULT;
1647 }
1648 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ste"))) {
1649 pParams->steParam[0].mode = VPP_FILTER_ENABLED_DEFAULT;
1650
1651 if (i + 1 < nArgNum) {
1652 ioStatus = msdk_sscanf(strInput[i + 1],
1653 MSDK_STRING("%hd"),
1654 reinterpret_cast<short int*>(&readData));
1655 if (ioStatus > 0) {
1656 pParams->steParam[0].SkinToneFactor = (mfxU8)readData;
1657 pParams->steParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1658 i++;
1659 }
1660 }
1661 }
1662 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:red"))) {
1663 pParams->tccParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1664 i++;
1665 msdk_sscanf(strInput[i],
1666 MSDK_STRING("%lf"),
1667 reinterpret_cast<double*>(&pParams->tccParam[0].Red));
1668 }
1669 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:green"))) {
1670 pParams->tccParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1671 i++;
1672 msdk_sscanf(strInput[i],
1673 MSDK_STRING("%lf"),
1674 reinterpret_cast<double*>(&pParams->tccParam[0].Green));
1675 }
1676 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:blue"))) {
1677 pParams->tccParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1678 i++;
1679 msdk_sscanf(strInput[i],
1680 MSDK_STRING("%lf"),
1681 reinterpret_cast<double*>(&pParams->tccParam[0].Blue));
1682 }
1683 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:magenta"))) {
1684 pParams->tccParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1685 i++;
1686 msdk_sscanf(strInput[i],
1687 MSDK_STRING("%lf"),
1688 reinterpret_cast<double*>(&pParams->tccParam[0].Magenta));
1689 }
1690 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:yellow"))) {
1691 pParams->tccParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1692 i++;
1693 msdk_sscanf(strInput[i],
1694 MSDK_STRING("%lf"),
1695 reinterpret_cast<double*>(&pParams->tccParam[0].Yellow));
1696 }
1697 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc:cyan"))) {
1698 pParams->tccParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
1699 i++;
1700 msdk_sscanf(strInput[i],
1701 MSDK_STRING("%lf"),
1702 reinterpret_cast<double*>(&pParams->tccParam[0].Cyan));
1703 }
1704 //-----------------------------------------------------------------------------------
1705 // Region of Interest Testing
1706 //-----------------------------------------------------------------------------------
1707 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-roi_check"))) {
1708 VAL_CHECK(1 + i == nArgNum);
1709 i++;
1710 pParams->roiCheckParam.mode = Str2ROIMode(strInput[i]);
1711
1712 VAL_CHECK(1 + i == nArgNum);
1713 i++;
1714 msdk_sscanf(strInput[i],
1715 MSDK_STRING("%hd"),
1716 reinterpret_cast<short int*>(&pParams->roiCheckParam.srcSeed));
1717
1718 VAL_CHECK(1 + i == nArgNum);
1719 i++;
1720 msdk_sscanf(strInput[i],
1721 MSDK_STRING("%hd"),
1722 reinterpret_cast<short int*>(&pParams->roiCheckParam.dstSeed));
1723 }
1724 //-----------------------------------------------------------------------------------
1725 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-i"))) {
1726 VAL_CHECK(1 + i == nArgNum);
1727 i++;
1728 msdk_strncopy_s(pParams->strSrcFile,
1729 MSDK_MAX_FILENAME_LEN,
1730 strInput[i],
1731 MSDK_MAX_FILENAME_LEN - 1);
1732 pParams->strSrcFile[MSDK_MAX_FILENAME_LEN - 1] = 0;
1733 }
1734 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-o"))) {
1735 VAL_CHECK(1 + i == nArgNum);
1736 i++;
1737
1738 pParams->strDstFiles.push_back(strInput[i]);
1739 pParams->isOutput = true;
1740 }
1741 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pf"))) {
1742 VAL_CHECK(1 + i == nArgNum);
1743 i++;
1744 msdk_strncopy_s(pParams->strPerfFile,
1745 MSDK_MAX_FILENAME_LEN,
1746 strInput[i],
1747 MSDK_MAX_FILENAME_LEN - 1);
1748 pParams->strPerfFile[MSDK_MAX_FILENAME_LEN - 1] = 0;
1749 }
1750 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-scc"))) {
1751 VAL_CHECK(1 + i == nArgNum);
1752 i++;
1753 pParams->fccSource = pParams->frameInfoIn[0].FourCC = Str2FourCC(strInput[i]);
1754
1755 //if (MFX_FOURCC_I420 == pParams->frameInfoIn[0].FourCC)
1756 //{
1757 // pParams->frameInfoIn[0].FourCC = MFX_FOURCC_YV12; // I420 input is implemented using YV12 internally
1758 //}
1759
1760 if (!pParams->frameInfoIn[0].FourCC) {
1761 vppPrintHelp(strInput[0], MSDK_STRING("Invalid -scc format\n"));
1762 return MFX_ERR_UNSUPPORTED;
1763 }
1764 }
1765 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dcc"))) {
1766 VAL_CHECK(1 + i == nArgNum);
1767 i++;
1768 pParams->frameInfoOut[0].FourCC = Str2FourCC(strInput[i]);
1769 pParams->forcedOutputFourcc = 0;
1770 if (MFX_FOURCC_I420 == pParams->frameInfoOut[0].FourCC ||
1771 MFX_FOURCC_YV12 == pParams->frameInfoOut[0].FourCC) {
1772 pParams->forcedOutputFourcc = pParams->frameInfoOut[0].FourCC;
1773 pParams->frameInfoOut[0].FourCC =
1774 MFX_FOURCC_NV12; // I420 output is implemented using NV12 internally
1775 }
1776
1777 if (!pParams->frameInfoOut[0].FourCC) {
1778 vppPrintHelp(strInput[0], MSDK_STRING("Invalid -dcc format\n"));
1779 return MFX_ERR_UNSUPPORTED;
1780 }
1781 }
1782 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dbitshift"))) {
1783 VAL_CHECK(1 + i == nArgNum);
1784 i++;
1785 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoOut[0].Shift);
1786 }
1787 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dbitdepthluma"))) {
1788 VAL_CHECK(1 + i == nArgNum);
1789 i++;
1790 msdk_sscanf(strInput[i],
1791 MSDK_STRING("%hu"),
1792 &pParams->frameInfoOut[0].BitDepthLuma);
1793 }
1794 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dbitdepthchroma"))) {
1795 VAL_CHECK(1 + i == nArgNum);
1796 i++;
1797 msdk_sscanf(strInput[i],
1798 MSDK_STRING("%hu"),
1799 &pParams->frameInfoOut[0].BitDepthChroma);
1800 }
1801 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sbitshift"))) {
1802 VAL_CHECK(1 + i == nArgNum);
1803 i++;
1804 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoIn[0].Shift);
1805 }
1806 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sbitdepthluma"))) {
1807 VAL_CHECK(1 + i == nArgNum);
1808 i++;
1809 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->frameInfoIn[0].BitDepthLuma);
1810 }
1811 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sbitdepthchroma"))) {
1812 VAL_CHECK(1 + i == nArgNum);
1813 i++;
1814 msdk_sscanf(strInput[i],
1815 MSDK_STRING("%hu"),
1816 &pParams->frameInfoIn[0].BitDepthChroma);
1817 }
1818 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-iopattern"))) {
1819 VAL_CHECK(1 + i == nArgNum);
1820 i++;
1821 pParams->IOPattern = Str2IOpattern(strInput[i]);
1822 }
1823 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-lib"))) {
1824 VAL_CHECK(1 + i == nArgNum);
1825 i++;
1826 if (0 == msdk_strcmp(strInput[i], MSDK_STRING("sw")))
1827 pParams->ImpLib = MFX_IMPL_SOFTWARE;
1828 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("hw"))) {
1829 pParams->ImpLib = MFX_IMPL_HARDWARE;
1830 }
1831 }
1832 #if (defined(LINUX32) || defined(LINUX64))
1833 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-device"))) {
1834 if (!pParams->strDevicePath.empty()) {
1835 msdk_printf(MSDK_STRING("error: you can specify only one device\n"));
1836 return MFX_ERR_UNSUPPORTED;
1837 }
1838 VAL_CHECK(i + 1 == nArgNum);
1839 pParams->strDevicePath = strInput[++i];
1840 #ifdef ONEVPL_EXPERIMENTAL
1841 size_t pos = pParams->strDevicePath.find("renderD");
1842 if (pos != std::string::npos) {
1843 pParams->DRMRenderNodeNum =
1844 std::stoi(pParams->strDevicePath.substr(pos + 7, 3));
1845 }
1846 #endif
1847 }
1848 #endif
1849 #ifdef ONEVPL_EXPERIMENTAL
1850 #if defined(_WIN32)
1851 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-luid"))) {
1852 // <HighPart:LowPart>
1853 msdk_char luid[MSDK_MAX_FILENAME_LEN];
1854 if (i + 1 >= nArgNum) {
1855 msdk_printf(MSDK_STRING("error: Not enough parameters for -luid key\n"));
1856 return MFX_ERR_UNSUPPORTED;
1857 }
1858 i++;
1859 if (MFX_ERR_NONE != msdk_opt_read(strInput[i], luid)) {
1860 msdk_printf(MSDK_STRING("error: '-luid' arguments is invalid\n"));
1861 return MFX_ERR_UNSUPPORTED;
1862 }
1863
1864 std::string temp = std::string(luid);
1865 const std::regex pieces_regex("(0[xX][0-9a-fA-F]+):(0[xX][0-9a-fA-F]+)");
1866 std::smatch pieces_match;
1867
1868 // pieces_match = [full match, HighPart, LowPart]
1869 if (std::regex_match(temp, pieces_match, pieces_regex) &&
1870 pieces_match.size() == 3) {
1871 pParams->luid.HighPart = std::strtol(pieces_match[1].str().c_str(), 0, 16);
1872 pParams->luid.LowPart = std::strtol(pieces_match[2].str().c_str(), 0, 16);
1873 }
1874 else {
1875 msdk_printf(MSDK_STRING(
1876 "error: format of -LUID is invalid, please, use: HighPart:LowPart\n"));
1877 return MFX_ERR_UNSUPPORTED;
1878 }
1879 }
1880 #endif
1881 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pci"))) {
1882 msdk_char deviceInfo[MSDK_MAX_FILENAME_LEN];
1883 if (i + 1 >= nArgNum) {
1884 msdk_printf(MSDK_STRING("error: Not enough parameters for -pci key\n"));
1885 return MFX_ERR_UNSUPPORTED;
1886 }
1887 i++;
1888 if ((msdk_strlen(strInput[i]) + 1) > MSDK_ARRAY_LEN(deviceInfo)) {
1889 msdk_printf(MSDK_STRING("error: '-pci' arguments is too long\n"));
1890 return MFX_ERR_UNSUPPORTED;
1891 }
1892 msdk_opt_read(strInput[i], deviceInfo);
1893
1894 // template: <domain:bus:device.function>
1895 std::string temp = std::string(deviceInfo);
1896 const std::regex pieces_regex("([0-9]+):([0-9]+):([0-9]+).([0-9]+)");
1897 std::smatch pieces_match;
1898
1899 // pieces_match = [full match, PCIDomain, PCIBus, PCIDevice, PCIFunction]
1900 if (std::regex_match(temp, pieces_match, pieces_regex) &&
1901 pieces_match.size() == 5) {
1902 pParams->PCIDomain = std::atoi(pieces_match[1].str().c_str());
1903 pParams->PCIBus = std::atoi(pieces_match[2].str().c_str());
1904 pParams->PCIDevice = std::atoi(pieces_match[3].str().c_str());
1905 pParams->PCIFunction = std::atoi(pieces_match[4].str().c_str());
1906 pParams->PCIDeviceSetup = true;
1907 }
1908 else {
1909 msdk_printf(MSDK_STRING(
1910 "format of -pci is invalid, please, use: domain:bus:device.function"));
1911 return MFX_ERR_UNSUPPORTED;
1912 }
1913 }
1914 #endif
1915 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dGfx"))) {
1916 pParams->adapterType = mfxMediaAdapterType::MFX_MEDIA_DISCRETE;
1917 if (i + 1 < nArgNum && isdigit(*strInput[1 + i])) {
1918 if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->dGfxIdx)) {
1919 msdk_printf(MSDK_STRING("value of -dGfx is invalid"));
1920 return MFX_ERR_UNSUPPORTED;
1921 }
1922 }
1923 }
1924 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-iGfx"))) {
1925 pParams->adapterType = mfxMediaAdapterType::MFX_MEDIA_INTEGRATED;
1926 }
1927 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-AdapterNum"))) {
1928 VAL_CHECK(1 + i == nArgNum);
1929 i++;
1930 msdk_sscanf(strInput[i],
1931 MSDK_STRING("%d"),
1932 reinterpret_cast<mfxI32*>(&pParams->adapterNum));
1933 }
1934 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dispatcher:fullSearch"))) {
1935 pParams->dispFullSearch = true;
1936 }
1937 #if defined(D3D_SURFACES_SUPPORT)
1938 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d"))) {
1939 pParams->IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
1940 pParams->ImpLib |= MFX_IMPL_VIA_D3D9;
1941 pParams->accelerationMode = MFX_ACCEL_MODE_VIA_D3D9;
1942 }
1943 #endif
1944 #if MFX_D3D11_SUPPORT
1945 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d11"))) {
1946 pParams->IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
1947 pParams->ImpLib |= MFX_IMPL_VIA_D3D11;
1948 pParams->accelerationMode = MFX_ACCEL_MODE_VIA_D3D11;
1949 }
1950 #endif
1951 #ifdef LIBVA_SUPPORT
1952 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-vaapi")) ||
1953 0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d"))) {
1954 pParams->IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
1955 pParams->ImpLib |= MFX_IMPL_VIA_VAAPI;
1956 pParams->accelerationMode = MFX_ACCEL_MODE_VIA_VAAPI;
1957 }
1958 #endif
1959 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-async"))) {
1960 VAL_CHECK(1 + i == nArgNum);
1961 i++;
1962 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->asyncNum);
1963 }
1964 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-perf_opt"))) {
1965 if (pParams->numFrames)
1966 return MFX_ERR_UNKNOWN;
1967
1968 VAL_CHECK(1 + i == nArgNum);
1969 pParams->bPerf = true;
1970 i++;
1971 msdk_sscanf(strInput[i],
1972 MSDK_STRING("%hd"),
1973 reinterpret_cast<short int*>(&pParams->numFrames));
1974 VAL_CHECK(1 + i == nArgNum);
1975 i++;
1976 msdk_sscanf(strInput[i], MSDK_STRING("%hu"), &pParams->numRepeat);
1977 }
1978 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pts_check"))) {
1979 pParams->ptsCheck = true;
1980 }
1981 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pts_jump"))) {
1982 pParams->ptsJump = true;
1983 }
1984 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pts_fr"))) {
1985 VAL_CHECK(1 + i == nArgNum);
1986 i++;
1987 msdk_sscanf(strInput[i], MSDK_STRING("%lf"), &pParams->ptsFR);
1988 }
1989 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pts_advanced"))) {
1990 pParams->ptsAdvanced = true;
1991 }
1992 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-n"))) {
1993 if (pParams->bPerf)
1994 return MFX_ERR_UNKNOWN;
1995
1996 VAL_CHECK(1 + i == nArgNum);
1997 i++;
1998 msdk_sscanf(strInput[i],
1999 MSDK_STRING("%hd"),
2000 reinterpret_cast<short int*>(&pParams->numFrames));
2001 }
2002 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-reset_start"))) {
2003 VAL_CHECK(1 + i == nArgNum);
2004 msdk_sscanf(strInput[i + 1],
2005 MSDK_STRING("%hd"),
2006 reinterpret_cast<short int*>(&readData));
2007 i += 2;
2008
2009 pParams->resetFrmNums.push_back((mfxU16)readData);
2010
2011 if (MFX_ERR_NONE != vppParseResetPar(strInput,
2012 nArgNum,
2013 i,
2014 pParams,
2015 (mfxU32)pParams->resetFrmNums.size(),
2016 pDefaultFiltersParam))
2017 return MFX_ERR_UNKNOWN;
2018 }
2019 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cf_disable"))) {
2020 pParams->colorfillParam[0].mode = VPP_FILTER_ENABLED_CONFIGURED;
2021 pParams->colorfillParam[0].Enable = MFX_CODINGOPTION_OFF;
2022 }
2023 else {
2024 msdk_printf(MSDK_STRING("Unknown option: %s\n"), strInput[i]);
2025
2026 return MFX_ERR_UNKNOWN;
2027 }
2028 }
2029 }
2030
2031 if ((pParams->ImpLib & MFX_IMPL_HARDWARE) && !(pParams->ImpLib & MFX_IMPL_VIA_D3D9)) {
2032 pParams->ImpLib = MFX_IMPL_HARDWARE;
2033 #ifdef LIBVA_SUPPORT
2034 pParams->ImpLib |= MFX_IMPL_VIA_VAAPI;
2035 pParams->accelerationMode = MFX_ACCEL_MODE_VIA_VAAPI;
2036 #else
2037 pParams->ImpLib |= MFX_IMPL_VIA_D3D11;
2038 pParams->accelerationMode = MFX_ACCEL_MODE_VIA_D3D11;
2039 #endif
2040 }
2041
2042 std::vector<sOwnFrameInfo>::iterator it = pParams->frameInfoIn.begin();
2043 while (it != pParams->frameInfoIn.end()) {
2044 if (NOT_INIT_VALUE == it->CropW) {
2045 it->CropW = it->nWidth;
2046 }
2047
2048 if (NOT_INIT_VALUE == it->CropH) {
2049 it->CropH = it->nHeight;
2050 }
2051 it++;
2052 }
2053
2054 it = pParams->frameInfoOut.begin();
2055 while (it != pParams->frameInfoOut.end()) {
2056 if (NOT_INIT_VALUE == it->CropW) {
2057 it->CropW = it->nWidth;
2058 }
2059
2060 if (NOT_INIT_VALUE == it->CropH) {
2061 it->CropH = it->nHeight;
2062 }
2063 it++;
2064 }
2065
2066 if (0 == msdk_strlen(pParams->strSrcFile) &&
2067 pParams->compositionParam.mode != VPP_FILTER_ENABLED_CONFIGURED) {
2068 vppPrintHelp(strInput[0], MSDK_STRING("Source file name not found"));
2069 return MFX_ERR_UNSUPPORTED;
2070 };
2071
2072 if (1 != pParams->strDstFiles.size() &&
2073 (pParams->resetFrmNums.size() + 1) != pParams->strDstFiles.size()) {
2074 vppPrintHelp(
2075 strInput[0],
2076 MSDK_STRING(
2077 "Destination file name should be declared once or for each parameter set (reset case)"));
2078 return MFX_ERR_UNSUPPORTED;
2079 };
2080
2081 if (0 == pParams->IOPattern) {
2082 vppPrintHelp(strInput[0], MSDK_STRING("Incorrect IOPattern"));
2083 return MFX_ERR_UNSUPPORTED;
2084 }
2085
2086 if ((pParams->ImpLib & MFX_IMPL_SOFTWARE) &&
2087 (pParams->IOPattern & (MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY))) {
2088 msdk_printf(MSDK_STRING(
2089 "Warning: IOPattern has been reset to 'sys_to_sys' mode because software library implementation is selected."));
2090 pParams->IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
2091 }
2092
2093 // Align values of luma and chroma bit depth if only one of them set by user
2094 AdjustBitDepth(*pParams);
2095
2096 return MFX_ERR_NONE;
2097
2098 } // mfxStatus vppParseInputString( ... )
2099
CheckInputParams(msdk_char * strInput[],sInputParams * pParams)2100 bool CheckInputParams(msdk_char* strInput[], sInputParams* pParams) {
2101 // Setting default width and height if it was omitted. For composition case parameters should be define explicitly
2102 if (pParams->frameInfoOut[0].nWidth == 0) {
2103 if (pParams->compositionParam.mode == VPP_FILTER_ENABLED_CONFIGURED) {
2104 vppPrintHelp(
2105 strInput[0],
2106 MSDK_STRING(
2107 "ERROR: Destination width should be set explicitely in case of composition mode.\n"));
2108 return false;
2109 }
2110 pParams->frameInfoOut[0].nWidth = pParams->frameInfoIn[0].nWidth;
2111 pParams->frameInfoOut[0].CropW = pParams->frameInfoIn[0].CropW;
2112 pParams->frameInfoOut[0].CropX = 0;
2113 }
2114
2115 if (pParams->frameInfoOut[0].nHeight == 0) {
2116 if (pParams->compositionParam.mode == VPP_FILTER_ENABLED_CONFIGURED) {
2117 vppPrintHelp(
2118 strInput[0],
2119 MSDK_STRING(
2120 "ERROR: Destination height should be set explicitely in case of composition mode.\n"));
2121 return false;
2122 }
2123 pParams->frameInfoOut[0].nHeight = pParams->frameInfoIn[0].nHeight;
2124 pParams->frameInfoOut[0].CropH = pParams->frameInfoIn[0].CropH;
2125 pParams->frameInfoOut[0].CropY = 0;
2126 }
2127
2128 // Checking other parameters
2129 if (0 == pParams->asyncNum) {
2130 vppPrintHelp(strInput[0],
2131 MSDK_STRING("Incompatible parameters: [ayncronous number must exceed 0]\n"));
2132 return false;
2133 }
2134
2135 for (mfxU32 i = 0; i < pParams->rotate.size(); i++) {
2136 if (pParams->rotate[i] != 0 && pParams->rotate[i] != 90 && pParams->rotate[i] != 180 &&
2137 pParams->rotate[i] != 270) {
2138 vppPrintHelp(
2139 strInput[0],
2140 MSDK_STRING("Invalid -rotate parameter: supported values 0, 90, 180, 270\n"));
2141 return false;
2142 }
2143 }
2144
2145 for (mfxU32 i = 0; i < pParams->numStreams; i++) {
2146 const mfxVPPCompInputStream& is = pParams->compositionParam.streamInfo[i].compStream;
2147
2148 if ((pParams->frameInfoOut[0].nWidth < is.DstW + is.DstX) ||
2149 (pParams->frameInfoOut[0].nHeight < is.DstH + is.DstY)) {
2150 vppPrintHelp(
2151 strInput[0],
2152 MSDK_STRING("One of composing frames cannot fit into destination frame.\n"));
2153 return false;
2154 }
2155 }
2156
2157 return true;
2158
2159 } // bool CheckInputParams(msdk_char* strInput[], sInputVppParams* pParams )
2160
2161 // trim from start
ltrim(std::string & s)2162 static inline std::string& ltrim(std::string& s) {
2163 s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char c) {
2164 return !std::isspace(c);
2165 }));
2166 return s;
2167 }
2168
2169 // trim from end
rtrim(std::string & s)2170 static inline std::string& rtrim(std::string& s) {
2171 s.erase(std::find_if(s.rbegin(),
2172 s.rend(),
2173 [](unsigned char c) {
2174 return !std::isspace(c);
2175 })
2176 .base(),
2177 s.end());
2178 return s;
2179 }
2180
2181 // trim from both ends
trim(std::string & s)2182 static inline std::string& trim(std::string& s) {
2183 return ltrim(rtrim(s));
2184 }
2185
getPair(std::string line,std::string & key,std::string & value)2186 void getPair(std::string line, std::string& key, std::string& value) {
2187 std::istringstream iss(line);
2188 getline(iss, key, '=');
2189 getline(iss, value, '=');
2190 trim(key);
2191 trim(value);
2192 }
2193
ParseCompositionParfile(const msdk_char * parFileName,sInputParams * pParams)2194 mfxStatus ParseCompositionParfile(const msdk_char* parFileName, sInputParams* pParams) {
2195 mfxStatus sts = MFX_ERR_NONE;
2196 if (msdk_strlen(parFileName) == 0)
2197 return MFX_ERR_UNKNOWN;
2198
2199 MSDK_ZERO_MEMORY(pParams->inFrameInfo);
2200
2201 std::string line;
2202 std::string key, value;
2203 mfxU8 nStreamInd = 0;
2204 mfxU8 firstStreamFound = 0;
2205 std::ifstream stream(parFileName);
2206 if (stream.fail())
2207 return MFX_ERR_UNKNOWN;
2208
2209 while (getline(stream, line) && nStreamInd < MAX_INPUT_STREAMS) {
2210 getPair(line, key, value);
2211 if (key.compare("width") == 0) {
2212 pParams->inFrameInfo[nStreamInd].nWidth = (mfxU16)MSDK_ALIGN16(atoi(value.c_str()));
2213 }
2214 else if (key.compare("height") == 0) {
2215 pParams->inFrameInfo[nStreamInd].nHeight =
2216 (MFX_PICSTRUCT_PROGRESSIVE == pParams->inFrameInfo[nStreamInd].PicStruct)
2217 ? (mfxU16)MSDK_ALIGN16(atoi(value.c_str()))
2218 : (mfxU16)MSDK_ALIGN32(atoi(value.c_str()));
2219 }
2220 else if (key.compare("cropx") == 0) {
2221 pParams->inFrameInfo[nStreamInd].CropX = (mfxU16)atoi(value.c_str());
2222 }
2223 else if (key.compare("cropy") == 0) {
2224 pParams->inFrameInfo[nStreamInd].CropY = (mfxU16)atoi(value.c_str());
2225 }
2226 else if (key.compare("cropw") == 0) {
2227 pParams->inFrameInfo[nStreamInd].CropW = (mfxU16)atoi(value.c_str());
2228 }
2229 else if (key.compare("croph") == 0) {
2230 pParams->inFrameInfo[nStreamInd].CropH = (mfxU16)atoi(value.c_str());
2231 }
2232 else if (key.compare("framerate") == 0) {
2233 pParams->inFrameInfo[nStreamInd].dFrameRate = (mfxF64)atof(value.c_str());
2234 }
2235 else if (key.compare("fourcc") == 0) {
2236 const mfxU16 len_size = 5;
2237 msdk_char fourcc[len_size];
2238 for (mfxU16 i = 0; i < (value.size() > len_size ? len_size : value.size()); i++)
2239 fourcc[i] = value.at(i);
2240 fourcc[len_size - 1] = 0;
2241 pParams->inFrameInfo[nStreamInd].FourCC = Str2FourCC(fourcc);
2242
2243 if (!pParams->inFrameInfo[nStreamInd].FourCC) {
2244 msdk_printf(MSDK_STRING("Invalid fourcc parameter in par file: %s\n"), fourcc);
2245 return MFX_ERR_INVALID_VIDEO_PARAM;
2246 }
2247 }
2248 else if (key.compare("picstruct") == 0) {
2249 pParams->inFrameInfo[nStreamInd].PicStruct = GetPicStruct((mfxI8)atoi(value.c_str()));
2250 }
2251 else if (key.compare("dstx") == 0) {
2252 pParams->compositionParam.streamInfo[nStreamInd].compStream.DstX =
2253 (mfxU16)atoi(value.c_str());
2254 }
2255 else if (key.compare("dsty") == 0) {
2256 pParams->compositionParam.streamInfo[nStreamInd].compStream.DstY =
2257 (mfxU16)atoi(value.c_str());
2258 }
2259 else if (key.compare("dstw") == 0) {
2260 pParams->compositionParam.streamInfo[nStreamInd].compStream.DstW =
2261 (mfxU16)atoi(value.c_str());
2262 }
2263 else if (key.compare("dsth") == 0) {
2264 pParams->compositionParam.streamInfo[nStreamInd].compStream.DstH =
2265 (mfxU16)atoi(value.c_str());
2266 }
2267 else if (key.compare("GlobalAlphaEnable") == 0) {
2268 pParams->compositionParam.streamInfo[nStreamInd].compStream.GlobalAlphaEnable =
2269 (mfxU16)atoi(value.c_str());
2270 }
2271 else if (key.compare("GlobalAlpha") == 0) {
2272 pParams->compositionParam.streamInfo[nStreamInd].compStream.GlobalAlpha =
2273 (mfxU16)atoi(value.c_str());
2274 }
2275 else if (key.compare("PixelAlphaEnable") == 0) {
2276 pParams->compositionParam.streamInfo[nStreamInd].compStream.PixelAlphaEnable =
2277 (mfxU16)atoi(value.c_str());
2278 }
2279 else if (key.compare("LumaKeyEnable") == 0) {
2280 pParams->compositionParam.streamInfo[nStreamInd].compStream.LumaKeyEnable =
2281 (mfxU16)atoi(value.c_str());
2282 }
2283 else if (key.compare("LumaKeyMin") == 0) {
2284 pParams->compositionParam.streamInfo[nStreamInd].compStream.LumaKeyMin =
2285 (mfxU16)atoi(value.c_str());
2286 }
2287 else if (key.compare("LumaKeyMax") == 0) {
2288 pParams->compositionParam.streamInfo[nStreamInd].compStream.LumaKeyMax =
2289 (mfxU16)atoi(value.c_str());
2290 }
2291 else if ((key.compare("stream") == 0 || key.compare("primarystream") == 0) &&
2292 nStreamInd < (MAX_INPUT_STREAMS - 1)) {
2293 const mfxU16 len_size = MSDK_MAX_FILENAME_LEN - 1;
2294
2295 if (firstStreamFound == 1) {
2296 nStreamInd++;
2297 }
2298 else {
2299 nStreamInd = 0;
2300 firstStreamFound = 1;
2301 }
2302 pParams->inFrameInfo[nStreamInd].CropX = 0;
2303 pParams->inFrameInfo[nStreamInd].CropY = 0;
2304 pParams->inFrameInfo[nStreamInd].CropW = NOT_INIT_VALUE;
2305 pParams->inFrameInfo[nStreamInd].CropH = NOT_INIT_VALUE;
2306 mfxU16 i = 0;
2307 for (; i < (value.size() > len_size ? len_size : value.size()); i++)
2308 pParams->compositionParam.streamInfo[nStreamInd].streamName[i] = value.at(i);
2309 pParams->compositionParam.streamInfo[nStreamInd].streamName[i] = 0;
2310 pParams->inFrameInfo[nStreamInd].dFrameRate = 30;
2311 pParams->inFrameInfo[nStreamInd].PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
2312 }
2313 }
2314
2315 pParams->numStreams = nStreamInd + 1;
2316
2317 for (int i = 0; i < pParams->numStreams; i++) {
2318 if (!pParams->inFrameInfo[i].FourCC) {
2319 msdk_printf(
2320 MSDK_STRING("Fourcc parameter of stream %d in par file is invalid or missing.\n"),
2321 i);
2322 return MFX_ERR_INVALID_VIDEO_PARAM;
2323 }
2324 }
2325 return sts;
2326 }
2327
2328 /* EOF */
2329