1#include <stdlib.h>
2#include <unistd.h>
3#include <sys/types.h>
4#include <sys/stat.h>
5#include <fcntl.h>
6#include <time.h>
7#include <semaphore.h>
8#include <pthread.h>
9#include <string.h>
10#include <assert.h>
11#include <climits>
12
13#include <ui/DisplayInfo.h>
14
15#include <gui/GLConsumer.h>
16#include <gui/Surface.h>
17#include <ui/GraphicBuffer.h>
18
19#include <camera/Camera.h>
20#include <camera/ICamera.h>
21#include <media/mediarecorder.h>
22
23#include <binder/IPCThreadState.h>
24#include <binder/ProcessState.h>
25#include <binder/IServiceManager.h>
26#include <cutils/properties.h>
27#include <camera/CameraParameters.h>
28#include <camera/ShotParameters.h>
29#include <system/audio.h>
30#include <system/camera.h>
31
32#include <binder/IMemory.h>
33#include <binder/MemoryBase.h>
34#include <binder/MemoryHeapBase.h>
35
36#include <cutils/memory.h>
37#include <utils/Log.h>
38
39#include <sys/wait.h>
40
41#include "camera_test.h"
42#include "camera_test_surfacetexture.h"
43#ifdef ANDROID_API_JB_OR_LATER
44#include "camera_test_bufferqueue.h"
45#endif
46
47using namespace android;
48
49int camera_index = 0;
50int print_menu;
51
52sp<Camera> camera;
53sp<MediaRecorder> recorder;
54sp<SurfaceComposerClient> client;
55sp<SurfaceControl> surfaceControl;
56sp<Surface> previewSurface;
57sp<BufferSourceThread> bufferSourceOutputThread;
58sp<BufferSourceInput> bufferSourceInput;
59
60CameraParameters params;
61ShotParameters shotParams;
62float compensation = 0.0;
63double latitude = 0.0;
64double longitude = 0.0;
65double degree_by_step = 17.5609756;
66double altitude = 0.0;
67int awb_mode = 0;
68int effects_mode = 0;
69int scene_mode = 0;
70int caf_mode = 0;
71int tempBracketRange = 1;
72int tempBracketIdx = 0;
73int measurementIdx = 0;
74int expBracketIdx = BRACKETING_IDX_DEFAULT;
75int AutoConvergenceModeIDX = 0;
76int gbceIDX = 0;
77int glbceIDX = 0;
78int rotation = 0;
79int previewRotation = 0;
80bool reSizePreview = true;
81bool hardwareActive = false;
82bool recordingMode = false;
83bool previewRunning = false;
84bool vstabtoggle = false;
85bool AutoExposureLocktoggle = false;
86bool AutoWhiteBalanceLocktoggle = false;
87bool vnftoggle = false;
88bool faceDetectToggle = false;
89bool metaDataToggle = false;
90bool shotConfigFlush = false;
91bool streamCapture = false;
92int saturation = 0;
93int zoomIDX = 0;
94int videoCodecIDX = 0;
95int audioCodecIDX = 0;
96int outputFormatIDX = 0;
97int contrast = 0;
98int brightness = 0;
99unsigned int burst = 0;
100unsigned int burstCount = 0;
101int sharpness = 0;
102int iso_mode = 0;
103int capture_mode = 0;
104int exposure_mode = 0;
105int ippIDX = 0;
106int ippIDX_old = 0;
107int previewFormat = 0;
108int pictureFormat = 0;
109int jpegQuality = 85;
110int thumbQuality = 85;
111int flashIdx = 0;
112int fpsRangeIdx = 0;
113timeval autofocus_start, picture_start;
114char script_name[80];
115int prevcnt = 0;
116int videoFd = -1;
117int afTimeoutIdx = 0;
118int platformID = BLAZE_TABLET2;
119int numAntibanding = 0;
120int numEffects = 0;
121int numcaptureSize = 0;
122int nummodevalues = 0;
123int numVcaptureSize = 0;
124int numpreviewSize = 0;
125int numthumbnailSize = 0;
126int numawb = 0;
127int numscene = 0;
128int numfocus = 0;
129int numflash = 0;
130int numExposureMode = 0;
131int numisoMode = 0;
132int antibanding_mode = 0;
133int effectsStrLenght = 0;
134int numfps = 0;
135int numpreviewFormat = 0;
136int numpictureFormat = 0;
137int *constFramerate = 0;
138int rangeCnt = 0;
139int constCnt = 0;
140int focus_mode = 0;
141int thumbSizeIDX =  0;
142int previewSizeIDX = 1;
143int captureSizeIDX = 0;
144int VcaptureSizeIDX = 1;
145int frameRateIDX = 0;
146char *str;
147char *param;
148char *antibandStr = 0;
149char *exposureModeStr = 0;
150char *isoModeStr = 0;
151char *effectssStr = 0;
152char *captureSizeStr  = 0;
153char *modevaluesstr = 0;
154char *videosnapshotstr = 0;
155char *autoconvergencestr = 0;
156char *VcaptureSizeStr  = 0;
157char *thumbnailSizeStr  = 0;
158char *vstabstr = 0;
159char *vnfstr = 0;
160char *zoomstr = 0;
161char *smoothzoomstr = 0;
162char *AutoExposureLockstr = 0;
163char *AutoWhiteBalanceLockstr = 0;
164char *previewSizeStr = 0;
165char *awbStr = 0;
166char *sceneStr = 0;
167char *focusStr = 0;
168char *flashStr = 0;
169char *fpsstr = 0;
170char *previewFormatStr = 0;
171char *pictureFormatStr = 0;
172char **modevalues = 0;
173char **elem;
174char **antiband = 0;
175char **effectss = 0;
176char **awb = 0;
177char **scene = 0;
178char **focus = 0;
179char **flash = 0;
180char **exposureMode = 0;
181char **isoMode = 0;
182char **previewFormatArray = 0;
183char **pictureFormatArray = 0;
184char **fps_const_str = 0;
185char **rangeDescription = 0;
186char **fps_range_str = 0;
187param_Array ** capture_Array = 0;
188param_Array ** Vcapture_Array = 0;
189param_Array ** preview_Array = 0;
190param_Array ** thumbnail_Array = 0;
191fps_Array * fpsArray = 0;
192
193int enableMisalignmentCorrectionIdx = 0;
194
195char **autoconvergencemode = 0;
196int numAutoConvergence = 0;
197const char MeteringAreas[] = "(-656,-671,188,454,1)";
198
199char **stereoLayout;
200int numLay = 0;
201
202char **stereoCapLayout;
203int numCLay = 0;
204
205int stereoLayoutIDX = 1;
206int stereoCapLayoutIDX = 0;
207
208char *layoutstr =0;
209char *capturelayoutstr =0;
210
211char output_dir_path[256];
212char videos_dir_path[256 + 8];
213char images_dir_path[256 + 8];
214
215const char *cameras[] = {"Primary Camera", "Secondary Camera 1", "Stereo Camera"};
216const char *measurement[] = {"disable", "enable"};
217
218param_NamedExpBracketList_t expBracketing[] = {
219  {
220    "Disabled",
221    PARAM_EXP_BRACKET_PARAM_NONE,
222    PARAM_EXP_BRACKET_VALUE_NONE,
223    PARAM_EXP_BRACKET_APPLY_NONE,
224    "0"
225  },
226  {
227    "Relative exposure compensation",
228    PARAM_EXP_BRACKET_PARAM_COMP,
229    PARAM_EXP_BRACKET_VALUE_REL,
230    PARAM_EXP_BRACKET_APPLY_ADJUST,
231    "-300,-150,0,150,300,150,0,-150,-300"
232  },
233  {
234    "Relative exposure compensation (forced)",
235    PARAM_EXP_BRACKET_PARAM_COMP,
236    PARAM_EXP_BRACKET_VALUE_REL,
237    PARAM_EXP_BRACKET_APPLY_FORCED,
238    "-300F,-150F,0F,150F,300F,150F,0F,-150F,-300F"
239  },
240  {
241    "Absolute exposure and gain",
242    PARAM_EXP_BRACKET_PARAM_PAIR,
243    PARAM_EXP_BRACKET_VALUE_ABS,
244    PARAM_EXP_BRACKET_APPLY_ADJUST,
245    "(33000,10),(0,70),(33000,100),(0,130),(33000,160),(0,180),(33000,200),(0,130),(33000,200)"
246  },
247  {
248    "Absolute exposure and gain (forced)",
249    PARAM_EXP_BRACKET_PARAM_PAIR,
250    PARAM_EXP_BRACKET_VALUE_ABS,
251    PARAM_EXP_BRACKET_APPLY_FORCED,
252    "(33000,10)F,(0,70)F,(33000,100)F,(0,130)F,(33000,160)F,(0,180)F,(33000,200)F,(0,130)F,(33000,200)F"
253  },
254  {
255    "Relative exposure and gain",
256    PARAM_EXP_BRACKET_PARAM_PAIR,
257    PARAM_EXP_BRACKET_VALUE_REL,
258    PARAM_EXP_BRACKET_APPLY_ADJUST,
259    "(-300,-100),(-300,+0),(-100, +0),(-100,+100),(+0,+0),(+100,-100),(+100,+0),(+300,+0),(+300,+100)"
260  },
261  {
262    "Relative exposure and gain (forced)",
263    PARAM_EXP_BRACKET_PARAM_PAIR,
264    PARAM_EXP_BRACKET_VALUE_REL,
265    PARAM_EXP_BRACKET_APPLY_FORCED,
266    "(-300,-100)F,(-300,+0)F,(-100, +0)F,(-100,+100)F,(+0,+0)F,(+100,-100)F,(+100,+0)F,(+300,+0)F,(+300,+100)F"
267  },
268};
269
270const char *tempBracketing[] = {"false", "true"};
271const char *faceDetection[] = {"disable", "enable"};
272const char *afTimeout[] = {"enable", "disable" };
273
274const char *misalignmentCorrection[] = {"enable", "disable" };
275
276#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
277const char *ipp_mode[] = { "off", "Chroma Suppression", "Edge Enhancement" };
278#else
279const char *ipp_mode[] = { "off", "ldc", "nsf", "ldc-nsf" };
280#endif
281
282
283const char *caf [] = { "Off", "On" };
284
285int numCamera = 0;
286bool stereoMode = false;
287
288int manualExp = 0;
289int manualExpMin = 0;
290int manualExpMax = 0;
291int manualExpStep = 0;
292int manualGain = 0;
293int manualGainMin = 0;
294int manualGainMax = 0;
295int manualGainStep = 0;
296int manualConv = 0;
297int manualConvMin = 0;
298int manualConvMax = 0;
299int manualConvStep = 0;
300
301param_Array previewSize [] = {
302  { 0,   0,  "NULL"},
303  { 128, 96, "SQCIF" },
304  { 176, 144, "QCIF" },
305  { 352, 288, "CIF" },
306  { 320, 240, "QVGA" },
307  { 352, 288, "CIF" },
308  { 640, 480, "VGA" },
309  { 720, 480, "NTSC" },
310  { 720, 576, "PAL" },
311  { 800, 480, "WVGA" },
312  { 848, 480, "WVGA2"},
313  { 864, 480, "WVGA3"},
314  { 992, 560, "WVGA4"},
315  { 1280, 720, "HD" },
316  { 1920, 1080, "FULLHD"},
317  { 240, 160,"240x160"},
318  { 768, 576,  "768x576" },
319  { 960, 720, "960x720"},
320  { 256, 96,"SQCIF"},// stereo
321  { 128, 192, "SQCIF"},
322  { 352, 144,"QCIF"},
323  { 176, 288, "QCIF"},
324  { 480, 160, "240x160"},
325  { 240, 320, "240x160"},
326  { 704, 288, "CIF"},
327  { 352, 576, "CIF"},
328  { 640, 240,"QVGA"},
329  { 320, 480, "QVGA"},
330  { 1280, 480,"VGA"},
331  { 640, 960, "VGA"},
332  { 1536, 576,"768x576"},
333  { 768, 1152, "768x576"},
334  { 1440, 480,"NTSC"},
335  { 720, 960,"NTSC"},
336  { 1440, 576, "PAL"},
337  { 720, 1152, "PAL"},
338  { 1600, 480, "WVGA"},
339  { 800, 960,"WVGA"},
340  { 2560, 720, "HD"},
341  { 1280, 1440,  "HD"}
342};
343
344size_t length_previewSize =  ARRAY_SIZE(previewSize);
345
346param_Array thumbnailSize [] = {
347  { 0,   0,  "NULL"},
348  { 128, 96, "SQCIF" },
349  { 176, 144, "QCIF" },
350  { 352, 288, "CIF" },
351  { 320, 240, "QVGA" },
352  { 352, 288, "CIF" },
353  { 640, 480, "VGA" },
354};
355
356size_t length_thumbnailSize =  ARRAY_SIZE(thumbnailSize);
357
358param_Array VcaptureSize [] = {
359  { 0,   0,  "NULL"},
360  { 128, 96, "SQCIF" },
361  { 176, 144, "QCIF" },
362  { 352, 288, "CIF" },
363  { 320, 240, "QVGA" },
364  { 352, 288, "CIF" },
365  { 640, 480, "VGA" },
366  { 720, 480, "NTSC" },
367  { 720, 576, "PAL" },
368  { 800, 480, "WVGA" },
369  #if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
370  { 848, 480, "WVGA2"},
371  { 864, 480, "WVGA3"},
372  { 992, 560, "WVGA4"},
373  #endif
374  { 1280, 720, "HD" },
375  { 1920, 1080, "FULLHD"},
376  { 240, 160,"240x160"},
377  { 768, 576,  "768x576" },
378  { 960, 720, "960x720"},
379  { 256, 96,"SQCIF"},// stereo
380  { 128, 192, "SQCIF"},
381  { 352, 144,"QCIF"},
382  { 176, 288, "QCIF"},
383  { 480, 160, "240x160"},
384  { 240, 320, "240x160"},
385  { 704, 288, "CIF"},
386  { 352, 576, "CIF"},
387  { 640, 240,"QVGA"},
388  { 320, 480, "QVGA"},
389  { 1280, 480,"VGA"},
390  { 640, 960, "VGA"},
391  { 1536, 576,"768x576"},
392  { 768, 1152, "768x576"},
393  { 1440, 480,"NTSC"},
394  { 720, 960,"NTSC"},
395  { 1440, 576, "PAL"},
396  { 720, 1152, "PAL"},
397  { 1600, 480, "WVGA"},
398  { 800, 960,"WVGA"},
399  { 2560, 720, "HD"},
400  { 1280, 1440,  "HD"}
401};
402
403size_t lenght_Vcapture_size = ARRAY_SIZE(VcaptureSize);
404
405param_Array captureSize[] = {
406  {  320, 240,  "QVGA" },
407  {  640, 480,  "VGA" },
408  {  800, 600,  "SVGA" },
409  { 1152, 864,  "1MP" },
410  { 1280, 1024, "1.3MP" },
411  { 1600, 1200,  "2MP" },
412  { 2016, 1512,  "3MP" },
413  { 2592, 1944,  "5MP" },
414  { 2608, 1960,  "5MP" },
415  { 3264, 2448,  "8MP" },
416  { 3648, 2736, "10MP"},
417  { 4032, 3024, "12MP"},
418  { 640, 240,   "QVGA"},   //stereo
419  { 320, 480, "QVGA"},
420  { 1280, 480, "VGA"},
421  { 640, 960,  "VGA"},
422  { 2560, 960,  "1280x960"},
423  { 1280, 1920,  "1280x960"},
424  { 2304, 864,  "1MP"},
425  { 1152, 1728,   "1MP"},
426  { 2560, 1024,  "1.3MP"},
427  { 1280, 2048, "1.3MP"},
428  { 3200, 1200,   "2MP"},
429  { 1600, 2400,  "2MP"},
430  { 4096, 1536,  "3MP"},
431  { 2048, 3072,  "3MP"}
432};
433
434size_t length_capture_Size = ARRAY_SIZE(captureSize);
435
436outformat outputFormat[] = {
437        { OUTPUT_FORMAT_THREE_GPP, "3gp" },
438        { OUTPUT_FORMAT_MPEG_4, "mp4" },
439    };
440
441size_t length_outformat = ARRAY_SIZE(outputFormat);
442
443video_Codecs videoCodecs[] = {
444  { VIDEO_ENCODER_H263, "H263" },
445  { VIDEO_ENCODER_H264, "H264" },
446  { VIDEO_ENCODER_MPEG_4_SP, "MPEG4"}
447};
448
449size_t length_video_Codecs = ARRAY_SIZE(videoCodecs);
450
451audio_Codecs audioCodecs[] = {
452  { AUDIO_ENCODER_AMR_NB, "AMR_NB" },
453  { AUDIO_ENCODER_AMR_WB, "AMR_WB" },
454  { AUDIO_ENCODER_AAC, "AAC" },
455  { AUDIO_ENCODER_HE_AAC, "AAC+" },
456  { AUDIO_ENCODER_LIST_END, "disabled"},
457};
458
459size_t length_audio_Codecs = ARRAY_SIZE(audioCodecs);
460
461V_bitRate VbitRate[] = {
462  {    64000, "64K"  },
463  {   128000, "128K" },
464  {   192000, "192K" },
465  {   240000, "240K" },
466  {   320000, "320K" },
467  {   360000, "360K" },
468  {   384000, "384K" },
469  {   420000, "420K" },
470  {   768000, "768K" },
471  {  1000000, "1M"   },
472  {  1500000, "1.5M" },
473  {  2000000, "2M"   },
474  {  4000000, "4M"   },
475  {  6000000, "6M"   },
476  {  8000000, "8M"   },
477  { 10000000, "10M"  },
478};
479
480size_t length_V_bitRate = ARRAY_SIZE(VbitRate);
481
482Zoom zoom[] = {
483  { 0,  "1x"  },
484  { 12,  "1.5x"},
485  { 20, "2x"  },
486  { 28, "2.5x"},
487  { 32, "3x"  },
488  { 36, "3.5x"},
489  { 40, "4x"  },
490  { 60, "8x"  },
491};
492
493size_t length_Zoom = ARRAY_SIZE(zoom);
494
495pixel_format pixelformat[] = {
496  { HAL_PIXEL_FORMAT_YCbCr_422_I, CameraParameters::PIXEL_FORMAT_YUV422I },
497  { HAL_PIXEL_FORMAT_YCrCb_420_SP, CameraParameters::PIXEL_FORMAT_YUV420SP },
498  { HAL_PIXEL_FORMAT_RGB_565, CameraParameters::PIXEL_FORMAT_RGB565 },
499  { -1, CameraParameters::PIXEL_FORMAT_JPEG },
500  { -1, CameraParameters::PIXEL_FORMAT_BAYER_RGGB },
501  };
502
503const char *gbce[] = {"disable", "enable"};
504
505int VbitRateIDX = ARRAY_SIZE(VbitRate) - 1;
506
507static unsigned int recording_counter = 1;
508
509int dump_preview = 0;
510int bufferStarvationTest = 0;
511bool showfps = false;
512
513const char *metering[] = {
514    "center",
515    "average",
516};
517int meter_mode = 0;
518bool stressTest = false;
519bool stopScript = false;
520int restartCount = 0;
521bool firstTime = true;
522bool firstTimeStereo = true;
523
524//TI extensions for enable/disable algos
525const char *algoFixedGamma[] = {CameraParameters::FALSE, CameraParameters::TRUE};
526const char *algoNSF1[] = {CameraParameters::FALSE, CameraParameters::TRUE};
527const char *algoNSF2[] = {CameraParameters::FALSE, CameraParameters::TRUE};
528const char *algoSharpening[] = {CameraParameters::FALSE, CameraParameters::TRUE};
529const char *algoThreeLinColorMap[] = {CameraParameters::FALSE, CameraParameters::TRUE};
530const char *algoGIC[] = {CameraParameters::FALSE, CameraParameters::TRUE};
531int algoFixedGammaIDX = 1;
532int algoNSF1IDX = 1;
533int algoNSF2IDX = 1;
534int algoSharpeningIDX = 1;
535int algoThreeLinColorMapIDX = 1;
536int algoGICIDX = 1;
537
538/** Buffer source reset */
539bool bufferSourceInputReset = false;
540bool bufferSourceOutputReset = false;
541
542/** Calculate delay from a reference time */
543unsigned long long timeval_delay(const timeval *ref) {
544    unsigned long long st, end, delay;
545    timeval current_time;
546
547    gettimeofday(&current_time, 0);
548
549    st = ref->tv_sec * 1000000 + ref->tv_usec;
550    end = current_time.tv_sec * 1000000 + current_time.tv_usec;
551    delay = end - st;
552
553    return delay;
554}
555
556/** Callback for takePicture() */
557void my_raw_callback(const sp<IMemory>& mem) {
558
559    static int      counter = 1;
560    unsigned char   *buff = NULL;
561    int             size;
562    int             fd = -1;
563    char            fn[384];
564
565    LOG_FUNCTION_NAME;
566
567    if (mem == NULL)
568        goto out;
569
570    if( strcmp(modevalues[capture_mode], "cp-cam") ) {
571        //Start preview after capture.
572        camera->startPreview();
573    }
574
575    fn[0] = 0;
576    sprintf(fn, "%s/img%03d.raw", images_dir_path, counter);
577    fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777);
578
579    if (fd < 0)
580        goto out;
581
582    size = mem->size();
583
584    if (size <= 0)
585        goto out;
586
587    buff = (unsigned char *)mem->pointer();
588
589    if (!buff)
590        goto out;
591
592    if (size != write(fd, buff, size))
593        printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno));
594
595    counter++;
596    printf("%s: buffer=%08X, size=%d stored at %s\n",
597           __FUNCTION__, (int)buff, size, fn);
598
599out:
600
601    if (fd >= 0)
602        close(fd);
603
604    LOG_FUNCTION_NAME_EXIT;
605}
606
607void saveFile(const sp<IMemory>& mem) {
608    static int      counter = 1;
609    unsigned char   *buff = NULL;
610    int             size;
611    int             fd = -1;
612    char            fn[384];
613
614    LOG_FUNCTION_NAME;
615
616    if (mem == NULL)
617        goto out;
618
619    fn[0] = 0;
620    sprintf(fn, "%s/preview%03d.yuv", images_dir_path, counter);
621    fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777);
622    if(fd < 0) {
623        CAMHAL_LOGE("Unable to open file %s: %s", fn, strerror(fd));
624        goto out;
625    }
626
627    size = mem->size();
628    if (size <= 0) {
629        CAMHAL_LOGE("IMemory object is of zero size");
630        goto out;
631    }
632
633    buff = (unsigned char *)mem->pointer();
634    if (!buff) {
635        CAMHAL_LOGE("Buffer pointer is invalid");
636        goto out;
637    }
638
639    if (size != write(fd, buff, size))
640        printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno));
641
642    counter++;
643    printf("%s: buffer=%08X, size=%d\n",
644           __FUNCTION__, (int)buff, size);
645
646out:
647
648    if (fd >= 0)
649        close(fd);
650
651    LOG_FUNCTION_NAME_EXIT;
652}
653
654
655void debugShowFPS()
656{
657    static int mFrameCount = 0;
658    static int mLastFrameCount = 0;
659    static nsecs_t mLastFpsTime = 0;
660    static float mFps = 0;
661    mFrameCount++;
662    if ( ( mFrameCount % 30 ) == 0 ) {
663        nsecs_t now = systemTime();
664        nsecs_t diff = now - mLastFpsTime;
665        mFps =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
666        mLastFpsTime = now;
667        mLastFrameCount = mFrameCount;
668        printf("####### [%d] Frames, %f FPS", mFrameCount, mFps);
669    }
670}
671
672/** Callback for startPreview() */
673void my_preview_callback(const sp<IMemory>& mem) {
674
675    printf("PREVIEW Callback 0x%x", ( unsigned int ) mem->pointer());
676    if (dump_preview) {
677
678        if(prevcnt==50)
679        saveFile(mem);
680
681        prevcnt++;
682
683        uint8_t *ptr = (uint8_t*) mem->pointer();
684
685        printf("PRV_CB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7], ptr[8], ptr[9]);
686
687    }
688
689    debugShowFPS();
690}
691
692/** Callback for takePicture() */
693void my_jpeg_callback(const sp<IMemory>& mem) {
694    static int  counter = 1;
695    unsigned char   *buff = NULL;
696    int     size;
697    int     fd = -1;
698    char        fn[384];
699
700    LOG_FUNCTION_NAME;
701
702    if( strcmp(modevalues[capture_mode], "cp-cam")) {
703        if(burstCount > 1) {
704            burstCount --;
705            // Restart preview if taking a single capture
706            // or after the last iteration of burstCount
707        } else if(burstCount == 0 || burstCount == 1) {
708            camera->startPreview();
709            burstCount = burst;
710        }
711    }
712
713    if (mem == NULL)
714        goto out;
715
716    fn[0] = 0;
717    sprintf(fn, "%s/img%03d.jpg", images_dir_path, counter);
718    fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777);
719
720    if(fd < 0) {
721        CAMHAL_LOGE("Unable to open file %s: %s", fn, strerror(fd));
722        goto out;
723    }
724
725    size = mem->size();
726    if (size <= 0) {
727        CAMHAL_LOGE("IMemory object is of zero size");
728        goto out;
729    }
730
731    buff = (unsigned char *)mem->pointer();
732    if (!buff) {
733        CAMHAL_LOGE("Buffer pointer is invalid");
734        goto out;
735    }
736
737    if (size != write(fd, buff, size))
738        printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno));
739
740    counter++;
741    printf("%s: buffer=%08X, size=%d stored at %s\n",
742           __FUNCTION__, (int)buff, size, fn);
743
744out:
745
746    if (fd >= 0)
747        close(fd);
748
749    LOG_FUNCTION_NAME_EXIT;
750}
751
752void my_face_callback(camera_frame_metadata_t *metadata) {
753    int idx;
754
755    if ( NULL == metadata ) {
756        return;
757    }
758
759    for ( idx = 0 ; idx < metadata->number_of_faces ; idx++ ) {
760        printf("Face %d at %d,%d %d,%d \n",
761               idx,
762               metadata->faces[idx].rect[0],
763               metadata->faces[idx].rect[1],
764               metadata->faces[idx].rect[2],
765               metadata->faces[idx].rect[3]);
766    }
767
768}
769
770void CameraHandler::notify(int32_t msgType, int32_t ext1, int32_t ext2) {
771
772    printf("Notify cb: %d %d %d\n", msgType, ext1, ext2);
773
774    if ( msgType & CAMERA_MSG_FOCUS )
775        printf("AutoFocus %s in %llu us\n", (ext1) ? "OK" : "FAIL", timeval_delay(&autofocus_start));
776
777    if ( msgType & CAMERA_MSG_SHUTTER )
778        printf("Shutter done in %llu us\n", timeval_delay(&picture_start));
779
780    if ( msgType & CAMERA_MSG_ERROR && (ext1 == 1))
781      {
782        printf("Camera Test CAMERA_MSG_ERROR.....\n");
783        if (stressTest)
784          {
785            printf("Camera Test Notified of Error Restarting.....\n");
786            stopScript = true;
787          }
788        else
789          {
790            printf("Camera Test Notified of Error Stopping.....\n");
791            stopScript =false;
792            stopPreview();
793
794            if (recordingMode)
795              {
796                stopRecording();
797                closeRecorder();
798                recordingMode = false;
799              }
800          }
801      }
802}
803
804void CameraHandler::postData(int32_t msgType,
805                             const sp<IMemory>& dataPtr,
806                             camera_frame_metadata_t *metadata) {
807    int32_t msgMask;
808    printf("Data cb: %d\n", msgType);
809
810    if ( msgType & CAMERA_MSG_PREVIEW_FRAME )
811        my_preview_callback(dataPtr);
812
813    msgMask = CAMERA_MSG_RAW_IMAGE;
814#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
815    msgMask |= CAMERA_MSG_RAW_BURST;
816#endif
817    if ( msgType & msgMask) {
818        printf("RAW done in %llu us\n", timeval_delay(&picture_start));
819        my_raw_callback(dataPtr);
820    }
821
822    if (msgType & CAMERA_MSG_POSTVIEW_FRAME) {
823        printf("Postview frame %llu us\n", timeval_delay(&picture_start));
824    }
825
826    if (msgType & CAMERA_MSG_COMPRESSED_IMAGE ) {
827        printf("JPEG done in %llu us\n", timeval_delay(&picture_start));
828        my_jpeg_callback(dataPtr);
829    }
830
831    if ( ( msgType & CAMERA_MSG_PREVIEW_METADATA ) &&
832         ( NULL != metadata ) ) {
833        if (metaDataToggle) {
834            printf("Preview exposure: %6d    Preview gain: %4d\n",
835                   metadata->exposure_time, metadata->analog_gain);
836        }
837
838        if (faceDetectToggle) {
839            printf("Face detected %d \n", metadata->number_of_faces);
840            my_face_callback(metadata);
841        }
842    }
843}
844
845void CameraHandler::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)
846
847{
848    static uint32_t count = 0;
849
850    //if(count==100)
851    //saveFile(dataPtr);
852
853    count++;
854
855    uint8_t *ptr = (uint8_t*) dataPtr->pointer();
856
857#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
858    if ( msgType & CAMERA_MSG_RAW_BURST) {
859        printf("RAW done timestamp: %llu\n", timestamp);
860        my_raw_callback(dataPtr);
861    } else
862#endif
863    {
864        printf("Recording cb: %d %lld %p\n", msgType, timestamp, dataPtr.get());
865        printf("VID_CB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7], ptr[8], ptr[9]);
866        camera->releaseRecordingFrame(dataPtr);
867    }
868}
869
870int createPreviewSurface(unsigned int width, unsigned int height, int32_t pixFormat) {
871    unsigned int previewWidth, previewHeight;
872    DisplayInfo dinfo;
873    SurfaceComposerClient::getDisplayInfo(0, &dinfo);
874
875    const unsigned MAX_PREVIEW_SURFACE_WIDTH = dinfo.w;
876    const unsigned MAX_PREVIEW_SURFACE_HEIGHT = dinfo.h;
877
878    if ( MAX_PREVIEW_SURFACE_WIDTH < width ) {
879        previewWidth = MAX_PREVIEW_SURFACE_WIDTH;
880    } else {
881        previewWidth = width;
882    }
883
884    if ( MAX_PREVIEW_SURFACE_HEIGHT < height ) {
885        previewHeight = MAX_PREVIEW_SURFACE_HEIGHT;
886    } else {
887        previewHeight = height;
888    }
889
890    client = new SurfaceComposerClient();
891
892    if ( NULL == client.get() ) {
893        printf("Unable to establish connection to Surface Composer \n");
894
895        return -1;
896    }
897
898    surfaceControl = client->createSurface(0,
899                                           previewWidth,
900                                           previewHeight,
901                                           pixFormat);
902
903    previewSurface = surfaceControl->getSurface();
904
905    client->openGlobalTransaction();
906    surfaceControl->setLayer(0x7fffffff);
907    surfaceControl->setPosition(0, 0);
908    surfaceControl->setSize(previewWidth, previewHeight);
909    surfaceControl->show();
910    client->closeGlobalTransaction();
911
912    return 0;
913}
914
915void printSupportedParams()
916{
917    printf("\n\r\tSupported Cameras: %s", params.get("camera-indexes"));
918    printf("\n\r\tSupported Picture Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));
919    printf("\n\r\tSupported Picture Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS));
920    printf("\n\r\tSupported Video Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
921    printf("\n\r\tSupported Preview Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
922    printf("\n\r\tSupported Preview Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS));
923    printf("\n\r\tSupported Preview Frame Rates: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES));
924    printf("\n\r\tSupported Thumbnail Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES));
925    printf("\n\r\tSupported Whitebalance Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE));
926    printf("\n\r\tSupported Effects: %s", params.get(CameraParameters::KEY_SUPPORTED_EFFECTS));
927    printf("\n\r\tSupported Scene Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES));
928    printf("\n\r\tSupported ISO Modes: %s", params.get("iso-mode-values"));
929    printf("\n\r\tSupported Focus Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES));
930    printf("\n\r\tSupported Antibanding Options: %s", params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING));
931    printf("\n\r\tSupported Flash Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES));
932    printf("\n\r\tSupported Focus Areas: %d", params.getInt(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS));
933    printf("\n\r\tSupported Metering Areas: %d", params.getInt(CameraParameters::KEY_MAX_NUM_METERING_AREAS));
934    printf("\n\r\tSupported Preview FPS Range: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE));
935    printf("\n\r\tSupported Exposure modes: %s", params.get("exposure-mode-values"));
936    printf("\n\r\tSupported VSTAB modes: %s", params.get(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED));
937    printf("\n\r\tSupported VNF modes: %s", params.get("vnf-supported"));
938    printf("\n\r\tSupported AutoExposureLock: %s", params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED));
939    printf("\n\r\tSupported AutoWhiteBalanceLock: %s", params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED));
940    printf("\n\r\tSupported Zoom: %s", params.get(CameraParameters::KEY_ZOOM_SUPPORTED));
941    printf("\n\r\tSupported Smooth Zoom: %s", params.get(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED));
942    printf("\n\r\tSupported Video Snapshot: %s", params.get(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED));
943    printf("\n\r\tSupported Capture modes: %s", params.get("mode-values"));
944
945    if ( NULL != params.get(CameraParameters::KEY_FOCUS_DISTANCES) ) {
946        printf("\n\r\tFocus Distances: %s \n", params.get(CameraParameters::KEY_FOCUS_DISTANCES));
947    }
948
949    return;
950}
951
952
953int destroyPreviewSurface() {
954
955    if ( NULL != previewSurface.get() ) {
956        previewSurface.clear();
957    }
958
959    if ( NULL != surfaceControl.get() ) {
960        surfaceControl->clear();
961        surfaceControl.clear();
962    }
963
964    if ( NULL != client.get() ) {
965        client->dispose();
966        client.clear();
967    }
968
969    return 0;
970}
971
972int openRecorder() {
973    recorder = new MediaRecorder();
974
975    if ( NULL == recorder.get() ) {
976        printf("Error while creating MediaRecorder\n");
977
978        return -1;
979    }
980
981    return 0;
982}
983
984int closeRecorder() {
985    if ( NULL == recorder.get() ) {
986        printf("invalid recorder reference\n");
987
988        return -1;
989    }
990
991    if ( recorder->init() < 0 ) {
992        printf("recorder failed to initialize\n");
993
994        return -1;
995    }
996
997    if ( recorder->close() < 0 ) {
998        printf("recorder failed to close\n");
999
1000        return -1;
1001    }
1002
1003    if ( recorder->release() < 0 ) {
1004        printf("error while releasing recorder\n");
1005
1006        return -1;
1007    }
1008
1009    recorder.clear();
1010
1011    return 0;
1012}
1013
1014int configureRecorder() {
1015
1016    char videoFile[384],vbit_string[50];
1017    videoFd = -1;
1018    struct CameraInfo cameraInfo;
1019    camera->getCameraInfo(camera_index, &cameraInfo);
1020
1021    if ( ( NULL == recorder.get() ) || ( NULL == camera.get() ) ) {
1022        printf("invalid recorder and/or camera references\n");
1023
1024        return -1;
1025    }
1026
1027    camera->unlock();
1028
1029    sprintf(vbit_string,"video-param-encoding-bitrate=%u", VbitRate[VbitRateIDX].bit_rate);
1030    String8 bit_rate(vbit_string);
1031    if ( recorder->setParameters(bit_rate) < 0 ) {
1032        printf("error while configuring bit rate\n");
1033
1034        return -1;
1035    }
1036
1037    if ( recorder->setCamera(camera->remote(), camera->getRecordingProxy()) < 0 ) {
1038        printf("error while setting the camera\n");
1039
1040        return -1;
1041    }
1042
1043    if ( recorder->setVideoSource(VIDEO_SOURCE_CAMERA) < 0 ) {
1044        printf("error while configuring camera video source\n");
1045
1046        return -1;
1047    }
1048
1049
1050    if ( AUDIO_ENCODER_LIST_END != audioCodecs[audioCodecIDX].type ) {
1051        if ( recorder->setAudioSource(AUDIO_SOURCE_DEFAULT) < 0 ) {
1052            printf("error while configuring camera audio source\n");
1053
1054            return -1;
1055        }
1056    }
1057
1058    if ( recorder->setOutputFormat(outputFormat[outputFormatIDX].type) < 0 ) {
1059        printf("error while configuring output format\n");
1060
1061        return -1;
1062    }
1063
1064    sprintf(videoFile, "%s/video%d.%s", videos_dir_path, recording_counter, outputFormat[outputFormatIDX].desc);
1065
1066    videoFd = open(videoFile, O_CREAT | O_RDWR);
1067
1068    if(videoFd < 0){
1069        printf("Error while creating video filename\n");
1070
1071        return -1;
1072    }
1073
1074    if ( recorder->setOutputFile(videoFd, 0, 0) < 0 ) {
1075        printf("error while configuring video filename\n");
1076
1077        return -1;
1078    }
1079
1080    recording_counter++;
1081
1082    if (cameraInfo.orientation == 90 || cameraInfo.orientation == 270 ) {
1083        if ( recorder->setVideoSize(Vcapture_Array[VcaptureSizeIDX]->height, Vcapture_Array[VcaptureSizeIDX]->width) < 0 ) {
1084            printf("error while configuring video size\n");
1085            return -1;
1086        }
1087    } else {
1088        if ( recorder->setVideoSize(Vcapture_Array[VcaptureSizeIDX]->width, Vcapture_Array[VcaptureSizeIDX]->height) < 0 ) {
1089            printf("error while configuring video size\n");
1090            return -1;
1091        }
1092    }
1093
1094    if ( recorder->setVideoEncoder(videoCodecs[videoCodecIDX].type) < 0 ) {
1095        printf("error while configuring video codec\n");
1096
1097        return -1;
1098    }
1099
1100    if ( AUDIO_ENCODER_LIST_END != audioCodecs[audioCodecIDX].type ) {
1101        if ( recorder->setAudioEncoder(audioCodecs[audioCodecIDX].type) < 0 ) {
1102            printf("error while configuring audio codec\n");
1103
1104            return -1;
1105        }
1106    }
1107
1108    if ( recorder->setPreviewSurface( surfaceControl->getSurface()->getIGraphicBufferProducer() ) < 0 ) {
1109        printf("error while configuring preview surface\n");
1110
1111        return -1;
1112    }
1113
1114    return 0;
1115}
1116
1117int startRecording() {
1118    if ( ( NULL == recorder.get() ) || ( NULL == camera.get() ) ) {
1119        printf("invalid recorder and/or camera references\n");
1120
1121        return -1;
1122    }
1123
1124    camera->unlock();
1125
1126    if ( recorder->prepare() < 0 ) {
1127        printf("recorder prepare failed\n");
1128
1129        return -1;
1130    }
1131
1132    if ( recorder->start() < 0 ) {
1133        printf("recorder start failed\n");
1134
1135        return -1;
1136    }
1137
1138    return 0;
1139}
1140
1141int stopRecording() {
1142    if ( NULL == recorder.get() ) {
1143        printf("invalid recorder reference\n");
1144
1145        return -1;
1146    }
1147
1148    if ( recorder->stop() < 0 ) {
1149        printf("recorder failed to stop\n");
1150
1151        return -1;
1152    }
1153
1154    if ( 0 < videoFd ) {
1155        close(videoFd);
1156    }
1157
1158    return 0;
1159}
1160
1161int openCamera() {
1162
1163    antibandStr = new char [256];
1164    effectssStr = new char [256];
1165    exposureModeStr = new char [256];
1166    captureSizeStr = new char [500];
1167    VcaptureSizeStr = new char [500];
1168    previewSizeStr = new char [500];
1169    thumbnailSizeStr = new char [500];
1170    awbStr = new char [400];
1171    sceneStr = new char [400];
1172    isoModeStr = new char [256];
1173    focusStr = new char [256];
1174    flashStr = new char [256];
1175    fpsstr = new char [256];
1176    previewFormatStr = new char [256];
1177    pictureFormatStr = new char [256];
1178    constFramerate = new int[32];
1179    vstabstr = new char[256];
1180    vnfstr = new char[256];
1181    AutoExposureLockstr = new char[256];
1182    AutoWhiteBalanceLockstr = new char[256];
1183    zoomstr = new char[256];
1184    smoothzoomstr = new char[256];
1185    modevaluesstr = new char[256];
1186    videosnapshotstr = new char[256];
1187    autoconvergencestr = new char[256];
1188    layoutstr = new char[256];
1189    capturelayoutstr = new char[256];
1190
1191    requestBufferSourceReset();
1192
1193    printf("openCamera(camera_index=%d)\n", camera_index);
1194    camera = Camera::connect(camera_index);
1195
1196    if ( NULL == camera.get() ) {
1197        printf("Unable to connect to CameraService\n");
1198        printf("Retrying... \n");
1199        sleep(1);
1200        camera = Camera::connect(camera_index);
1201
1202        if ( NULL == camera.get() ) {
1203            printf("Giving up!! \n");
1204            return -1;
1205        }
1206    }
1207
1208    if ( firstTime ) {
1209        params = camera->getParameters();
1210        firstTime = false;
1211    }
1212    getParametersFromCapabilities();
1213    getSizeParametersFromCapabilities();
1214    camera->setParameters(params.flatten());
1215    camera->setListener(new CameraHandler());
1216
1217    hardwareActive = true;
1218
1219
1220
1221    return 0;
1222}
1223
1224int closeCamera() {
1225    if ( NULL == camera.get() ) {
1226        printf("invalid camera reference\n");
1227
1228        return -1;
1229    }
1230
1231    deleteAllocatedMemory();
1232
1233    camera->disconnect();
1234    camera.clear();
1235
1236    hardwareActive = false;
1237    return 0;
1238}
1239
1240void createBufferOutputSource() {
1241    if(bufferSourceOutputThread.get() && bufferSourceOutputReset) {
1242        bufferSourceOutputThread->requestExit();
1243        bufferSourceOutputThread.clear();
1244    }
1245    if(!bufferSourceOutputThread.get()) {
1246#ifdef ANDROID_API_JB_OR_LATER
1247        bufferSourceOutputThread = new BQ_BufferSourceThread(123, camera);
1248#else
1249        bufferSourceOutputThread = new ST_BufferSourceThread(false, 123, camera);
1250#endif
1251        bufferSourceOutputThread->run();
1252    }
1253    bufferSourceOutputReset = false;
1254}
1255
1256void createBufferInputSource() {
1257    if (bufferSourceInput.get() && bufferSourceInputReset) {
1258        bufferSourceInput.clear();
1259    }
1260    if (!bufferSourceInput.get()) {
1261#ifdef ANDROID_API_JB_OR_LATER
1262        bufferSourceInput = new BQ_BufferSourceInput(1234, camera);
1263#else
1264        bufferSourceInput = new ST_BufferSourceInput(1234, camera);
1265#endif
1266    }
1267    bufferSourceInputReset = false;
1268}
1269
1270void requestBufferSourceReset() {
1271    bufferSourceInputReset = true;
1272    bufferSourceOutputReset = true;
1273}
1274
1275int startPreview() {
1276    int previewWidth, previewHeight;
1277    struct CameraInfo cameraInfo;
1278    DisplayInfo dinfo;
1279    int orientation;
1280    unsigned int correctedHeight;
1281
1282    SurfaceComposerClient::getDisplayInfo(0, &dinfo);
1283
1284    printf ("dinfo.orientation = %d\n", dinfo.orientation);
1285    printf ("dinfo.w = %d\n", dinfo.w);
1286    printf ("dinfo.h = %d\n", dinfo.h);
1287
1288    // calculate display orientation from sensor orientation
1289    camera->getCameraInfo(camera_index, &cameraInfo);
1290    if (cameraInfo.facing == CAMERA_FACING_FRONT) {
1291        orientation = (cameraInfo.orientation + dinfo.orientation) % 360;
1292        orientation = (360 - orientation) % 360;  // compensate the mirror
1293    } else {  // back-facing
1294        orientation = (cameraInfo.orientation - dinfo.orientation + 360) % 360;
1295    }
1296
1297
1298    if (reSizePreview) {
1299        int orientedWidth, orientedHeight;
1300
1301        if(recordingMode)
1302        {
1303            previewWidth = Vcapture_Array[VcaptureSizeIDX]->width;
1304            previewHeight = Vcapture_Array[VcaptureSizeIDX]->height;
1305        }else
1306        {
1307            previewWidth = preview_Array[previewSizeIDX]->width;
1308            previewHeight = preview_Array[previewSizeIDX]->height;
1309        }
1310
1311        // corrected height for aspect ratio
1312        if ((orientation == 90) || (orientation == 270)) {
1313            orientedHeight = previewWidth;
1314            orientedWidth = previewHeight;
1315        } else {
1316            orientedHeight = previewHeight;
1317            orientedWidth = previewWidth;
1318        }
1319        correctedHeight = (dinfo.w * orientedHeight) / orientedWidth;
1320        printf("correctedHeight = %d", correctedHeight);
1321
1322        if ( createPreviewSurface(dinfo.w, correctedHeight,
1323                                  pixelformat[previewFormat].pixelFormatDesc) < 0 ) {
1324            printf("Error while creating preview surface\n");
1325            return -1;
1326        }
1327
1328        if ( !hardwareActive ) {
1329            openCamera();
1330        }
1331        if(stereoMode && firstTimeStereo)
1332        {
1333             params.set(KEY_S3D_PRV_FRAME_LAYOUT, stereoLayout[stereoLayoutIDX]);
1334             params.set(KEY_S3D_CAP_FRAME_LAYOUT, stereoCapLayout[stereoCapLayoutIDX]);
1335        }
1336
1337        if ((cameraInfo.orientation == 90 || cameraInfo.orientation == 270) && recordingMode) {
1338            params.setPreviewSize(previewHeight, previewWidth);
1339        } else {
1340            params.setPreviewSize(previewWidth, previewHeight);
1341        }
1342        params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
1343
1344        // calculate display orientation from sensor orientation
1345        camera->getCameraInfo(camera_index, &cameraInfo);
1346        if (cameraInfo.facing == CAMERA_FACING_FRONT) {
1347            orientation = (cameraInfo.orientation + dinfo.orientation) % 360;
1348            orientation= (360 - orientation) % 360;  // compensate the mirror
1349        } else {  // back-facing
1350            orientation = (cameraInfo.orientation - dinfo.orientation + 360) % 360;
1351        }
1352
1353        if(!strcmp(params.get(KEY_MODE), "video-mode") ) {
1354            orientation = 0;
1355        }
1356
1357        camera->sendCommand(CAMERA_CMD_SET_DISPLAY_ORIENTATION, orientation, 0);
1358
1359        camera->setParameters(params.flatten());
1360        camera->setPreviewTexture(previewSurface->getIGraphicBufferProducer());
1361    }
1362
1363    if(hardwareActive) prevcnt = 0;
1364    camera->startPreview();
1365    previewRunning = true;
1366    reSizePreview = false;
1367
1368    const char *format = params.getPictureFormat();
1369    if((NULL != format) && isRawPixelFormat(format)) {
1370        createBufferOutputSource();
1371        createBufferInputSource();
1372    }
1373
1374    return 0;
1375}
1376
1377int getParametersFromCapabilities() {
1378    const char *valstr = NULL;
1379
1380    numCamera = camera->getNumberOfCameras();
1381
1382    params.unflatten(camera->getParameters());
1383
1384    valstr = params.get(KEY_AUTOCONVERGENCE_MODE_VALUES);
1385    if (NULL != valstr) {
1386        strcpy(autoconvergencestr, valstr);
1387        getSupportedParameters(autoconvergencestr,&numAutoConvergence,(char***)&autoconvergencemode);
1388    } else {
1389        printf("no supported parameteters for autoconvergence\n\t");
1390    }
1391
1392    valstr = params.get(CameraParameters::KEY_SUPPORTED_EFFECTS);
1393    if (NULL != valstr) {
1394        strcpy(effectssStr, valstr);
1395        getSupportedParameters(effectssStr, &numEffects, (char***)&effectss);
1396    } else {
1397        printf("Color effects are not supported\n");
1398    }
1399
1400    valstr = params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING);
1401    if (NULL != valstr) {
1402        strcpy(antibandStr, valstr);
1403        getSupportedParameters(antibandStr, &numAntibanding, (char***)&antiband);
1404    } else {
1405        printf("Antibanding not supported\n");
1406    }
1407
1408    valstr = params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE);
1409    if (NULL != valstr) {
1410        strcpy(awbStr, valstr);
1411        getSupportedParameters(awbStr, &numawb, (char***)&awb);
1412    } else {
1413        printf("White balance is not supported\n");
1414    }
1415
1416    valstr = params.get(KEY_S3D_PRV_FRAME_LAYOUT_VALUES);
1417    if ((NULL != valstr) && (0 != strcmp(valstr, "none"))) {
1418        stereoMode = true;
1419        strcpy(layoutstr, valstr);
1420        getSupportedParameters(layoutstr,&numLay,(char***)&stereoLayout);
1421    } else {
1422        stereoMode = false;
1423        printf("layout is not supported\n");
1424    }
1425
1426    valstr = params.get(KEY_S3D_CAP_FRAME_LAYOUT_VALUES);
1427    if ((NULL != valstr) && (0 != strcmp(valstr, "none"))) {
1428        strcpy(capturelayoutstr, valstr);
1429        getSupportedParameters(capturelayoutstr,&numCLay,(char***)&stereoCapLayout);
1430    } else {
1431        printf("capture layout is not supported\n");
1432    }
1433
1434    valstr = params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES);
1435    if (NULL != valstr) {
1436        strcpy(sceneStr, valstr);
1437        getSupportedParameters(sceneStr, &numscene, (char***)&scene);
1438    } else {
1439        printf("Scene modes are not supported\n");
1440    }
1441
1442    valstr = params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES);
1443    if (NULL != valstr) {
1444        strcpy(focusStr, valstr);
1445        getSupportedParameters(focusStr, &numfocus, (char***)&focus);
1446    } else {
1447        printf("Focus modes are not supported\n");
1448    }
1449
1450    valstr = params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
1451    if (NULL != valstr) {
1452        strcpy(flashStr, valstr);
1453        getSupportedParameters(flashStr, &numflash, (char***)&flash);
1454    } else {
1455        printf("Flash modes are not supported\n");
1456    }
1457
1458    valstr = params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES);
1459    if (NULL != valstr) {
1460        strcpy(VcaptureSizeStr, valstr);
1461        getSupportedParametersVideoCaptureSize(VcaptureSizeStr, &numVcaptureSize, VcaptureSize, lenght_Vcapture_size);
1462    } else {
1463        printf("Preview sizes are not supported\n");
1464    }
1465
1466    valstr = params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE);
1467    if (NULL != valstr) {
1468        strcpy(fpsstr, valstr);
1469        getSupportedParametersfps(fpsstr, &numfps);
1470    } else {
1471        printf("Preview fps range is not supported\n");
1472    }
1473
1474    valstr = params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS);
1475    if (NULL != valstr) {
1476        strcpy(previewFormatStr, valstr);
1477        getSupportedParameters(previewFormatStr, &numpreviewFormat, (char ***)&previewFormatArray);
1478    } else {
1479        printf("Preview formats are not supported\n");
1480    }
1481
1482    valstr = params.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS);
1483    if (NULL != valstr) {
1484        strcpy(pictureFormatStr, valstr);
1485        getSupportedParameters(pictureFormatStr, &numpictureFormat, (char ***)&pictureFormatArray);
1486    } else {
1487        printf("Picture formats are not supported\n");
1488    }
1489
1490    valstr = params.get("exposure-mode-values");
1491    if (NULL != valstr) {
1492        strcpy(exposureModeStr, valstr);
1493        getSupportedParameters(exposureModeStr, &numExposureMode, (char***)&exposureMode);
1494    } else {
1495        printf("Exposure modes are not supported\n");
1496    }
1497
1498    valstr = params.get("iso-mode-values");
1499    if (NULL != valstr) {
1500        strcpy(isoModeStr, valstr);
1501        getSupportedParameters(isoModeStr, &numisoMode , (char***)&isoMode);
1502    } else {
1503        printf("iso modes are not supported\n");
1504    }
1505
1506    valstr = params.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES);
1507    if (NULL != valstr) {
1508        strcpy(thumbnailSizeStr, valstr);
1509        getSupportedParametersThumbnailSize(thumbnailSizeStr, &numthumbnailSize, thumbnailSize, length_thumbnailSize);
1510    } else {
1511        printf("Thumbnail sizes are not supported\n");
1512    }
1513
1514    valstr = params.get(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED);
1515    if (NULL != valstr) {
1516        strcpy(vstabstr, valstr);
1517    } else {
1518        printf("VSTAB is not supported\n");
1519    }
1520
1521    valstr = params.get("vnf-supported");
1522    if (NULL != valstr) {
1523        strcpy(vnfstr, valstr);
1524    } else {
1525        printf("VNF is not supported\n");
1526    }
1527
1528    valstr = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED);
1529    if (NULL != valstr) {
1530        strcpy(AutoExposureLockstr, valstr);
1531    } else {
1532        printf("AutoExposureLock is not supported\n");
1533    }
1534
1535    valstr = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED);
1536    if (NULL != valstr) {
1537        strcpy(AutoWhiteBalanceLockstr, valstr);
1538    } else {
1539        printf("AutoWhiteBalanceLock is not supported\n");
1540    }
1541
1542    valstr = params.get(CameraParameters::KEY_ZOOM_SUPPORTED);
1543    if (NULL != valstr) {
1544        strcpy(zoomstr, valstr);
1545    } else {
1546        printf("Zoom is not supported\n");
1547    }
1548
1549    valstr = params.get(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED);
1550    if (NULL != valstr) {
1551        strcpy(smoothzoomstr, valstr);
1552    } else {
1553        printf("SmoothZoom is not supported\n");
1554    }
1555
1556    valstr = params.get("mode-values");
1557    if (NULL != valstr) {
1558        strcpy(modevaluesstr, valstr);
1559        getSupportedParameters(modevaluesstr, &nummodevalues , (char***)&modevalues);
1560    } else {
1561        printf("Mode values is not supported\n");
1562    }
1563
1564    valstr = params.get(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED);
1565    if (NULL != valstr) {
1566        strcpy(videosnapshotstr, valstr);
1567    } else {
1568        printf("Video Snapshot is not supported\n");
1569    }
1570
1571    if (params.get(KEY_SUPPORTED_MANUAL_CONVERGENCE_MIN) != NULL) {
1572        manualConvMin = params.getInt(KEY_SUPPORTED_MANUAL_CONVERGENCE_MIN);
1573    } else {
1574        printf("no supported parameteters for manual convergence min\n\t");
1575    }
1576
1577    if (params.get(KEY_SUPPORTED_MANUAL_CONVERGENCE_MAX) != NULL) {
1578        manualConvMax = params.getInt(KEY_SUPPORTED_MANUAL_CONVERGENCE_MAX);
1579    } else {
1580        printf("no supported parameteters for manual convergence max\n\t");
1581    }
1582
1583    if (params.get(KEY_SUPPORTED_MANUAL_CONVERGENCE_STEP) != NULL) {
1584        manualConvStep = params.getInt(KEY_SUPPORTED_MANUAL_CONVERGENCE_STEP);
1585    } else {
1586        printf("no supported parameteters for manual convergence step\n\t");
1587    }
1588
1589    if (params.get(KEY_SUPPORTED_MANUAL_EXPOSURE_MIN) != NULL) {
1590        manualExpMin = params.getInt(KEY_SUPPORTED_MANUAL_EXPOSURE_MIN);
1591    } else {
1592        printf("no supported parameteters for manual exposure min\n\t");
1593    }
1594
1595    if (params.get(KEY_SUPPORTED_MANUAL_EXPOSURE_MAX) != NULL) {
1596        manualExpMax = params.getInt(KEY_SUPPORTED_MANUAL_EXPOSURE_MAX);
1597    } else {
1598        printf("no supported parameteters for manual exposure max\n\t");
1599    }
1600
1601    if (params.get(KEY_SUPPORTED_MANUAL_EXPOSURE_STEP) != NULL) {
1602        manualExpStep = params.getInt(KEY_SUPPORTED_MANUAL_EXPOSURE_STEP);
1603    } else {
1604        printf("no supported parameteters for manual exposure step\n\t");
1605    }
1606
1607    if (params.get(KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN) != NULL) {
1608        manualGainMin = params.getInt(KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN);
1609    } else {
1610        printf("no supported parameteters for manual gain min\n\t");
1611    }
1612
1613    if (params.get(KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX) != NULL) {
1614        manualGainMax = params.getInt(KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX);
1615    } else {
1616        printf("no supported parameteters for manual gain max\n\t");
1617    }
1618
1619    if (params.get(KEY_SUPPORTED_MANUAL_GAIN_ISO_STEP) != NULL) {
1620        manualGainStep = params.getInt(KEY_SUPPORTED_MANUAL_GAIN_ISO_STEP);
1621    } else {
1622        printf("no supported parameteters for manual gain step\n\t");
1623    }
1624
1625    return 0;
1626}
1627
1628void getSizeParametersFromCapabilities() {
1629    if(!stereoMode) {
1630        if (params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES) != NULL) {
1631            strcpy(captureSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));
1632        } else {
1633            printf("Picture sizes are not supported\n");
1634        }
1635
1636        if (params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES) != NULL) {
1637            strcpy(previewSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
1638            strcpy(VcaptureSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
1639        } else {
1640            printf("Preview sizes are not supported\n");
1641        }
1642    } else { //stereo
1643        if(strcmp(stereoLayout[stereoLayoutIDX],"tb-full") == 0)
1644        {
1645                    if (params.get(KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES) != NULL) {
1646                        strcpy(previewSizeStr, params.get(KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES));
1647                        strcpy(VcaptureSizeStr, params.get(KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES));
1648                    } else {
1649                        printf("Preview sizes are not supported\n");
1650                    }
1651        }
1652        else  if(strcmp(stereoLayout[stereoLayoutIDX],"ss-full") == 0)
1653        {
1654                    if (params.get(KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES) != NULL) {
1655                        strcpy(previewSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES));
1656                        strcpy(VcaptureSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES));
1657                    } else {
1658                        printf("Preview sizes are not supported\n");
1659                    }
1660        }
1661        else  if(strcmp(stereoLayout[stereoLayoutIDX],"tb-subsampled") == 0)
1662        {
1663                    if (params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES) != NULL) {
1664                        strcpy(previewSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
1665                        strcpy(VcaptureSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
1666                    } else {
1667                        printf("Preview sizes are not supported\n");
1668                    }
1669        }
1670        else  if(strcmp(stereoLayout[stereoLayoutIDX],"ss-subsampled") == 0)
1671        {
1672                    if (params.get(KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES) != NULL) {
1673                        strcpy(previewSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES));
1674                        strcpy(VcaptureSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES));
1675                    } else {
1676                        printf("Preview sizes are not supported\n");
1677                    }
1678        }
1679        else
1680        {
1681                    printf("Preview sizes are not supported\n");
1682        }
1683        if(strcmp(stereoCapLayout[stereoCapLayoutIDX],"tb-full") == 0)
1684        {
1685                    if (params.get(KEY_SUPPORTED_PICTURE_TOPBOTTOM_SIZES) != NULL) {
1686                        strcpy(captureSizeStr, params.get(KEY_SUPPORTED_PICTURE_TOPBOTTOM_SIZES));
1687                    } else {
1688                        printf("Picture sizes are not supported\n");
1689                    }
1690        }
1691        else  if(strcmp(stereoCapLayout[stereoCapLayoutIDX],"ss-full") == 0)
1692        {
1693                    if (params.get(KEY_SUPPORTED_PICTURE_SIDEBYSIDE_SIZES) != NULL) {
1694                        strcpy(captureSizeStr, params.get(KEY_SUPPORTED_PICTURE_SIDEBYSIDE_SIZES));
1695                    } else {
1696                        printf("Picture sizes are not supported\n");
1697                    }
1698        }
1699        else
1700        {
1701                    printf("Picture sizes are not supported\n");
1702        }
1703
1704    }
1705    getSupportedParametersCaptureSize(captureSizeStr, &numcaptureSize, captureSize, length_capture_Size);
1706    getSupportedParametersPreviewSize(previewSizeStr, &numpreviewSize, previewSize, length_previewSize);
1707    getSupportedParametersVideoCaptureSize(VcaptureSizeStr, &numVcaptureSize, VcaptureSize, lenght_Vcapture_size);
1708}
1709
1710int getDefaultParameter(const char* val, int numOptions,  char **array) {
1711    int cnt = 0;
1712
1713    if ((NULL == val) || (NULL == array)) {
1714        printf("Some default parameters are not valid");
1715        return 0;
1716    }
1717
1718    for(cnt=0;cnt<numOptions;cnt++) {
1719        if (NULL == array[cnt]) {
1720            printf("Some parameter arrays are not valid");
1721            continue;
1722        }
1723        if (strcmp(val, array[cnt]) ==0 ) {
1724            return cnt;
1725        }
1726    }
1727    return 0;
1728}
1729
1730int getDefaultParameterResol(const char* val, int numOptions,  param_Array **array) {
1731    int cnt = 0;
1732
1733    for(cnt=0;cnt<numOptions;cnt++) {
1734        if (strcmp(val, array[cnt]->name) ==0 ) {
1735            return cnt;
1736        }
1737    }
1738    return 0;
1739}
1740
1741int getSupportedParameters(char* parameters, int *optionsCount, char  ***elem) {
1742    str = new char [400];
1743    param = new char [400];
1744    int cnt = 0;
1745
1746    strcpy(str, parameters);
1747    param = strtok(str, ",");
1748    *elem = new char*[30];
1749
1750    while (param != NULL) {
1751        (*elem)[cnt] = new char[strlen(param) + 1];
1752        strcpy((*elem)[cnt], param);
1753        param = strtok (NULL, ",");
1754        cnt++;
1755    }
1756    *optionsCount = cnt;
1757    return 0;
1758}
1759
1760int getSupportedParametersfps(char* parameters, int *optionsCount) {
1761    str = new char [400];
1762    param = new char [400];
1763    int cnt = 0;
1764    constCnt = 0;
1765    rangeCnt = 0;
1766    strcpy(str, parameters);
1767    fps_const_str = new char*[32];
1768    fps_range_str = new char*[32];
1769    rangeDescription = new char*[32];
1770    fpsArray = new fps_Array[50];
1771    param = strtok(str, "(,)");
1772
1773    while (param != NULL) {
1774        fps_const_str[constCnt] = new char;
1775        fps_range_str[rangeCnt] = new char;
1776        rangeDescription[rangeCnt] = new char;
1777        fpsArray[cnt].rangeMin = atoi(param);
1778        param = strtok (NULL, "(,)");
1779        fpsArray[cnt].rangeMax = atoi(param);
1780        param = strtok (NULL, "(,)");
1781        if (fpsArray[cnt].rangeMin == fpsArray[cnt].rangeMax) {
1782            sprintf(fps_const_str[constCnt], "%d,%d", fpsArray[cnt].rangeMin, fpsArray[cnt].rangeMax);
1783            constFramerate[constCnt] = fpsArray[cnt].rangeMin/1000;
1784            sprintf(fps_range_str[rangeCnt], "%d,%d", fpsArray[cnt].rangeMin, fpsArray[cnt].rangeMax);
1785            sprintf(rangeDescription[rangeCnt], "[%d:%d]", fpsArray[cnt].rangeMin/1000, fpsArray[cnt].rangeMax/1000);
1786            constCnt ++;
1787            rangeCnt ++;
1788
1789        } else {
1790            sprintf(fps_range_str[rangeCnt], "%d,%d", fpsArray[cnt].rangeMin, fpsArray[cnt].rangeMax);
1791            sprintf(rangeDescription[rangeCnt], "[%d:%d]", fpsArray[cnt].rangeMin/1000, fpsArray[cnt].rangeMax/1000);
1792            rangeCnt ++;
1793        }
1794
1795        cnt++;
1796    }
1797    *optionsCount = cnt;
1798    return 0;
1799}
1800
1801
1802int getSupportedParametersCaptureSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
1803    str = new char [400];
1804    param = new char [400];
1805    int cnt = 0;
1806    strcpy(str, parameters);
1807    param = strtok(str, ",x");
1808    capture_Array = new param_Array*[50];
1809    while (param != NULL) {
1810
1811        capture_Array[cnt] = new param_Array;
1812        capture_Array[cnt]->width = atoi(param);
1813        param = strtok (NULL, ",x");
1814        capture_Array[cnt]->height = atoi(param);
1815        param = strtok (NULL, ",x");
1816
1817        int x = getSupportedParametersNames(capture_Array[cnt]->width,
1818                capture_Array[cnt]->height, array, arraySize);
1819
1820        if (x > -1) {
1821            strcpy(capture_Array[cnt]->name, array[x].name);
1822        } else {
1823            strcpy(capture_Array[cnt]->name, "Needs to be added/Not supported");
1824        }
1825
1826        cnt++;
1827    }
1828
1829    *optionsCount = cnt;
1830    return 0;
1831}
1832
1833int getSupportedParametersVideoCaptureSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
1834    str = new char [800];
1835    param = new char [800];
1836    int cnt = 0;
1837    strcpy(str, parameters);
1838    param = strtok(str, ",x");
1839    Vcapture_Array = new param_Array*[100];
1840    while (param != NULL) {
1841
1842        Vcapture_Array[cnt] = new param_Array;
1843        Vcapture_Array[cnt]->width = atoi(param);
1844        param = strtok (NULL, ",x");
1845        Vcapture_Array[cnt]->height = atoi(param);
1846        param = strtok (NULL, ",x");
1847
1848        int x = getSupportedParametersNames(Vcapture_Array[cnt]->width,
1849                Vcapture_Array[cnt]->height, array, arraySize);
1850
1851        if (x > -1) {
1852            strcpy(Vcapture_Array[cnt]->name, array[x].name);
1853        } else {
1854            strcpy(Vcapture_Array[cnt]->name, "Needs to be added/Not supported");
1855        }
1856
1857        cnt++;
1858    }
1859
1860    *optionsCount = cnt;
1861    return 0;
1862}
1863
1864int getSupportedParametersPreviewSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
1865    str = new char [500];
1866    param = new char [500];
1867    int cnt = 0;
1868    strcpy(str, parameters);
1869    param = strtok(str, ",x");
1870    preview_Array = new param_Array*[60];
1871    while (param != NULL) {
1872        preview_Array[cnt] = new param_Array;
1873        preview_Array[cnt]->width = atoi(param);
1874        param = strtok (NULL, ",x");
1875        preview_Array[cnt]->height = atoi(param);
1876        param = strtok (NULL, ",x");
1877
1878        int x = getSupportedParametersNames(preview_Array[cnt]->width,
1879                preview_Array[cnt]->height, array, arraySize);
1880        if (x > -1) {
1881            strcpy(preview_Array[cnt]->name, array[x].name);
1882        } else {
1883            strcpy(preview_Array[cnt]->name, "Needs to be added/Not supported");
1884        }
1885
1886        cnt++;
1887    }
1888
1889    *optionsCount = cnt;
1890    return 0;
1891}
1892
1893int getSupportedParametersThumbnailSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
1894    str = new char [500];
1895    param = new char [500];
1896    int cnt = 0;
1897    strcpy(str, parameters);
1898    param = strtok(str, ",x");
1899    thumbnail_Array = new param_Array*[60];
1900    while (param != NULL) {
1901        thumbnail_Array[cnt] = new param_Array;
1902        thumbnail_Array[cnt]->width = atoi(param);
1903        param = strtok (NULL, ",x");
1904        thumbnail_Array[cnt]->height = atoi(param);
1905        param = strtok (NULL, ",x");
1906
1907        int x = getSupportedParametersNames(thumbnail_Array[cnt]->width,
1908                thumbnail_Array[cnt]->height, array, arraySize);
1909        if (x > -1) {
1910            strcpy(thumbnail_Array[cnt]->name, array[x].name);
1911        } else {
1912            strcpy(thumbnail_Array[cnt]->name, "Needs to be added/Not supported");
1913        }
1914
1915        cnt++;
1916    }
1917
1918    *optionsCount = cnt;
1919    return 0;
1920}
1921
1922int getSupportedParametersNames(int width, int height, param_Array array[], int arraySize) {
1923    for (int i = 0; i<arraySize; i++) {
1924
1925        if ((width == array[i].width) && (height == array[i].height)) {
1926            return (i);
1927        }
1928    }
1929    return -1;
1930}
1931
1932int deleteAllocatedMemory() {
1933    int i;
1934
1935    for (i=0; i<numAntibanding; i++){
1936        delete [] antiband[i];
1937    }
1938
1939
1940
1941
1942    for (i=0; i<numEffects; i++){
1943        delete [] effectss[i];
1944    }
1945
1946    for (i=0; i<numExposureMode; i++){
1947        delete [] exposureMode[i];
1948    }
1949
1950    for (i=0; i<numawb; i++) {
1951        delete [] awb[i];
1952    }
1953
1954    for (i=0; i<numscene; i++){
1955        delete [] scene[i];
1956    }
1957
1958    for (i=0; i<numfocus; i++){
1959        delete [] focus[i];
1960    }
1961
1962    for (i=0; i<numflash; i++){
1963        delete [] flash[i];
1964    }
1965
1966    for (i=0; i<numpreviewSize; i++){
1967        delete [] preview_Array[i];
1968    }
1969
1970    for (i=0; i<numcaptureSize; i++){
1971        delete [] capture_Array[i];
1972    }
1973
1974    for (i=0; i<numVcaptureSize; i++){
1975        delete [] Vcapture_Array[i];
1976    }
1977
1978    for (i=0; i<numthumbnailSize; i++){
1979        delete [] thumbnail_Array[i];
1980    }
1981
1982    for (i=0; i<constCnt; i++){
1983        delete [] fps_const_str[i];
1984    }
1985
1986    for (i=0; i<rangeCnt; i++){
1987        delete [] fps_range_str[i];
1988    }
1989
1990    for (i=0; i<rangeCnt; i++){
1991        delete [] rangeDescription[i];
1992    }
1993
1994    for (i=0; i<numpreviewFormat; i++){
1995        delete [] previewFormatArray[i];
1996    }
1997
1998    for (i=0; i<numpictureFormat; i++){
1999        delete [] pictureFormatArray[i];
2000    }
2001
2002    for (i=0; i<nummodevalues; i++){
2003        delete [] modevalues[i];
2004    }
2005
2006    if (numLay) {
2007        for (i = 0; i < numLay; i++) {
2008            delete [] stereoLayout[i];
2009        }
2010        numLay = 0;
2011    }
2012
2013    if (numCLay) {
2014        for (i = 0; i < numCLay; i++) {
2015            delete [] stereoCapLayout[i];
2016        }
2017        numCLay = 0;
2018    }
2019
2020    delete [] antibandStr;
2021    delete [] effectssStr;
2022    delete [] exposureModeStr;
2023    delete [] awbStr;
2024    delete [] sceneStr;
2025    delete [] focusStr;
2026    delete [] flashStr;
2027    delete [] previewSizeStr;
2028    delete [] captureSizeStr;
2029    delete [] VcaptureSizeStr;
2030    delete [] thumbnailSizeStr;
2031    delete [] fpsstr;
2032    delete [] previewFormatStr;
2033    delete [] pictureFormatStr;
2034    delete [] fpsArray;
2035    delete [] vstabstr;
2036    delete [] vnfstr;
2037    delete [] isoModeStr;
2038    delete [] AutoExposureLockstr;
2039    delete [] AutoWhiteBalanceLockstr;
2040    delete [] zoomstr;
2041    delete [] smoothzoomstr;
2042    delete [] modevaluesstr;
2043    delete [] videosnapshotstr;
2044    delete [] autoconvergencestr;
2045    delete [] layoutstr;
2046    delete [] capturelayoutstr;
2047
2048    // Release buffer sources if any
2049    if (bufferSourceOutputThread.get()) {
2050        bufferSourceOutputThread->requestExit();
2051        bufferSourceOutputThread.clear();
2052    }
2053    if ( bufferSourceInput.get() ) {
2054        bufferSourceInput.clear();
2055    }
2056
2057    return 0;
2058}
2059
2060int trySetVideoStabilization(bool toggle) {
2061    if (strcmp(vstabstr, "true") == 0) {
2062        params.set(params.KEY_VIDEO_STABILIZATION, toggle ? params.TRUE : params.FALSE);
2063        return 0;
2064    }
2065    return 0;
2066}
2067
2068int trySetVideoNoiseFilter(bool toggle) {
2069    if (strcmp(vnfstr, "true") == 0) {
2070        params.set("vnf", toggle ? params.TRUE : params.FALSE);
2071        return 0;
2072    }
2073    return 0;
2074}
2075
2076int trySetAutoExposureLock(bool toggle) {
2077    if (strcmp(AutoExposureLockstr, "true") == 0) {
2078        params.set(KEY_AUTO_EXPOSURE_LOCK, toggle ? params.TRUE : params.FALSE);
2079        return 0;
2080    }
2081    return 0;
2082}
2083
2084int trySetAutoWhiteBalanceLock(bool toggle) {
2085    if (strcmp(AutoWhiteBalanceLockstr, "true") == 0) {
2086        params.set(KEY_AUTO_WHITEBALANCE_LOCK, toggle ? params.TRUE : params.FALSE);
2087        return 0;
2088    }
2089    return 0;
2090}
2091
2092bool isRawPixelFormat (const char *format) {
2093    bool ret = false;
2094    if ((0 == strcmp (format, CameraParameters::PIXEL_FORMAT_YUV422I)) ||
2095        (0 == strcmp (format, CameraParameters::PIXEL_FORMAT_YUV420SP)) ||
2096        (0 == strcmp (format, CameraParameters::PIXEL_FORMAT_RGB565)) ||
2097        (0 == strcmp (format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB))) {
2098        ret = true;
2099    }
2100    return ret;
2101}
2102
2103void stopPreview() {
2104    if ( hardwareActive ) {
2105        camera->stopPreview();
2106
2107        destroyPreviewSurface();
2108
2109        previewRunning  = false;
2110        reSizePreview = true;
2111    }
2112}
2113
2114void initDefaults() {
2115
2116    struct CameraInfo cameraInfo;
2117
2118    camera->getCameraInfo(camera_index, &cameraInfo);
2119    if (cameraInfo.facing == CAMERA_FACING_FRONT) {
2120        rotation = cameraInfo.orientation;
2121    } else {  // back-facing
2122        rotation = cameraInfo.orientation;
2123    }
2124
2125    antibanding_mode = getDefaultParameter("off", numAntibanding, antiband);
2126    focus_mode = getDefaultParameter("auto", numfocus, focus);
2127    fpsRangeIdx = getDefaultParameter("5000,30000", rangeCnt, fps_range_str);
2128    afTimeoutIdx = 0;
2129    previewSizeIDX = getDefaultParameterResol("VGA", numpreviewSize, preview_Array);
2130    captureSizeIDX = getDefaultParameterResol("12MP", numcaptureSize, capture_Array);
2131    frameRateIDX = getDefaultParameter("30000,30000", constCnt, fps_const_str);
2132    VcaptureSizeIDX = getDefaultParameterResol("HD", numVcaptureSize, Vcapture_Array);
2133    VbitRateIDX = 0;
2134    thumbSizeIDX = getDefaultParameterResol("VGA", numthumbnailSize, thumbnail_Array);
2135    compensation = 0.0;
2136    awb_mode = getDefaultParameter("auto", numawb, awb);
2137    effects_mode = getDefaultParameter("none", numEffects, effectss);
2138    scene_mode = getDefaultParameter("auto", numscene, scene);
2139    caf_mode = 0;
2140
2141    shotConfigFlush = false;
2142    streamCapture = false;
2143    vstabtoggle = false;
2144    vnftoggle = false;
2145    AutoExposureLocktoggle = false;
2146    AutoWhiteBalanceLocktoggle = false;
2147    faceDetectToggle = false;
2148    metaDataToggle = false;
2149    expBracketIdx = BRACKETING_IDX_DEFAULT;
2150    flashIdx = getDefaultParameter("off", numflash, flash);
2151    previewRotation = 0;
2152    zoomIDX = 0;
2153    videoCodecIDX = 0;
2154    gbceIDX = 0;
2155    glbceIDX = 0;
2156    contrast = 100;
2157#ifdef TARGET_OMAP4
2158    ///Temporary fix until OMAP3 and OMAP4 3A values are synced
2159    brightness = 50;
2160    sharpness = 100;
2161#else
2162    brightness = 100;
2163    sharpness = 0;
2164#endif
2165    saturation = 100;
2166    iso_mode = getDefaultParameter("auto", numisoMode, isoMode);
2167    capture_mode = getDefaultParameter("high-quality", nummodevalues, modevalues);
2168    exposure_mode = getDefaultParameter("auto", numExposureMode, exposureMode);
2169    ippIDX = 0;
2170    ippIDX_old = ippIDX;
2171    jpegQuality = 85;
2172    bufferStarvationTest = 0;
2173    meter_mode = 0;
2174    previewFormat = getDefaultParameter("yuv420sp", numpreviewFormat, previewFormatArray);
2175    pictureFormat = getDefaultParameter("jpeg", numpictureFormat, pictureFormatArray);
2176    stereoCapLayoutIDX = 0;
2177    stereoLayoutIDX = 1;
2178    manualConv = 0;
2179    manualExp = manualExpMin;
2180    manualGain = manualGainMin;
2181
2182    algoFixedGammaIDX = 1;
2183    algoNSF1IDX = 1;
2184    algoNSF2IDX = 1;
2185    algoSharpeningIDX = 1;
2186    algoThreeLinColorMapIDX = 1;
2187    algoGICIDX = 1;
2188
2189    params.set(params.KEY_VIDEO_STABILIZATION, params.FALSE);
2190    params.set("vnf", params.FALSE);
2191    params.setPreviewSize(preview_Array[previewSizeIDX]->width, preview_Array[previewSizeIDX]->height);
2192    params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
2193    params.set(CameraParameters::KEY_ROTATION, rotation);
2194    params.set(KEY_SENSOR_ORIENTATION, previewRotation);
2195    params.set(KEY_COMPENSATION, (int) (compensation * 10));
2196    params.set(params.KEY_WHITE_BALANCE, awb[awb_mode]);
2197    params.set(KEY_MODE, (modevalues[capture_mode]));
2198    params.set(params.KEY_SCENE_MODE, scene[scene_mode]);
2199    params.set(KEY_CAF, caf_mode);
2200    params.set(KEY_ISO, isoMode[iso_mode]);
2201    params.set(KEY_GBCE, gbce[gbceIDX]);
2202    params.set(KEY_GLBCE, gbce[glbceIDX]);
2203    params.set(KEY_SHARPNESS, sharpness);
2204    params.set(KEY_CONTRAST, contrast);
2205    params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
2206    params.set(KEY_EXPOSURE, exposureMode[exposure_mode]);
2207    params.set(KEY_BRIGHTNESS, brightness);
2208    params.set(KEY_SATURATION, saturation);
2209    params.set(params.KEY_EFFECT, effectss[effects_mode]);
2210    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRateIDX]);
2211    params.set(params.KEY_ANTIBANDING, antiband[antibanding_mode]);
2212    params.set(params.KEY_FOCUS_MODE, focus[focus_mode]);
2213    params.set(KEY_IPP, ipp_mode[ippIDX]);
2214    params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);
2215    params.setPreviewFormat(previewFormatArray[previewFormat]);
2216    params.setPictureFormat(pictureFormatArray[pictureFormat]);
2217    params.set(KEY_BUFF_STARV, bufferStarvationTest);
2218    params.set(KEY_METERING_MODE, metering[meter_mode]);
2219    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, thumbnail_Array[thumbSizeIDX]->width);
2220    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, thumbnail_Array[thumbSizeIDX]->height);
2221    params.set(KEY_MANUAL_CONVERGENCE, manualConv);
2222    params.set(KEY_MANUAL_EXPOSURE, manualExp);
2223    params.set(KEY_MANUAL_GAIN_ISO, manualGain);
2224    params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
2225    params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
2226    params.set(KEY_S3D2D_PREVIEW_MODE, "off");
2227    params.set(KEY_EXIF_MODEL, MODEL);
2228    params.set(KEY_EXIF_MAKE, MAKE);
2229
2230    setDefaultExpGainPreset(shotParams, expBracketIdx);
2231}
2232
2233void setDefaultExpGainPreset(ShotParameters &params, int idx) {
2234    if ( ((int)ARRAY_SIZE(expBracketing) > idx) && (0 <= idx) ) {
2235        setExpGainPreset(params, expBracketing[idx].value, false, expBracketing[idx].param_type, shotConfigFlush);
2236    } else {
2237        printf("setDefaultExpGainPreset: Index (%d) is out of range 0 ~ %u\n", idx, ARRAY_SIZE(expBracketing) - 1);
2238    }
2239}
2240
2241void setSingleExpGainPreset(ShotParameters &params, int idx, int exp, int gain) {
2242    String8 val;
2243
2244    if (PARAM_EXP_BRACKET_PARAM_PAIR == expBracketing[idx].param_type) {
2245        val.append("(");
2246    }
2247
2248    if (PARAM_EXP_BRACKET_VALUE_REL == expBracketing[idx].value_type) {
2249        val.appendFormat("%+d", exp);
2250    } else {
2251        val.appendFormat("%u", (unsigned int) exp);
2252    }
2253
2254    if (PARAM_EXP_BRACKET_PARAM_PAIR == expBracketing[idx].param_type) {
2255        if (PARAM_EXP_BRACKET_VALUE_REL == expBracketing[idx].value_type) {
2256            val.appendFormat(",%+d)", gain);
2257        } else {
2258            val.appendFormat(",%u)", (unsigned int) gain);
2259        }
2260    }
2261
2262    if (PARAM_EXP_BRACKET_APPLY_FORCED == expBracketing[idx].apply_type) {
2263        val.append("F");
2264    }
2265
2266    setExpGainPreset(params, val, false, expBracketing[idx].param_type, false);
2267}
2268
2269void setExpGainPreset(ShotParameters &params, const char *input, bool force, param_ExpBracketParamType_t type, bool flush) {
2270    const char *startPtr = NULL;
2271    size_t i = 0;
2272
2273    if (NULL == input) {
2274        printf("setExpGainPreset: missing input string\n");
2275    } else if ( (force && (NULL == strpbrk(input, "()"))) ||
2276         (PARAM_EXP_BRACKET_PARAM_COMP == type) ) {
2277        // parse for the number of inputs (count the number of ',' + 1)
2278        startPtr = strchr(input, ',');
2279        while (startPtr != NULL) {
2280            i++;
2281            startPtr = strchr(startPtr + 1, ',');
2282        }
2283        i++;
2284        printf("relative EV input: \"%s\"\nnumber of relative EV values: %d (%s)\n",
2285               input, i, flush ? "reset" : "append");
2286        burst = i;
2287        burstCount = i;
2288        params.set(ShotParameters::KEY_BURST, burst);
2289        params.set(ShotParameters::KEY_EXP_COMPENSATION, input);
2290        params.remove(ShotParameters::KEY_EXP_GAIN_PAIRS);
2291        params.set(ShotParameters::KEY_FLUSH_CONFIG,
2292                       flush ? ShotParameters::TRUE : ShotParameters::FALSE);
2293    } else if ( force || (PARAM_EXP_BRACKET_PARAM_PAIR == type) ) {
2294        // parse for the number of inputs (count the number of '(')
2295        startPtr = strchr(input, '(');
2296        while (startPtr != NULL) {
2297            i++;
2298            startPtr = strchr(startPtr + 1, '(');
2299        }
2300        printf("absolute exposure,gain input: \"%s\"\nNumber of brackets: %d (%s)\n",
2301               input, i, flush ? "reset" : "append");
2302        burst = i;
2303        burstCount = i;
2304        params.set(ShotParameters::KEY_BURST, burst);
2305        params.set(ShotParameters::KEY_EXP_GAIN_PAIRS, input);
2306        params.remove(ShotParameters::KEY_EXP_COMPENSATION);
2307        params.set(ShotParameters::KEY_FLUSH_CONFIG,
2308                       flush ? ShotParameters::TRUE : ShotParameters::FALSE);
2309    } else {
2310        printf("no bracketing input: \"%s\"\n", input);
2311        params.remove(ShotParameters::KEY_EXP_GAIN_PAIRS);
2312        params.remove(ShotParameters::KEY_EXP_COMPENSATION);
2313        params.remove(ShotParameters::KEY_BURST);
2314        params.remove(ShotParameters::KEY_FLUSH_CONFIG);
2315    }
2316}
2317
2318void calcNextSingleExpGainPreset(int idx, int &exp, int &gain) {
2319    if (PARAM_EXP_BRACKET_VALUE_ABS == expBracketing[idx].value_type) {
2320        // absolute
2321        if ( (0 == exp) && (0 == gain) ) {
2322            exp=100;
2323            gain = 150;
2324            printf("Streaming: Init default absolute exp./gain: %d,%d\n", exp, gain);
2325        }
2326
2327        exp *= 2;
2328        if (1000000 < exp) {
2329            exp = 100;
2330            gain += 50;
2331            if(400 < gain) {
2332                gain = 50;
2333            }
2334        }
2335    } else {
2336        // relative
2337        exp += 50;
2338        if (200 < exp) {
2339            exp = -200;
2340            gain += 50;
2341            if(200 < gain) {
2342                gain = -200;
2343            }
2344        }
2345    }
2346}
2347
2348void updateShotConfigFlushParam() {
2349    // Will update flush shot config parameter if already present
2350    // Otherwise, keep empty (will be set later in setExpGainPreset())
2351    if (NULL != shotParams.get(ShotParameters::KEY_FLUSH_CONFIG)) {
2352        shotParams.set(ShotParameters::KEY_FLUSH_CONFIG,
2353                       shotConfigFlush ? ShotParameters::TRUE : ShotParameters::FALSE);
2354    }
2355}
2356
2357int menu_gps() {
2358    char ch;
2359    char coord_str[100];
2360
2361    if (print_menu) {
2362        printf("\n\n== GPS MENU ============================\n\n");
2363        printf("   e. Latitude:       %.7lf\n", latitude);
2364        printf("   d. Longitude:      %.7lf\n", longitude);
2365        printf("   c. Altitude:       %.7lf\n", altitude);
2366        printf("\n");
2367        printf("   q. Return to main menu\n");
2368        printf("\n");
2369        printf("   Choice: ");
2370    }
2371
2372    ch = getchar();
2373    printf("%c", ch);
2374
2375    print_menu = 1;
2376
2377    switch (ch) {
2378
2379        case 'e':
2380            latitude += degree_by_step;
2381
2382            if (latitude > 90.0) {
2383                latitude -= 180.0;
2384            }
2385
2386            snprintf(coord_str, 7, "%.7lf", latitude);
2387            params.set(params.KEY_GPS_LATITUDE, coord_str);
2388
2389            if ( hardwareActive )
2390                camera->setParameters(params.flatten());
2391
2392            break;
2393
2394        case 'd':
2395            longitude += degree_by_step;
2396
2397            if (longitude > 180.0) {
2398                longitude -= 360.0;
2399            }
2400
2401            snprintf(coord_str, 7, "%.7lf", longitude);
2402            params.set(params.KEY_GPS_LONGITUDE, coord_str);
2403
2404            if ( hardwareActive )
2405                camera->setParameters(params.flatten());
2406
2407            break;
2408
2409        case 'c':
2410            altitude += 12345.67890123456789;
2411
2412            if (altitude > 100000.0) {
2413                altitude -= 200000.0;
2414            }
2415
2416            snprintf(coord_str, 100, "%.20lf", altitude);
2417            params.set(params.KEY_GPS_ALTITUDE, coord_str);
2418
2419            if ( hardwareActive )
2420                camera->setParameters(params.flatten());
2421
2422            break;
2423
2424        case 'q':
2425            return -1;
2426
2427        default:
2428            print_menu = 0;
2429            break;
2430    }
2431
2432    return 0;
2433}
2434
2435int menu_algo() {
2436    char ch;
2437
2438    if (print_menu) {
2439        printf("\n\n== ALGO ENABLE/DISABLE MENU ============\n\n");
2440        printf("   a.                      Fixed Gamma: %s\n", algoFixedGamma[algoFixedGammaIDX]);
2441        printf("   s.                             NSF1: %s\n", algoNSF1[algoNSF1IDX]);
2442        printf("   d.                             NSF2: %s\n", algoNSF2[algoNSF2IDX]);
2443        printf("   f.                       Sharpening: %s\n", algoSharpening[algoSharpeningIDX]);
2444        printf("   g.                 Color Conversion: %s\n", algoThreeLinColorMap[algoThreeLinColorMapIDX]);
2445        printf("   h.      Green Inballance Correction: %s\n", algoGIC[algoGICIDX]);
2446        printf("\n");
2447        printf("   q. Return to main menu\n");
2448        printf("\n");
2449        printf("   Choice: ");
2450    }
2451
2452    ch = getchar();
2453    printf("%c", ch);
2454
2455    print_menu = 1;
2456
2457    switch (ch) {
2458
2459        case 'a':
2460        case 'A':
2461            algoFixedGammaIDX++;
2462            algoFixedGammaIDX %= ARRAY_SIZE(algoFixedGamma);
2463            params.set(KEY_ALGO_FIXED_GAMMA, (algoFixedGamma[algoFixedGammaIDX]));
2464
2465            if ( hardwareActive )
2466                camera->setParameters(params.flatten());
2467
2468            break;
2469
2470        case 's':
2471        case 'S':
2472            algoNSF1IDX++;
2473            algoNSF1IDX %= ARRAY_SIZE(algoNSF1);
2474            params.set(KEY_ALGO_NSF1, (algoNSF1[algoNSF1IDX]));
2475
2476            if ( hardwareActive )
2477                camera->setParameters(params.flatten());
2478
2479            break;
2480
2481        case 'd':
2482        case 'D':
2483            algoNSF2IDX++;
2484            algoNSF2IDX %= ARRAY_SIZE(algoNSF2);
2485            params.set(KEY_ALGO_NSF2, (algoNSF2[algoNSF2IDX]));
2486
2487            if ( hardwareActive )
2488                camera->setParameters(params.flatten());
2489
2490            break;
2491
2492        case 'f':
2493        case 'F':
2494            algoSharpeningIDX++;
2495            algoSharpeningIDX %= ARRAY_SIZE(algoSharpening);
2496            params.set(KEY_ALGO_SHARPENING, (algoSharpening[algoSharpeningIDX]));
2497
2498            if ( hardwareActive )
2499                camera->setParameters(params.flatten());
2500
2501            break;
2502
2503        case 'g':
2504        case 'G':
2505            algoThreeLinColorMapIDX++;
2506            algoThreeLinColorMapIDX %= ARRAY_SIZE(algoThreeLinColorMap);
2507            params.set(KEY_ALGO_THREELINCOLORMAP, (algoThreeLinColorMap[algoThreeLinColorMapIDX]));
2508
2509            if ( hardwareActive )
2510                camera->setParameters(params.flatten());
2511
2512            break;
2513
2514        case 'h':
2515        case 'H':
2516            algoGICIDX++;
2517            algoGICIDX %= ARRAY_SIZE(algoGIC);
2518            params.set(KEY_ALGO_GIC, (algoGIC[algoGICIDX]));
2519
2520            if ( hardwareActive )
2521                camera->setParameters(params.flatten());
2522
2523            break;
2524
2525        case 'Q':
2526        case 'q':
2527            return -1;
2528
2529        default:
2530            print_menu = 0;
2531            break;
2532    }
2533
2534    return 0;
2535}
2536
2537int functional_menu() {
2538    char ch;
2539    char area1[MAX_LINES][MAX_SYMBOLS+1];
2540    char area2[MAX_LINES][MAX_SYMBOLS+1];
2541    int j = 0;
2542    int k = 0;
2543    const char *valstr = NULL;
2544    struct CameraInfo cameraInfo;
2545    bool queueEmpty = true;
2546
2547    memset(area1, '\0', MAX_LINES*(MAX_SYMBOLS+1));
2548    memset(area2, '\0', MAX_LINES*(MAX_SYMBOLS+1));
2549
2550    if (print_menu) {
2551
2552        printf("\n========================================= FUNCTIONAL TEST MENU =========================================\n");
2553
2554        snprintf(area1[j++], MAX_SYMBOLS, "   START / STOP / GENERAL SERVICES");
2555        snprintf(area1[j++], MAX_SYMBOLS, "   -----------------------------");
2556        snprintf(area1[j++], MAX_SYMBOLS, "A  Select Camera %s", cameras[camera_index]);
2557        snprintf(area1[j++], MAX_SYMBOLS, "[. Resume Preview after capture");
2558        snprintf(area1[j++], MAX_SYMBOLS, "0. Reset to defaults");
2559        snprintf(area1[j++], MAX_SYMBOLS, "q. Quit");
2560        snprintf(area1[j++], MAX_SYMBOLS, "@. Disconnect and Reconnect to CameraService");
2561        snprintf(area1[j++], MAX_SYMBOLS, "/. Enable/Disable showfps: %s", ((showfps)? "Enabled":"Disabled"));
2562        snprintf(area1[j++], MAX_SYMBOLS, "a. GEO tagging settings menu");
2563        snprintf(area1[j++], MAX_SYMBOLS, "E. Camera Capability Dump");
2564
2565        snprintf(area1[j++], MAX_SYMBOLS, "        PREVIEW SUB MENU");
2566        snprintf(area1[j++], MAX_SYMBOLS, "   -----------------------------");
2567        snprintf(area1[j++], MAX_SYMBOLS, "1. Start Preview");
2568        snprintf(area1[j++], MAX_SYMBOLS, "2. Stop Preview");
2569        snprintf(area1[j++], MAX_SYMBOLS, "~. Preview format %s", previewFormatArray[previewFormat]);
2570#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
2571        snprintf(area1[j++], MAX_SYMBOLS, "4. Preview size: %4d x %4d - %s",preview_Array[previewSizeIDX]->width,  preview_Array[previewSizeIDX]->height, preview_Array[previewSizeIDX]->name);
2572#else
2573        snprintf(area1[j++], MAX_SYMBOLS, "4. Preview size: %4d x %4d - %s",preview_Array[previewSizeIDX]->width, stereoMode ? preview_Array[previewSizeIDX]->height*2 : preview_Array[previewSizeIDX]->height, preview_Array[previewSizeIDX]->name);
2574#endif
2575        snprintf(area1[j++], MAX_SYMBOLS, "R. Preview framerate range: %s", rangeDescription[fpsRangeIdx]);
2576        snprintf(area1[j++], MAX_SYMBOLS, "&. Dump a preview frame");
2577        if (stereoMode) {
2578            snprintf(area1[j++], MAX_SYMBOLS, "_. Auto Convergence mode: %s", autoconvergencemode[AutoConvergenceModeIDX]);
2579            snprintf(area1[j++], MAX_SYMBOLS, "^. Manual Convergence Value: %d\n", manualConv);
2580            snprintf(area1[j++], MAX_SYMBOLS, "L. Stereo Preview Layout: %s\n", stereoLayout[stereoLayoutIDX]);
2581            snprintf(area1[j++], MAX_SYMBOLS, ".  Stereo Capture Layout: %s\n", stereoCapLayout[stereoCapLayoutIDX]);
2582        }
2583        snprintf(area1[j++], MAX_SYMBOLS, "{. 2D Preview in 3D Stereo Mode: %s", params.get(KEY_S3D2D_PREVIEW_MODE));
2584
2585        snprintf(area1[j++], MAX_SYMBOLS, "     IMAGE CAPTURE SUB MENU");
2586        snprintf(area1[j++], MAX_SYMBOLS, "   -----------------------------");
2587        snprintf(area1[j++], MAX_SYMBOLS, "p. Take picture/Full Press");
2588        snprintf(area1[j++], MAX_SYMBOLS, "n. Flush shot config queue: %s", shotConfigFlush ? "On" : "Off");
2589        snprintf(area1[j++], MAX_SYMBOLS, "H. Exposure Bracketing: %s", expBracketing[expBracketIdx].desc);
2590        snprintf(area1[j++], MAX_SYMBOLS, "U. Temporal Bracketing:   %s", tempBracketing[tempBracketIdx]);
2591        snprintf(area1[j++], MAX_SYMBOLS, "W. Temporal Bracketing Range: [-%d;+%d]", tempBracketRange, tempBracketRange);
2592        snprintf(area1[j++], MAX_SYMBOLS, "$. Picture Format: %s", pictureFormatArray[pictureFormat]);
2593        snprintf(area1[j++], MAX_SYMBOLS, "3. Picture Rotation:       %3d degree", rotation );
2594        snprintf(area1[j++], MAX_SYMBOLS, "V. Preview Rotation:       %3d degree", previewRotation );
2595        snprintf(area1[j++], MAX_SYMBOLS, "5. Picture size:   %4d x %4d - %s",capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height,              capture_Array[captureSizeIDX]->name);
2596        snprintf(area1[j++], MAX_SYMBOLS, "i. ISO mode:       %s", isoMode[iso_mode]);
2597        snprintf(area1[j++], MAX_SYMBOLS, ",  Manual gain iso value  = %d\n", manualGain);
2598        snprintf(area1[j++], MAX_SYMBOLS, "u. Capture Mode:   %s", modevalues[capture_mode]);
2599        snprintf(area1[j++], MAX_SYMBOLS, "k. IPP Mode:       %s", ipp_mode[ippIDX]);
2600        snprintf(area1[j++], MAX_SYMBOLS, "K. GBCE: %s", gbce[gbceIDX]);
2601        snprintf(area1[j++], MAX_SYMBOLS, "O. GLBCE %s", gbce[glbceIDX]);
2602        snprintf(area1[j++], MAX_SYMBOLS, "o. Jpeg Quality:   %d", jpegQuality);
2603        snprintf(area1[j++], MAX_SYMBOLS, "#. Burst Images:  %3d", burst);
2604        snprintf(area1[j++], MAX_SYMBOLS, ":. Thumbnail Size:  %4d x %4d - %s",thumbnail_Array[thumbSizeIDX]->width, thumbnail_Array[thumbSizeIDX]->height, thumbnail_Array[thumbSizeIDX]->name);
2605        snprintf(area1[j++], MAX_SYMBOLS, "': Thumbnail Quality %d", thumbQuality);
2606
2607        snprintf(area2[k++], MAX_SYMBOLS, "     VIDEO CAPTURE SUB MENU");
2608        snprintf(area2[k++], MAX_SYMBOLS, "   -----------------------------");
2609        snprintf(area2[k++], MAX_SYMBOLS, "6. Start Video Recording");
2610        snprintf(area2[k++], MAX_SYMBOLS, "2. Stop Recording");
2611        snprintf(area2[k++], MAX_SYMBOLS, "l. Video Capture resolution:   %4d x %4d - %s",Vcapture_Array[VcaptureSizeIDX]->width,Vcapture_Array[VcaptureSizeIDX]->height, Vcapture_Array[VcaptureSizeIDX]->name);
2612        snprintf(area2[k++], MAX_SYMBOLS, "]. Video Bit rate :  %s", VbitRate[VbitRateIDX].desc);
2613        snprintf(area2[k++], MAX_SYMBOLS, "9. Video Codec:    %s", videoCodecs[videoCodecIDX].desc);
2614        snprintf(area2[k++], MAX_SYMBOLS, "D. Audio Codec:    %s", audioCodecs[audioCodecIDX].desc);
2615        snprintf(area2[k++], MAX_SYMBOLS, "v. Output Format:  %s", outputFormat[outputFormatIDX].desc);
2616        snprintf(area2[k++], MAX_SYMBOLS, "r. Framerate:     %d", constFramerate[frameRateIDX]);
2617        snprintf(area2[k++], MAX_SYMBOLS, "*. Start Video Recording dump ( 1 raw frame )");
2618        snprintf(area2[k++], MAX_SYMBOLS, "B  VNF              %s", vnftoggle? "On" : "Off");
2619        snprintf(area2[k++], MAX_SYMBOLS, "C  VSTAB              %s", vstabtoggle? "On" : "Off");
2620
2621        snprintf(area2[k++], MAX_SYMBOLS, "       3A SETTING SUB MENU");
2622        snprintf(area2[k++], MAX_SYMBOLS, "   -----------------------------");
2623        snprintf(area2[k++], MAX_SYMBOLS, "M. Measurement Data: %s", measurement[measurementIdx]);
2624        snprintf(area2[k++], MAX_SYMBOLS, "F. Toggle face detection: %s", faceDetectToggle ? "On" : "Off");
2625        snprintf(area2[k++], MAX_SYMBOLS, "T. Toggle metadata: %s", metaDataToggle ? "On" : "Off");
2626        snprintf(area2[k++], MAX_SYMBOLS, "G. Touch/Focus area AF");
2627        snprintf(area2[k++], MAX_SYMBOLS, "y. Metering area");
2628        snprintf(area2[k++], MAX_SYMBOLS, "Y. Metering area center");
2629        snprintf(area2[k++], MAX_SYMBOLS, "N. Metering area average");
2630        snprintf(area2[k++], MAX_SYMBOLS, "f. Auto Focus/Half Press");
2631        snprintf(area2[k++], MAX_SYMBOLS, "I. AF Timeout       %s", afTimeout[afTimeoutIdx]);
2632        snprintf(area2[k++], MAX_SYMBOLS, "J.Flash:              %s", flash[flashIdx]);
2633        snprintf(area2[k++], MAX_SYMBOLS, "7. EV offset:      %4.1f", compensation);
2634        snprintf(area2[k++], MAX_SYMBOLS, "8. AWB mode:       %s", awb[awb_mode]);
2635        snprintf(area2[k++], MAX_SYMBOLS, "z. Zoom            %s", zoom[zoomIDX].zoom_description);
2636        snprintf(area2[k++], MAX_SYMBOLS, "Z. Smooth Zoom     %s", zoom[zoomIDX].zoom_description);
2637        snprintf(area2[k++], MAX_SYMBOLS, "j. Exposure        %s", exposureMode[exposure_mode]);
2638        snprintf(area2[k++], MAX_SYMBOLS, "Q. manual exposure value  =  %d\n", manualExp);
2639        snprintf(area2[k++], MAX_SYMBOLS, "e. Effect:         %s", effectss[effects_mode]);
2640        snprintf(area2[k++], MAX_SYMBOLS, "w. Scene:          %s", scene[scene_mode]);
2641        snprintf(area2[k++], MAX_SYMBOLS, "s. Saturation:     %d", saturation);
2642        snprintf(area2[k++], MAX_SYMBOLS, "c. Contrast:       %d", contrast);
2643        snprintf(area2[k++], MAX_SYMBOLS, "h. Sharpness:      %d", sharpness);
2644        snprintf(area2[k++], MAX_SYMBOLS, "b. Brightness:     %d", brightness);
2645        snprintf(area2[k++], MAX_SYMBOLS, "x. Antibanding:    %s", antiband[antibanding_mode]);
2646        snprintf(area2[k++], MAX_SYMBOLS, "g. Focus mode:     %s", focus[focus_mode]);
2647        snprintf(area2[k++], MAX_SYMBOLS, "m. Metering mode:     %s" , metering[meter_mode]);
2648        snprintf(area2[k++], MAX_SYMBOLS, "<. Exposure Lock:     %s", AutoExposureLocktoggle ? "On" : "Off");
2649        snprintf(area2[k++], MAX_SYMBOLS, ">. WhiteBalance Lock:  %s",AutoWhiteBalanceLocktoggle ? "On": "Off");
2650        snprintf(area2[k++], MAX_SYMBOLS, "). Mechanical Misalignment Correction:  %s",misalignmentCorrection[enableMisalignmentCorrectionIdx]);
2651        snprintf(area2[k++], MAX_SYMBOLS, "d. Algo enable/disable functions menu");
2652
2653        printf("\n");
2654        for (int i=0; (i<j || i < k) && i<MAX_LINES; i++) {
2655            printf("%-65s \t %-65s\n", area1[i], area2[i]);
2656        }
2657        printf("   Choice:");
2658    }
2659
2660    ch = getchar();
2661    printf("%c", ch);
2662
2663    print_menu = 1;
2664
2665    switch (ch) {
2666
2667    case '_':
2668        AutoConvergenceModeIDX++;
2669        AutoConvergenceModeIDX %= numAutoConvergence;
2670        params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]);
2671        if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], "manual") == 0) {
2672            params.set(KEY_MANUAL_CONVERGENCE, manualConv);
2673        } else {
2674            if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], "touch") == 0) {
2675                params.set(CameraParameters::KEY_METERING_AREAS, MeteringAreas);
2676            }
2677            manualConv = 0;
2678            params.set(KEY_MANUAL_CONVERGENCE, manualConv);
2679        }
2680        camera->setParameters(params.flatten());
2681
2682        break;
2683    case '^':
2684        if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], "manual") == 0) {
2685            manualConv += manualConvStep;
2686            if( manualConv > manualConvMax) {
2687               manualConv = manualConvMin;
2688            }
2689            params.set(KEY_MANUAL_CONVERGENCE, manualConv);
2690            camera->setParameters(params.flatten());
2691        }
2692        break;
2693    case 'A':
2694        camera_index++;
2695        camera_index %= numCamera;
2696        firstTime = true;
2697        closeCamera();
2698        openCamera();
2699        initDefaults();
2700
2701
2702        break;
2703    case '[':
2704        if ( hardwareActive ) {
2705            camera->setParameters(params.flatten());
2706            camera->startPreview();
2707        }
2708        break;
2709
2710    case '0':
2711        initDefaults();
2712        camera_index = 0;
2713        break;
2714
2715        case '1':
2716
2717            if ( startPreview() < 0 ) {
2718                printf("Error while starting preview\n");
2719
2720                return -1;
2721            }
2722
2723            break;
2724
2725        case '2':
2726            if ( recordingMode ) {
2727                stopRecording();
2728                stopPreview();
2729                closeRecorder();
2730                camera->disconnect();
2731                camera.clear();
2732                camera = Camera::connect(camera_index);
2733                  if ( NULL == camera.get() ) {
2734                      sleep(1);
2735                      camera = Camera::connect(camera_index);
2736                      if ( NULL == camera.get() ) {
2737                          return -1;
2738                      }
2739                  }
2740                  camera->setListener(new CameraHandler());
2741                  camera->setParameters(params.flatten());
2742                  recordingMode = false;
2743            } else {
2744                stopPreview();
2745            }
2746
2747            break;
2748
2749        case '3':
2750            rotation += 90;
2751            rotation %= 360;
2752            params.set(CameraParameters::KEY_ROTATION, rotation);
2753            if ( hardwareActive )
2754                camera->setParameters(params.flatten());
2755
2756            break;
2757
2758        case 'V':
2759            previewRotation += 90;
2760            previewRotation %= 360;
2761            params.set(KEY_SENSOR_ORIENTATION, previewRotation);
2762
2763            if ( hardwareActive )
2764                camera->setParameters(params.flatten());
2765
2766            break;
2767
2768        case '4':
2769            previewSizeIDX += 1;
2770            previewSizeIDX %= numpreviewSize;
2771            params.setPreviewSize(preview_Array[previewSizeIDX]->width, preview_Array[previewSizeIDX]->height);
2772
2773            reSizePreview = true;
2774
2775            if ( hardwareActive && previewRunning ) {
2776                camera->stopPreview();
2777                camera->setParameters(params.flatten());
2778                camera->startPreview();
2779            } else if ( hardwareActive ) {
2780                camera->setParameters(params.flatten());
2781            }
2782
2783            break;
2784
2785        case '5':
2786            captureSizeIDX += 1;
2787            captureSizeIDX %= numcaptureSize;
2788            printf("CaptureSizeIDX %d \n", captureSizeIDX);
2789            params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
2790
2791            if ( hardwareActive )
2792                camera->setParameters(params.flatten());
2793
2794            requestBufferSourceReset();
2795
2796            break;
2797
2798        case 'l':
2799
2800            VcaptureSizeIDX++;
2801            VcaptureSizeIDX %= numVcaptureSize;
2802            break;
2803
2804        case 'L' :
2805            stereoLayoutIDX++;
2806            stereoLayoutIDX %= numLay;
2807
2808            if (stereoMode) {
2809                firstTimeStereo = false;
2810                params.set(KEY_S3D_PRV_FRAME_LAYOUT, stereoLayout[stereoLayoutIDX]);
2811            }
2812
2813            getSizeParametersFromCapabilities();
2814
2815            if (hardwareActive && previewRunning) {
2816                stopPreview();
2817                camera->setParameters(params.flatten());
2818                startPreview();
2819            } else if (hardwareActive) {
2820                camera->setParameters(params.flatten());
2821            }
2822
2823            break;
2824
2825        case '.' :
2826            stereoCapLayoutIDX++;
2827            stereoCapLayoutIDX %= numCLay;
2828
2829            if (stereoMode) {
2830                firstTimeStereo = false;
2831                params.set(KEY_S3D_CAP_FRAME_LAYOUT, stereoCapLayout[stereoCapLayoutIDX]);
2832            }
2833
2834            getSizeParametersFromCapabilities();
2835
2836            if (hardwareActive && previewRunning) {
2837                stopPreview();
2838                camera->setParameters(params.flatten());
2839                startPreview();
2840            } else if (hardwareActive) {
2841                camera->setParameters(params.flatten());
2842            }
2843
2844            break;
2845
2846        case ']':
2847            VbitRateIDX++;
2848            VbitRateIDX %= ARRAY_SIZE(VbitRate);
2849            break;
2850
2851
2852        case '6':
2853
2854            if ( !recordingMode ) {
2855
2856                recordingMode = true;
2857
2858                if ( startPreview() < 0 ) {
2859                    printf("Error while starting preview\n");
2860
2861                    return -1;
2862                }
2863
2864                if ( openRecorder() < 0 ) {
2865                    printf("Error while openning video recorder\n");
2866
2867                    return -1;
2868                }
2869
2870                if ( configureRecorder() < 0 ) {
2871                    printf("Error while configuring video recorder\n");
2872
2873                    return -1;
2874                }
2875
2876                if ( startRecording() < 0 ) {
2877                    printf("Error while starting video recording\n");
2878
2879                    return -1;
2880                }
2881            }
2882
2883            break;
2884
2885        case '7':
2886
2887            if ( compensation > 2.0) {
2888                compensation = -2.0;
2889            } else {
2890                compensation += 0.1;
2891            }
2892
2893            params.set(KEY_COMPENSATION, (int) (compensation * 10));
2894
2895            if ( hardwareActive )
2896                camera->setParameters(params.flatten());
2897
2898            break;
2899
2900        case '8':
2901            awb_mode++;
2902            awb_mode %= numawb;
2903            params.set(params.KEY_WHITE_BALANCE, awb[awb_mode]);
2904
2905            if ( hardwareActive )
2906                camera->setParameters(params.flatten());
2907
2908            break;
2909
2910        case '9':
2911            videoCodecIDX++;
2912            videoCodecIDX %= ARRAY_SIZE(videoCodecs);
2913            break;
2914        case '~':
2915            previewFormat += 1;
2916            previewFormat %= numpreviewFormat;
2917            params.setPreviewFormat(previewFormatArray[previewFormat]);
2918
2919            if ( hardwareActive )
2920                camera->setParameters(params.flatten());
2921
2922            break;
2923        case '$':
2924            pictureFormat += 1;
2925            pictureFormat %= numpictureFormat;
2926            printf("pictureFormat %d\n", pictureFormat);
2927            printf("numpreviewFormat %d\n", numpictureFormat);
2928            params.setPictureFormat(pictureFormatArray[pictureFormat]);
2929
2930            queueEmpty = true;
2931            if ( bufferSourceOutputThread.get() ) {
2932                if ( 0 < bufferSourceOutputThread->hasBuffer() ) {
2933                    queueEmpty = false;
2934                }
2935            }
2936            if ( hardwareActive && queueEmpty )
2937                camera->setParameters(params.flatten());
2938
2939            break;
2940
2941        case ':':
2942            thumbSizeIDX += 1;
2943            thumbSizeIDX %= numthumbnailSize;
2944            printf("ThumbnailSizeIDX %d \n", thumbSizeIDX);
2945
2946            params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, thumbnail_Array[thumbSizeIDX]->width);
2947            params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,thumbnail_Array[thumbSizeIDX]->height);
2948
2949            if ( hardwareActive )
2950                camera->setParameters(params.flatten());
2951
2952            break;
2953
2954        case '\'':
2955            if ( thumbQuality >= 100) {
2956                thumbQuality = 0;
2957            } else {
2958                thumbQuality += 5;
2959            }
2960
2961            params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, thumbQuality);
2962            if ( hardwareActive )
2963                camera->setParameters(params.flatten());
2964            break;
2965
2966        case 'B' :
2967            if(strcmp(vnfstr, "true") == 0) {
2968                if(vnftoggle == false) {
2969                    trySetVideoNoiseFilter(true);
2970                    vnftoggle = true;
2971                } else {
2972                    trySetVideoNoiseFilter(false);
2973                    vnftoggle = false;
2974                }
2975
2976            }else {
2977                trySetVideoNoiseFilter(false);
2978                vnftoggle = false;
2979                printf("VNF is not supported\n");
2980            }
2981            if ( hardwareActive )
2982                camera->setParameters(params.flatten());
2983
2984            break;
2985
2986        case 'C' :
2987            if(strcmp(vstabstr, "true") == 0) {
2988                if(vstabtoggle == false) {
2989                    trySetVideoStabilization(true);
2990                    vstabtoggle = true;
2991                } else {
2992                    trySetVideoStabilization(false);
2993                    vstabtoggle = false;
2994                }
2995
2996            } else {
2997                trySetVideoStabilization(false);
2998                vstabtoggle = false;
2999                printf("VSTAB is not supported\n");
3000            }
3001            if ( hardwareActive )
3002                camera->setParameters(params.flatten());
3003
3004            break;
3005
3006        case 'E':
3007            if(hardwareActive)
3008                params.unflatten(camera->getParameters());
3009            printSupportedParams();
3010            break;
3011
3012        case '*':
3013            if ( hardwareActive )
3014                camera->startRecording();
3015            break;
3016
3017        case 'o':
3018            if ( jpegQuality >= 100) {
3019                jpegQuality = 0;
3020            } else {
3021                jpegQuality += 5;
3022            }
3023
3024            params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);
3025            if ( hardwareActive )
3026                camera->setParameters(params.flatten());
3027            break;
3028
3029        case 'M':
3030            measurementIdx = (measurementIdx + 1)%ARRAY_SIZE(measurement);
3031            params.set(KEY_MEASUREMENT, measurement[measurementIdx]);
3032            if ( hardwareActive )
3033                camera->setParameters(params.flatten());
3034            break;
3035
3036        case 'm':
3037            meter_mode = (meter_mode + 1)%ARRAY_SIZE(metering);
3038            params.set(KEY_METERING_MODE, metering[meter_mode]);
3039            if ( hardwareActive )
3040                camera->setParameters(params.flatten());
3041            break;
3042
3043        case 'k':
3044            ippIDX += 1;
3045            ippIDX %= ARRAY_SIZE(ipp_mode);
3046            ippIDX_old = ippIDX;
3047
3048            params.set(KEY_IPP, ipp_mode[ippIDX]);
3049
3050            if ( hardwareActive )
3051                camera->setParameters(params.flatten());
3052
3053            requestBufferSourceReset();
3054
3055            break;
3056
3057        case 'K':
3058            gbceIDX+= 1;
3059            gbceIDX %= ARRAY_SIZE(gbce);
3060            params.set(KEY_GBCE, gbce[gbceIDX]);
3061
3062            if ( hardwareActive )
3063                camera->setParameters(params.flatten());
3064            break;
3065
3066        case 'O':
3067            glbceIDX+= 1;
3068            glbceIDX %= ARRAY_SIZE(gbce);
3069            params.set(KEY_GLBCE, gbce[glbceIDX]);
3070
3071            if ( hardwareActive )
3072                camera->setParameters(params.flatten());
3073            break;
3074
3075        case 'F':
3076            faceDetectToggle = !faceDetectToggle;
3077            if ( hardwareActive ) {
3078                if (faceDetectToggle)
3079                    camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, 0, 0);
3080                else
3081                    camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0);
3082            }
3083            break;
3084
3085        case 'I':
3086            afTimeoutIdx++;
3087            afTimeoutIdx %= ARRAY_SIZE(afTimeout);
3088            params.set(KEY_AF_TIMEOUT, afTimeout[afTimeoutIdx]);
3089            if ( hardwareActive )
3090                camera->setParameters(params.flatten());
3091
3092            break;
3093
3094        case 'T':
3095            metaDataToggle = !metaDataToggle;
3096            break;
3097
3098        case '@':
3099            if ( hardwareActive ) {
3100
3101                closeCamera();
3102
3103                if ( 0 >= openCamera() ) {
3104                    printf( "Reconnected to CameraService \n");
3105                }
3106            }
3107
3108            break;
3109
3110        case '#':
3111
3112            if ( burst >= MAX_BURST ) {
3113                burst = 0;
3114            } else {
3115                burst += BURST_INC;
3116            }
3117            burstCount = burst;
3118            params.set(KEY_TI_BURST, burst);
3119
3120            if ( hardwareActive )
3121                camera->setParameters(params.flatten());
3122
3123            break;
3124
3125        case 'J':
3126            flashIdx++;
3127            flashIdx %= numflash;
3128            params.set(CameraParameters::KEY_FLASH_MODE, (flash[flashIdx]));
3129
3130            if ( hardwareActive )
3131                camera->setParameters(params.flatten());
3132
3133            break;
3134
3135        case 'u':
3136            capture_mode++;
3137            capture_mode %= nummodevalues;
3138
3139            // HQ should always be in ldc-nsf
3140            // if not HQ, then return the ipp to its previous state
3141            if( !strcmp(modevalues[capture_mode], "high-quality") ) {
3142                ippIDX_old = ippIDX;
3143                ippIDX = 3;
3144                params.set(KEY_IPP, ipp_mode[ippIDX]);
3145                params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::FALSE);
3146                previewRotation = 0;
3147                params.set(KEY_SENSOR_ORIENTATION, previewRotation);
3148            } else if ( !strcmp(modevalues[capture_mode], "video-mode") ) {
3149                params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::TRUE);
3150                camera->getCameraInfo(camera_index, &cameraInfo);
3151                previewRotation = ((360-cameraInfo.orientation)%360);
3152                if (previewRotation >= 0 || previewRotation <=360) {
3153                    params.set(KEY_SENSOR_ORIENTATION, previewRotation);
3154                }
3155            } else {
3156                ippIDX = ippIDX_old;
3157                params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::FALSE);
3158                previewRotation = 0;
3159                params.set(KEY_SENSOR_ORIENTATION, previewRotation);
3160            }
3161
3162            params.set(KEY_MODE, (modevalues[capture_mode]));
3163
3164            if ( hardwareActive ) {
3165                if (previewRunning) {
3166                    stopPreview();
3167                }
3168                camera->setParameters(params.flatten());
3169                // Get parameters from capabilities for the new capture mode
3170                params = camera->getParameters();
3171                getSizeParametersFromCapabilities();
3172                getParametersFromCapabilities();
3173                // Set framerate 30fps and 12MP capture resolution if available for the new capture mode.
3174                // If not available set framerate and capture mode under index 0 from fps_const_str and capture_Array.
3175                frameRateIDX = getDefaultParameter("30000,30000", constCnt, fps_const_str);
3176                captureSizeIDX = getDefaultParameterResol("12MP", numcaptureSize, capture_Array);
3177                params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRateIDX]);
3178                params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
3179                camera->setParameters(params.flatten());
3180            }
3181
3182            requestBufferSourceReset();
3183
3184            break;
3185
3186        case 'U':
3187            tempBracketIdx++;
3188            tempBracketIdx %= ARRAY_SIZE(tempBracketing);
3189            params.set(KEY_TEMP_BRACKETING, tempBracketing[tempBracketIdx]);
3190
3191            if ( hardwareActive )
3192                camera->setParameters(params.flatten());
3193
3194            break;
3195
3196        case 'H':
3197            expBracketIdx++;
3198            expBracketIdx %= ARRAY_SIZE(expBracketing);
3199            setDefaultExpGainPreset(shotParams, expBracketIdx);
3200
3201            break;
3202
3203        case 'n':
3204            if (shotConfigFlush)
3205                shotConfigFlush = false;
3206            else
3207                shotConfigFlush = true;
3208
3209            updateShotConfigFlushParam();
3210
3211            break;
3212
3213        case '(':
3214        {
3215            char input[256];
3216            input[0] = ch;
3217            scanf("%254s", input+1);
3218            setExpGainPreset(shotParams, input, true, PARAM_EXP_BRACKET_PARAM_NONE, shotConfigFlush);
3219            break;
3220        }
3221        case 'W':
3222            tempBracketRange++;
3223            tempBracketRange %= TEMP_BRACKETING_MAX_RANGE;
3224            if ( 0 == tempBracketRange ) {
3225                tempBracketRange = 1;
3226            }
3227
3228            params.set(KEY_TEMP_BRACKETING_NEG, tempBracketRange);
3229            params.set(KEY_TEMP_BRACKETING_POS, tempBracketRange);
3230
3231            if ( hardwareActive )
3232                camera->setParameters(params.flatten());
3233
3234            break;
3235
3236        case 'w':
3237            scene_mode++;
3238            scene_mode %= numscene;
3239            params.set(params.KEY_SCENE_MODE, scene[scene_mode]);
3240
3241            if ( hardwareActive )
3242                camera->setParameters(params.flatten());
3243
3244            break;
3245
3246        case 'i':
3247            iso_mode++;
3248            iso_mode %= numisoMode;
3249            params.set(KEY_ISO, isoMode[iso_mode]);
3250            if ( hardwareActive )
3251                camera->setParameters(params.flatten());
3252            break;
3253
3254
3255        case 'h':
3256#ifdef TARGET_OMAP4
3257            if ( sharpness >= 200)
3258#else
3259            if ( sharpness >= 100)
3260#endif
3261            {
3262                sharpness = 0;
3263            } else {
3264                sharpness += 10;
3265            }
3266            params.set(KEY_SHARPNESS, sharpness);
3267            if ( hardwareActive )
3268                camera->setParameters(params.flatten());
3269            break;
3270
3271        case 'D':
3272        {
3273            audioCodecIDX++;
3274            audioCodecIDX %= ARRAY_SIZE(audioCodecs);
3275            break;
3276        }
3277
3278        case 'v':
3279        {
3280            outputFormatIDX++;
3281            outputFormatIDX %= ARRAY_SIZE(outputFormat);
3282            break;
3283        }
3284
3285        case 'z':
3286            if(strcmp(zoomstr, "true") == 0) {
3287                zoomIDX++;
3288                zoomIDX %= ARRAY_SIZE(zoom);
3289                params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
3290
3291                if ( hardwareActive )
3292                    camera->setParameters(params.flatten());
3293            }
3294            break;
3295
3296        case 'Z':
3297            if(strcmp(smoothzoomstr, "true") == 0) {
3298                zoomIDX++;
3299                zoomIDX %= ARRAY_SIZE(zoom);
3300
3301                if ( hardwareActive )
3302                    camera->sendCommand(CAMERA_CMD_START_SMOOTH_ZOOM, zoom[zoomIDX].idx, 0);
3303            }
3304            break;
3305
3306        case 'j':
3307            exposure_mode++;
3308            exposure_mode %= numExposureMode;
3309            params.set(KEY_EXPOSURE, exposureMode[exposure_mode]);
3310            if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
3311                params.set(KEY_MANUAL_EXPOSURE, manualExp);
3312                params.set(KEY_MANUAL_GAIN_ISO, manualGain);
3313                params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
3314                params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
3315            }
3316            else
3317            {
3318                manualExp = manualExpMin;
3319                params.set(KEY_MANUAL_EXPOSURE, manualExp);
3320                params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
3321                manualGain = manualGainMin;
3322                params.set(KEY_MANUAL_GAIN_ISO, manualGain);
3323                params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
3324            }
3325
3326            if ( hardwareActive ) {
3327                camera->setParameters(params.flatten());
3328            }
3329
3330            break;
3331
3332        case 'Q':
3333            if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
3334                manualExp += manualExpStep;
3335                if( manualExp > manualExpMax) {
3336                    manualExp = manualExpMin;
3337                }
3338                params.set(KEY_MANUAL_EXPOSURE, manualExp);
3339                params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
3340                camera->setParameters(params.flatten());
3341            }
3342            break;
3343
3344        case ',':
3345            if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
3346                manualGain += manualGainStep;
3347                if( manualGain > manualGainMax) {
3348                   manualGain = manualGainMin;
3349                }
3350                params.set(KEY_MANUAL_GAIN_ISO, manualGain);
3351                params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
3352                camera->setParameters(params.flatten());
3353            }
3354            break;
3355
3356        case 'c':
3357            if( contrast >= 200){
3358                contrast = 0;
3359            } else {
3360                contrast += 10;
3361            }
3362            params.set(KEY_CONTRAST, contrast);
3363            if ( hardwareActive ) {
3364                camera->setParameters(params.flatten());
3365            }
3366            break;
3367        case 'b':
3368#ifdef TARGET_OMAP4
3369            if ( brightness >= 100)
3370#else
3371            if ( brightness >= 200)
3372#endif
3373            {
3374                brightness = 0;
3375            } else {
3376                brightness += 10;
3377            }
3378
3379            params.set(KEY_BRIGHTNESS, brightness);
3380
3381            if ( hardwareActive ) {
3382                camera->setParameters(params.flatten());
3383            }
3384
3385            break;
3386
3387        case 's':
3388            if ( saturation >= 200) {
3389                saturation = 0;
3390            } else {
3391                saturation += 10;
3392            }
3393
3394            params.set(KEY_SATURATION, saturation);
3395
3396            if ( hardwareActive )
3397                camera->setParameters(params.flatten());
3398
3399            break;
3400
3401        case 'e':
3402            effects_mode++;
3403            effects_mode %= numEffects;
3404            printf("%d", numEffects);
3405            params.set(params.KEY_EFFECT, effectss[effects_mode]);
3406            printf("Effects_mode %d", effects_mode);
3407
3408            if ( hardwareActive )
3409                camera->setParameters(params.flatten());
3410
3411            break;
3412
3413        case 'r':
3414            frameRateIDX++;
3415            frameRateIDX %= constCnt;
3416            params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRateIDX]);
3417            printf("fps_const_str[frameRateIDX] %s\n", fps_const_str[frameRateIDX]);
3418
3419            if ( hardwareActive ) {
3420                camera->setParameters(params.flatten());
3421            }
3422
3423            break;
3424
3425        case 'R':
3426            fpsRangeIdx += 1;
3427            fpsRangeIdx %= rangeCnt;
3428            params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_range_str[fpsRangeIdx]);
3429            printf("fps_range_str[fpsRangeIdx] %s\n", fps_range_str[fpsRangeIdx]);
3430
3431            if ( hardwareActive ) {
3432                camera->setParameters(params.flatten());
3433            }
3434
3435            break;
3436
3437        case 'x':
3438            antibanding_mode++;
3439            antibanding_mode %= numAntibanding;
3440            printf("%d", numAntibanding);
3441            params.set(params.KEY_ANTIBANDING, antiband[antibanding_mode]);
3442
3443            if ( hardwareActive )
3444                camera->setParameters(params.flatten());
3445
3446            break;
3447
3448        case 'g':
3449            focus_mode++;
3450            focus_mode %= numfocus;
3451            params.set(params.KEY_FOCUS_MODE, focus[focus_mode]);
3452
3453            if ( hardwareActive )
3454                camera->setParameters(params.flatten());
3455
3456            break;
3457
3458        case 'G':
3459            params.set(CameraParameters::KEY_FOCUS_AREAS, TEST_FOCUS_AREA);
3460
3461            if ( hardwareActive )
3462                camera->setParameters(params.flatten());
3463
3464            break;
3465
3466        case 'y':
3467            params.set(CameraParameters::KEY_METERING_AREAS, TEST_METERING_AREA);
3468
3469            if ( hardwareActive ) {
3470                camera->setParameters(params.flatten());
3471            }
3472
3473            break;
3474
3475        case 'Y':
3476
3477            params.set(CameraParameters::KEY_METERING_AREAS, TEST_METERING_AREA_CENTER);
3478
3479            if ( hardwareActive ) {
3480                camera->setParameters(params.flatten());
3481            }
3482
3483            break;
3484
3485        case 'N':
3486
3487            params.set(CameraParameters::KEY_METERING_AREAS, TEST_METERING_AREA_AVERAGE);
3488
3489            if ( hardwareActive ) {
3490                camera->setParameters(params.flatten());
3491            }
3492
3493            break;
3494
3495        case 'f':
3496            gettimeofday(&autofocus_start, 0);
3497
3498            if ( hardwareActive )
3499                camera->autoFocus();
3500
3501            break;
3502
3503        case 'p':
3504        {
3505            int msgType = 0;
3506
3507            if((0 == strcmp(modevalues[capture_mode], "video-mode")) &&
3508               (0 != strcmp(videosnapshotstr, "true"))) {
3509                printf("Video Snapshot is not supported\n");
3510            } else if ( hardwareActive ) {
3511                if(isRawPixelFormat(pictureFormatArray[pictureFormat])) {
3512                    createBufferOutputSource();
3513                    if (bufferSourceOutputThread.get()) {
3514                        bufferSourceOutputThread->setBuffer(shotParams);
3515                        bufferSourceOutputThread->setStreamCapture(streamCapture, expBracketIdx);
3516                    }
3517                } else {
3518                    msgType = CAMERA_MSG_COMPRESSED_IMAGE |
3519                              CAMERA_MSG_RAW_IMAGE;
3520#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
3521                    msgType |= CAMERA_MSG_RAW_BURST;
3522#endif
3523                }
3524
3525                gettimeofday(&picture_start, 0);
3526                camera->setParameters(params.flatten());
3527                camera->takePictureWithParameters(msgType, shotParams.flatten());
3528            }
3529            break;
3530        }
3531
3532        case 'S':
3533        {
3534            if (streamCapture) {
3535                streamCapture = false;
3536                setDefaultExpGainPreset(shotParams, expBracketIdx);
3537                // Stop streaming
3538                if (bufferSourceOutputThread.get()) {
3539                    bufferSourceOutputThread->setStreamCapture(streamCapture, expBracketIdx);
3540                }
3541            } else {
3542                streamCapture = true;
3543                setSingleExpGainPreset(shotParams, expBracketIdx, 0, 0);
3544                // Queue more frames initially
3545                shotParams.set(ShotParameters::KEY_BURST, BRACKETING_STREAM_BUFFERS);
3546            }
3547            break;
3548        }
3549
3550        case 'P':
3551        {
3552            int msgType = CAMERA_MSG_COMPRESSED_IMAGE;
3553            ShotParameters reprocParams;
3554
3555            gettimeofday(&picture_start, 0);
3556            createBufferInputSource();
3557            if (bufferSourceOutputThread.get() &&
3558                bufferSourceOutputThread->hasBuffer())
3559            {
3560                bufferSourceOutputThread->setStreamCapture(false, expBracketIdx);
3561                if (hardwareActive) camera->setParameters(params.flatten());
3562
3563                if (bufferSourceInput.get()) {
3564                    buffer_info_t info = bufferSourceOutputThread->popBuffer();
3565                    bufferSourceInput->setInput(info, pictureFormatArray[pictureFormat], reprocParams);
3566                    if (hardwareActive) camera->reprocess(msgType, reprocParams.flatten());
3567                }
3568            }
3569            break;
3570        }
3571
3572        case '&':
3573            printf("Enabling Preview Callback");
3574            dump_preview = 1;
3575            if ( hardwareActive )
3576            camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
3577            break;
3578
3579        case '{':
3580            valstr = params.get(KEY_S3D2D_PREVIEW_MODE);
3581            if ( (NULL != valstr) && (0 == strcmp(valstr, "on")) )
3582                {
3583                params.set(KEY_S3D2D_PREVIEW_MODE, "off");
3584                }
3585            else
3586                {
3587                params.set(KEY_S3D2D_PREVIEW_MODE, "on");
3588                }
3589            if ( hardwareActive )
3590                camera->setParameters(params.flatten());
3591            break;
3592
3593        case 'a':
3594
3595            while (1) {
3596                if ( menu_gps() < 0)
3597                    break;
3598            };
3599
3600            break;
3601
3602        case 'q':
3603            stopPreview();
3604            deleteAllocatedMemory();
3605
3606            return -1;
3607
3608        case '/':
3609        {
3610            if (showfps)
3611            {
3612                property_set("debug.image.showfps", "0");
3613                showfps = false;
3614            }
3615            else
3616            {
3617                property_set("debug.image.showfps", "1");
3618                showfps = true;
3619            }
3620            break;
3621        }
3622
3623        case '<':
3624            if(strcmp(AutoExposureLockstr, "true") == 0) {
3625                if(AutoExposureLocktoggle == false) {
3626                    trySetAutoExposureLock(true);
3627                    AutoExposureLocktoggle = true;
3628                } else {
3629                    trySetAutoExposureLock(false);
3630                    AutoExposureLocktoggle = false;
3631                    printf("ExposureLock is not supported\n");
3632                }
3633            }
3634
3635            if ( hardwareActive )
3636                camera->setParameters(params.flatten());
3637
3638            break;
3639
3640        case '>':
3641            if(strcmp(AutoWhiteBalanceLockstr, "true") == 0) {
3642                if(AutoWhiteBalanceLocktoggle == false) {
3643                    trySetAutoWhiteBalanceLock(true);
3644                    AutoWhiteBalanceLocktoggle = true;
3645                } else {
3646                    trySetAutoWhiteBalanceLock(false);
3647                    AutoWhiteBalanceLocktoggle = false;
3648                    printf("ExposureLock is not supported\n");
3649                }
3650            }
3651
3652            if ( hardwareActive ) {
3653                camera->setParameters(params.flatten());
3654            }
3655
3656            break;
3657
3658    case ')':
3659      enableMisalignmentCorrectionIdx++;
3660      enableMisalignmentCorrectionIdx %= ARRAY_SIZE(misalignmentCorrection);
3661      params.set(KEY_MECHANICAL_MISALIGNMENT_CORRECTION, misalignmentCorrection[enableMisalignmentCorrectionIdx]);
3662      if ( hardwareActive ) {
3663        camera->setParameters(params.flatten());
3664      }
3665      break;
3666
3667    case 'd':
3668        while (1) {
3669            if ( menu_algo() < 0)
3670                break;
3671        }
3672        break;
3673
3674    default:
3675      print_menu = 0;
3676
3677      break;
3678    }
3679
3680    return 0;
3681}
3682
3683void print_usage() {
3684    printf(" USAGE: camera_test <options>\n");
3685    printf(" <options> (case insensitive)\n");
3686    printf("-----------\n");
3687    printf(" -f            -> Functional tests.\n");
3688    printf(" -a            -> API tests.\n");
3689    printf(" -e [<script>] -> Error scenario tests. If no script file is provided\n");
3690    printf("                  the test is run in interactive mode.\n");
3691    printf(" -s <script> -c <sensorID>  -> Stress / regression tests.\n");
3692    printf(" -l [<flags>]  -> Enable different kinds of logging capture. Multiple flags\n");
3693    printf("                  should be combined into a string. If flags are not provided\n");
3694    printf("                  no logs are captured.\n");
3695    printf("                   <flags>\n");
3696    printf("                  ---------\n");
3697    printf("                   l -> logcat [default]\n");
3698    printf("                   s -> syslink [default]\n");
3699    printf(" -o <path>     -> Output directory to store the test results. Image and video\n");
3700    printf("                  files are stored in corresponding sub-directories.\n");
3701    printf(" -p <platform> -> Target platform. Only for stress tests.\n");
3702    printf("                   <platform>\n");
3703    printf("                  ------------\n");
3704    printf("                   blaze or B    -> BLAZE\n");
3705    printf("                   tablet1 or T1 -> Blaze TABLET-1\n");
3706    printf("                   tablet2 or T2 -> Blaze TABLET-2 [default]\n\n");
3707    return;
3708}
3709
3710int error_scenario() {
3711    char ch;
3712    status_t stat = NO_ERROR;
3713
3714    if (print_menu) {
3715        printf("   0. Buffer need\n");
3716        printf("   1. Not enough memory\n");
3717        printf("   2. Media server crash\n");
3718        printf("   3. Overlay object request\n");
3719        printf("   4. Pass unsupported preview&picture format\n");
3720        printf("   5. Pass unsupported preview&picture resolution\n");
3721        printf("   6. Pass unsupported preview framerate\n");
3722
3723        printf("   q. Quit\n");
3724        printf("   Choice: ");
3725    }
3726
3727    print_menu = 1;
3728    ch = getchar();
3729    printf("%c\n", ch);
3730
3731    switch (ch) {
3732        case '0': {
3733            printf("Case0:Buffer need\n");
3734            bufferStarvationTest = 1;
3735            params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation
3736
3737            if ( !recordingMode ) {
3738                recordingMode = true;
3739                if ( startPreview() < 0 ) {
3740                    printf("Error while starting preview\n");
3741
3742                    return -1;
3743                }
3744
3745                if ( openRecorder() < 0 ) {
3746                    printf("Error while openning video recorder\n");
3747
3748                    return -1;
3749                }
3750
3751                if ( configureRecorder() < 0 ) {
3752                    printf("Error while configuring video recorder\n");
3753
3754                    return -1;
3755                }
3756
3757                if ( startRecording() < 0 ) {
3758                    printf("Error while starting video recording\n");
3759
3760                    return -1;
3761                }
3762
3763            }
3764
3765            usleep(1000000);//1s
3766
3767            stopPreview();
3768
3769            if ( recordingMode ) {
3770                stopRecording();
3771                closeRecorder();
3772
3773                recordingMode = false;
3774            }
3775
3776            break;
3777        }
3778
3779        case '1': {
3780            printf("Case1:Not enough memory\n");
3781            int* tMemoryEater = new int[999999999];
3782
3783            if (!tMemoryEater) {
3784                printf("Not enough memory\n");
3785                return -1;
3786            } else {
3787                delete tMemoryEater;
3788            }
3789
3790            break;
3791        }
3792
3793        case '2': {
3794            printf("Case2:Media server crash\n");
3795            //camera = Camera::connect();
3796
3797            if ( NULL == camera.get() ) {
3798                printf("Unable to connect to CameraService\n");
3799                return -1;
3800            }
3801
3802            break;
3803        }
3804
3805        case '3': {
3806            printf("Case3:Overlay object request\n");
3807            int err = 0;
3808
3809            err = open("/dev/video5", O_RDWR);
3810
3811            if (err < 0) {
3812                printf("Could not open the camera device5: %d\n",  err );
3813                return err;
3814            }
3815
3816            if ( startPreview() < 0 ) {
3817                printf("Error while starting preview\n");
3818                return -1;
3819            }
3820
3821            usleep(1000000);//1s
3822
3823            stopPreview();
3824
3825            close(err);
3826            break;
3827        }
3828
3829        case '4': {
3830
3831            if ( hardwareActive ) {
3832
3833                params.setPictureFormat("invalid-format");
3834                params.setPreviewFormat("invalid-format");
3835
3836                stat = camera->setParameters(params.flatten());
3837
3838                if ( NO_ERROR != stat ) {
3839                    printf("Test passed!\n");
3840                } else {
3841                    printf("Test failed!\n");
3842                }
3843
3844                initDefaults();
3845            }
3846
3847            break;
3848        }
3849
3850        case '5': {
3851
3852            if ( hardwareActive ) {
3853
3854                params.setPictureSize(-1, -1);
3855                params.setPreviewSize(-1, -1);
3856
3857                stat = camera->setParameters(params.flatten());
3858
3859                if ( NO_ERROR != stat ) {
3860                    printf("Test passed!\n");
3861                } else {
3862                    printf("Test failed!\n");
3863                }
3864
3865                initDefaults();
3866            }
3867
3868            break;
3869        }
3870
3871        case '6': {
3872
3873            if ( hardwareActive ) {
3874
3875                params.setPreviewFrameRate(-1);
3876
3877                stat = camera->setParameters(params.flatten());
3878
3879                if ( NO_ERROR != stat ) {
3880                    printf("Test passed!\n");
3881                } else {
3882                    printf("Test failed!\n");
3883                }
3884
3885                initDefaults();
3886            }
3887
3888
3889            break;
3890        }
3891
3892        case 'q': {
3893            return -1;
3894        }
3895
3896        default: {
3897            print_menu = 0;
3898            break;
3899        }
3900    }
3901
3902    return 0;
3903}
3904
3905int restartCamera() {
3906
3907  printf("+++Restarting Camera After Error+++\n");
3908  stopPreview();
3909
3910  if (recordingMode) {
3911    stopRecording();
3912    closeRecorder();
3913
3914    recordingMode = false;
3915  }
3916
3917  sleep(3); //Wait a bit before restarting
3918
3919  restartCount++;
3920
3921  if ( openCamera() < 0 )
3922  {
3923    printf("+++Camera Restarted Failed+++\n");
3924    system("echo camerahal_test > /sys/power/wake_unlock");
3925    return -1;
3926  }
3927
3928  initDefaults();
3929
3930  stopScript = false;
3931
3932  printf("+++Camera Restarted Successfully+++\n");
3933  return 0;
3934}
3935
3936int parseCommandLine(int argc, char *argv[], cmd_args_t *cmd_args) {
3937    if (argc < 2) {
3938        printf("Please enter at least 1 argument\n");
3939        return -2;
3940    }
3941
3942    // Set defaults
3943    memset(cmd_args, 0, sizeof(*cmd_args));
3944    cmd_args->logging = LOGGING_LOGCAT | LOGGING_SYSLINK;
3945    cmd_args->platform_id = BLAZE_TABLET2;
3946
3947    for (int a = 1; a < argc; a++) {
3948        const char * const arg = argv[a];
3949        if (arg[0] != '-') {
3950            printf("Error: Invalid argument \"%s\"\n", arg);
3951            return -2;
3952        }
3953
3954        switch (arg[1]) {
3955            case 's':
3956                cmd_args->test_type = TEST_TYPE_REGRESSION;
3957                if (a < argc - 1) {
3958                    cmd_args->script_file_name = argv[++a];
3959                } else {
3960                    printf("Error: No script is specified for stress / regression test.\n");
3961                    return -2;
3962                }
3963                break;
3964
3965            case 'f':
3966                cmd_args->test_type = TEST_TYPE_FUNCTIONAL;
3967                break;
3968
3969            case 'a':
3970                cmd_args->test_type = TEST_TYPE_API;
3971                break;
3972
3973            case 'e':
3974                cmd_args->test_type = TEST_TYPE_ERROR;
3975                if (a < argc - 1) {
3976                    cmd_args->script_file_name = argv[++a];
3977                }
3978                break;
3979
3980            case 'l':
3981                cmd_args->logging = 0;
3982
3983                if (a < argc - 1 && argv[a + 1][0] != '-') {
3984                    const char *flags = argv[++a];
3985                    while (*flags) {
3986                        char flag = *flags++;
3987                        switch (flag) {
3988                            case 'l':
3989                                cmd_args->logging |= LOGGING_LOGCAT;
3990                                break;
3991
3992                            case 's':
3993                                cmd_args->logging |= LOGGING_SYSLINK;
3994                                break;
3995
3996                            default:
3997                                printf("Error: Unknown logging type \"%c\"\n", flag);
3998                                return -2;
3999                        }
4000                    }
4001                }
4002                break;
4003
4004            case 'p':
4005                if (a < argc - 1) {
4006                    const char *platform = argv[++a];
4007                    if( strcasecmp(platform,"blaze") == 0 || strcasecmp(platform,"B") == 0 ){
4008                        cmd_args->platform_id = BLAZE;
4009                    }
4010                    else if( (strcasecmp(platform,"tablet1") == 0) || (strcasecmp(platform,"T1") == 0) ) {
4011                        cmd_args->platform_id = BLAZE_TABLET1;
4012                    }
4013                    else if( (strcasecmp(platform,"tablet2") == 0) || (strcasecmp(platform,"T2") == 0) ) {
4014                        cmd_args->platform_id = BLAZE_TABLET2;
4015                    }
4016                    else {
4017                        printf("Error: Unknown argument for platform ID.\n");
4018                        return -2;
4019                    }
4020                } else {
4021                    printf("Error: No argument is specified for platform ID.\n");
4022                    return -2;
4023                }
4024                break;
4025
4026            case 'o':
4027                if (a < argc - 1) {
4028                    cmd_args->output_path = argv[++a];
4029                } else {
4030                    printf("Error: No output path is specified.\n");
4031                    return -2;
4032                }
4033                break;
4034
4035            case 'c':
4036                if (a < argc -1) {
4037                    camera_index = atoi(argv[++a]);
4038                } else {
4039                    printf("Error: No sensorID is specified.\n");
4040                    return -2;
4041                }
4042                break;
4043
4044            default:
4045                printf("Error: Unknown option \"%s\"\n", argv[a]);
4046                return -2;
4047        }
4048    }
4049
4050    return 0;
4051}
4052
4053int setOutputDirPath(cmd_args_t *cmd_args, int restart_count) {
4054    if ((cmd_args->output_path != NULL) &&
4055            (strlen(cmd_args->output_path) < sizeof(output_dir_path))) {
4056        strcpy(output_dir_path, cmd_args->output_path);
4057    } else {
4058        strcpy(output_dir_path, SDCARD_PATH);
4059
4060        if (cmd_args->script_file_name != NULL) {
4061            const char *config = cmd_args->script_file_name;
4062            char dir_name[40];
4063            size_t count = 0;
4064            char *p;
4065
4066            // remove just the '.txt' part of the config
4067            while ((config[count] != '.') && ((count + 1) < sizeof(dir_name))) {
4068                count++;
4069            }
4070
4071            strncpy(dir_name, config, count);
4072
4073            dir_name[count] = NULL;
4074            p = dir_name;
4075            while (*p != '\0') {
4076                if (*p == '/') {
4077                    printf("SDCARD_PATH is not added to the output directory.\n");
4078                    // Needed when camera_test script is executed using the OTC
4079                    strcpy(output_dir_path, "");
4080                    break;
4081                }
4082            }
4083
4084            strcat(output_dir_path, dir_name);
4085            if (camera_index == 1) {
4086                strcat(output_dir_path, SECONDARY_SENSOR);
4087            }else if (camera_index == 2) {
4088                strcat(output_dir_path, S3D_SENSOR);
4089            }
4090        }
4091    }
4092
4093    if (restart_count && (strlen(output_dir_path) + 16) < sizeof(output_dir_path)) {
4094        char count[16];
4095        sprintf(count, "_%d", restart_count);
4096        strcat(output_dir_path, count);
4097    }
4098
4099    if (access(output_dir_path, F_OK) == -1) {
4100        if (mkdir(output_dir_path, 0777) == -1) {
4101             printf("\nError: Output directory \"%s\" was not created\n", output_dir_path);
4102             return -1;
4103        }
4104    }
4105
4106    sprintf(videos_dir_path, "%s/videos", output_dir_path);
4107
4108    if (access(videos_dir_path, F_OK) == -1) {
4109        if (mkdir(videos_dir_path, 0777) == -1) {
4110             printf("\nError: Videos directory \"%s\" was not created\n", videos_dir_path);
4111             return -1;
4112        }
4113    }
4114
4115    sprintf(images_dir_path, "%s/images", output_dir_path);
4116
4117    if (access(images_dir_path, F_OK) == -1) {
4118        if (mkdir(images_dir_path, 0777) == -1) {
4119             printf("\nError: Images directory \"%s\" was not created\n", images_dir_path);
4120             return -1;
4121        }
4122    }
4123
4124    return 0;
4125}
4126
4127int startTest() {
4128    ProcessState::self()->startThreadPool();
4129
4130    if (openCamera() < 0) {
4131        printf("Camera initialization failed\n");
4132        return -1;
4133    }
4134
4135    initDefaults();
4136
4137    return 0;
4138}
4139
4140int runRegressionTest(cmd_args_t *cmd_args) {
4141    char *cmd;
4142    int pid;
4143
4144    platformID = cmd_args->platform_id;
4145
4146    int res = startTest();
4147    if (res != 0) {
4148        return res;
4149    }
4150
4151    cmd = load_script(cmd_args->script_file_name);
4152
4153    if (cmd != NULL) {
4154        start_logging(cmd_args->logging, pid);
4155        stressTest = true;
4156
4157        while (1) {
4158            if (execute_functional_script(cmd) == 0) {
4159                break;
4160            }
4161
4162            printf("CameraTest Restarting Camera...\n");
4163
4164            free(cmd);
4165            cmd = NULL;
4166
4167            if ( (restartCamera() != 0)  || ((cmd = load_script(cmd_args->script_file_name)) == NULL) ) {
4168                printf("ERROR::CameraTest Restarting Camera...\n");
4169                res = -1;
4170                break;
4171            }
4172
4173            res = setOutputDirPath(cmd_args, restartCount);
4174            if (res != 0) {
4175                break;
4176            }
4177        }
4178
4179        free(cmd);
4180        stop_logging(cmd_args->logging, pid);
4181    }
4182
4183    return 0;
4184}
4185
4186int runFunctionalTest() {
4187    int res = startTest();
4188    if (res != 0) {
4189        return res;
4190    }
4191
4192    print_menu = 1;
4193
4194    while (1) {
4195        if (functional_menu() < 0) {
4196            break;
4197        }
4198    }
4199
4200    return 0;
4201}
4202
4203int runApiTest() {
4204    printf("API level test cases coming soon ... \n");
4205    return 0;
4206}
4207
4208int runErrorTest(cmd_args_t *cmd_args) {
4209    int res = startTest();
4210    if (res != 0) {
4211        return res;
4212    }
4213
4214    if (cmd_args->script_file_name != NULL) {
4215        char *cmd;
4216        int pid;
4217
4218        cmd = load_script(cmd_args->script_file_name);
4219
4220        if (cmd != NULL) {
4221            start_logging(cmd_args->logging, pid);
4222            execute_error_script(cmd);
4223            free(cmd);
4224            stop_logging(cmd_args->logging, pid);
4225        }
4226    } else {
4227        print_menu = 1;
4228
4229        while (1) {
4230            if (error_scenario() < 0) {
4231                break;
4232            }
4233        }
4234    }
4235
4236    return 0;
4237}
4238
4239int main(int argc, char *argv[]) {
4240    sp<ProcessState> proc(ProcessState::self());
4241
4242    unsigned long long st, end, delay;
4243    timeval current_time;
4244    cmd_args_t cmd_args;
4245    int res;
4246
4247    res = parseCommandLine(argc, argv, &cmd_args);
4248    if (res != 0) {
4249        print_usage();
4250        return res;
4251    }
4252
4253    res = setOutputDirPath(&cmd_args, 0);
4254    if (res != 0) {
4255        return res;
4256    }
4257
4258    gettimeofday(&current_time, 0);
4259
4260    st = current_time.tv_sec * 1000000 + current_time.tv_usec;
4261
4262    system("echo camerahal_test > /sys/power/wake_lock");
4263
4264    switch (cmd_args.test_type) {
4265        case TEST_TYPE_REGRESSION:
4266            res = runRegressionTest(&cmd_args);
4267            break;
4268
4269        case TEST_TYPE_FUNCTIONAL:
4270            res = runFunctionalTest();
4271            break;
4272
4273        case TEST_TYPE_API:
4274            res = runApiTest();
4275            break;
4276
4277        case TEST_TYPE_ERROR:
4278            res = runErrorTest(&cmd_args);
4279            break;
4280    }
4281
4282    system("echo camerahal_test > /sys/power/wake_unlock");
4283
4284    gettimeofday(&current_time, 0);
4285    end = current_time.tv_sec * 1000000 + current_time.tv_usec;
4286    delay = end - st;
4287    printf("Application closed after: %llu ms\n", delay);
4288
4289    return res;
4290}
4291