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
10 #include <camera/Camera.h>
11 #include <camera/ICamera.h>
12 #include <media/mediarecorder.h>
13
14 #include <binder/IPCThreadState.h>
15 #include <binder/ProcessState.h>
16 #include <binder/IServiceManager.h>
17 #include <cutils/properties.h>
18 #include <camera/CameraParameters.h>
19 #include <camera/ShotParameters.h>
20
21 #include <sys/wait.h>
22
23 #include "camera_test.h"
24 #include "camera_test_surfacetexture.h"
25 #ifdef ANDROID_API_JB_OR_LATER
26 #include "camera_test_bufferqueue.h"
27 #endif
28
29 using namespace android;
30
31 extern bool stopScript;
32 extern bool hardwareActive;
33 extern sp<Camera> camera;
34 extern sp<BufferSourceThread> bufferSourceOutputThread;
35 extern sp<BufferSourceInput> bufferSourceInput;
36 extern CameraParameters params;
37 extern ShotParameters shotParams;
38 extern bool shotConfigFlush;
39 extern bool streamCapture;
40 extern bool recordingMode;
41 extern int camera_index;
42 extern int rotation;
43 extern int previewRotation;
44 extern const param_Array captureSize[];
45 extern const param_Array VcaptureSize[];
46 extern const outformat outputFormat[];
47 extern const video_Codecs videoCodecs[];
48 extern const audio_Codecs audioCodecs[];
49 extern const V_bitRate VbitRate[];
50 extern const Zoom zoom [];
51 extern int previewSizeIDX;
52 extern bool reSizePreview;
53 extern bool previewRunning;
54 extern int captureSizeIDX;
55 extern float compensation;
56 extern int videoCodecIDX;
57 extern int outputFormatIDX;
58 extern int audioCodecIDX;
59 extern int VcaptureSizeIDX;
60 extern int VbitRateIDX;
61 extern int thumbSizeIDX;
62 extern int thumbQuality;
63 extern int jpegQuality;
64 extern int dump_preview;
65 extern int ippIDX_old;
66 extern const char *capture[];
67 extern int capture_mode;
68 extern int ippIDX;
69 extern const char *ipp_mode[];
70 extern int tempBracketRange;
71 extern int iso_mode;
72 extern int sharpness;
73 extern int contrast;
74 extern int zoomIDX;
75 extern int brightness;
76 extern int saturation;
77 extern int fpsRangeIdx;
78 extern int numAntibanding;
79 extern int numEffects;
80 extern int numawb;
81 extern int numExposureMode;
82 extern int numscene;
83 extern int numisoMode;
84 extern int numflash;
85 extern int numcaptureSize;
86 extern int numVcaptureSize;
87 extern int numpreviewSize;
88 extern int numthumbnailSize;
89 extern int numfocus;
90 extern int numpreviewFormat;
91 extern int numpictureFormat;
92 extern int nummodevalues;
93 extern int numLay;
94 extern int numCLay;
95 extern int constCnt;
96 extern int rangeCnt;
97 extern int * constFramerate;
98 extern int frameRateIDX;
99 extern int fpsRangeIdx;
100 extern int stereoLayoutIDX;
101 extern int stereoCapLayoutIDX;
102 extern int expBracketIdx;
103 int resol_index = 0;
104 int a = 0;
105 extern char * vstabstr;
106 extern char * vnfstr;
107 extern char * zoomstr;
108 extern char * smoothzoomstr;
109 extern char * videosnapshotstr;
110 extern char ** antiband;
111 extern char **effectss;
112 extern bool firstTime;
113 extern char **exposureMode;
114 extern char **awb;
115 extern char **scene;
116 extern char ** isoMode;
117 extern char ** modevalues;
118 extern char **focus;
119 extern char **flash;
120 extern char **previewFormatArray;
121 extern char **pictureFormatArray;
122 extern char ** fps_const_str;
123 extern char ** fps_range_str;
124 extern char ** rangeDescription;
125 extern param_Array ** capture_Array;
126 extern param_Array ** Vcapture_Array;
127 extern param_Array ** preview_Array;
128 extern param_Array ** thumbnail_Array;
129 extern timeval autofocus_start, picture_start;
130 extern const char *cameras[];
131 extern double latitude;
132 extern double degree_by_step;
133 extern double longitude;
134 extern double altitude;
135 extern char output_dir_path[];
136 extern char images_dir_path[];
137 extern int AutoConvergenceModeIDX;
138 extern const char *autoconvergencemode[];
139 extern int numCamera;
140 extern bool stereoMode;
141 extern char script_name[];
142 extern int bufferStarvationTest;
143 extern size_t length_previewSize;
144 extern size_t length_thumbnailSize;
145 extern size_t lenght_Vcapture_size;
146 extern size_t length_outformat;
147 extern size_t length_capture_Size;
148 extern size_t length_video_Codecs;
149 extern size_t length_audio_Codecs;
150 extern size_t length_V_bitRate;
151 extern size_t length_Zoom;
152 extern size_t length_fps_ranges;
153 extern size_t length_fpsConst_Ranges;
154 extern size_t length_fpsConst_RangesSec;
155 extern int platformID;
156 extern char **stereoLayout;
157 extern char **stereoCapLayout;
158 extern void getSizeParametersFromCapabilities();
159 extern int exposure_mode;
160 int manE = 0;
161 extern int manualExp ;
162 extern int manualExpMin ;
163 extern int manualExpMax ;
164 int manG = 0;
165 extern int manualGain ;
166 extern int manualGainMin ;
167 extern int manualGainMax ;
168 int manC = 0;
169 extern int manualConv ;
170 extern int manualConvMin ;
171 extern int manualConvMax ;
172 extern bool faceDetectToggle;
173 extern unsigned int burstCount;
174
175 /** Buffer source reset */
176 extern bool bufferSourceInputReset;
177 extern bool bufferSourceOutputReset;
178
trim_script_cmd(char * cmd)179 void trim_script_cmd(char *cmd) {
180 char *nl, *cr;
181
182 // first remove all carriage return symbols
183 while ( NULL != (cr = strchr(cmd, '\r'))) {
184 for (char *c = cr; '\0' != *c; c++) {
185 *c = *(c+1);
186 }
187 }
188
189 // then remove all single line feed symbols
190 while ( NULL != (nl = strchr(cmd, '\n'))) {
191 if (*nl == *(nl+1)) {
192 // two or more concatenated newlines:
193 // end of script found
194 break;
195 }
196 // clip the newline
197 for (char *c = nl; '\0' != *c; c++) {
198 *c = *(c+1);
199 }
200 }
201 }
202
execute_functional_script(char * script)203 int execute_functional_script(char *script) {
204 char *cmd, *ctx, *cycle_cmd, *temp_cmd;
205 char id;
206 unsigned int i;
207 int dly;
208 int cycleCounter = 1;
209 int tLen = 0;
210 unsigned int iteration = 0;
211 bool zoomtoggle = false;
212 bool smoothzoomtoggle = false;
213 status_t ret = NO_ERROR;
214 //int frameR = 20;
215 int frameRConst = 0;
216 int frameRRange = 0;
217 struct CameraInfo cameraInfo;
218 bool queueEmpty = true;
219
220 LOG_FUNCTION_NAME;
221
222 dump_mem_status();
223
224 cmd = strtok_r((char *) script, DELIMITER, &ctx);
225
226 while ( NULL != cmd && (stopScript == false)) {
227 trim_script_cmd(cmd);
228 id = cmd[0];
229 printf("Full Command: %s \n", cmd);
230 printf("Command: %c \n", cmd[0]);
231
232 switch (id) {
233
234 // Case for Suspend-Resume Feature
235 case '!': {
236 // STEP 1: Mount Debugfs
237 system("mkdir /debug");
238 system("mount -t debugfs debugfs /debug");
239
240 // STEP 2: Set up wake up Timer - wake up happens after 5 seconds
241 system("echo 10 > /debug/pm_debug/wakeup_timer_seconds");
242
243 // STEP 3: Make system ready for Suspend
244 system("echo camerahal_test > /sys/power/wake_unlock");
245 // Release wake lock held by test app
246 printf(" Wake lock released ");
247 system("cat /sys/power/wake_lock");
248 system("sendevent /dev/input/event0 1 60 1");
249 system("sendevent /dev/input/event0 1 60 0");
250 // Simulate F2 key press to make display OFF
251 printf(" F2 event simulation complete ");
252
253 //STEP 4: Wait for system Resume and then simuate F1 key
254 sleep(50);//50s // This delay is not related to suspend resume timer
255 printf(" After 30 seconds of sleep");
256 system("sendevent /dev/input/event0 1 59 0");
257 system("sendevent /dev/input/event0 1 59 1");
258 // Simulate F1 key press to make display ON
259 system("echo camerahal_test > /sys/power/wake_lock");
260 // Acquire wake lock for test app
261
262 break;
263 }
264
265 case '[':
266 if ( hardwareActive )
267 {
268
269 camera->setParameters(params.flatten());
270
271 printf("starting camera preview..");
272 status_t ret = camera->startPreview();
273 if(ret !=NO_ERROR)
274 {
275 printf("startPreview failed %d..", ret);
276 }
277 }
278 break;
279 case '+': {
280 cycleCounter = atoi(cmd + 1);
281 cycle_cmd = get_cycle_cmd(ctx);
282 tLen = strlen(cycle_cmd);
283 temp_cmd = new char[tLen+1];
284
285 for (int ind = 0; ind < cycleCounter; ind++) {
286 strcpy(temp_cmd, cycle_cmd);
287 if ( execute_functional_script(temp_cmd) != 0 )
288 return -1;
289 temp_cmd[0] = '\0';
290
291 //patch for image capture
292 //[
293 if (ind < cycleCounter - 1) {
294 if (hardwareActive == false) {
295 if ( openCamera() < 0 ) {
296 printf("Camera initialization failed\n");
297
298 return -1;
299 }
300
301 initDefaults();
302 }
303 }
304
305 //]
306 }
307
308 ctx += tLen + 1;
309
310 if (temp_cmd) {
311 delete temp_cmd;
312 temp_cmd = NULL;
313 }
314
315 if (cycle_cmd) {
316 delete cycle_cmd;
317 cycle_cmd = NULL;
318 }
319
320 break;
321 }
322
323 case '0':
324 {
325 initDefaults();
326 break;
327 }
328
329 case '1':
330
331 if ( startPreview() < 0 ) {
332 printf("Error while starting preview\n");
333
334 return -1;
335 }
336
337 break;
338
339 case '2':
340 if ( recordingMode ) {
341 stopRecording();
342 stopPreview();
343 closeRecorder();
344 camera->disconnect();
345 camera.clear();
346 camera = Camera::connect(camera_index);
347 if ( NULL == camera.get() ) {
348 sleep(1);
349 camera = Camera::connect(camera_index);
350 if ( NULL == camera.get() ) {
351 return -1;
352 }
353 }
354 camera->setListener(new CameraHandler());
355 camera->setParameters(params.flatten());
356 recordingMode = false;
357 } else {
358 stopPreview();
359 }
360
361 break;
362
363 case '3':
364 rotation = atoi(cmd + 1);
365 params.set(CameraParameters::KEY_ROTATION, rotation);
366
367 if ( hardwareActive )
368 camera->setParameters(params.flatten());
369
370 break;
371
372 case 'V':
373 previewRotation = atoi(cmd + 1);
374 params.set(KEY_SENSOR_ORIENTATION, previewRotation);
375
376 if ( hardwareActive )
377 camera->setParameters(params.flatten());
378
379 break;
380
381 case '4':
382 printf("Setting resolution...");
383
384 a = checkSupportedParamScriptResol(preview_Array, numpreviewSize, cmd, &resol_index);
385 if (a > -1) {
386 params.setPreviewSize(preview_Array[resol_index]->width, preview_Array[resol_index]->height);
387 previewSizeIDX = resol_index;
388 } else {
389 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
390 }
391 if ( hardwareActive && previewRunning ) {
392 camera->stopPreview();
393 camera->setParameters(params.flatten());
394 camera->startPreview();
395 } else if ( hardwareActive ) {
396 camera->setParameters(params.flatten());
397 }
398 break;
399
400 case '5':
401 if( strcmp((cmd + 1), "MAX_CAPTURE_SIZE") == 0) {
402 resol_index = 0;
403 for (int i=0; i<numcaptureSize; i++) {
404 if ((capture_Array[resol_index]->width * capture_Array[resol_index]->height) < (capture_Array[i]->width * capture_Array[i]->height)) {
405 resol_index = i;
406 }
407 }
408 if ((0 < capture_Array[resol_index]->width) && (0 < capture_Array[resol_index]->height)) {
409 params.setPictureSize(capture_Array[resol_index]->width, capture_Array[resol_index]->height);
410 captureSizeIDX = resol_index;
411 printf("Capture Size set: %dx%d\n", capture_Array[resol_index]->width, capture_Array[resol_index]->height);
412 } else {
413 printf("\nCapture size is 0!\n");
414 }
415 } else {
416 a = checkSupportedParamScriptResol(capture_Array, numcaptureSize, cmd, &resol_index);
417 if (camera_index != 2) {
418 if (a > -1) {
419 params.setPictureSize(capture_Array[resol_index]->width, capture_Array[resol_index]->height);
420 captureSizeIDX = resol_index;
421 } else {
422 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
423 }
424 } else {
425 int widthC, heightC;
426 char *resC = NULL;
427 resC = strtok(cmd + 1, "x");
428 widthC = atoi(resC);
429 resC = strtok(NULL, "x");
430 heightC = atoi(resC);
431 params.setPictureSize(widthC,heightC);
432 a = checkSupportedParamScriptResol(capture_Array, numcaptureSize,
433 widthC, heightC, &resol_index);
434 if (a > -1) captureSizeIDX = resol_index;
435 }
436
437 if ( hardwareActive ) {
438 camera->setParameters(params.flatten());
439 }
440 }
441
442 requestBufferSourceReset();
443
444 break;
445
446 case '6':
447
448 if ( !recordingMode ) {
449
450 recordingMode = true;
451
452 if ( startPreview() < 0 ) {
453 printf("Error while starting preview\n");
454
455 return -1;
456 }
457
458 if ( openRecorder() < 0 ) {
459 printf("Error while openning video recorder\n");
460
461 return -1;
462 }
463
464 if ( configureRecorder() < 0 ) {
465 printf("Error while configuring video recorder\n");
466
467 return -1;
468 }
469
470 if ( startRecording() < 0 ) {
471 printf("Error while starting video recording\n");
472
473 return -1;
474 }
475
476 }
477
478 break;
479
480 case '7':
481 compensation = atof(cmd + 1);
482 params.set(KEY_COMPENSATION, (int) (compensation * 10));
483
484 if ( hardwareActive )
485 camera->setParameters(params.flatten());
486
487 break;
488
489 case '8':
490
491 a = checkSupportedParamScript(awb, numawb, cmd);
492 if (a > -1) {
493 params.set(params.KEY_WHITE_BALANCE, (cmd + 1));
494 } else {
495 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
496 }
497
498 if ( hardwareActive )
499 camera->setParameters(params.flatten());
500
501 break;
502
503 case '9':
504 for(i = 0; i < length_video_Codecs; i++)
505 {
506 if( strcmp((cmd + 1), videoCodecs[i].desc) == 0)
507 {
508 videoCodecIDX = i;
509 printf("Video Codec Selected: %s\n",
510 videoCodecs[i].desc);
511 break;
512 }
513 }
514 break;
515
516 case 'v':
517 for(i = 0; i < length_outformat; i++)
518
519 {
520 if( strcmp((cmd + 1), outputFormat[i].desc) == 0)
521 {
522 outputFormatIDX = i;
523 printf("Video Codec Selected: %s\n",
524 videoCodecs[i].desc);
525 break;
526 }
527 }
528 break;
529
530 case '~':
531
532 a = checkSupportedParamScript(previewFormatArray, numpreviewFormat, cmd);
533 if (a > -1) {
534 params.setPreviewFormat(cmd + 1);
535 } else {
536 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
537 }
538
539 if ( hardwareActive )
540 camera->setParameters(params.flatten());
541
542 break;
543
544 case '$':
545
546 a = checkSupportedParamScript(pictureFormatArray, numpictureFormat, cmd);
547 if (a > -1) {
548 params.setPictureFormat(cmd + 1);
549 } else {
550 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
551 }
552
553 queueEmpty = true;
554 if ( bufferSourceOutputThread.get() ) {
555 if ( 0 < bufferSourceOutputThread->hasBuffer() ) {
556 queueEmpty = false;
557 }
558 }
559 if ( hardwareActive && queueEmpty ) {
560 camera->setParameters(params.flatten());
561 }
562
563 break;
564 case '-':
565 for(i = 0; i < length_audio_Codecs; i++)
566 {
567 if( strcmp((cmd + 1), audioCodecs[i].desc) == 0)
568 {
569 audioCodecIDX = i;
570 printf("Selected Audio: %s\n", audioCodecs[i].desc);
571 break;
572 }
573 }
574 break;
575
576 case 'A':
577 camera_index=atoi(cmd+1);
578 camera_index %= numCamera;
579
580 printf("%s selected.\n", cameras[camera_index]);
581 firstTime = true;
582
583 if ( hardwareActive ) {
584 stopPreview();
585 closeCamera();
586 openCamera();
587 } else {
588 closeCamera();
589 openCamera();
590 }
591 break;
592
593 case 'a':
594 char * temp_str;
595
596 temp_str = strtok(cmd+1,"!");
597 printf("Latitude %s \n",temp_str);
598 params.set(params.KEY_GPS_LATITUDE, temp_str);
599 temp_str=strtok(NULL,"!");
600 printf("Longitude %s \n",temp_str);
601 params.set(params.KEY_GPS_LONGITUDE, temp_str);
602 temp_str=strtok(NULL,"!");
603 printf("Altitude %s \n",temp_str);
604 params.set(params.KEY_GPS_ALTITUDE, temp_str);
605
606 if ( hardwareActive )
607 camera->setParameters(params.flatten());
608 break;
609
610 case 'l':
611 a = checkSupportedParamScriptResol(Vcapture_Array, numVcaptureSize, cmd, &resol_index);
612 if (a > -1) {
613 VcaptureSizeIDX = resol_index;
614 } else {
615 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
616 }
617 break;
618
619 case 'L':
620 if(stereoMode)
621 {
622 a = checkSupportedParamScriptLayout(stereoLayout, numLay, cmd, &stereoLayoutIDX);
623 if (a > -1) {
624 params.set(KEY_S3D_PRV_FRAME_LAYOUT, cmd + 1);
625 } else {
626 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
627 }
628
629
630 getSizeParametersFromCapabilities();
631 if (hardwareActive && previewRunning) {
632 stopPreview();
633 camera->setParameters(params.flatten());
634 startPreview();
635 } else if (hardwareActive) {
636 camera->setParameters(params.flatten());
637 }
638 }
639 break;
640
641
642 case '.':
643 if(stereoMode)
644 {
645 a = checkSupportedParamScriptLayout(stereoCapLayout, numCLay, cmd, &stereoCapLayoutIDX);
646 if (a > -1) {
647 params.set(KEY_S3D_CAP_FRAME_LAYOUT_VALUES, cmd + 1);
648 } else {
649 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
650 }
651
652
653 getSizeParametersFromCapabilities();
654 if (hardwareActive && previewRunning) {
655 stopPreview();
656 camera->setParameters(params.flatten());
657 startPreview();
658 } else if (hardwareActive) {
659 camera->setParameters(params.flatten());
660 }
661 }
662 break;
663
664 case ']':
665 for(i = 0; i < length_V_bitRate; i++)
666 {
667 if( strcmp((cmd + 1), VbitRate[i].desc) == 0)
668 {
669 VbitRateIDX = i;
670 printf("Video Bit Rate: %s\n", VbitRate[i].desc);
671 break;
672 }
673 }
674 break;
675 case ':':
676
677 a = checkSupportedParamScriptResol(thumbnail_Array, numthumbnailSize, cmd, &resol_index);
678 if (a > -1) {
679 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, thumbnail_Array[resol_index]->width);
680 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,thumbnail_Array[resol_index]->height);
681 thumbSizeIDX = resol_index;
682 } else {
683 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
684 }
685
686 if ( hardwareActive ) {
687 camera->setParameters(params.flatten());
688 }
689
690
691 break;
692
693 case '\'':
694 thumbQuality = atoi(cmd + 1);
695
696 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, thumbQuality);
697 if ( hardwareActive )
698 camera->setParameters(params.flatten());
699 break;
700
701 case '*':
702 if ( hardwareActive )
703 camera->startRecording();
704 break;
705
706 case 't':
707 params.setPreviewFormat((cmd + 1));
708 if ( hardwareActive )
709 camera->setParameters(params.flatten());
710 break;
711
712 case 'o':
713 jpegQuality = atoi(cmd + 1);
714 params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);
715
716 if ( hardwareActive )
717 camera->setParameters(params.flatten());
718
719 break;
720
721
722 case '&':
723 printf("Enabling Preview Callback");
724 dump_preview = 1;
725 camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
726 break;
727
728
729 case 'k':
730 ippIDX_old = atoi(cmd + 1);
731 params.set(KEY_IPP, atoi(cmd + 1));
732 if ( hardwareActive )
733 camera->setParameters(params.flatten());
734
735 requestBufferSourceReset();
736
737 break;
738
739 case 'K':
740 params.set(KEY_GBCE, (cmd+1));
741 if ( hardwareActive )
742 camera->setParameters(params.flatten());
743
744 break;
745
746 case 'F':
747 if ( hardwareActive ) {
748 camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, 0, 0);
749 faceDetectToggle = true;
750 }
751
752 break;
753
754 case 'I':
755 params.set(KEY_AF_TIMEOUT, (cmd + 1));
756
757 if ( hardwareActive )
758 camera->setParameters(params.flatten());
759
760 break;
761
762 case 'T':
763
764 if ( hardwareActive ) {
765 camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0);
766 faceDetectToggle = false;
767 }
768
769 break;
770
771 case 'O':
772 params.set(KEY_GLBCE, (cmd+1));
773 if ( hardwareActive )
774 camera->setParameters(params.flatten());
775
776 break;
777
778 case 'u':
779 // HQ should always be in ldc-nsf
780 // if not HQ, then return the ipp to its previous state
781 if ( !strcmp((cmd + 1), "high-quality") ) {
782 ippIDX_old = ippIDX;
783 ippIDX = 3;
784 params.set(KEY_IPP, ipp_mode[ippIDX]);
785 params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::FALSE);
786 previewRotation = 0;
787 params.set(KEY_SENSOR_ORIENTATION, previewRotation);
788 } else if ( !strcmp((cmd + 1), "video-mode") ) {
789 params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::TRUE);
790 camera->getCameraInfo(camera_index, &cameraInfo);
791 previewRotation = ((360-cameraInfo.orientation)%360);
792 if (previewRotation >= 0 || previewRotation <=360) {
793 params.set(KEY_SENSOR_ORIENTATION, previewRotation);
794 }
795 printf("previewRotation: %d\n", previewRotation);
796 } else {
797 ippIDX = ippIDX_old;
798 params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::FALSE);
799 previewRotation = 0;
800 params.set(KEY_SENSOR_ORIENTATION, previewRotation);
801 }
802 a = checkSupportedParamScript(modevalues, nummodevalues, cmd);
803 if (a > -1) {
804 params.set(KEY_MODE, (cmd + 1));
805 } else {
806 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
807 }
808
809 if ( hardwareActive ) {
810 if (previewRunning) {
811 stopPreview();
812 }
813 camera->setParameters(params.flatten());
814 // Get parameters from capabilities for the new capture mode
815 params = camera->getParameters();
816 getSizeParametersFromCapabilities();
817 getParametersFromCapabilities();
818 // Set framerate 30fps and 12MP capture resolution if available for the new capture mode.
819 // If not available set framerate and capture mode under index 0 from fps_const_str and capture_Array.
820 frameRateIDX = getDefaultParameter("30000,30000", constCnt, fps_const_str);
821 captureSizeIDX = getDefaultParameterResol("12MP", numcaptureSize, capture_Array);
822 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRateIDX]);
823 params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
824 camera->setParameters(params.flatten());
825 }
826
827 requestBufferSourceReset();
828
829 break;
830
831 case 'U':
832
833 params.set(KEY_TEMP_BRACKETING, (cmd + 1));
834
835 if ( hardwareActive )
836 camera->setParameters(params.flatten());
837
838 break;
839
840 case 'H':
841
842 setDefaultExpGainPreset(shotParams, atoi(cmd + 1));
843 break;
844
845
846 case 'n':
847
848 switch (*(cmd + 1)) {
849 case 0:
850 shotConfigFlush = false;
851 break;
852 case 1:
853 shotConfigFlush = true;
854 break;
855 default:
856 printf ("Mangling flush shot config command: \"%s\"\n", (cmd + 1));
857 break;
858 }
859
860 updateShotConfigFlushParam();
861
862 break;
863
864 case '?':
865
866 setExpGainPreset(shotParams, cmd + 1, true, PARAM_EXP_BRACKET_PARAM_NONE, shotConfigFlush);
867
868 break;
869
870 case 'W':
871
872 tempBracketRange = atoi(cmd + 1);
873 tempBracketRange %= TEMP_BRACKETING_MAX_RANGE;
874 if ( 0 == tempBracketRange ) {
875 tempBracketRange = 1;
876 }
877
878 params.set(KEY_TEMP_BRACKETING_NEG, tempBracketRange);
879 params.set(KEY_TEMP_BRACKETING_POS, tempBracketRange);
880
881 if ( hardwareActive )
882 camera->setParameters(params.flatten());
883
884 break;
885
886 case '#':
887
888 params.set(KEY_TI_BURST, atoi(cmd + 1));
889 burstCount = atoi(cmd + 1);
890
891 if ( hardwareActive )
892 camera->setParameters(params.flatten());
893
894 break;
895
896 case 'J':
897
898 a = checkSupportedParamScript(flash, numflash, cmd);
899 if (a > -1) {
900 params.set(CameraParameters::KEY_FLASH_MODE, (cmd + 1));
901 } else {
902 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
903 }
904
905 if ( hardwareActive )
906 camera->setParameters(params.flatten());
907
908 break;
909
910 case 'w':
911
912 a = checkSupportedParamScript(scene, numscene, cmd);
913 if (a > -1) {
914 params.set(params.KEY_SCENE_MODE, (cmd + 1));
915 } else {
916 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
917 }
918 if ( hardwareActive )
919 camera->setParameters(params.flatten());
920
921 break;
922
923 case 'B' :
924 if(strcmp(vnfstr, "true") == 0) {
925 if (strcmp(cmd + 1, "1") == 0) {
926 trySetVideoNoiseFilter(true);
927 }
928 else if (strcmp(cmd + 1, "0") == 0){
929 trySetVideoNoiseFilter(false);
930 }
931 } else {
932 trySetVideoNoiseFilter(false);
933 printf("\n VNF is not supported \n\n");
934 }
935
936 if ( hardwareActive ) {
937 camera->setParameters(params.flatten());
938 }
939 break;
940
941
942 case 'C' :
943
944 if (strcmp(vstabstr, "true") == 0) {
945 if (strcmp(cmd + 1, "1") == 0) {
946 trySetVideoStabilization(true);
947 } else if (strcmp(cmd + 1, "0") == 0) {
948 trySetVideoStabilization(false);
949 } else {
950 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
951 }
952 } else {
953 printf("\nNot supported parameter vstab from sensor %d\n\n", camera_index);
954 }
955
956 if ( hardwareActive ) {
957 camera->setParameters(params.flatten());
958 }
959 break;
960
961 case 'D':
962 if ( hardwareActive )
963 camera->stopRecording();
964 break;
965
966 case 'E':
967 if(hardwareActive)
968 params.unflatten(camera->getParameters());
969 printSupportedParams();
970 break;
971
972 case 'i':
973 iso_mode = atoi(cmd + 1);
974 if (iso_mode < numisoMode) {
975 params.set(KEY_ISO, isoMode[iso_mode]);
976 } else {
977 printf("\nNot supported parameter %s for iso mode from sensor %d\n\n", cmd + 1, camera_index);
978 }
979
980 if ( hardwareActive )
981 camera->setParameters(params.flatten());
982
983 break;
984
985 case 'h':
986 sharpness = atoi(cmd + 1);
987 params.set(KEY_SHARPNESS, sharpness);
988
989 if ( hardwareActive )
990 camera->setParameters(params.flatten());
991
992 break;
993
994 case '@':
995 if ( hardwareActive ) {
996
997 closeCamera();
998
999 if ( 0 >= openCamera() ) {
1000 printf( "Reconnected to CameraService \n");
1001 }
1002 }
1003
1004 break;
1005
1006 case 'c':
1007 contrast = atoi(cmd + 1);
1008 params.set(KEY_CONTRAST, contrast);
1009
1010 if ( hardwareActive ) {
1011 camera->setParameters(params.flatten());
1012 }
1013
1014 break;
1015
1016 case 'z':
1017 zoomtoggle = false;
1018
1019 if(strcmp(zoomstr, "true") == 0) {
1020 for(i = 0; i < length_Zoom; i++) {
1021 if( strcmp((cmd + 1), zoom[i].zoom_description) == 0) {
1022 zoomIDX = i;
1023 zoomtoggle = true;
1024 break;
1025 }
1026 }
1027
1028 if (!zoomtoggle) {
1029 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1030 }
1031
1032
1033 params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
1034
1035 if ( hardwareActive ) {
1036 camera->setParameters(params.flatten());
1037 }
1038 }
1039
1040 case 'Z':
1041 smoothzoomtoggle = false;
1042
1043 if(strcmp(smoothzoomstr, "true") == 0) {
1044 for(i = 0; i < length_Zoom; i++) {
1045 if( strcmp((cmd + 1), zoom[i].zoom_description) == 0) {
1046 zoomIDX = i;
1047 smoothzoomtoggle = true;
1048 break;
1049 }
1050 }
1051
1052 if (!smoothzoomtoggle) {
1053 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1054 }
1055
1056 if ( hardwareActive ) {
1057 camera->sendCommand(CAMERA_CMD_START_SMOOTH_ZOOM, zoom[zoomIDX].idx, 0);
1058 }
1059 }
1060 break;
1061
1062 case 'j':
1063
1064 a = checkSupportedParamScript(exposureMode, numExposureMode, cmd);
1065 if (a > -1) {
1066 params.set(KEY_EXPOSURE, (cmd + 1));
1067 } else {
1068 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1069 }
1070
1071 if ( hardwareActive )
1072 camera->setParameters(params.flatten());
1073
1074 break;
1075
1076 case 'b':
1077 brightness = atoi(cmd + 1);
1078 params.set(KEY_BRIGHTNESS, brightness);
1079
1080 if ( hardwareActive )
1081 camera->setParameters(params.flatten());
1082
1083 break;
1084
1085 case 's':
1086 saturation = atoi(cmd + 1);
1087 params.set(KEY_SATURATION, saturation);
1088
1089 if ( hardwareActive )
1090 camera->setParameters(params.flatten());
1091
1092 break;
1093
1094 case 'e':
1095 a = checkSupportedParamScript(effectss, numEffects, cmd);
1096 if (a > -1) {
1097 params.set(params.KEY_EFFECT, (cmd + 1));
1098 } else {
1099 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1100 }
1101
1102 if ( hardwareActive )
1103 camera->setParameters(params.flatten());
1104
1105 break;
1106
1107 case 'r':
1108 if (strcmp((cmd + 1), "MAX_FRAMERATE") == 0) {
1109 frameRConst = 0;
1110 for (int i=0; i<constCnt; i++) {
1111 if (constFramerate[frameRConst] < constFramerate[i]) {
1112 frameRConst = i;
1113 }
1114 }
1115 if (0 < constFramerate[frameRConst]) {
1116 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRConst]);
1117 frameRateIDX = frameRConst;
1118 printf("Framerate set: %d fps\n", constFramerate[frameRConst]);
1119 } else {
1120 printf("\nFramerate is 0!\n");
1121 }
1122 } else {
1123 a = checkSupportedParamScriptfpsConst(constFramerate, constCnt, cmd, &frameRConst);
1124 if (a > -1) {
1125 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRConst]);
1126 frameRateIDX = frameRConst;
1127 } else {
1128 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1129 }
1130 }
1131 if ( hardwareActive && previewRunning ) {
1132 camera->stopPreview();
1133 camera->setParameters(params.flatten());
1134 camera->startPreview();
1135 } else if ( hardwareActive ) {
1136 camera->setParameters(params.flatten());
1137 }
1138 break;
1139
1140 case 'R':
1141 a = checkSupportedParamScriptfpsRange(rangeDescription, rangeCnt, cmd, &frameRRange);
1142 if (a > -1) {
1143 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_range_str[frameRRange]);
1144 fpsRangeIdx = frameRRange;
1145 } else {
1146 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1147 }
1148 break;
1149
1150 case 'x':
1151 a = checkSupportedParamScript(antiband, numAntibanding, cmd);
1152 if (a > -1) {
1153 params.set(params.KEY_ANTIBANDING, (cmd + 1));
1154 } else {
1155 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1156 }
1157
1158 if ( hardwareActive )
1159 camera->setParameters(params.flatten());
1160 break;
1161
1162 case 'g':
1163 a = checkSupportedParamScript(focus, numfocus, cmd);
1164 if (a > -1) {
1165 params.set(params.KEY_FOCUS_MODE, (cmd + 1));
1166 } else {
1167 printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1168 }
1169
1170 if ( hardwareActive )
1171 camera->setParameters(params.flatten());
1172 break;
1173
1174 case 'G':
1175
1176 params.set(CameraParameters::KEY_FOCUS_AREAS, (cmd + 1));
1177
1178 if ( hardwareActive )
1179 camera->setParameters(params.flatten());
1180
1181 break;
1182
1183 case 'y':
1184
1185 params.set(CameraParameters::KEY_METERING_AREAS, (cmd + 1));
1186
1187 if ( hardwareActive ) {
1188 camera->setParameters(params.flatten());
1189 }
1190
1191 break;
1192
1193 case 'f':
1194 gettimeofday(&autofocus_start, 0);
1195
1196 if ( hardwareActive )
1197 camera->autoFocus();
1198
1199 break;
1200
1201 case 'p':
1202 {
1203 int msgType = 0;
1204 const char *format = params.getPictureFormat();
1205
1206 if((0 == strcmp(modevalues[capture_mode], "video-mode")) &&
1207 (0 != strcmp(videosnapshotstr, "true"))) {
1208 printf("Video Snapshot is not supported\n");
1209 } else if ( hardwareActive ) {
1210 if((NULL != format) && isRawPixelFormat(format)) {
1211 createBufferOutputSource();
1212 if (bufferSourceOutputThread.get()) {
1213 bufferSourceOutputThread->setBuffer(shotParams);
1214 bufferSourceOutputThread->setStreamCapture(streamCapture, expBracketIdx);
1215 }
1216 } else if(strcmp(modevalues[capture_mode], "video-mode") == 0) {
1217 msgType = CAMERA_MSG_COMPRESSED_IMAGE |
1218 CAMERA_MSG_RAW_IMAGE;
1219 #ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
1220 msgType |= CAMERA_MSG_RAW_BURST;
1221 #endif
1222 } else {
1223 msgType = CAMERA_MSG_POSTVIEW_FRAME |
1224 CAMERA_MSG_RAW_IMAGE_NOTIFY |
1225 CAMERA_MSG_COMPRESSED_IMAGE |
1226 CAMERA_MSG_SHUTTER;
1227 #ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
1228 msgType |= CAMERA_MSG_RAW_BURST;
1229 #endif
1230 }
1231
1232 gettimeofday(&picture_start, 0);
1233 ret = camera->setParameters(params.flatten());
1234 if ( ret != NO_ERROR ) {
1235 printf("Error returned while setting parameters");
1236 break;
1237 }
1238 ret = camera->takePictureWithParameters(msgType, shotParams.flatten());
1239 if ( ret != NO_ERROR ) {
1240 printf("Error returned while taking a picture");
1241 break;
1242 }
1243 }
1244 break;
1245 }
1246
1247 case 'S':
1248 {
1249 if (streamCapture) {
1250 streamCapture = false;
1251 expBracketIdx = BRACKETING_IDX_DEFAULT;
1252 setDefaultExpGainPreset(shotParams, expBracketIdx);
1253 // Stop streaming
1254 if (bufferSourceOutputThread.get()) {
1255 bufferSourceOutputThread->setStreamCapture(streamCapture, expBracketIdx);
1256 }
1257 } else {
1258 streamCapture = true;
1259 expBracketIdx = BRACKETING_IDX_STREAM;
1260 setSingleExpGainPreset(shotParams, expBracketIdx, 0, 0);
1261 // Queue more frames initially
1262 shotParams.set(ShotParameters::KEY_BURST, BRACKETING_STREAM_BUFFERS);
1263 }
1264 break;
1265 }
1266
1267 case 'P':
1268 {
1269 int msgType = CAMERA_MSG_COMPRESSED_IMAGE;
1270 ShotParameters reprocParams;
1271
1272 gettimeofday(&picture_start, 0);
1273
1274 createBufferInputSource();
1275
1276 if (bufferSourceOutputThread.get() &&
1277 bufferSourceOutputThread->hasBuffer())
1278 {
1279 bufferSourceOutputThread->setStreamCapture(false, expBracketIdx);
1280 if (hardwareActive) camera->setParameters(params.flatten());
1281
1282 if (bufferSourceInput.get()) {
1283 buffer_info_t info = bufferSourceOutputThread->popBuffer();
1284 bufferSourceInput->setInput(info, params.getPictureFormat(), reprocParams);
1285 if (hardwareActive) camera->reprocess(msgType, String8());
1286 }
1287 }
1288 break;
1289 }
1290
1291 case 'd':
1292 dly = atoi(cmd + 1);
1293 sleep(dly);
1294 break;
1295
1296 case 'q':
1297 dump_mem_status();
1298 stopPreview();
1299
1300 if ( recordingMode ) {
1301 stopRecording();
1302 closeRecorder();
1303
1304 recordingMode = false;
1305 }
1306 goto exit;
1307
1308 case '\n':
1309 printf("Iteration: %d \n", iteration);
1310 iteration++;
1311 break;
1312
1313 case '{':
1314 if ( atoi(cmd + 1) > 0 )
1315 params.set(KEY_S3D2D_PREVIEW_MODE, "on");
1316 else
1317 params.set(KEY_S3D2D_PREVIEW_MODE, "off");
1318 if ( hardwareActive )
1319 camera->setParameters(params.flatten());
1320 break;
1321
1322 case 'M':
1323 params.set(KEY_MEASUREMENT, (cmd + 1));
1324 if ( hardwareActive )
1325 camera->setParameters(params.flatten());
1326 break;
1327 case 'm':
1328 {
1329 params.set(KEY_METERING_MODE, (cmd + 1));
1330 if ( hardwareActive )
1331 {
1332 camera->setParameters(params.flatten());
1333 }
1334 break;
1335 }
1336 case '<':
1337 {
1338 char coord_str[8];
1339 latitude += degree_by_step;
1340 if (latitude > 90.0)
1341 {
1342 latitude -= 180.0;
1343 }
1344 snprintf(coord_str, 7, "%.7lf", latitude);
1345 params.set(params.KEY_GPS_LATITUDE, coord_str);
1346 if ( hardwareActive )
1347 {
1348 camera->setParameters(params.flatten());
1349 }
1350 break;
1351 }
1352
1353 case '=':
1354 {
1355 char coord_str[8];
1356 longitude += degree_by_step;
1357 if (longitude > 180.0)
1358 {
1359 longitude -= 360.0;
1360 }
1361 snprintf(coord_str, 7, "%.7lf", longitude);
1362 params.set(params.KEY_GPS_LONGITUDE, coord_str);
1363 if ( hardwareActive )
1364 {
1365 camera->setParameters(params.flatten());
1366 }
1367 break;
1368 }
1369
1370 case '>':
1371 {
1372 char coord_str[8];
1373 altitude += 12345.67890123456789;
1374 if (altitude > 100000.0)
1375 {
1376 altitude -= 200000.0;
1377 }
1378 snprintf(coord_str, 7, "%.7lf", altitude);
1379 params.set(params.KEY_GPS_ALTITUDE, coord_str);
1380 if ( hardwareActive )
1381 {
1382 camera->setParameters(params.flatten());
1383 }
1384 break;
1385 }
1386
1387 case 'X':
1388 {
1389 char rem_str[384];
1390 printf("Deleting images from %s \n", images_dir_path);
1391 if (!sprintf(rem_str, "rm %s/*.jpg", images_dir_path)) {
1392 printf("Sprintf Error");
1393 }
1394 if (system(rem_str)) {
1395 printf("Images were not deleted\n");
1396 }
1397 break;
1398 }
1399
1400 case '_':
1401 {
1402 AutoConvergenceModeIDX = atoi(cmd + 1);
1403 if ( AutoConvergenceModeIDX < 0 || AutoConvergenceModeIDX > 4 )
1404 AutoConvergenceModeIDX = 0;
1405 params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]);
1406 if (AutoConvergenceModeIDX != 4) {
1407 params.set(KEY_MANUAL_CONVERGENCE, manualConv);
1408 }
1409 if (hardwareActive) {
1410 camera->setParameters(params.flatten());
1411 }
1412 break;
1413 }
1414
1415 case '^':
1416 if (strcmp(autoconvergencemode[AutoConvergenceModeIDX], "manual") == 0) {
1417 manC = atoi(cmd + 1);
1418 if(manC >= manualConvMin && manC <= manualConvMax)
1419 {
1420 params.set(KEY_MANUAL_CONVERGENCE, manC);
1421 }
1422 else if(manC < manualConvMin)
1423 {
1424 printf(" wrong parameter for manual convergence \n");
1425 params.set(KEY_MANUAL_CONVERGENCE, manualConvMin);
1426 }
1427 else
1428 {
1429 printf(" wrong parameter for manual convergence \n");
1430 params.set(KEY_MANUAL_CONVERGENCE, manualConvMax);
1431 }
1432 if ( hardwareActive )
1433 camera->setParameters(params.flatten());
1434 }
1435 break;
1436
1437
1438 case 'Q':
1439 if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
1440 manE = atoi(cmd + 1);
1441 if(manE >= manualExpMin && manE <= manualExpMax)
1442 {
1443 params.set(KEY_MANUAL_EXPOSURE, manE);
1444 params.set(KEY_MANUAL_EXPOSURE_RIGHT, manE);
1445 }
1446 else if(manE < manualExpMin)
1447 {
1448 printf(" wrong parameter for manual exposure \n");
1449 params.set(KEY_MANUAL_EXPOSURE, manualExpMin);
1450 params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExpMin);
1451 }
1452 else
1453 {
1454 printf(" wrong parameter for manual exposure \n");
1455 params.set(KEY_MANUAL_EXPOSURE, manualExpMax);
1456 params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExpMax);
1457 }
1458
1459 if ( hardwareActive )
1460 camera->setParameters(params.flatten());
1461 }
1462 break;
1463
1464 case ',':
1465 if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
1466 manG = atoi(cmd + 1);
1467 if(manG >= manualGainMin && manG <= manualGainMax)
1468 {
1469 params.set(KEY_MANUAL_GAIN_ISO, manG);
1470 params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manG);
1471 }
1472 else if(manG < manualGainMin)
1473 {
1474 printf(" wrong parameter for manual gain \n");
1475 params.set(KEY_MANUAL_GAIN_ISO, manualGainMin);
1476 params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGainMin);
1477 }
1478 else
1479 {
1480 printf(" wrong parameter for manual gain \n");
1481 params.set(KEY_MANUAL_GAIN_ISO, manualGainMax);
1482 params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGainMax);
1483 }
1484
1485 if ( hardwareActive )
1486 camera->setParameters(params.flatten());
1487 }
1488 break;
1489
1490 default:
1491 printf("Unrecognized command!\n");
1492 break;
1493 }
1494
1495 cmd = strtok_r(NULL, DELIMITER, &ctx);
1496 }
1497
1498 exit:
1499 if (stopScript == true)
1500 {
1501 return -1;
1502 }
1503 else
1504 {
1505 return 0;
1506 }
1507 }
1508
1509
checkSupportedParamScript(char ** array,int size,char * param)1510 int checkSupportedParamScript(char **array, int size, char *param) {
1511 for (int i=0; i<size; i++) {
1512 if (strcmp((param + 1), array[i]) == 0) {
1513 return 0;
1514 }
1515 }
1516 return -1;
1517 }
1518
checkSupportedParamScriptLayout(char ** array,int size,char * param,int * index)1519 int checkSupportedParamScriptLayout(char **array, int size, char *param, int *index) {
1520 for (int i=0; i<size; i++) {
1521 if (strcmp((param + 1), array[i]) == 0) {
1522 *index = i;
1523 return 0;
1524 }
1525 }
1526 return -1;
1527 }
1528
checkSupportedParamScriptResol(param_Array ** array,int size,char * param,int * num)1529 int checkSupportedParamScriptResol(param_Array **array, int size, char *param, int *num) {
1530 for (int i=0; i<size; i++) {
1531 if (strcmp((param + 1), array[i]->name) == 0) {
1532 *num = i;
1533 return 0;
1534 }
1535 }
1536 return -1;
1537 }
1538
checkSupportedParamScriptResol(param_Array ** array,int size,int width,int height,int * num)1539 int checkSupportedParamScriptResol(param_Array **array, int size,
1540 int width, int height, int *num) {
1541 for (int i=0; i<size; i++) {
1542 if ((width == array[i]->width) && (height == array[i]->height)) {
1543 *num = i;
1544 return 0;
1545 }
1546 }
1547 return -1;
1548 }
1549
checkSupportedParamScriptfpsConst(int * array,int size,char * param,int * num)1550 int checkSupportedParamScriptfpsConst(int *array, int size, char *param, int *num) {
1551 for (int i=0; i<size; i++) {
1552 if (atoi(param + 1) == array[i]) {
1553 *num = i;
1554 return 0;
1555 }
1556 }
1557 return -1;
1558 }
1559
checkSupportedParamScriptfpsRange(char ** array,int size,char * param,int * num)1560 int checkSupportedParamScriptfpsRange(char **array, int size, char *param, int *num) {
1561 for (int i=0; i<size; i++) {
1562 if (strcmp(param + 1, array[i]) == 0) {
1563 *num = i;
1564 return 0;
1565 }
1566 }
1567 return -1;
1568 }
1569
get_cycle_cmd(const char * aSrc)1570 char * get_cycle_cmd(const char *aSrc) {
1571 unsigned ind = 0;
1572 char *cycle_cmd = new char[256];
1573
1574 while ((*aSrc != '+') && (*aSrc != '\0')) {
1575 cycle_cmd[ind++] = *aSrc++;
1576 }
1577 cycle_cmd[ind] = '\0';
1578
1579 return cycle_cmd;
1580 }
1581
dump_mem_status()1582 status_t dump_mem_status() {
1583 system(MEDIASERVER_DUMP);
1584 return system(MEMORY_DUMP);
1585 }
1586
load_script(const char * config)1587 char *load_script(const char *config) {
1588 FILE *infile;
1589 size_t fileSize;
1590 char *script;
1591 size_t nRead = 0;
1592
1593 infile = fopen(config, "r");
1594
1595 strcpy(script_name,config);
1596
1597 printf("\n SCRIPT : <%s> is currently being executed \n", script_name);
1598
1599 printf("\n DIRECTORY CREATED FOR TEST RESULT IMAGES IN MMC CARD : %s \n", output_dir_path);
1600
1601 if( (NULL == infile)){
1602 printf("Error while opening script file %s!\n", config);
1603 return NULL;
1604 }
1605
1606 fseek(infile, 0, SEEK_END);
1607 fileSize = ftell(infile);
1608 fseek(infile, 0, SEEK_SET);
1609
1610 script = (char *) malloc(fileSize + 1);
1611
1612 if ( NULL == script ) {
1613 printf("Unable to allocate buffer for the script\n");
1614
1615 return NULL;
1616 }
1617
1618 memset(script, 0, fileSize + 1);
1619
1620 if ((nRead = fread(script, 1, fileSize, infile)) != fileSize) {
1621 printf("Error while reading script file!\n");
1622
1623 free(script);
1624 fclose(infile);
1625 return NULL;
1626 }
1627
1628 fclose(infile);
1629
1630 return script;
1631 }
1632
start_logging(int flags,int & pid)1633 int start_logging(int flags, int &pid) {
1634 int status = 0;
1635
1636 if (flags == 0) {
1637 pid = -1;
1638 return 0;
1639 }
1640
1641 pid = fork();
1642 if (pid == 0)
1643 {
1644 char *command_list[] = {"sh", "-c", NULL, NULL};
1645 char log_cmd[1024];
1646 // child process to run logging
1647
1648 // set group id of this process to itself
1649 // we will use this group id to kill the
1650 // application logging
1651 setpgid(getpid(), getpid());
1652
1653 /* Start logcat */
1654 if (flags & LOGGING_LOGCAT) {
1655 if (!sprintf(log_cmd,"logcat > %s/log.txt &", output_dir_path)) {
1656 printf(" Sprintf Error");
1657 }
1658 }
1659
1660 /* Start Syslink Trace */
1661 if (flags & LOGGING_SYSLINK) {
1662 if (!sprintf(log_cmd,"%s /system/bin/syslink_trace_daemon.out -l %s/syslink_trace.txt -f &", log_cmd, output_dir_path)) {
1663 printf(" Sprintf Error");
1664 }
1665 }
1666
1667 command_list[2] = (char *)log_cmd;
1668 execvp("/system/bin/sh", command_list);
1669 } if(pid < 0)
1670 {
1671 printf("failed to fork logcat\n");
1672 return -1;
1673 }
1674
1675 //wait for logging to start
1676 if(waitpid(pid, &status, 0) != pid)
1677 {
1678 printf("waitpid failed in log fork\n");
1679 return -1;
1680 }else
1681 printf("logging started... status=%d\n", status);
1682
1683 return 0;
1684 }
1685
stop_logging(int flags,int & pid)1686 int stop_logging(int flags, int &pid)
1687 {
1688 if (pid > 0) {
1689 if (killpg(pid, SIGKILL)) {
1690 printf("Exit command failed");
1691 return -1;
1692 } else {
1693 printf("\nlogging for script %s is complete\n", script_name);
1694
1695 if (flags & LOGGING_LOGCAT) {
1696 printf(" logcat saved @ location: %s\n", output_dir_path);
1697 }
1698
1699 if (flags & LOGGING_SYSLINK) {
1700 printf(" syslink_trace is saved @ location: %s\n\n", output_dir_path);
1701 }
1702 }
1703 }
1704 return 0;
1705 }
1706
execute_error_script(char * script)1707 int execute_error_script(char *script) {
1708 char *cmd, *ctx;
1709 char id;
1710 status_t stat = NO_ERROR;
1711
1712 LOG_FUNCTION_NAME;
1713
1714 cmd = strtok_r((char *) script, DELIMITER, &ctx);
1715
1716 while ( NULL != cmd ) {
1717 id = cmd[0];
1718
1719 switch (id) {
1720
1721 case '0': {
1722 bufferStarvationTest = 1;
1723 params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation
1724
1725 if ( !recordingMode ) {
1726
1727 recordingMode = true;
1728
1729 if ( startPreview() < 0 ) {
1730 printf("Error while starting preview\n");
1731
1732 return -1;
1733 }
1734
1735 if ( openRecorder() < 0 ) {
1736 printf("Error while openning video recorder\n");
1737
1738 return -1;
1739 }
1740
1741 if ( configureRecorder() < 0 ) {
1742 printf("Error while configuring video recorder\n");
1743
1744 return -1;
1745 }
1746
1747 if ( startRecording() < 0 ) {
1748 printf("Error while starting video recording\n");
1749
1750 return -1;
1751 }
1752
1753 }
1754
1755 usleep(1000000);//1s
1756
1757 stopPreview();
1758
1759 if ( recordingMode ) {
1760 stopRecording();
1761 closeRecorder();
1762
1763 recordingMode = false;
1764 }
1765
1766 break;
1767 }
1768
1769 case '1': {
1770 int* tMemoryEater = new int[999999999];
1771
1772 if (!tMemoryEater) {
1773 printf("Not enough memory\n");
1774 return -1;
1775 } else {
1776 delete tMemoryEater;
1777 }
1778
1779 break;
1780 }
1781
1782 case '2': {
1783 //camera = Camera::connect();
1784
1785 if ( NULL == camera.get() ) {
1786 printf("Unable to connect to CameraService\n");
1787 return -1;
1788 }
1789
1790 break;
1791 }
1792
1793 case '3': {
1794 int err = 0;
1795
1796 err = open("/dev/video5", O_RDWR);
1797
1798 if (err < 0) {
1799 printf("Could not open the camera device5: %d\n", err );
1800 return err;
1801 }
1802
1803 if ( startPreview() < 0 ) {
1804 printf("Error while starting preview\n");
1805 return -1;
1806 }
1807
1808 usleep(1000000);//1s
1809
1810 stopPreview();
1811
1812 close(err);
1813 break;
1814 }
1815
1816 case '4': {
1817
1818 if ( hardwareActive ) {
1819
1820 params.setPictureFormat("invalid-format");
1821 params.setPreviewFormat("invalid-format");
1822
1823 stat = camera->setParameters(params.flatten());
1824
1825 if ( NO_ERROR != stat ) {
1826 printf("Test passed!\n");
1827 } else {
1828 printf("Test failed!\n");
1829 }
1830
1831 initDefaults();
1832 }
1833
1834 break;
1835 }
1836
1837 case '5': {
1838
1839 if ( hardwareActive ) {
1840
1841 params.setPictureSize(-1, -1);
1842 params.setPreviewSize(-1, -1);
1843
1844 stat = camera->setParameters(params.flatten());
1845
1846 if ( NO_ERROR != stat ) {
1847 printf("Test passed!\n");
1848 } else {
1849 printf("Test failed!\n");
1850 }
1851
1852 initDefaults();
1853 }
1854
1855 break;
1856 }
1857
1858 case '6': {
1859
1860 if ( hardwareActive ) {
1861
1862 params.setPreviewFrameRate(-1);
1863
1864 stat = camera->setParameters(params.flatten());
1865
1866 if ( NO_ERROR != stat ) {
1867 printf("Test passed!\n");
1868 } else {
1869 printf("Test failed!\n");
1870 }
1871
1872 initDefaults();
1873 }
1874
1875
1876 break;
1877 }
1878
1879 case 'q': {
1880 goto exit;
1881
1882 break;
1883 }
1884
1885 default: {
1886 printf("Unrecognized command!\n");
1887
1888 break;
1889 }
1890 }
1891
1892 cmd = strtok_r(NULL, DELIMITER, &ctx);
1893 }
1894
1895 exit:
1896
1897 return 0;
1898 }
1899
1900
1901
1902