1 /******************************************************************************\
2 Copyright (c) 2005-2019, Intel Corporation
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
6
7 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
8
9 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
10
11 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
12
13 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14
15 This sample was distributed or derived from the Intel's Media Samples package.
16 The original version of this sample may be obtained from https://software.intel.com/en-us/intel-media-server-studio
17 or https://software.intel.com/en-us/media-client-solutions-support.
18 \**********************************************************************************/
19 #include "pipeline_camera.h"
20 #include <sstream>
21 #include "version.h"
22
PrintHelp(msdk_char * strAppName,const msdk_char * strErrorMessage)23 void PrintHelp(msdk_char *strAppName, const msdk_char *strErrorMessage)
24 {
25 msdk_printf(MSDK_STRING("Intel(R) Camera Expert SDK Sample Version %s\n\n"), GetMSDKSampleVersion().c_str());
26
27 if (strErrorMessage)
28 {
29 msdk_printf(MSDK_STRING("Error: %s\n"), strErrorMessage);
30 }
31
32 msdk_printf(MSDK_STRING("Usage: %s [Options] -i InputFileNameBase -o OutputFileNameBase [numberOfFilesToDump]\n"), strAppName);
33 msdk_printf(MSDK_STRING("Options: \n"));
34 msdk_printf(MSDK_STRING(" [-plugin_version ver] - define camera plugin version\n"));
35 msdk_printf(MSDK_STRING(" [-a asyncDepth] / [-asyncDepth asyncDepth] - set async depth, default %d \n"), CAM_SAMPLE_ASYNC_DEPTH);
36 msdk_printf(MSDK_STRING(" [-b bitDepth] / [-bitDepth bitDepth] - set bit depth, default 10 \n"));
37 msdk_printf(MSDK_STRING(" [-f format] / [-format format] - input Bayer format: rggb, bggr, grbg or gbrg\n"));
38 msdk_printf(MSDK_STRING(" [-of format] / [-outFormat format] - output format: of argb16 or 16 meaning 16 bit ARGB, 8 bit ARGB, NV12\n"));
39 msdk_printf(MSDK_STRING(" [-offset pre1 pre2 pre3 post1 post2 post3] - In case of NV12 output, offset set color pre and post offsets\n"));
40 msdk_printf(MSDK_STRING(" [-3DLUT_gamma] - use 3D LUT gamma correction\n"));
41 msdk_printf(MSDK_STRING(" [-ng] / [-noGamma] - no gamma correction\n"));
42 msdk_printf(MSDK_STRING(" [-gamma_points] - set specific gamma points (64 points expected)\n"));
43 msdk_printf(MSDK_STRING(" [-gamma_corrected] - set specific gamma corrected values (64 values expected)\n"));
44 msdk_printf(MSDK_STRING(" -gamma_points and -gamma_corrected options must be used together\n"));
45 msdk_printf(MSDK_STRING(" [-bdn threshold] / [-bayerDenoise threshold] - bayer denoise on\n"));
46 msdk_printf(MSDK_STRING(" [-hot_pixel Diff Num] - bayer hot pixel removal\n"));
47 msdk_printf(MSDK_STRING(" [-bbl B G0 G1 R] / [-bayerBlackLevel B G0 G1 R] - bayer black level correction\n"));
48 msdk_printf(MSDK_STRING(" [-tcc R G B C M Y] / [-totalColorControl R G B C M Y] - total color control \n"));
49 msdk_printf(MSDK_STRING(" [-bwb B G0 G1 R] / [-bayerWhiteBalance B G0 G1 R] - bayer white balance\n"));
50 msdk_printf(MSDK_STRING(" [-ccm n00 n01 ... n33 ] - color correction 3x3 matrix\n"));
51 msdk_printf(MSDK_STRING(" [-vignette maskfile ] - enable vignette correction using mask from specified file\n"));
52 msdk_printf(MSDK_STRING(" [-lens a b c d ] - enable lens geometry distortion correction\n"));
53 msdk_printf(MSDK_STRING(" [-chroma_aberration aR bR cR dR aG bG cG dG aB bB cB dB ] - enable chroma aberration correction\n"));
54 msdk_printf(MSDK_STRING(" [-w width] / [-width width] - input width, default 4096\n"));
55 msdk_printf(MSDK_STRING(" [-h height] / [-height height] - input height, default 2160\n"));
56 msdk_printf(MSDK_STRING(" [-n numFrames] / [-numFramesToProcess numFrames] - number of frames to process\n"));
57 msdk_printf(MSDK_STRING(" [-alpha alpha] - write value to alpha channel of output surface \n"));
58 msdk_printf(MSDK_STRING(" [-pd] / [-padding] - do input surface padding \n"));
59 msdk_printf(MSDK_STRING(" [-perf_opt] - buffered reading of input (support: Bayer sequence \n"));
60 msdk_printf(MSDK_STRING(" [-resetInterval resetInterval] - reset interval in frames, default 7 \n"));
61 msdk_printf(MSDK_STRING(" [-reset -i ... -o ... -f ... -w ... -h ... -bbl ... -bwb ... -ccm ...] - params to be used after next reset.\n"));
62 msdk_printf(MSDK_STRING(" Only params listed above are supported, if a param is not set here, the originally set value is used. \n"));
63 msdk_printf(MSDK_STRING(" There can be any number of resets, applied in order of appearance in the command line, \n"));
64 msdk_printf(MSDK_STRING(" after resetInterval frames are processed with the current params \n"));
65 msdk_printf(MSDK_STRING(" [-imem] - input memory type (sys|video). Default is system\n"));
66 #if D3D_SURFACES_SUPPORT
67 msdk_printf(MSDK_STRING(" [-omem] - output memory type (sys|video). Default is system\n"));
68 msdk_printf(MSDK_STRING(" [-accel] - type of acceleration device (d3d9|d3d11). Default is d3d9\n"));
69 msdk_printf(MSDK_STRING(" [-r] / [-render] - render output in a separate window \n"));
70 msdk_printf(MSDK_STRING(" [-wall w h n m f t tmo] - same as -r, and positioned rendering window in a particular cell on specific monitor \n"));
71 msdk_printf(MSDK_STRING(" w - number of columns of video windows on selected monitor\n"));
72 msdk_printf(MSDK_STRING(" h - number of rows of video windows on selected monitor\n"));
73 msdk_printf(MSDK_STRING(" n(0,.,w*h-1) - order of video window in table that will be rendered\n"));
74 msdk_printf(MSDK_STRING(" m(0,1..) - monitor id \n"));
75 msdk_printf(MSDK_STRING(" f - rendering framerate\n"));
76 msdk_printf(MSDK_STRING(" t(0/1) - enable/disable window's title\n"));
77 msdk_printf(MSDK_STRING(" tmo - timeout for -wall option\n"));
78 #endif
79 #if defined(_WIN32) || defined(_WIN64)
80 msdk_printf(MSDK_STRING("\nFeatures: \n"));
81 msdk_printf(MSDK_STRING(" Press 1 to toggle fullscreen rendering on/off\n"));
82 #endif
83 msdk_printf(MSDK_STRING("\n"));
84 }
85
86 #define GET_OPTION_POINTER(PTR) \
87 { \
88 if (2 == msdk_strlen(strInput[i])) \
89 { \
90 i++; \
91 if (strInput[i][0] == MSDK_CHAR('-')) \
92 { \
93 i = i - 1; \
94 } \
95 else \
96 { \
97 PTR = strInput[i]; \
98 } \
99 } \
100 else \
101 { \
102 PTR = strInput[i] + 2; \
103 } \
104 }
105
ParseInputString(msdk_char * strInput[],mfxU8 nArgNum,sInputParams * pParams)106 mfxStatus ParseInputString(msdk_char* strInput[], mfxU8 nArgNum, sInputParams* pParams)
107 {
108 if (1 == nArgNum)
109 {
110 PrintHelp(strInput[0], NULL);
111 return MFX_ERR_UNSUPPORTED;
112 }
113
114 sResetParams resPar;
115
116 MSDK_CHECK_POINTER(pParams, MFX_ERR_NULL_PTR);
117
118 for (mfxU8 i = 1; i < nArgNum; i++)
119 {
120 // multi-character options
121 if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-plugin_version")))
122 {
123 msdk_opt_read(strInput[++i], pParams->CameraPluginVersion);
124 }
125 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-accel")))
126 {
127 if(i + 1 >= nArgNum)
128 {
129 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -accel key"));
130 return MFX_ERR_UNSUPPORTED;
131 }
132
133 if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("d3d9")))
134 {
135 pParams->accelType = D3D9;
136 }
137 else if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("d3d11")))
138 {
139 pParams->accelType = D3D11;
140 }
141 else
142 {
143 PrintHelp(strInput[0], MSDK_STRING("Unsupported value for -accel key"));
144 return MFX_ERR_UNSUPPORTED;
145 }
146 i++;
147 }
148 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-perf_opt")))
149 {
150 pParams->bPerf_opt = true;
151 }
152 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-imem")))
153 {
154 if(i + 1 >= nArgNum)
155 {
156 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -imem key"));
157 return MFX_ERR_UNSUPPORTED;
158 }
159 if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("system")))
160 {
161 pParams->memTypeIn = SYSTEM;
162 }
163 else if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("video")))
164 {
165 pParams->memTypeIn = VIDEO;
166 }
167 else
168 {
169 PrintHelp(strInput[0], MSDK_STRING("Unsupported value for -imem key"));
170 return MFX_ERR_UNSUPPORTED;
171 }
172 i++;
173 }
174 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-omem")))
175 {
176 if(i + 1 >= nArgNum)
177 {
178 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -omem key"));
179 return MFX_ERR_UNSUPPORTED;
180 }
181 if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("system")))
182 {
183 pParams->memTypeOut = SYSTEM;
184 }
185 else if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("video")))
186 {
187 pParams->memTypeOut = VIDEO;
188 }
189 else
190 {
191 PrintHelp(strInput[0], MSDK_STRING("Unsupported value for -omem key"));
192 return MFX_ERR_UNSUPPORTED;
193 }
194 i++;
195 }
196 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-r")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-render")))
197 {
198 pParams->bRendering = true;
199 }
200 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-a")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-asyncDepth")))
201 {
202 msdk_opt_read(strInput[++i], pParams->asyncDepth);
203 }
204 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-n")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-numFramesToProcess")))
205 {
206 msdk_opt_read(strInput[++i], pParams->nFramesToProceed);
207 }
208 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ng")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-noGamma")))
209 {
210 pParams->bGamma = false;
211 }
212 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-offset")))
213 {
214
215 if (i + 6>= nArgNum)
216 {
217 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for offset key"));
218 return MFX_ERR_UNSUPPORTED;
219 }
220 pParams->offset = true;
221
222 msdk_opt_read(strInput[++i], pParams->pre[0]);
223 msdk_opt_read(strInput[++i], pParams->pre[1]);
224 msdk_opt_read(strInput[++i], pParams->pre[2]);
225 msdk_opt_read(strInput[++i], pParams->post[0]);
226 msdk_opt_read(strInput[++i], pParams->post[1]);
227 msdk_opt_read(strInput[++i], pParams->post[2]);
228
229 }
230 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-3DLUT_gamma")))
231 {
232 pParams->b3DLUTGamma = false;
233 }
234 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bdn")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-bayerDenoise")))
235 {
236 if(i + 1 >= nArgNum)
237 {
238 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bdn key"));
239 return MFX_ERR_UNSUPPORTED;
240 }
241 pParams->bBayerDenoise = true;
242 msdk_opt_read(strInput[++i], pParams->denoiseThreshold);
243 }
244 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bbl")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-bayerBlackLevel")))
245 {
246 if(i + 4 >= nArgNum)
247 {
248 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bbl key"));
249 return MFX_ERR_UNSUPPORTED;
250 }
251 pParams->bBlackLevel = true;
252 msdk_opt_read(strInput[++i], pParams->black_level_B);
253 msdk_opt_read(strInput[++i], pParams->black_level_G0);
254 msdk_opt_read(strInput[++i], pParams->black_level_G1);
255 msdk_opt_read(strInput[++i], pParams->black_level_R);
256 }
257 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-totalColorControl"))) {
258 if (i + 6 >= nArgNum)
259 {
260 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -tcc key"));
261 return MFX_ERR_UNSUPPORTED;
262 }
263 pParams->bTCC = true;
264 msdk_opt_read(strInput[++i], pParams->tcc_red);
265 msdk_opt_read(strInput[++i], pParams->tcc_green);
266 msdk_opt_read(strInput[++i], pParams->tcc_blue);
267 msdk_opt_read(strInput[++i], pParams->tcc_cyan);
268 msdk_opt_read(strInput[++i], pParams->tcc_magenta);
269 msdk_opt_read(strInput[++i], pParams->tcc_yellow);
270 }
271 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-hot_pixel")))
272 {
273 if(i + 2 >= nArgNum)
274 {
275 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -hot_pixel key"));
276 return MFX_ERR_UNSUPPORTED;
277 }
278 pParams->bHP = true;
279 msdk_opt_read(strInput[++i], pParams->hp_diff);
280 msdk_opt_read(strInput[++i], pParams->hp_num);
281 }
282 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bwb")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-bayerWhiteBalance")))
283 {
284 if(i + 4 >= nArgNum)
285 {
286 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bwb key"));
287 return MFX_ERR_UNSUPPORTED;
288 }
289 pParams->bWhiteBalance = true;
290 msdk_opt_read(strInput[++i], pParams->white_balance_B);
291 msdk_opt_read(strInput[++i], pParams->white_balance_G0);
292 msdk_opt_read(strInput[++i], pParams->white_balance_G1);
293 msdk_opt_read(strInput[++i], pParams->white_balance_R);
294 }
295 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-lens")) )
296 {
297 if(i + 4 >= nArgNum)
298 {
299 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -lens key"));
300 return MFX_ERR_UNSUPPORTED;
301 }
302 pParams->bLens = true;
303 msdk_opt_read(strInput[++i], pParams->lens_aR);
304 msdk_opt_read(strInput[++i], pParams->lens_bR);
305 msdk_opt_read(strInput[++i], pParams->lens_cR);
306 msdk_opt_read(strInput[++i], pParams->lens_dR);
307 pParams->lens_aB = pParams->lens_aG = pParams->lens_aR;
308 pParams->lens_bB = pParams->lens_bG = pParams->lens_bR;
309 pParams->lens_cB = pParams->lens_cG = pParams->lens_cR;
310 pParams->lens_dB = pParams->lens_dG = pParams->lens_dR;
311 }
312 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-chroma_aberration")) )
313 {
314 if(i + 12 >= nArgNum)
315 {
316 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -chroma_aberration key"));
317 return MFX_ERR_UNSUPPORTED;
318 }
319 pParams->bLens = true;
320 msdk_opt_read(strInput[++i], pParams->lens_aR);
321 msdk_opt_read(strInput[++i], pParams->lens_bR);
322 msdk_opt_read(strInput[++i], pParams->lens_cR);
323 msdk_opt_read(strInput[++i], pParams->lens_dR);
324 msdk_opt_read(strInput[++i], pParams->lens_aB);
325 msdk_opt_read(strInput[++i], pParams->lens_bB);
326 msdk_opt_read(strInput[++i], pParams->lens_cB);
327 msdk_opt_read(strInput[++i], pParams->lens_dB);
328 msdk_opt_read(strInput[++i], pParams->lens_aG);
329 msdk_opt_read(strInput[++i], pParams->lens_bG);
330 msdk_opt_read(strInput[++i], pParams->lens_cG);
331 msdk_opt_read(strInput[++i], pParams->lens_dG);
332 }
333 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ccm")))
334 {
335 if(i + 9 >= nArgNum)
336 {
337 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -ccm key."));
338 return MFX_ERR_UNSUPPORTED;
339 }
340 pParams->bCCM = true;
341 for(int k = 0; k < 3; k++)
342 for (int z = 0; z < 3; z++)
343 msdk_opt_read(strInput[++i], pParams->CCM[k][z]);
344 }
345 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gamma_points")))
346 {
347 if(i + 64 >= nArgNum)
348 {
349 PrintHelp(strInput[0], MSDK_STRING("There should be 64 points provided."));
350 return MFX_ERR_UNSUPPORTED;
351 }
352 for(int k = 0; k < 64; k++)
353 msdk_opt_read(strInput[++i], pParams->gamma_point[k]);
354
355 pParams->bExternalGammaLUT = true;
356 }
357 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gamma_corrected")))
358 {
359 if(i + 64 >= nArgNum)
360 {
361 PrintHelp(strInput[0], MSDK_STRING("There should be 64 points provided."));
362 return MFX_ERR_UNSUPPORTED;
363 }
364 for(int k = 0; k < 64; k++)
365 msdk_opt_read(strInput[++i], pParams->gamma_corrected[k]);
366
367 pParams->bExternalGammaLUT = true;
368 }
369 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pd")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-padding")))
370 {
371 pParams->bDoPadding = true;
372 }
373 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-vignette")))
374 {
375 pParams->bVignette = true;
376 msdk_strcopy(pParams->strVignetteMaskFile, strInput[++i]);
377 }
378 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-i")))
379 {
380 msdk_strcopy(pParams->strSrcFile, strInput[++i]);
381 }
382 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-o")))
383 {
384 msdk_strcopy(pParams->strDstFile, strInput[++i]);
385 pParams->bOutput = true;
386 if (i + 1 < nArgNum) {
387 int n;
388 if (msdk_opt_read(strInput[++i], n) == MFX_ERR_NONE) {
389 pParams->maxNumBmpFiles = n;
390 }
391 }
392 }
393 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-f")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-format")))
394 {
395 i++;
396 if (0 == msdk_strcmp(strInput[i], MSDK_STRING("bggr")))
397 pParams->inputType = MFX_CAM_BAYER_BGGR;
398 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("rggb")))
399 pParams->inputType = MFX_CAM_BAYER_RGGB;
400 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("grbg")))
401 pParams->inputType = MFX_CAM_BAYER_GRBG;
402 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("gbrg")))
403 pParams->inputType = MFX_CAM_BAYER_GBRG;
404 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("argb16")))
405 pParams->inputType = MFX_FOURCC_ARGB16;
406 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("abgr16")))
407 pParams->inputType = MFX_FOURCC_ABGR16;
408 else
409 {
410 PrintHelp(strInput[0], MSDK_STRING("Format %s is unknown."));
411 return MFX_ERR_UNSUPPORTED;
412 }
413
414 }
415 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-b")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-bitDepth")))
416 {
417 msdk_opt_read(strInput[++i], pParams->bitDepth);
418 }
419 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-of")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-outFormat")))
420 {
421 i++;
422 if (0 == msdk_strcmp(strInput[i], MSDK_STRING("argb16")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("16")))
423 pParams->frameInfo[VPP_OUT].FourCC = MFX_FOURCC_ARGB16;
424 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("abgr16")))
425 pParams->frameInfo[VPP_OUT].FourCC = MFX_FOURCC_ABGR16;
426 #if MFX_VERSION >= 1023
427 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("nv12"))) {
428 pParams->frameInfo[VPP_OUT].FourCC = MFX_FOURCC_NV12;
429 pParams->bRGBToYUV = true;
430 }
431 #endif
432 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("rgb4")))
433 pParams->frameInfo[VPP_OUT].FourCC = MFX_FOURCC_RGB4;
434 }
435 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-w")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-width")))
436 {
437 msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].nWidth);
438 }
439 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-3dlut")))
440 {
441 pParams->b3DLUT = true;
442 }
443 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-h")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-height")))
444 {
445 msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].nHeight);
446 }
447 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropW")))
448 {
449 msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].CropW);
450 }
451 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropH")))
452 {
453 msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].CropH);
454 }
455 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropX")))
456 {
457 msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].CropX);
458 }
459 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropY")))
460 {
461 msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].CropY);
462 }
463 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-alpha")))
464 {
465 msdk_opt_read(strInput[++i], pParams->alphaValue);
466 }
467 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-reset")))
468 {
469 resPar.inputType = pParams->inputType;
470 msdk_strcopy(resPar.strSrcFile, pParams->strSrcFile);
471 msdk_strcopy(resPar.strDstFile, pParams->strDstFile);
472 resPar.width = pParams->frameInfo[VPP_IN].nWidth;
473 resPar.height = pParams->frameInfo[VPP_IN].nHeight;
474 resPar.bHP = pParams->bHP;
475 resPar.hp_diff = pParams->hp_diff;
476 resPar.hp_num = pParams->hp_num;
477
478 resPar.bBlackLevel = pParams->bBlackLevel;
479 resPar.black_level_B = pParams->black_level_B;
480 resPar.black_level_G0 = pParams->black_level_G0;
481 resPar.black_level_G1 = pParams->black_level_G1;
482 resPar.black_level_R = pParams->black_level_R;
483 i++;
484 for (;i < nArgNum; i++)
485 {
486 if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-f")))
487 {
488 i++;
489 if (0 == msdk_strcmp(strInput[i], MSDK_STRING("bggr")))
490 resPar.inputType = MFX_CAM_BAYER_BGGR;
491 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("rggb")))
492 resPar.inputType = MFX_CAM_BAYER_RGGB;
493 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("grbg")))
494 resPar.inputType = MFX_CAM_BAYER_GRBG;
495 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("gbrg")))
496 resPar.inputType = MFX_CAM_BAYER_GBRG;
497 }
498 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bbl")))
499 {
500 if(i + 4 >= nArgNum)
501 {
502 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bbl key"));
503 return MFX_ERR_UNSUPPORTED;
504 }
505 resPar.bBlackLevel = true;
506 msdk_opt_read(strInput[++i], resPar.black_level_B);
507 msdk_opt_read(strInput[++i], resPar.black_level_G0);
508 msdk_opt_read(strInput[++i], resPar.black_level_G1);
509 msdk_opt_read(strInput[++i], resPar.black_level_R);
510 } else if(0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcc")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-totalColorControl"))) {
511 if (i + 6 >= nArgNum)
512 {
513 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -tcc key"));
514 return MFX_ERR_UNSUPPORTED;
515 }
516 pParams->bTCC = true;
517 msdk_opt_read(strInput[++i], pParams->tcc_red);
518 msdk_opt_read(strInput[++i], pParams->tcc_green);
519 msdk_opt_read(strInput[++i], pParams->tcc_blue);
520 msdk_opt_read(strInput[++i], pParams->tcc_cyan);
521 msdk_opt_read(strInput[++i], pParams->tcc_magenta);
522 msdk_opt_read(strInput[++i], pParams->tcc_yellow);
523 }
524 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-hot_pixel")))
525 {
526 if(i + 2 >= nArgNum)
527 {
528 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -hot_pixel key"));
529 return MFX_ERR_UNSUPPORTED;
530 }
531 resPar.bHP = true;
532 msdk_opt_read(strInput[++i], resPar.hp_diff);
533 msdk_opt_read(strInput[++i], resPar.hp_num);
534 }
535 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bdn")))
536 {
537 if(i + 1 >= nArgNum)
538 {
539 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bdn key"));
540 return MFX_ERR_UNSUPPORTED;
541 }
542 resPar.bDenoise = true;
543 msdk_opt_read(strInput[++i], resPar.denoiseThreshold);
544 }
545 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bwb")))
546 {
547 if(i + 4 >= nArgNum)
548 {
549 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bwb key"));
550 return MFX_ERR_UNSUPPORTED;
551 }
552 resPar.bWhiteBalance = true;
553 msdk_opt_read(strInput[++i], resPar.white_balance_B);
554 msdk_opt_read(strInput[++i], resPar.white_balance_G0);
555 msdk_opt_read(strInput[++i], resPar.white_balance_G1);
556 msdk_opt_read(strInput[++i], resPar.white_balance_R);
557 }
558 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ccm")))
559 {
560 if(i + 9 >= nArgNum)
561 {
562 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -ccm key."));
563 return MFX_ERR_UNSUPPORTED;
564 }
565 resPar.bCCM = true;
566 for(int k = 0; k < 3; k++)
567 for (int z = 0; z < 3; z++)
568 msdk_opt_read(strInput[++i], resPar.CCM[k][z]);
569 }
570 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-w")))
571 {
572 msdk_opt_read(strInput[++i], resPar.width);
573 }
574 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-h")))
575 {
576 msdk_opt_read(strInput[++i], resPar.height);
577 }
578 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropW")))
579 {
580 msdk_opt_read(strInput[++i], resPar.cropW);
581 }
582 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropH")))
583 {
584 msdk_opt_read(strInput[++i], resPar.cropH);
585 }
586 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropX")))
587 {
588 msdk_opt_read(strInput[++i], resPar.cropX);
589 }
590 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropY")))
591 {
592 msdk_opt_read(strInput[++i], resPar.cropY);
593 }
594 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-vignette")))
595 {
596 resPar.bVignette = true;
597 msdk_strcopy(resPar.strVignetteMaskFile, strInput[++i]);
598 }
599 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-i")))
600 {
601 msdk_strcopy(resPar.strSrcFile, strInput[++i]);
602 }
603 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-o")))
604 {
605 msdk_strcopy(resPar.strDstFile, strInput[++i]);
606 }
607 else
608 {
609 i--;
610 break;
611 }
612 }
613 pParams->resetParams.push_back(resPar);
614 }
615 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-resetInterval")))
616 {
617 msdk_opt_read(strInput[++i], pParams->resetInterval);
618 }
619 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-?")))
620 {
621 PrintHelp(strInput[0], NULL);
622 return MFX_ERR_UNSUPPORTED;
623 }
624 else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-wall")))
625 {
626 if(i + 7 >= nArgNum)
627 {
628 PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -wall key"));
629 return MFX_ERR_UNSUPPORTED;
630 }
631 pParams->bRendering = true;
632
633 msdk_opt_read(strInput[++i], pParams->nWallW);
634 msdk_opt_read(strInput[++i], pParams->nWallH);
635 msdk_opt_read(strInput[++i], pParams->nWallCell);
636 msdk_opt_read(strInput[++i], pParams->nWallMonitor);
637 msdk_opt_read(strInput[++i], pParams->nWallFPS);
638
639 int nTitle;
640 msdk_opt_read(strInput[++i], nTitle);
641
642 pParams->bWallNoTitle = 0 == nTitle;
643
644 msdk_opt_read(strInput[++i], pParams->nWallTimeout);
645 }
646 else // 1-character options
647 {
648 std::basic_stringstream<msdk_char> stream;
649 stream << MSDK_STRING("Unknown option: ") << strInput[i];
650 PrintHelp(strInput[0], stream.str().c_str());
651 return MFX_ERR_UNSUPPORTED;
652 }
653 }
654
655 if (0 == msdk_strlen(pParams->strSrcFile))
656 {
657 PrintHelp(strInput[0], MSDK_STRING("Source file name not found"));
658 return MFX_ERR_UNSUPPORTED;
659 }
660
661 if (0 == msdk_strlen(pParams->strDstFile))
662 {
663 pParams->bOutput = false;
664 }
665
666 return MFX_ERR_NONE;
667 }
668
669 #if defined(_WIN32) || defined(_WIN64)
_tmain(int argc,TCHAR * argv[])670 int _tmain(int argc, TCHAR *argv[])
671 #else
672 int main(int argc, char *argv[])
673 #endif
674 {
675 sInputParams Params; // input parameters from command line
676 CCameraPipeline Pipeline; // pipeline for decoding, includes input file reader, decoder and output file writer
677
678 mfxStatus sts = MFX_ERR_NONE; // return value check
679
680 sts = ParseInputString(argv, (mfxU8)argc, &Params);
681 MSDK_CHECK_PARSE_RESULT(sts, MFX_ERR_NONE, 1);
682
683 sts = Pipeline.Init(&Params);
684 MSDK_CHECK_STATUS(sts, "Pipeline.Init failed");
685
686 // print stream info
687 Pipeline.PrintInfo();
688
689 msdk_printf(MSDK_STRING("Camera pipe started\n"));
690 #if defined(_WIN32) || defined(_WIN64)
691 LARGE_INTEGER timeBegin, timeEnd, m_Freq;
692 QueryPerformanceFrequency(&m_Freq);
693
694 QueryPerformanceCounter(&timeBegin);
695 #endif
696 int resetNum = 0;
697 for (;;) {
698 sts = Pipeline.Run();
699 if (MFX_WRN_VIDEO_PARAM_CHANGED == sts) {
700 sInputParams *pParams = &Params;
701 if (resetNum >= (int)Params.resetParams.size())
702 break;
703 msdk_strcopy(Params.strSrcFile, Params.resetParams[resetNum].strSrcFile);
704 msdk_strcopy(pParams->strDstFile, Params.resetParams[resetNum].strDstFile);
705 pParams->frameInfo[VPP_IN].nWidth = (mfxU16)Params.resetParams[resetNum].width;
706 pParams->frameInfo[VPP_IN].nHeight = (mfxU16)Params.resetParams[resetNum].height;
707 pParams->frameInfo[VPP_IN].CropW = pParams->frameInfo[VPP_IN].nWidth;
708 if ( Params.resetParams[resetNum].cropW )
709 pParams->frameInfo[VPP_IN].CropW = Params.resetParams[resetNum].cropW;
710 pParams->frameInfo[VPP_IN].CropH = pParams->frameInfo[VPP_IN].nHeight;
711 if ( Params.resetParams[resetNum].cropH )
712 pParams->frameInfo[VPP_IN].CropH = Params.resetParams[resetNum].cropH;
713 pParams->frameInfo[VPP_IN].CropX = align(Params.resetParams[resetNum].cropX);
714 pParams->frameInfo[VPP_IN].CropY = Params.resetParams[resetNum].cropY;
715
716 if ( ! pParams->frameInfo[VPP_IN].CropW )
717 {
718 pParams->frameInfo[VPP_IN].CropW = pParams->frameInfo[VPP_IN].nWidth;
719 }
720
721 if ( ! pParams->frameInfo[VPP_IN].CropH )
722 {
723 pParams->frameInfo[VPP_IN].CropH = pParams->frameInfo[VPP_IN].nHeight;
724 }
725
726 pParams->frameInfo[VPP_OUT].nWidth = pParams->frameInfo[VPP_IN].CropW;
727 pParams->frameInfo[VPP_OUT].nHeight = pParams->frameInfo[VPP_IN].CropH;
728 pParams->frameInfo[VPP_OUT].CropW = pParams->frameInfo[VPP_IN].CropW;
729 pParams->frameInfo[VPP_OUT].CropH = pParams->frameInfo[VPP_IN].CropH;
730
731 pParams->inputType = Params.resetParams[resetNum].inputType;
732 pParams->bHP = Params.resetParams[resetNum].bHP;
733 pParams->hp_diff = Params.resetParams[resetNum].hp_diff;
734 pParams->hp_num = Params.resetParams[resetNum].hp_num;
735
736 pParams->bBayerDenoise = Params.resetParams[resetNum].bDenoise;
737 pParams->denoiseThreshold = Params.resetParams[resetNum].denoiseThreshold;
738
739 pParams->bBlackLevel = Params.resetParams[resetNum].bBlackLevel;
740 pParams->black_level_B = Params.resetParams[resetNum].black_level_B;
741 pParams->black_level_G0= Params.resetParams[resetNum].black_level_G0;
742 pParams->black_level_G1= Params.resetParams[resetNum].black_level_G1;
743 pParams->black_level_R = Params.resetParams[resetNum].black_level_R;
744 pParams->bWhiteBalance = Params.resetParams[resetNum].bWhiteBalance;
745 pParams->white_balance_B = Params.resetParams[resetNum].white_balance_B;
746 pParams->white_balance_G0= Params.resetParams[resetNum].white_balance_G0;
747 pParams->white_balance_G1= Params.resetParams[resetNum].white_balance_G1;
748 pParams->white_balance_R = Params.resetParams[resetNum].white_balance_R;
749 pParams->tcc_red = Params.resetParams[resetNum].tcc_red;
750 pParams->tcc_blue = Params.resetParams[resetNum].tcc_blue;
751 pParams->tcc_green = Params.resetParams[resetNum].tcc_green;
752 pParams->tcc_cyan = Params.resetParams[resetNum].tcc_cyan;
753 pParams->tcc_magenta = Params.resetParams[resetNum].tcc_magenta;
754 pParams->tcc_yellow = Params.resetParams[resetNum].tcc_yellow;
755 pParams->bCCM = Params.resetParams[resetNum].bCCM;
756 for (int k = 0; k < 3; k++)
757 for (int z = 0; z < 3; z++)
758 pParams->CCM[k][z] = Params.resetParams[resetNum].CCM[k][z];
759
760 //pParams->frameInfo[VPP_OUT].FourCC = MFX_FOURCC_ARGB16;
761 //pParams->memTypeIn = pParams->memTypeOut = SYSTEM_MEMORY;
762
763 sts = Pipeline.Reset(&Params);
764 if (sts == MFX_ERR_INCOMPATIBLE_VIDEO_PARAM)
765 {
766 Pipeline.Close();
767 sts = Pipeline.Init(&Params);
768 }
769 if (sts != MFX_ERR_NONE)
770 break;
771 resetNum++;
772 } else
773 break;
774 }
775
776 #if defined(_WIN32) || defined(_WIN64)
777 QueryPerformanceCounter(&timeEnd);
778
779
780 double time = ((double)timeEnd.QuadPart - (double)timeBegin.QuadPart)/ (double)m_Freq.QuadPart;
781
782 int frames = Pipeline.GetNumberProcessedFrames();
783 _tprintf(_T("Total frames %d \n"), frames);
784 _tprintf(_T("Total time %.2lf sec\n"), time);
785 _tprintf(_T("Total FPS %.2lf fps\n"), frames/time);
786 #endif
787 //Pipeline.Close();
788
789 if(MFX_ERR_ABORTED != sts)
790 MSDK_CHECK_STATUS(sts, "Unexpected error!!");
791
792 msdk_printf(MSDK_STRING("\nCamera pipe finished\n"));
793
794 return 0;
795 }
796