1 /* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
2  *
3  * Redistribution and use in source and binary forms, with or without
4  * modification, are permitted provided that the following conditions are
5  * met:
6  *     * Redistributions of source code must retain the above copyright
7  *       notice, this list of conditions and the following disclaimer.
8  *     * Redistributions in binary form must reproduce the above
9  *       copyright notice, this list of conditions and the following
10  *       disclaimer in the documentation and/or other materials provided
11  *       with the distribution.
12  *     * Neither the name of The Linux Foundation nor the names of its
13  *       contributors may be used to endorse or promote products derived
14  *       from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  *
28  */
29 
30 #include <stdlib.h>
31 #include <unistd.h>
32 #include <fcntl.h>
33 #include <time.h>
34 #include <semaphore.h>
35 #include <pthread.h>
36 
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #include <sys/wait.h>
40 
41 #include <ui/DisplayInfo.h>
42 #include <gui/Surface.h>
43 #include <gui/SurfaceComposerClient.h>
44 #include <gui/ISurfaceComposer.h>
45 
46 #include <system/camera.h>
47 
48 #include <camera/Camera.h>
49 #include <camera/ICamera.h>
50 #include <camera/CameraParameters.h>
51 #include <media/mediarecorder.h>
52 
53 #include <utils/RefBase.h>
54 #include <utils/Mutex.h>
55 #include <utils/Condition.h>
56 #include <binder/IPCThreadState.h>
57 #include <binder/ProcessState.h>
58 #include <binder/IServiceManager.h>
59 #include <cutils/properties.h>
60 #include <cutils/memory.h>
61 #include <SkImageDecoder.h>
62 #include <SkImageEncoder.h>
63 #include <MediaCodec.h>
64 #include <OMX_IVCommon.h>
65 #include <foundation/AMessage.h>
66 #include <media/ICrypto.h>
67 #include <MediaMuxer.h>
68 #include <foundation/ABuffer.h>
69 #include <MediaErrors.h>
70 #include <gralloc_priv.h>
71 #include <math.h>
72 
73 #include "qcamera_test.h"
74 #include "cam_types.h"
75 #include "mm_camera_dbg.h"
76 
77 #define VIDEO_BUF_ALLIGN(size, allign) \
78   (((size) + (allign-1)) & (typeof(size))(~(allign-1)))
79 
80 namespace qcamera {
81 
82 using namespace android;
83 
84 int CameraContext::JpegIdx = 0;
85 int CameraContext::mPiPIdx = 0;
86 const char CameraContext::KEY_ZSL[] = "zsl";
87 
88 /*===========================================================================
89  * FUNCTION   : previewCallback
90  *
91  * DESCRIPTION: preview callback preview mesages are enabled
92  *
93  * PARAMETERS :
94  *   @mem : preview buffer
95  *
96  * RETURN     : None
97  *==========================================================================*/
previewCallback(const sp<IMemory> & mem)98 void CameraContext::previewCallback(const sp<IMemory>& mem)
99 {
100     printf("PREVIEW Callback %p", mem->pointer());
101     uint8_t *ptr = (uint8_t*) mem->pointer();
102     if (NULL != ptr) {
103         printf("PRV_CB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x",
104                 ptr[0],
105                 ptr[1],
106                 ptr[2],
107                 ptr[3],
108                 ptr[4],
109                 ptr[5],
110                 ptr[6],
111                 ptr[7],
112                 ptr[8],
113                 ptr[9]);
114     } else {
115         ALOGE(" no preview for NULL CB\n");
116     }
117 }
118 
119 /*===========================================================================
120  * FUNCTION   : useLock
121  *
122  * DESCRIPTION: Mutex lock for CameraContext
123  *
124  * PARAMETERS : none
125  *
126  * RETURN     : none
127  *==========================================================================*/
useLock()128 void CameraContext::useLock()
129 {
130     Mutex::Autolock l(mLock);
131     while (mInUse) {
132         mCond.wait(mLock);
133     }
134     mInUse = true;
135 }
136 
137 /*===========================================================================
138  * FUNCTION   : signalFinished
139  *
140  * DESCRIPTION: Mutex unlock CameraContext
141  *
142  * PARAMETERS : none
143  *
144  * RETURN     : none
145  *==========================================================================*/
signalFinished()146 void CameraContext::signalFinished()
147 {
148     Mutex::Autolock l(mLock);
149     mInUse = false;
150     mCond.signal();
151 }
152 
153 /*===========================================================================
154  * FUNCTION   : saveFile
155  *
156  * DESCRIPTION: helper function for saving buffers on filesystem
157  *
158  * PARAMETERS :
159  *   @mem : buffer to save to filesystem
160  *   @path: File path
161  *
162  * RETURN     : status_t type of status
163  *              NO_ERROR  -- success
164  *              none-zero failure code
165  *==========================================================================*/
saveFile(const sp<IMemory> & mem,String8 path)166 status_t CameraContext::saveFile(const sp<IMemory>& mem, String8 path)
167 {
168     unsigned char *buff = NULL;
169     ssize_t size;
170     int fd = -1;
171 
172     if (mem == NULL) {
173         return BAD_VALUE;
174     }
175 
176     fd = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0655);
177     if(fd < 0) {
178         printf("Unable to open file %s %s\n", path.string(), strerror(fd));
179         return -errno;
180     }
181 
182     size = (ssize_t)mem->size();
183     if (size <= 0) {
184         printf("IMemory object is of zero size\n");
185         close(fd);
186         return BAD_VALUE;
187     }
188 
189     buff = (unsigned char *)mem->pointer();
190     if (!buff) {
191         printf("Buffer pointer is invalid\n");
192         close(fd);
193         return BAD_VALUE;
194     }
195 
196     if (size != write(fd, buff, (size_t)size)) {
197         printf("Bad Write error (%d)%s\n", errno, strerror(errno));
198         close(fd);
199         return INVALID_OPERATION;
200     }
201 
202     printf("%s: buffer=%p, size=%lld stored at %s\n",
203             __FUNCTION__, buff, (long long int) size, path.string());
204 
205     if (fd >= 0)
206         close(fd);
207 
208     return NO_ERROR;
209 }
210 
211 /*===========================================================================
212  * FUNCTION   : PiPCopyToOneFile
213  *
214  * DESCRIPTION: Copy the smaller picture to the bigger one
215  *
216  * PARAMETERS :
217  *   @bitmap0 : Decoded image buffer 0
218  *   @bitmap1 : Decoded image buffer 1
219  *
220  * RETURN     : decoded picture in picture in SkBitmap
221  *==========================================================================*/
PiPCopyToOneFile(SkBitmap * bitmap0,SkBitmap * bitmap1)222 SkBitmap * CameraContext::PiPCopyToOneFile(
223     SkBitmap *bitmap0, SkBitmap *bitmap1)
224 {
225     size_t size0;
226     size_t size1;
227     SkBitmap *src;
228     SkBitmap *dst;
229     unsigned int dstOffset;
230     unsigned int srcOffset;
231 
232     if (bitmap0 == NULL || bitmap1 == NULL) {
233         ALOGE(" bitmap0 : %p, bitmap1 : %p\n",  bitmap0, bitmap1);
234         return NULL;
235     }
236 
237     size0 = bitmap0->getSize();
238     if (size0 <= 0) {
239         printf("Decoded image 0 is of zero size\n");
240         return NULL;
241     }
242 
243     size1 = bitmap1->getSize();
244         if (size1 <= 0) {
245             printf("Decoded image 1 is of zero size\n");
246             return NULL;
247         }
248 
249     if (size0 > size1) {
250         dst = bitmap0;
251         src = bitmap1;
252     } else if (size1 > size0){
253         dst = bitmap1;
254         src = bitmap0;
255     } else {
256         printf("Picture size should be with different size!\n");
257         return NULL;
258     }
259 
260     for (unsigned int i = 0; i < (unsigned int)src->height(); i++) {
261         dstOffset = i * (unsigned int)dst->width() * mfmtMultiplier;
262         srcOffset = i * (unsigned int)src->width() * mfmtMultiplier;
263         memcpy(((unsigned char *)dst->getPixels()) + dstOffset,
264                 ((unsigned char *)src->getPixels()) + srcOffset,
265                 (unsigned int)src->width() * mfmtMultiplier);
266     }
267 
268     return dst;
269 }
270 
271 /*===========================================================================
272  * FUNCTION   : decodeJPEG
273  *
274  * DESCRIPTION: decode jpeg input buffer.
275  *
276  * PARAMETERS :
277  *   @mem     : buffer to decode
278  *   @skBM    : decoded buffer
279  *
280  * RETURN     : status_t type of status
281  *              NO_ERROR  -- success
282  *              none-zero failure code
283 
284  *==========================================================================*/
decodeJPEG(const sp<IMemory> & mem,SkBitmap * skBM)285 status_t CameraContext::decodeJPEG(const sp<IMemory>& mem, SkBitmap *skBM)
286 {
287 #ifndef USE_SDK_20_OR_HIGHER
288     SkBitmap::Config prefConfig = SkBitmap::kARGB_8888_Config;
289     const void *buff = NULL;
290     size_t size;
291 
292     buff = (const void *)mem->pointer();
293     size= mem->size();
294 
295     switch(prefConfig) {
296         case SkBitmap::kARGB_8888_Config:
297         {
298             mfmtMultiplier = 4;
299         }
300             break;
301 
302         case SkBitmap::kARGB_4444_Config:
303         {
304             mfmtMultiplier = 2;
305         }
306         break;
307 
308         case SkBitmap::kRGB_565_Config:
309         {
310             mfmtMultiplier = 2;
311         }
312         break;
313 
314         case SkBitmap::kIndex8_Config:
315         {
316             mfmtMultiplier = 4;
317         }
318         break;
319 
320         case SkBitmap::kA8_Config:
321         {
322             mfmtMultiplier = 4;
323         }
324         break;
325 
326         default:
327         {
328             mfmtMultiplier = 0;
329             printf("Decode format is not correct!\n");
330         }
331         break;
332     }
333 
334     if (SkImageDecoder::DecodeMemory(buff, size, skBM, prefConfig,
335             SkImageDecoder::kDecodePixels_Mode) == false) {
336         printf("%s():%d:: Failed during jpeg decode\n",__FUNCTION__,__LINE__);
337         return BAD_VALUE;
338     }
339 #else
340     SkColorType prefConfig = kRGBA_8888_SkColorType;
341     const void *buff = NULL;
342     size_t size;
343 
344     buff = (const void *)mem->pointer();
345     size= mem->size();
346 
347     switch(prefConfig) {
348         case kRGBA_8888_SkColorType:
349         {
350             mfmtMultiplier = 4;
351         }
352         break;
353 
354         case kBGRA_8888_SkColorType:
355         {
356             mfmtMultiplier = 4;
357         }
358         break;
359 
360         case kARGB_4444_SkColorType:
361         {
362             mfmtMultiplier = 2;
363         }
364         break;
365 
366         case kRGB_565_SkColorType:
367         {
368             mfmtMultiplier = 2;
369         }
370         break;
371 
372         case kIndex_8_SkColorType:
373         {
374             mfmtMultiplier = 4;
375         }
376         break;
377 
378         case kAlpha_8_SkColorType:
379         {
380             mfmtMultiplier = 4;
381         }
382         break;
383 
384         default:
385         {
386             mfmtMultiplier = 0;
387             printf("Decode format is not correct!\n");
388         }
389         break;
390     }
391 
392     if (SkImageDecoder::DecodeMemory(buff, size, skBM, prefConfig,
393             SkImageDecoder::kDecodePixels_Mode) == false) {
394         printf("%s():%d:: Failed during jpeg decode\n",__FUNCTION__,__LINE__);
395         return BAD_VALUE;
396     }
397 
398 #endif
399     return NO_ERROR;
400 }
401 
402 /*===========================================================================
403  * FUNCTION   : encodeJPEG
404  *
405  * DESCRIPTION: encode the decoded input buffer.
406  *
407  * PARAMETERS :
408  *   @stream  : SkWStream
409  *   @bitmap  : SkBitmap decoded image to encode
410  *   @path    : File path
411  *
412  * RETURN     : status_t type of status
413  *              NO_ERROR  -- success
414  *              none-zero failure code
415 
416  *==========================================================================*/
encodeJPEG(SkWStream * stream,const SkBitmap * bitmap,String8 path)417 status_t CameraContext::encodeJPEG(SkWStream * stream,
418     const SkBitmap *bitmap, String8 path)
419 {
420     int qFactor = 100;
421 
422     skJpegEnc = SkImageEncoder::Create(SkImageEncoder::kJPEG_Type);
423     if (!skJpegEnc) {
424         ALOGE(" skJpegEnc is NULL\n");
425         return BAD_VALUE;
426     }
427 
428     if (skJpegEnc->encodeStream(stream, *bitmap, qFactor) == false) {
429         return BAD_VALUE;
430     }
431 
432     FILE *fh = fopen(path.string(), "r+");
433     if ( !fh ) {
434         printf("Could not open file %s\n", path.string());
435         return BAD_VALUE;
436     }
437 
438     fseek(fh, 0, SEEK_END);
439     size_t len = (size_t)ftell(fh);
440     rewind(fh);
441 
442     if( !len ) {
443         printf("File %s is empty !\n", path.string());
444         fclose(fh);
445         return BAD_VALUE;
446     }
447 
448     unsigned char *buff = (unsigned char*)malloc(len);
449     if (!buff) {
450         printf("Cannot allocate memory for buffer reading!\n");
451         return BAD_VALUE;
452     }
453 
454     size_t readSize = fread(buff, 1, len, fh);
455     if (readSize != len) {
456         printf("Reading error\n");
457         return BAD_VALUE;
458     }
459 
460     status_t ret = ReadSectionsFromBuffer(buff, len, READ_ALL);
461     if (ret != NO_ERROR) {
462         printf("Cannot read sections from buffer\n");
463         DiscardData();
464         DiscardSections();
465         return BAD_VALUE;
466     }
467     free(buff);
468     rewind(fh);
469 
470     unsigned char temp = 0xff;
471     size_t writeSize = fwrite(&temp, sizeof(unsigned char), 1, fh);
472     if (1 != writeSize) {
473         printf("Writing error\n");
474     }
475     temp = 0xd8;
476     fwrite(&temp, sizeof(unsigned char), 1, fh);
477 
478     for (size_t i = 0; i < mSectionsRead; i++) {
479         switch((mSections[i].Type)) {
480 
481         case 0x123:
482             fwrite(mSections[i].Data, sizeof(unsigned char),
483                 mSections[i].Size, fh);
484             break;
485 
486         case 0xe0:
487             temp = 0xff;
488             fwrite(&temp, sizeof(unsigned char), 1, fh);
489             temp = 0xe1;
490             fwrite(&temp, sizeof(unsigned char), 1, fh);
491             fwrite(mJEXIFSection.Data, sizeof(unsigned char),
492                 mJEXIFSection.Size, fh);
493             break;
494 
495         default:
496             temp = 0xff;
497             fwrite(&temp, sizeof(unsigned char), 1, fh);
498             fwrite(&mSections[i].Type, sizeof(unsigned char), 1, fh);
499             fwrite(mSections[i].Data, sizeof(unsigned char),
500                 mSections[i].Size, fh);
501             break;
502         }
503     }
504     fseek(fh, 0, SEEK_END);
505     len = (size_t)ftell(fh);
506     rewind(fh);
507     printf("%s: buffer=%p, size=%zu stored at %s\n",
508             __FUNCTION__, bitmap->getPixels(), len, path.string());
509 
510     free(mJEXIFSection.Data);
511     DiscardData();
512     DiscardSections();
513     fclose(fh);
514     ret = NO_ERROR;
515 
516     return ret;
517 }
518 
519 /*===========================================================================
520  * FUNCTION   : readSectionsFromBuffer
521  *
522  * DESCRIPTION: read all jpeg sections of input buffer.
523  *
524  * PARAMETERS :
525  *   @mem : buffer to read from Metadata Sections
526  *   @buffer_size: buffer size
527  *   @ReadMode: Read mode - all, jpeg or exif
528  *
529  * RETURN     : status_t type of status
530  *              NO_ERROR  -- success
531  *              none-zero failure code
532  *==========================================================================*/
ReadSectionsFromBuffer(unsigned char * buffer,size_t buffer_size,ReadMode_t ReadMode)533 status_t CameraContext::ReadSectionsFromBuffer (unsigned char *buffer,
534         size_t buffer_size, ReadMode_t ReadMode)
535 {
536     int a;
537     size_t pos = 0;
538     int HaveCom = 0;
539     mSectionsAllocated = 10;
540 
541     mSections = (Sections_t *)malloc(sizeof(Sections_t) * mSectionsAllocated);
542     if (!mSections) {
543         printf(" not enough memory\n");
544         return BAD_VALUE;
545     }
546 
547     if (!buffer) {
548         printf("Input buffer is null\n");
549         return BAD_VALUE;
550     }
551 
552     if (buffer_size < 1) {
553         printf("Input size is 0\n");
554         return BAD_VALUE;
555     }
556 
557     a = (int) buffer[pos++];
558 
559     if (a != 0xff || buffer[pos++] != M_SOI){
560         printf("No valid image\n");
561         return BAD_VALUE;
562     }
563 
564     for(;;){
565         size_t itemlen;
566         int marker = 0;
567         size_t ll,lh;
568         unsigned char * Data;
569 
570         CheckSectionsAllocated();
571 
572         // The call to CheckSectionsAllocated() may reallocate mSections
573         // so need to check for NULL again.
574         if (mSections == NULL) {
575             printf(" not enough memory\n");
576             return BAD_VALUE;
577         }
578 
579         for (a = 0; a <= 16; a++){
580             marker = buffer[pos++];
581             if (marker != 0xff) break;
582 
583             if (a >= 16){
584                 fprintf(stderr,"too many padding bytes\n");
585                 return BAD_VALUE;
586             }
587         }
588 
589         mSections[mSectionsRead].Type = marker;
590 
591         // Read the length of the section.
592         lh = buffer[pos++];
593         ll = buffer[pos++];
594 
595         itemlen = (lh << 8) | ll;
596 
597         if (itemlen < 2) {
598             ALOGE("invalid marker");
599             return BAD_VALUE;
600         }
601 
602         mSections[mSectionsRead].Size = itemlen;
603 
604         Data = (unsigned char *)malloc(itemlen);
605         if (Data == NULL) {
606             ALOGE("Could not allocate memory");
607             return NO_MEMORY;
608         }
609         mSections[mSectionsRead].Data = Data;
610 
611         // Store first two pre-read bytes.
612         Data[0] = (unsigned char)lh;
613         Data[1] = (unsigned char)ll;
614 
615         if (pos+itemlen-2 > buffer_size) {
616             ALOGE("Premature end of file?");
617             return BAD_VALUE;
618         }
619 
620         memcpy(Data+2, buffer+pos, itemlen-2); // Read the whole section.
621         pos += itemlen-2;
622 
623         mSectionsRead += 1;
624 
625         switch(marker){
626 
627             case M_SOS:   // stop before hitting compressed data
628                 // If reading entire image is requested, read the rest of the
629                 // data.
630                 if (ReadMode & READ_IMAGE){
631                     size_t size;
632                     // Determine how much file is left.
633                     size = buffer_size - pos;
634 
635                     if (size < 1) {
636                         ALOGE("could not read the rest of the image");
637                         return BAD_VALUE;
638                     }
639                     Data = (unsigned char *)malloc(size);
640                     if (Data == NULL) {
641                         ALOGE("%d: could not allocate data for entire "
642                                 "image size: %d", __LINE__, size);
643                         return BAD_VALUE;
644                     }
645 
646                     memcpy(Data, buffer+pos, size);
647 
648                     CheckSectionsAllocated();
649 
650                     // The call to CheckSectionsAllocated()
651                     // may reallocate mSections
652                     // so need to check for NULL again.
653                     if (mSections == NULL) {
654                         printf(" not enough memory\n");
655                         return BAD_VALUE;
656                     }
657 
658                     mSections[mSectionsRead].Data = Data;
659                     mSections[mSectionsRead].Size = size;
660                     mSections[mSectionsRead].Type = PSEUDO_IMAGE_MARKER;
661                     mSectionsRead ++;
662                     mHaveAll = 1;
663                 }
664                 return NO_ERROR;
665 
666             case M_EOI:   // in case it's a tables-only JPEG stream
667                 ALOGE("No image in jpeg!\n");
668                 return BAD_VALUE;
669 
670             case M_COM: // Comment section
671                 if (HaveCom || ((ReadMode & READ_METADATA) == 0)){
672                     // Discard this section.
673                     free(mSections[--mSectionsRead].Data);
674                 }
675                 break;
676 
677             case M_JFIF:
678                 // Regular jpegs always have this tag, exif images have the
679                 // exif marker instead, althogh ACDsee will write images
680                 // with both markers.
681                 // this program will re-create this marker on absence of exif
682                 // marker.
683                 // hence no need to keep the copy from the file.
684                 if (ReadMode & READ_METADATA){
685                     if (memcmp(Data+2, "JFIF", 4) == 0) {
686                         break;
687                     }
688                     free(mSections[--mSectionsRead].Data);
689                 }
690                 break;
691 
692             case M_EXIF:
693                 // There can be different section using the same marker.
694                 if (ReadMode & READ_METADATA){
695                     if (memcmp(Data+2, "Exif", 4) == 0){
696                         break;
697                     }else if (memcmp(Data+2, "http:", 5) == 0){
698                         // Change tag for internal purposes.
699                         mSections[mSectionsRead-1].Type = M_XMP;
700                         break;
701                     }
702                 }
703                 // Oterwise, discard this section.
704                 free(mSections[--mSectionsRead].Data);
705                 break;
706 
707             case M_IPTC:
708                 if (ReadMode & READ_METADATA){
709                     // Note: We just store the IPTC section.
710                     // Its relatively straightforward
711                     // and we don't act on any part of it,
712                     // so just display it at parse time.
713                 }else{
714                     free(mSections[--mSectionsRead].Data);
715                 }
716                 break;
717 
718             case M_SOF0:
719             case M_SOF1:
720             case M_SOF2:
721             case M_SOF3:
722             case M_SOF5:
723             case M_SOF6:
724             case M_SOF7:
725             case M_SOF9:
726             case M_SOF10:
727             case M_SOF11:
728             case M_SOF13:
729             case M_SOF14:
730             case M_SOF15:
731                 break;
732             default:
733                 // Skip any other sections.
734                 break;
735         }
736     }
737     return NO_ERROR;
738 }
739 
740 /*===========================================================================
741  * FUNCTION   : CheckSectionsAllocated
742  *
743  * DESCRIPTION: Check allocated jpeg sections.
744  *
745  * PARAMETERS : none
746  *
747  * RETURN     : none
748 
749  *==========================================================================*/
CheckSectionsAllocated(void)750 void CameraContext::CheckSectionsAllocated(void)
751 {
752     if (mSectionsRead > mSectionsAllocated){
753         ALOGE("allocation screw up");
754     }
755     if (mSectionsRead >= mSectionsAllocated){
756         mSectionsAllocated += mSectionsAllocated +1;
757         mSections = (Sections_t *)realloc(mSections,
758             sizeof(Sections_t) * mSectionsAllocated);
759         if (mSections == NULL){
760             ALOGE("could not allocate data for entire image");
761         }
762     }
763 }
764 
765 /*===========================================================================
766  * FUNCTION   : findSection
767  *
768  * DESCRIPTION: find the desired Section of the JPEG buffer.
769  *
770  * PARAMETERS :
771  *  @SectionType: Section type
772  *
773  * RETURN     : return the found section
774 
775  *==========================================================================*/
FindSection(int SectionType)776 CameraContext::Sections_t *CameraContext::FindSection(int SectionType)
777 {
778     for (unsigned int a = 0; a < mSectionsRead; a++) {
779         if (mSections[a].Type == SectionType){
780             return &mSections[a];
781         }
782     }
783     // Could not be found.
784     return NULL;
785 }
786 
787 
788 /*===========================================================================
789  * FUNCTION   : DiscardData
790  *
791  * DESCRIPTION: DiscardData
792  *
793  * PARAMETERS : none
794  *
795  * RETURN     : none
796 
797  *==========================================================================*/
DiscardData()798 void CameraContext::DiscardData()
799 {
800     for (unsigned int a = 0; a < mSectionsRead; a++) {
801         free(mSections[a].Data);
802     }
803 
804     mSectionsRead = 0;
805     mHaveAll = 0;
806 }
807 
808 /*===========================================================================
809  * FUNCTION   : DiscardSections
810  *
811  * DESCRIPTION: Discard allocated sections
812  *
813  * PARAMETERS : none
814  *
815  * RETURN     : none
816 
817  *==========================================================================*/
DiscardSections()818 void CameraContext::DiscardSections()
819 {
820     free(mSections);
821     mSectionsAllocated = 0;
822     mHaveAll = 0;
823 }
824 
825 /*===========================================================================
826  * FUNCTION   : notify
827  *
828  * DESCRIPTION: notify callback
829  *
830  * PARAMETERS :
831  *   @msgType : type of callback
832  *   @ext1: extended parameters
833  *   @ext2: extended parameters
834  *
835  * RETURN     : None
836  *==========================================================================*/
notify(int32_t msgType,int32_t ext1,int32_t ext2)837 void CameraContext::notify(int32_t msgType, int32_t ext1, int32_t ext2)
838 {
839     printf("Notify cb: %d %d %d\n", msgType, ext1, ext2);
840 
841     if (( msgType & CAMERA_MSG_PREVIEW_FRAME)
842 #ifndef VANILLA_HAL
843             && (ext1 == CAMERA_FRAME_DATA_FD)
844 #endif
845        )
846     {
847         int fd = dup(ext2);
848         printf("notify Preview Frame fd: %d dup fd: %d\n", ext2, fd);
849         close(fd);
850     }
851 
852     if ( msgType & CAMERA_MSG_FOCUS ) {
853         printf("AutoFocus %s \n",
854                (ext1) ? "OK" : "FAIL");
855     }
856 
857     if ( msgType & CAMERA_MSG_SHUTTER ) {
858         printf("Shutter done \n");
859     }
860 
861     if ( msgType & CAMERA_MSG_ERROR) {
862         printf("Camera Test CAMERA_MSG_ERROR\n");
863         stopPreview();
864         closeCamera();
865     }
866 }
867 
868 /*===========================================================================
869  * FUNCTION   : postData
870  *
871  * DESCRIPTION: handles data callbacks
872  *
873  * PARAMETERS :
874  *   @msgType : type of callback
875  *   @dataPtr: buffer data
876  *   @metadata: additional metadata where available
877  *
878  * RETURN     : None
879  *==========================================================================*/
postData(int32_t msgType,const sp<IMemory> & dataPtr,camera_frame_metadata_t * metadata)880 void CameraContext::postData(int32_t msgType,
881                              const sp<IMemory>& dataPtr,
882                              camera_frame_metadata_t *metadata)
883 {
884     mInterpr->PiPLock();
885     Size currentPictureSize = mSupportedPictureSizes.itemAt(
886         mCurrentPictureSizeIdx);
887     unsigned char *buff = NULL;
888     size_t size;
889     status_t ret = 0;
890 
891     memset(&mJEXIFSection, 0, sizeof(mJEXIFSection)),
892 
893     printf("Data cb: %d\n", msgType);
894 
895     if ( msgType & CAMERA_MSG_PREVIEW_FRAME ) {
896         previewCallback(dataPtr);
897     }
898 
899     if ( msgType & CAMERA_MSG_RAW_IMAGE ) {
900         printf("RAW done \n");
901     }
902 
903     if (msgType & CAMERA_MSG_POSTVIEW_FRAME) {
904         printf("Postview frame \n");
905     }
906 
907     if (msgType & CAMERA_MSG_COMPRESSED_IMAGE ) {
908         String8 jpegPath;
909         jpegPath = jpegPath.format(QCAMERA_DUMP_FRM_LOCATION"img_%d.jpg",
910                 JpegIdx);
911         if (!mPiPCapture) {
912             // Normal capture case
913             printf("JPEG done\n");
914             saveFile(dataPtr, jpegPath);
915             JpegIdx++;
916         } else {
917             // PiP capture case
918             SkFILEWStream *wStream;
919             ret = decodeJPEG(dataPtr, &skBMtmp);
920             if (NO_ERROR != ret) {
921                 printf("Error in decoding JPEG!\n");
922                 mInterpr->PiPUnlock();
923                 return;
924             }
925 
926             mWidthTmp = currentPictureSize.width;
927             mHeightTmp = currentPictureSize.height;
928             PiPPtrTmp = dataPtr;
929             // If there are two jpeg buffers
930             if (mPiPIdx == 1) {
931                 printf("PiP done\n");
932 
933                 // Find the the capture with higher width and height and read
934                 // its jpeg sections
935                 if ((mInterpr->camera[0]->mWidthTmp * mInterpr->camera[0]->mHeightTmp) >
936                         (mInterpr->camera[1]->mWidthTmp * mInterpr->camera[1]->mHeightTmp)) {
937                     buff = (unsigned char *)PiPPtrTmp->pointer();
938                     size= PiPPtrTmp->size();
939                 } else if ((mInterpr->camera[0]->mWidthTmp * mInterpr->camera[0]->mHeightTmp) <
940                         (mInterpr->camera[1]->mWidthTmp * mInterpr->camera[1]->mHeightTmp)) {
941                     buff = (unsigned char *)PiPPtrTmp->pointer();
942                     size= PiPPtrTmp->size();
943                 } else {
944                     printf("Cannot take PiP. Images are with the same width"
945                             " and height size!!!\n");
946                     mInterpr->PiPUnlock();
947                     return;
948                 }
949 
950                 if (buff != NULL && size != 0) {
951                     ret = ReadSectionsFromBuffer(buff, size, READ_ALL);
952                     if (ret != NO_ERROR) {
953                         printf("Cannot read sections from buffer\n");
954                         DiscardData();
955                         DiscardSections();
956                         mInterpr->PiPUnlock();
957                         return;
958                     }
959 
960                     mJEXIFTmp = FindSection(M_EXIF);
961                     if (!mJEXIFTmp) {
962                         ALOGE("skBMDec is null\n");
963                         DiscardData();
964                         DiscardSections();
965                         return;
966                     }
967                     mJEXIFSection = *mJEXIFTmp;
968                     mJEXIFSection.Data = (unsigned char*)malloc(mJEXIFTmp->Size);
969                     if (!mJEXIFSection.Data) {
970                         ALOGE(" Not enough memory\n");
971                         DiscardData();
972                         DiscardSections();
973                         return;
974                     }
975                     memcpy(mJEXIFSection.Data,
976                         mJEXIFTmp->Data, mJEXIFTmp->Size);
977                     DiscardData();
978                     DiscardSections();
979 
980                     wStream = new SkFILEWStream(jpegPath.string());
981                     skBMDec = PiPCopyToOneFile(&mInterpr->camera[0]->skBMtmp,
982                             &mInterpr->camera[1]->skBMtmp);
983                     if (!skBMDec) {
984                         ALOGE("skBMDec is null\n");
985                         delete wStream;
986                         return;
987                     }
988 
989                     if (encodeJPEG(wStream, skBMDec, jpegPath) != false) {
990                         printf("%s():%d:: Failed during jpeg encode\n",
991                                 __FUNCTION__,__LINE__);
992                         mInterpr->PiPUnlock();
993                         return;
994                     }
995                     mPiPIdx = 0;
996                     JpegIdx++;
997                     delete wStream;
998                 }
999             } else {
1000                 mPiPIdx++;
1001             }
1002             disablePiPCapture();
1003         }
1004     }
1005 
1006     if ((msgType & CAMERA_MSG_PREVIEW_METADATA) && (NULL != metadata)) {
1007         printf("Face detected %d \n", metadata->number_of_faces);
1008     }
1009     mInterpr->PiPUnlock();
1010 
1011 }
1012 
1013 /*===========================================================================
1014  * FUNCTION   : postDataTimestamp
1015  *
1016  * DESCRIPTION: handles recording callbacks
1017  *
1018  * PARAMETERS :
1019  *   @timestamp : timestamp of buffer
1020  *   @msgType : type of buffer
1021  *   @dataPtr : buffer data
1022  *
1023  * RETURN     : None
1024  *==========================================================================*/
postDataTimestamp(nsecs_t timestamp,int32_t msgType,const sp<IMemory> & dataPtr)1025 void CameraContext::postDataTimestamp(nsecs_t timestamp,
1026                                       int32_t msgType,
1027                                       const sp<IMemory>& dataPtr)
1028 {
1029     printf("Recording cb: %d %lld %p\n",
1030             msgType, (long long int)timestamp, dataPtr.get());
1031 }
1032 
1033 /*===========================================================================
1034  * FUNCTION   : dataCallbackTimestamp
1035  *
1036  * DESCRIPTION: handles recording callbacks. Used for ViV recording
1037  *
1038  * PARAMETERS :
1039  *   @timestamp : timestamp of buffer
1040  *   @msgType : type of buffer
1041  *   @dataPtr : buffer data
1042  *
1043  * RETURN     : None
1044  *==========================================================================*/
dataCallbackTimestamp(nsecs_t timestamp,int32_t msgType,const sp<IMemory> & dataPtr)1045 void CameraContext::dataCallbackTimestamp(nsecs_t timestamp,
1046         int32_t msgType,
1047         const sp<IMemory>& dataPtr)
1048 {
1049     mInterpr->ViVLock();
1050     // Not needed check. Just avoiding warnings of not used variables.
1051     if (timestamp > 0)
1052         timestamp = 0;
1053     // Not needed check. Just avoiding warnings of not used variables.
1054     if (msgType > 0)
1055         msgType = 0;
1056     size_t i = 0;
1057     void * srcBuff = NULL;
1058     void * dstBuff = NULL;
1059 
1060     size_t srcYStride = 0, dstYStride = 0;
1061     size_t srcUVStride = 0, dstUVStride = 0;
1062     size_t srcYScanLines = 0, dstYScanLines = 0;
1063     size_t srcUVScanLines = 0, dstUVScanLines = 0;
1064     size_t srcOffset = 0, dstOffset = 0;
1065     size_t srcBaseOffset = 0;
1066     size_t dstBaseOffset = 0;
1067     Size currentVideoSize = mSupportedVideoSizes.itemAt(mCurrentVideoSizeIdx);
1068     status_t err = NO_ERROR;
1069     ANativeWindowBuffer* anb = NULL;
1070 
1071     dstBuff = (void *) dataPtr->pointer();
1072     if (NULL == dstBuff) {
1073         printf("Cannot access destination buffer!!!\n");
1074         mInterpr->ViVUnlock();
1075         return;
1076     }
1077 
1078     if (mCameraIndex == mInterpr->mViVVid.sourceCameraID) {
1079         srcYStride = calcStride(currentVideoSize.width);
1080         srcUVStride = calcStride(currentVideoSize.width);
1081         srcYScanLines = calcYScanLines(currentVideoSize.height);
1082         srcUVScanLines = calcUVScanLines(currentVideoSize.height);
1083         mInterpr->mViVBuff.srcWidth = (size_t)currentVideoSize.width;
1084         mInterpr->mViVBuff.srcHeight = (size_t)currentVideoSize.height;
1085 
1086 
1087         mInterpr->mViVBuff.YStride = srcYStride;
1088         mInterpr->mViVBuff.UVStride = srcUVStride;
1089         mInterpr->mViVBuff.YScanLines = srcYScanLines;
1090         mInterpr->mViVBuff.UVScanLines = srcUVScanLines;
1091 
1092         memcpy( mInterpr->mViVBuff.buff, dstBuff,
1093             mInterpr->mViVBuff.buffSize);
1094 
1095         mInterpr->mViVVid.isBuffValid = true;
1096     } else if (mCameraIndex == mInterpr->mViVVid.destinationCameraID) {
1097         if(mInterpr->mViVVid.isBuffValid == true) {
1098             dstYStride = calcStride(currentVideoSize.width);
1099             dstUVStride = calcStride(currentVideoSize.width);
1100             dstYScanLines = calcYScanLines(currentVideoSize.height);
1101             dstUVScanLines = calcUVScanLines(currentVideoSize.height);
1102 
1103             srcYStride = mInterpr->mViVBuff.YStride;
1104             srcUVStride = mInterpr->mViVBuff.UVStride;
1105             srcYScanLines = mInterpr->mViVBuff.YScanLines;
1106             srcUVScanLines = mInterpr->mViVBuff.UVScanLines;
1107 
1108 
1109             for (i = 0; i < mInterpr->mViVBuff.srcHeight; i++) {
1110                 srcOffset = i*srcYStride;
1111                 dstOffset = i*dstYStride;
1112                 memcpy((unsigned char *) dstBuff + dstOffset,
1113                     (unsigned char *) mInterpr->mViVBuff.buff +
1114                     srcOffset, mInterpr->mViVBuff.srcWidth);
1115             }
1116             srcBaseOffset = srcYStride * srcYScanLines;
1117             dstBaseOffset = dstYStride * dstYScanLines;
1118             for (i = 0; i < mInterpr->mViVBuff.srcHeight / 2; i++) {
1119                 srcOffset = i*srcUVStride + srcBaseOffset;
1120                 dstOffset = i*dstUVStride + dstBaseOffset;
1121                 memcpy((unsigned char *) dstBuff + dstOffset,
1122                     (unsigned char *) mInterpr->mViVBuff.buff +
1123                     srcOffset, mInterpr->mViVBuff.srcWidth);
1124             }
1125 
1126             err = native_window_dequeue_buffer_and_wait(
1127                 mInterpr->mViVVid.ANW.get(),&anb);
1128             if (err != NO_ERROR) {
1129                 printf("Cannot dequeue anb for sensor %d!!!\n", mCameraIndex);
1130                 mInterpr->ViVUnlock();
1131                 return;
1132             }
1133             mInterpr->mViVVid.graphBuf = new GraphicBuffer(anb, false);
1134             if(NULL == mInterpr->mViVVid.graphBuf.get()) {
1135                 printf("Invalid Graphic buffer\n");
1136                 mInterpr->ViVUnlock();
1137                 return;
1138             }
1139             err = mInterpr->mViVVid.graphBuf->lock(
1140                 GRALLOC_USAGE_SW_WRITE_OFTEN,
1141                 (void**)(&mInterpr->mViVVid.mappedBuff));
1142             if (err != NO_ERROR) {
1143                 printf("Graphic buffer could not be locked %d!!!\n", err);
1144                 mInterpr->ViVUnlock();
1145                 return;
1146             }
1147 
1148             srcYStride = dstYStride;
1149             srcUVStride = dstUVStride;
1150             srcYScanLines = dstYScanLines;
1151             srcUVScanLines = dstUVScanLines;
1152             srcBuff = dstBuff;
1153 
1154             for (i = 0; i < (size_t)currentVideoSize.height; i++) {
1155                 srcOffset = i*srcYStride;
1156                 dstOffset = i*dstYStride;
1157                 memcpy((unsigned char *) mInterpr->mViVVid.mappedBuff +
1158                     dstOffset, (unsigned char *) srcBuff +
1159                     srcOffset, (size_t)currentVideoSize.width);
1160             }
1161 
1162             srcBaseOffset = srcYStride * srcYScanLines;
1163             dstBaseOffset = dstUVStride * (size_t)currentVideoSize.height;
1164 
1165             for (i = 0; i < (size_t)currentVideoSize.height / 2; i++) {
1166                 srcOffset = i*srcUVStride + srcBaseOffset;
1167                 dstOffset = i*dstUVStride + dstBaseOffset;
1168                 memcpy((unsigned char *) mInterpr->mViVVid.mappedBuff +
1169                     dstOffset, (unsigned char *) srcBuff +
1170                     srcOffset, (size_t)currentVideoSize.width);
1171             }
1172 
1173 
1174             mInterpr->mViVVid.graphBuf->unlock();
1175 
1176             err = mInterpr->mViVVid.ANW->queueBuffer(
1177                 mInterpr->mViVVid.ANW.get(), anb, -1);
1178             if(err)
1179                 printf("Failed to enqueue buffer to recorder!!!\n");
1180         }
1181     }
1182     mCamera->releaseRecordingFrame(dataPtr);
1183 
1184     mInterpr->ViVUnlock();
1185 }
1186 
1187 /*===========================================================================
1188  * FUNCTION   : ViVEncoderThread
1189  *
1190  * DESCRIPTION: Creates a separate thread for ViV recording
1191  *
1192  * PARAMETERS : None
1193  *
1194  * RETURN     : None
1195  *==========================================================================*/
ViVEncoderThread()1196 status_t Interpreter::ViVEncoderThread()
1197 {
1198     int ret = NO_ERROR;
1199     pthread_attr_t attr;
1200     pthread_attr_init(&attr);
1201 
1202     ret = pthread_create(&mViVEncThread, &attr, ThreadWrapper, this);
1203     ret = pthread_attr_destroy(&attr);
1204 
1205     return ret;
1206 }
1207 
1208 /*===========================================================================
1209  * FUNCTION   : ThreadWrapper
1210  *
1211  * DESCRIPTION: Helper function for for ViV recording thread
1212  *
1213  * PARAMETERS : Interpreter context
1214  *
1215  * RETURN     : None
1216  *==========================================================================*/
ThreadWrapper(void * context)1217 void *Interpreter::ThreadWrapper(void *context) {
1218     Interpreter *writer = static_cast<Interpreter *>(context);
1219     writer->ViVEncode();
1220     return NULL;
1221 }
1222 
1223 /*===========================================================================
1224  * FUNCTION   : ViVEncode
1225  *
1226  * DESCRIPTION: Thread for ViV encode. Buffers from video codec are sent to
1227  *              muxer and saved in a file.
1228  *
1229  * PARAMETERS : Interpreter context
1230  *
1231  * RETURN     : None
1232  *==========================================================================*/
ViVEncode()1233 void Interpreter::ViVEncode()
1234 {
1235     status_t err = NO_ERROR;
1236     ssize_t trackIdx = -1;
1237     uint32_t debugNumFrames = 0;
1238 
1239     size_t bufIndex, offset, size;
1240     int64_t ptsUsec;
1241     uint32_t flags;
1242     bool DoRecording = true;
1243 
1244 
1245     err = mTestContext->mViVVid.codec->getOutputBuffers(
1246         &mTestContext->mViVVid.buffers);
1247     if (err != NO_ERROR) {
1248         printf("Unable to get output buffers (err=%d)\n", err);
1249     }
1250 
1251     while (DoRecording) {
1252         err = mTestContext->mViVVid.codec->dequeueOutputBuffer(
1253             &bufIndex,
1254             &offset,
1255             &size,
1256             &ptsUsec,
1257             &flags, -1);
1258 
1259         switch (err) {
1260 
1261         case NO_ERROR:
1262             // got a buffer
1263             if ((flags & MediaCodec::BUFFER_FLAG_CODECCONFIG) != 0) {
1264                 // ignore this -- we passed the CSD into MediaMuxer when
1265                 // we got the format change notification
1266                 size = 0;
1267             }
1268             if (size != 0) {
1269                 // If the virtual display isn't providing us with timestamps,
1270                 // use the current time.
1271                 if (ptsUsec == 0) {
1272                     ptsUsec = systemTime(SYSTEM_TIME_MONOTONIC) / 1000;
1273                 }
1274 
1275                 // The MediaMuxer docs are unclear, but it appears that we
1276                 // need to pass either the full set of BufferInfo flags, or
1277                 // (flags & BUFFER_FLAG_SYNCFRAME).
1278                 err = mTestContext->mViVVid.muxer->writeSampleData(
1279                     mTestContext->mViVVid.buffers[bufIndex],
1280                     (size_t)trackIdx,
1281                     ptsUsec,
1282                     flags);
1283                 if (err != NO_ERROR) {
1284                     fprintf(stderr, "Failed writing data to muxer (err=%d)\n",
1285                             err);
1286                 }
1287                 debugNumFrames++;
1288             }
1289             err = mTestContext->mViVVid.codec->releaseOutputBuffer(bufIndex);
1290             if (err != NO_ERROR) {
1291                 fprintf(stderr, "Unable to release output buffer (err=%d)\n",
1292                         err);
1293             }
1294             if ((flags & MediaCodec::BUFFER_FLAG_EOS) != 0) {
1295                 // Not expecting EOS from SurfaceFlinger.  Go with it.
1296                 printf("Received end-of-stream\n");
1297                 //DoRecording = false;
1298             }
1299             break;
1300         case -EAGAIN:                       // INFO_TRY_AGAIN_LATER
1301             ALOGV("Got -EAGAIN, looping");
1302             break;
1303         case INFO_FORMAT_CHANGED:           // INFO_OUTPUT_FORMAT_CHANGED
1304         {
1305             // format includes CSD, which we must provide to muxer
1306             sp<AMessage> newFormat;
1307             mTestContext->mViVVid.codec->getOutputFormat(&newFormat);
1308             trackIdx = mTestContext->mViVVid.muxer->addTrack(newFormat);
1309             err = mTestContext->mViVVid.muxer->start();
1310             if (err != NO_ERROR) {
1311                 printf("Unable to start muxer (err=%d)\n", err);
1312             }
1313         }
1314         break;
1315         case INFO_OUTPUT_BUFFERS_CHANGED:   // INFO_OUTPUT_BUFFERS_CHANGED
1316             // not expected for an encoder; handle it anyway
1317             ALOGV("Encoder buffers changed");
1318             err = mTestContext->mViVVid.codec->getOutputBuffers(
1319                 &mTestContext->mViVVid.buffers);
1320             if (err != NO_ERROR) {
1321                 printf("Unable to get new output buffers (err=%d)\n", err);
1322             }
1323         break;
1324         case INVALID_OPERATION:
1325             DoRecording = false;
1326         break;
1327         default:
1328             printf("Got weird result %d from dequeueOutputBuffer\n", err);
1329         break;
1330         }
1331     }
1332 
1333     return;
1334 }
1335 
1336 /*===========================================================================
1337  * FUNCTION   : calcBufferSize
1338  *
1339  * DESCRIPTION: Temp buffer size calculation. Temp buffer is used to store
1340  *              the buffer from the camera with smaller resolution. It is
1341  *              copied to the buffer from camera with higher resolution.
1342  *
1343  * PARAMETERS :
1344  *   @width   : video size width
1345  *   @height  : video size height
1346  *
1347  * RETURN     : size_t
1348  *==========================================================================*/
calcBufferSize(int width,int height)1349 size_t CameraContext::calcBufferSize(int width, int height)
1350 {
1351     size_t size = 0;
1352     size_t UVAlignment;
1353     size_t YPlane, UVPlane, YStride, UVStride, YScanlines, UVScanlines;
1354     if (!width || !height) {
1355         return size;
1356     }
1357     UVAlignment = 4096;
1358     YStride = calcStride(width);
1359     UVStride = calcStride(width);
1360     YScanlines = calcYScanLines(height);
1361     UVScanlines = calcUVScanLines(height);
1362     YPlane = YStride * YScanlines;
1363     UVPlane = UVStride * UVScanlines + UVAlignment;
1364     size = YPlane + UVPlane;
1365     size = VIDEO_BUF_ALLIGN(size, 4096);
1366 
1367     return size;
1368 }
1369 
1370 /*===========================================================================
1371  * FUNCTION   : calcStride
1372  *
1373  * DESCRIPTION: Temp buffer stride calculation.
1374  *
1375  * PARAMETERS :
1376  *   @width   : video size width
1377  *
1378  * RETURN     : size_t
1379  *==========================================================================*/
calcStride(int width)1380 size_t CameraContext::calcStride(int width)
1381 {
1382     size_t alignment, stride = 0;
1383     if (!width) {
1384         return stride;
1385     }
1386     alignment = 128;
1387     stride = VIDEO_BUF_ALLIGN((size_t)width, alignment);
1388 
1389     return stride;
1390 }
1391 
1392 /*===========================================================================
1393  * FUNCTION   : calcYScanLines
1394  *
1395  * DESCRIPTION: Temp buffer scanlines calculation for Y plane.
1396  *
1397  * PARAMETERS :
1398  *   @width   : video size height
1399  *
1400  * RETURN     : size_t
1401  *==========================================================================*/
calcYScanLines(int height)1402 size_t CameraContext::calcYScanLines(int height)
1403 {
1404     size_t alignment, scanlines = 0;
1405         if (!height) {
1406             return scanlines;
1407         }
1408     alignment = 32;
1409     scanlines = VIDEO_BUF_ALLIGN((size_t)height, alignment);
1410 
1411     return scanlines;
1412 }
1413 
1414 /*===========================================================================
1415  * FUNCTION   : calcUVScanLines
1416  *
1417  * DESCRIPTION: Temp buffer scanlines calculation for UV plane.
1418  *
1419  * PARAMETERS :
1420  *   @width   : video size height
1421  *
1422  * RETURN     : size_t
1423  *==========================================================================*/
calcUVScanLines(int height)1424 size_t CameraContext::calcUVScanLines(int height)
1425 {
1426     size_t alignment, scanlines = 0;
1427     if (!height) {
1428         return scanlines;
1429     }
1430     alignment = 16;
1431     scanlines = VIDEO_BUF_ALLIGN((size_t)((height + 1) >> 1), alignment);
1432 
1433     return scanlines;
1434 }
1435 
1436 /*===========================================================================
1437  * FUNCTION   : printSupportedParams
1438  *
1439  * DESCRIPTION: dump common supported parameters
1440  *
1441  * PARAMETERS : None
1442  *
1443  * RETURN     : None
1444  *==========================================================================*/
printSupportedParams()1445 void CameraContext::printSupportedParams()
1446 {
1447     const char *camera_ids = mParams.get("camera-indexes");
1448     const char *pic_sizes = mParams.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES);
1449     const char *pic_formats = mParams.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS);
1450     const char *preview_sizes = mParams.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES);
1451     const char *video_sizes = mParams.get(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES);
1452     const char *preview_formats = mParams.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS);
1453     const char *frame_rates = mParams.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES);
1454     const char *thumb_sizes = mParams.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES);
1455     const char *wb_modes = mParams.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE);
1456     const char *effects = mParams.get(CameraParameters::KEY_SUPPORTED_EFFECTS);
1457     const char *scene_modes = mParams.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES);
1458     const char *focus_modes = mParams.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES);
1459     const char *antibanding_modes = mParams.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING);
1460     const char *flash_modes = mParams.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
1461     int focus_areas = mParams.getInt(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS);
1462     const char *fps_ranges = mParams.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE);
1463     const char *focus_distances = mParams.get(CameraParameters::KEY_FOCUS_DISTANCES);
1464 
1465     printf("\n\r\tSupported Cameras: %s",
1466            (camera_ids != NULL)? camera_ids : "NULL");
1467     printf("\n\r\tSupported Picture Sizes: %s",
1468            (pic_sizes != NULL)? pic_sizes : "NULL");
1469     printf("\n\r\tSupported Picture Formats: %s",
1470            (pic_formats != NULL)? pic_formats : "NULL");
1471     printf("\n\r\tSupported Preview Sizes: %s",
1472            (preview_sizes != NULL)? preview_sizes : "NULL");
1473     printf("\n\r\tSupported Video Sizes: %s",
1474             (video_sizes != NULL)? video_sizes : "NULL");
1475     printf("\n\r\tSupported Preview Formats: %s",
1476            (preview_formats != NULL)? preview_formats : "NULL");
1477     printf("\n\r\tSupported Preview Frame Rates: %s",
1478            (frame_rates != NULL)? frame_rates : "NULL");
1479     printf("\n\r\tSupported Thumbnail Sizes: %s",
1480            (thumb_sizes != NULL)? thumb_sizes : "NULL");
1481     printf("\n\r\tSupported Whitebalance Modes: %s",
1482            (wb_modes != NULL)? wb_modes : "NULL");
1483     printf("\n\r\tSupported Effects: %s",
1484            (effects != NULL)? effects : "NULL");
1485     printf("\n\r\tSupported Scene Modes: %s",
1486            (scene_modes != NULL)? scene_modes : "NULL");
1487     printf("\n\r\tSupported Focus Modes: %s",
1488            (focus_modes != NULL)? focus_modes : "NULL");
1489     printf("\n\r\tSupported Antibanding Options: %s",
1490            (antibanding_modes != NULL)? antibanding_modes : "NULL");
1491     printf("\n\r\tSupported Flash Modes: %s",
1492            (flash_modes != NULL)? flash_modes : "NULL");
1493     printf("\n\r\tSupported Focus Areas: %d", focus_areas);
1494     printf("\n\r\tSupported FPS ranges : %s",
1495            (fps_ranges != NULL)? fps_ranges : "NULL");
1496     printf("\n\r\tFocus Distances: %s \n",
1497            (focus_distances != NULL)? focus_distances : "NULL");
1498 }
1499 
1500 /*===========================================================================
1501  * FUNCTION   : createPreviewSurface
1502  *
1503  * DESCRIPTION: helper function for creating preview surfaces
1504  *
1505  * PARAMETERS :
1506  *   @width : preview width
1507  *   @height: preview height
1508  *   @pixFormat : surface pixelformat
1509  *
1510  * RETURN     : status_t type of status
1511  *              NO_ERROR  -- success
1512  *              none-zero failure code
1513  *==========================================================================*/
createPreviewSurface(int width,int height,int32_t pixFormat)1514 status_t CameraContext::createPreviewSurface(int width, int height, int32_t pixFormat)
1515 {
1516     int ret = NO_ERROR;
1517     DisplayInfo dinfo;
1518     sp<IBinder> display(SurfaceComposerClient::getBuiltInDisplay(
1519                         ISurfaceComposer::eDisplayIdMain));
1520     SurfaceComposerClient::getDisplayInfo(display, &dinfo);
1521     uint32_t previewWidth, previewHeight;
1522 
1523     if ((0 >= width) || (0 >= height)) {
1524         printf("Bad preview surface size %dx%d\n", width, height);
1525         return BAD_VALUE;
1526     }
1527 
1528     if ((int)dinfo.w < width) {
1529         previewWidth = dinfo.w;
1530     } else {
1531         previewWidth = (unsigned int)width;
1532     }
1533 
1534     if ((int)dinfo.h < height) {
1535         previewHeight = dinfo.h;
1536     } else {
1537         previewHeight = (unsigned int)height;
1538     }
1539 
1540     mClient = new SurfaceComposerClient();
1541 
1542     if ( NULL == mClient.get() ) {
1543         printf("Unable to establish connection to Surface Composer \n");
1544         return NO_INIT;
1545     }
1546 
1547     mSurfaceControl = mClient->createSurface(String8("QCamera_Test"),
1548                                              previewWidth,
1549                                              previewHeight,
1550                                              pixFormat,
1551                                              0);
1552     if ( NULL == mSurfaceControl.get() ) {
1553         printf("Unable to create preview surface \n");
1554         return NO_INIT;
1555     }
1556 
1557     mPreviewSurface = mSurfaceControl->getSurface();
1558     if ( NULL != mPreviewSurface.get() ) {
1559         mClient->openGlobalTransaction();
1560         ret |= mSurfaceControl->setLayer(0x7fffffff);
1561         if ( mCameraIndex == 0 )
1562             ret |= mSurfaceControl->setPosition(0, 0);
1563         else
1564             ret |= mSurfaceControl->setPosition((float)(dinfo.w - previewWidth),
1565                     (float)(dinfo.h - previewHeight));
1566 
1567         ret |= mSurfaceControl->setSize(previewWidth, previewHeight);
1568         ret |= mSurfaceControl->show();
1569         mClient->closeGlobalTransaction();
1570 
1571         if ( NO_ERROR != ret ) {
1572             printf("Preview surface configuration failed! \n");
1573         }
1574     } else {
1575         ret = NO_INIT;
1576     }
1577 
1578     return ret;
1579 }
1580 
1581 /*===========================================================================
1582  * FUNCTION   : destroyPreviewSurface
1583  *
1584  * DESCRIPTION: closes previously open preview surface
1585  *
1586  * PARAMETERS : None
1587  *
1588  * RETURN     : status_t type of status
1589  *              NO_ERROR  -- success
1590  *              none-zero failure code
1591  *==========================================================================*/
destroyPreviewSurface()1592 status_t CameraContext::destroyPreviewSurface()
1593 {
1594     if ( NULL != mPreviewSurface.get() ) {
1595         mPreviewSurface.clear();
1596     }
1597 
1598     if ( NULL != mSurfaceControl.get() ) {
1599         mSurfaceControl->clear();
1600         mSurfaceControl.clear();
1601     }
1602 
1603     if ( NULL != mClient.get() ) {
1604         mClient->dispose();
1605         mClient.clear();
1606     }
1607 
1608     return NO_ERROR;
1609 }
1610 
1611 /*===========================================================================
1612  * FUNCTION   : CameraContext
1613  *
1614  * DESCRIPTION: camera context constructor
1615  *
1616  * PARAMETERS : None
1617  *
1618  * RETURN     : None
1619  *==========================================================================*/
CameraContext(int cameraIndex)1620 CameraContext::CameraContext(int cameraIndex) :
1621     mCameraIndex(cameraIndex),
1622     mResizePreview(true),
1623     mHardwareActive(false),
1624     mPreviewRunning(false),
1625     mRecordRunning(false),
1626     mVideoFd(-1),
1627     mVideoIdx(0),
1628     mRecordingHint(false),
1629     mDoPrintMenu(true),
1630     mPiPCapture(false),
1631     mfmtMultiplier(1),
1632     mSectionsRead(false),
1633     mSectionsAllocated(0),
1634     mSections(NULL),
1635     mJEXIFTmp(NULL),
1636     mHaveAll(false),
1637     mCamera(NULL),
1638     mClient(NULL),
1639     mSurfaceControl(NULL),
1640     mPreviewSurface(NULL),
1641     mInUse(false)
1642 {
1643     mRecorder = new MediaRecorder(String16("camera"));
1644 }
1645 
1646 /*===========================================================================
1647  * FUNCTION     : setTestCtxInstance
1648  *
1649  * DESCRIPTION  : Sends TestContext instance to CameraContext
1650  *
1651  * PARAMETERS   :
1652  *    @instance : TestContext instance
1653  *
1654  * RETURN     : None
1655  *==========================================================================*/
setTestCtxInstance(TestContext * instance)1656 void CameraContext::setTestCtxInstance(TestContext  *instance)
1657 {
1658     mInterpr = instance;
1659 }
1660 
1661 /*===========================================================================
1662  * FUNCTION     : setTestCtxInst
1663  *
1664  * DESCRIPTION  : Sends TestContext instance to Interpreter
1665  *
1666  * PARAMETERS   :
1667  *    @instance : TestContext instance
1668  *
1669  * RETURN     : None
1670  *==========================================================================*/
setTestCtxInst(TestContext * instance)1671 void Interpreter::setTestCtxInst(TestContext  *instance)
1672 {
1673     mTestContext = instance;
1674 }
1675 
1676 /*===========================================================================
1677  * FUNCTION   : ~CameraContext
1678  *
1679  * DESCRIPTION: camera context destructor
1680  *
1681  * PARAMETERS : None
1682  *
1683  * RETURN     : None
1684  *==========================================================================*/
~CameraContext()1685 CameraContext::~CameraContext()
1686 {
1687     stopPreview();
1688     closeCamera();
1689 }
1690 
1691 /*===========================================================================
1692  * FUNCTION   : openCamera
1693  *
1694  * DESCRIPTION: connects to and initializes camera
1695  *
1696  * PARAMETERS : None
1697  *
1698  * RETURN     : status_t type of status
1699  *              NO_ERROR  -- success
1700  *              none-zero failure code
1701  *==========================================================================*/
openCamera()1702 status_t  CameraContext::openCamera()
1703 {
1704     useLock();
1705     const char *ZSLStr = NULL;
1706     size_t ZSLStrSize = 0;
1707 
1708     if ( NULL != mCamera.get() ) {
1709         printf("Camera already open! \n");
1710         signalFinished();
1711         return NO_ERROR;
1712     }
1713 
1714     printf("openCamera(camera_index=%d)\n", mCameraIndex);
1715 
1716 #ifndef USE_JB_MR1
1717 
1718     String16 packageName("CameraTest");
1719 
1720     mCamera = Camera::connect(mCameraIndex,
1721                               packageName,
1722                               Camera::USE_CALLING_UID);
1723 
1724 #else
1725 
1726     mCamera = Camera::connect(mCameraIndex);
1727 
1728 #endif
1729 
1730     if ( NULL == mCamera.get() ) {
1731         printf("Unable to connect to CameraService\n");
1732         signalFinished();
1733         return NO_INIT;
1734     }
1735 
1736     mParams = mCamera->getParameters();
1737     mParams.getSupportedPreviewSizes(mSupportedPreviewSizes);
1738     mParams.getSupportedPictureSizes(mSupportedPictureSizes);
1739     mParams.getSupportedVideoSizes(mSupportedVideoSizes);
1740 
1741     mCurrentPictureSizeIdx = mSupportedPictureSizes.size() / 2;
1742     mCurrentPreviewSizeIdx = mSupportedPreviewSizes.size() / 2;
1743     mCurrentVideoSizeIdx   = mSupportedVideoSizes.size() / 2;
1744 
1745     mCamera->setListener(this);
1746     mHardwareActive = true;
1747 
1748     mInterpr->setViVSize((Size) mSupportedVideoSizes.itemAt(
1749         mCurrentVideoSizeIdx),
1750         mCameraIndex);
1751 
1752     ZSLStr = mParams.get(CameraContext::KEY_ZSL);
1753     if (NULL != ZSLStr) {
1754         ZSLStrSize = strlen(ZSLStr);
1755         if (!strncmp(ZSLStr, "on", ZSLStrSize)) {
1756             mInterpr->mIsZSLOn = true;
1757         } else if (!strncmp(ZSLStr, "off", ZSLStrSize)) {
1758             mInterpr->mIsZSLOn = false;
1759         } else {
1760             printf("zsl value is not valid!\n");
1761         }
1762     } else {
1763         printf("zsl is NULL\n");
1764     }
1765 
1766     signalFinished();
1767 
1768     return NO_ERROR;
1769 }
1770 
1771 /*===========================================================================
1772  * FUNCTION   : onAsBinder
1773  *
1774  * DESCRIPTION: onAsBinder
1775  *
1776  * PARAMETERS : None
1777  *
1778  * RETURN     : Pointer to IBinder
1779  *==========================================================================*/
onAsBinder()1780 IBinder* CameraContext::onAsBinder() {
1781     return NULL;
1782 }
1783 
1784 /*===========================================================================
1785  * FUNCTION   : getNumberOfCameras
1786  *
1787  * DESCRIPTION: returns the number of supported camera by the system
1788  *
1789  * PARAMETERS : None
1790  *
1791  * RETURN     : supported camera count
1792  *==========================================================================*/
getNumberOfCameras()1793 int CameraContext::getNumberOfCameras()
1794 {
1795     int ret = -1;
1796 
1797     if ( NULL != mCamera.get() ) {
1798         ret = mCamera->getNumberOfCameras();
1799     }
1800 
1801     return ret;
1802 }
1803 
1804 /*===========================================================================
1805  * FUNCTION   : closeCamera
1806  *
1807  * DESCRIPTION: closes a previously the initialized camera reference
1808  *
1809  * PARAMETERS : None
1810  *
1811  * RETURN     : status_t type of status
1812  *              NO_ERROR  -- success
1813  *              none-zero failure code
1814  *==========================================================================*/
closeCamera()1815 status_t CameraContext::closeCamera()
1816 {
1817     useLock();
1818     if ( NULL == mCamera.get() ) {
1819         return NO_INIT;
1820     }
1821 
1822     mCamera->disconnect();
1823     mCamera.clear();
1824 
1825     mRecorder->init();
1826     mRecorder->close();
1827     mRecorder->release();
1828     mRecorder.clear();
1829 
1830     mHardwareActive = false;
1831     mPreviewRunning = false;
1832     mRecordRunning = false;
1833 
1834     signalFinished();
1835     return NO_ERROR;
1836 }
1837 
1838 /*===========================================================================
1839  * FUNCTION   : startPreview
1840  *
1841  * DESCRIPTION: starts camera preview
1842  *
1843  * PARAMETERS : None
1844  *
1845  * RETURN     : status_t type of status
1846  *              NO_ERROR  -- success
1847  *              none-zero failure code
1848  *==========================================================================*/
startPreview()1849 status_t CameraContext::startPreview()
1850 {
1851     useLock();
1852 
1853     int ret = NO_ERROR;
1854     int previewWidth, previewHeight;
1855     Size calculatedPreviewSize;
1856     Size currentPreviewSize = mSupportedPreviewSizes.itemAt(
1857         mCurrentPreviewSizeIdx);
1858     Size currentPictureSize = mSupportedPictureSizes.itemAt(
1859         mCurrentPictureSizeIdx);
1860     Size currentVideoSize   = mSupportedVideoSizes.itemAt(
1861         mCurrentVideoSizeIdx);
1862 
1863 #ifndef USE_JB_MR1
1864 
1865     sp<IGraphicBufferProducer> gbp;
1866 
1867 #endif
1868 
1869     if (!mHardwareActive ) {
1870         printf("Camera not active! \n");
1871         return NO_INIT;
1872     }
1873 
1874     if (mPreviewRunning) {
1875         printf("Preview is already running! \n");
1876         signalFinished();
1877         return NO_ERROR;
1878     }
1879 
1880     if (mResizePreview) {
1881         mPreviewRunning = false;
1882 
1883         if ( mRecordingHint ) {
1884             calculatedPreviewSize =
1885                 getPreviewSizeFromVideoSizes(currentVideoSize);
1886             previewWidth = calculatedPreviewSize.width;
1887             previewHeight = calculatedPreviewSize.height;
1888         } else {
1889             previewWidth = currentPreviewSize.width;
1890             previewHeight = currentPreviewSize.height;
1891         }
1892 
1893         ret = createPreviewSurface(previewWidth,
1894                                    previewHeight,
1895                                    HAL_PIXEL_FORMAT_YCrCb_420_SP);
1896         if (  NO_ERROR != ret ) {
1897             printf("Error while creating preview surface\n");
1898             return ret;
1899         }
1900 
1901         // set rdi mode if system prop is set for front camera
1902         if (mCameraIndex == 1) {
1903             char value[32];
1904             property_get("persist.camera.rdimode", value, "0");
1905             int rdimode = atoi(value);
1906             printf("rdi mode = %d\n", rdimode);
1907             if (rdimode == 1) {
1908                 mParams.set("rdi-mode", "enable");
1909             } else {
1910                 mParams.set("rdi-mode", "disable");
1911             }
1912         } else {
1913             mParams.set("rdi-mode", "disable");
1914         }
1915 
1916         //mParams.set("rdi-mode", "enable");
1917         mParams.set("recording-hint", "true");
1918         mParams.setPreviewSize(previewWidth, previewHeight);
1919         mParams.setPictureSize(currentPictureSize.width,
1920             currentPictureSize.height);
1921         mParams.setVideoSize(
1922             currentVideoSize.width, currentVideoSize.height);
1923 
1924         ret |= mCamera->setParameters(mParams.flatten());
1925 
1926 #ifndef USE_JB_MR1
1927 
1928         gbp = mPreviewSurface->getIGraphicBufferProducer();
1929         ret |= mCamera->setPreviewTarget(gbp);
1930 
1931 #else
1932 
1933         ret |= mCamera->setPreviewDisplay(mPreviewSurface);
1934 
1935 #endif
1936         mResizePreview = false;
1937     }
1938 
1939     if ( !mPreviewRunning ) {
1940         ret |= mCamera->startPreview();
1941         if ( NO_ERROR != ret ) {
1942             printf("Preview start failed! \n");
1943             return ret;
1944         }
1945 
1946         mPreviewRunning = true;
1947     }
1948 
1949     signalFinished();
1950 
1951     return ret;
1952 }
1953 
1954 /*===========================================================================
1955  * FUNCTION   : getPreviewSizeFromVideoSizes
1956  *
1957  * DESCRIPTION: Get the preview size from video size. Find all resolutions with
1958  *              the same aspect ratio and choose the same or the closest
1959  *              from them.
1960  *
1961  * PARAMETERS :
1962  *   @currentVideoSize: current video size
1963 
1964  *
1965  * RETURN     : PreviewSize
1966  *==========================================================================*/
getPreviewSizeFromVideoSizes(Size currentVideoSize)1967 Size CameraContext::getPreviewSizeFromVideoSizes(Size currentVideoSize)
1968 {
1969 
1970     Size tmpPreviewSize;
1971     Size PreviewSize;
1972     Size PreviewSizes[mSupportedPreviewSizes.size()];
1973     double tolerance = 0.00001;
1974     double videoRatio;
1975     double previewRatio;
1976     size_t i = 0;
1977     size_t j = 0;
1978     int delta;
1979 
1980     // Find all the resolutions with the same aspect ratio and choose the
1981     // same or the closest resolution from them. Choose the closest resolution
1982     // in case same aspect ratio is not found
1983     if (currentVideoSize.width * currentVideoSize.height > 0 &&
1984             mSupportedPreviewSizes.size() > 0) {
1985         videoRatio = (float)currentVideoSize.width /
1986             (float)currentVideoSize.height;
1987         for (i=0; i<mSupportedPreviewSizes.size(); i++) {
1988             tmpPreviewSize = mSupportedPreviewSizes.itemAt(i);
1989             previewRatio = (float)tmpPreviewSize.width /
1990                 (float)tmpPreviewSize.height;
1991             if (fabs(videoRatio - previewRatio) < tolerance) {
1992                 PreviewSizes[j] = tmpPreviewSize;
1993                 j++;
1994             }
1995         }
1996 
1997         if ( j > 0 ) {
1998             delta = abs((currentVideoSize.width *currentVideoSize.height)-
1999                 (PreviewSizes[0].width * PreviewSizes[0].height));
2000             PreviewSize = PreviewSizes[0];
2001             for (i=0; i<j; i++) {
2002                 if(abs(currentVideoSize.width * currentVideoSize.height) -
2003                     (PreviewSizes[i].width * PreviewSizes[i].height) <
2004                     delta) {
2005                     PreviewSize = PreviewSizes[i];
2006                     delta = abs((currentVideoSize.width *
2007                         currentVideoSize.height) -
2008                         (PreviewSizes[i].width * PreviewSizes[i].height));
2009                 }
2010             }
2011         } else {
2012             // Choose the closest resolution in case same aspect ratio is
2013             // not found
2014             tmpPreviewSize = mSupportedPreviewSizes.itemAt(j);
2015             PreviewSize = tmpPreviewSize;
2016             delta = abs(
2017                     (currentVideoSize.width * currentVideoSize.height)-
2018                     (tmpPreviewSize.width * tmpPreviewSize.height));
2019             for (i=0; i<mSupportedPreviewSizes.size(); i++) {
2020                 tmpPreviewSize = mSupportedPreviewSizes.itemAt(i);
2021                 if(abs(
2022                         (currentVideoSize.width * currentVideoSize.height)-
2023                         (tmpPreviewSize.width * tmpPreviewSize.height)) <
2024                         delta) {
2025                     PreviewSize = tmpPreviewSize;
2026                     delta = abs(
2027                             (currentVideoSize.width * currentVideoSize.height)-
2028                             (tmpPreviewSize.width * tmpPreviewSize.height));
2029                 }
2030             }
2031         }
2032     } else {
2033         memset(&PreviewSize, 0, sizeof(PreviewSize));
2034     }
2035     return PreviewSize;
2036 }
2037 
2038 /*===========================================================================
2039  * FUNCTION   : autoFocus
2040  *
2041  * DESCRIPTION: Triggers autofocus
2042  *
2043  * PARAMETERS : None
2044  *
2045  * RETURN     : status_t type of status
2046  *              NO_ERROR  -- success
2047  *              none-zero failure code
2048  *==========================================================================*/
autoFocus()2049 status_t CameraContext::autoFocus()
2050 {
2051     useLock();
2052     status_t ret = NO_ERROR;
2053 
2054     if ( mPreviewRunning ) {
2055         ret = mCamera->autoFocus();
2056     }
2057 
2058     signalFinished();
2059     return ret;
2060 }
2061 
2062 /*===========================================================================
2063  * FUNCTION   : enablePreviewCallbacks
2064  *
2065  * DESCRIPTION: Enables preview callback messages
2066  *
2067  * PARAMETERS : None
2068  *
2069  * RETURN     : status_t type of status
2070  *              NO_ERROR  -- success
2071  *              none-zero failure code
2072  *==========================================================================*/
enablePreviewCallbacks()2073 status_t CameraContext::enablePreviewCallbacks()
2074 {
2075     useLock();
2076     if ( mHardwareActive ) {
2077         mCamera->setPreviewCallbackFlags(
2078             CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
2079     }
2080 
2081     signalFinished();
2082     return NO_ERROR;
2083 }
2084 
2085 /*===========================================================================
2086  * FUNCTION   : takePicture
2087  *
2088  * DESCRIPTION: triggers image capture
2089  *
2090  * PARAMETERS : None
2091  *
2092  * RETURN     : status_t type of status
2093  *              NO_ERROR  -- success
2094  *              none-zero failure code
2095  *==========================================================================*/
takePicture()2096 status_t CameraContext::takePicture()
2097 {
2098     status_t ret = NO_ERROR;
2099     useLock();
2100     if ( mPreviewRunning ) {
2101         ret = mCamera->takePicture(
2102             CAMERA_MSG_COMPRESSED_IMAGE|
2103             CAMERA_MSG_RAW_IMAGE);
2104         if (!mRecordingHint && !mInterpr->mIsZSLOn) {
2105             mPreviewRunning = false;
2106         }
2107     } else {
2108         printf("Please resume/start the preview before taking a picture!\n");
2109     }
2110     signalFinished();
2111     return ret;
2112 }
2113 
2114 /*===========================================================================
2115  * FUNCTION   : configureRecorder
2116  *
2117  * DESCRIPTION: Configure video recorder
2118  *
2119  * PARAMETERS : None
2120  *
2121  * RETURN     : status_t type of status
2122  *              NO_ERROR  -- success
2123  *              none-zero failure code
2124  *==========================================================================*/
configureRecorder()2125 status_t CameraContext::configureRecorder()
2126 {
2127     useLock();
2128     status_t ret = NO_ERROR;
2129 
2130     mResizePreview = true;
2131     mParams.set("recording-hint", "true");
2132     mRecordingHint = true;
2133     mCamera->setParameters(mParams.flatten());
2134 
2135     Size videoSize = mSupportedVideoSizes.itemAt(mCurrentVideoSizeIdx);
2136     ret = mRecorder->setParameters(
2137         String8("video-param-encoding-bitrate=64000"));
2138     if ( ret != NO_ERROR ) {
2139         LOGE("Could not configure recorder (%d)", ret);
2140         return ret;
2141     }
2142 
2143     ret = mRecorder->setCamera(
2144         mCamera->remote(), mCamera->getRecordingProxy());
2145     if ( ret != NO_ERROR ) {
2146         LOGE("Could not set camera (%d)", ret);
2147         return ret;
2148     }
2149     ret = mRecorder->setVideoSource(VIDEO_SOURCE_CAMERA);
2150     if ( ret != NO_ERROR ) {
2151         LOGE("Could not set video soruce (%d)", ret);
2152         return ret;
2153     }
2154     ret = mRecorder->setAudioSource(AUDIO_SOURCE_DEFAULT);
2155     if ( ret != NO_ERROR ) {
2156         LOGE("Could not set audio source (%d)", ret);
2157         return ret;
2158     }
2159     ret = mRecorder->setOutputFormat(OUTPUT_FORMAT_DEFAULT);
2160     if ( ret != NO_ERROR ) {
2161         LOGE("Could not set output format (%d)", ret);
2162         return ret;
2163     }
2164 
2165     ret = mRecorder->setVideoEncoder(VIDEO_ENCODER_DEFAULT);
2166     if ( ret != NO_ERROR ) {
2167         LOGE("Could not set video encoder (%d)", ret);
2168         return ret;
2169     }
2170 
2171     char fileName[100];
2172 
2173     snprintf(fileName, sizeof(fileName) / sizeof(char),
2174             "/sdcard/vid_cam%d_%dx%d_%d.mpeg", mCameraIndex,
2175             videoSize.width, videoSize.height, mVideoIdx++);
2176 
2177     if ( mVideoFd < 0 ) {
2178         mVideoFd = open(fileName, O_CREAT | O_RDWR );
2179     }
2180 
2181     if ( mVideoFd < 0 ) {
2182         LOGE("Could not open video file for writing %s!", fileName);
2183         return UNKNOWN_ERROR;
2184     }
2185 
2186     ret = mRecorder->setOutputFile(mVideoFd, 0, 0);
2187     if ( ret != NO_ERROR ) {
2188         LOGE("Could not set output file (%d)", ret);
2189         return ret;
2190     }
2191 
2192     ret = mRecorder->setVideoSize(videoSize.width, videoSize.height);
2193     if ( ret  != NO_ERROR ) {
2194         LOGE("Could not set video size %dx%d", videoSize.width,
2195             videoSize.height);
2196         return ret;
2197     }
2198 
2199     ret = mRecorder->setVideoFrameRate(30);
2200     if ( ret != NO_ERROR ) {
2201         LOGE("Could not set video frame rate (%d)", ret);
2202         return ret;
2203     }
2204 
2205     ret = mRecorder->setAudioEncoder(AUDIO_ENCODER_DEFAULT);
2206     if ( ret != NO_ERROR ) {
2207         LOGE("Could not set audio encoder (%d)", ret);
2208         return ret;
2209     }
2210 
2211     signalFinished();
2212     return ret;
2213 }
2214 
2215 /*===========================================================================
2216  * FUNCTION   : unconfigureViVRecording
2217  *
2218  * DESCRIPTION: Unconfigures video in video recording
2219  *
2220  * PARAMETERS : None
2221  *
2222  * RETURN     : status_t type of status
2223  *              NO_ERROR  -- success
2224  *              none-zero failure code
2225  *==========================================================================*/
unconfigureRecorder()2226 status_t CameraContext::unconfigureRecorder()
2227 {
2228     useLock();
2229 
2230     if ( !mRecordRunning ) {
2231         mResizePreview = true;
2232         mParams.set("recording-hint", "false");
2233         mRecordingHint = false;
2234         mCamera->setParameters(mParams.flatten());
2235     }
2236 
2237     signalFinished();
2238     return NO_ERROR;
2239 }
2240 
2241 /*===========================================================================
2242  * FUNCTION   : configureViVRecording
2243  *
2244  * DESCRIPTION: Configures video in video recording
2245  *
2246  * PARAMETERS : None
2247  *
2248  * RETURN     : status_t type of status
2249  *              NO_ERROR  -- success
2250  *              none-zero failure code
2251  *==========================================================================*/
configureViVRecording()2252 status_t CameraContext::configureViVRecording()
2253 {
2254     status_t ret = NO_ERROR;
2255 
2256     mResizePreview = true;
2257     mParams.set("recording-hint", "true");
2258     mRecordingHint = true;
2259     mCamera->setParameters(mParams.flatten());
2260     mCamera->setRecordingProxyListener(this);
2261 
2262     signalFinished();
2263     return ret;
2264 }
2265 
2266 /*===========================================================================
2267  * FUNCTION   : startRecording
2268  *
2269  * DESCRIPTION: triggers start recording
2270  *
2271  * PARAMETERS : None
2272  *
2273  * RETURN     : status_t type of status
2274  *              NO_ERROR  -- success
2275  *              none-zero failure code
2276  *==========================================================================*/
startRecording()2277 status_t CameraContext::startRecording()
2278 {
2279     useLock();
2280     status_t ret = NO_ERROR;
2281 
2282 
2283     if ( mPreviewRunning ) {
2284 
2285         mCamera->unlock();
2286 
2287         ret = mRecorder->prepare();
2288         if ( ret != NO_ERROR ) {
2289             LOGE("Could not prepare recorder");
2290             return ret;
2291         }
2292 
2293         ret = mRecorder->start();
2294         if ( ret != NO_ERROR ) {
2295             LOGE("Could not start recorder");
2296             return ret;
2297         }
2298 
2299         mRecordRunning = true;
2300     }
2301     signalFinished();
2302     return ret;
2303 }
2304 
2305 /*===========================================================================
2306  * FUNCTION   : stopRecording
2307  *
2308  * DESCRIPTION: triggers start recording
2309  *
2310  * PARAMETERS : None
2311  *
2312  * RETURN     : status_t type of status
2313  *              NO_ERROR  -- success
2314  *              none-zero failure code
2315  *==========================================================================*/
stopRecording()2316 status_t CameraContext::stopRecording()
2317 {
2318     useLock();
2319     status_t ret = NO_ERROR;
2320 
2321     if ( mRecordRunning ) {
2322             mRecorder->stop();
2323             close(mVideoFd);
2324             mVideoFd = -1;
2325 
2326         mRecordRunning = false;
2327     }
2328 
2329     signalFinished();
2330 
2331     return ret;
2332 }
2333 
2334 /*===========================================================================
2335  * FUNCTION   : startViVRecording
2336  *
2337  * DESCRIPTION: Starts video in video recording
2338  *
2339  * PARAMETERS : None
2340  *
2341  * RETURN     : status_t type of status
2342  *              NO_ERROR  -- success
2343  *              none-zero failure code
2344  *==========================================================================*/
startViVRecording()2345 status_t CameraContext::startViVRecording()
2346 {
2347     useLock();
2348     status_t ret;
2349 
2350     if (mInterpr->mViVVid.VideoSizes[0].width *
2351             mInterpr->mViVVid.VideoSizes[0].height >=
2352             mInterpr->mViVVid.VideoSizes[1].width *
2353             mInterpr->mViVVid.VideoSizes[1].height) {
2354         mInterpr->mViVBuff.buffSize = calcBufferSize(
2355             mInterpr->mViVVid.VideoSizes[1].width,
2356             mInterpr->mViVVid.VideoSizes[1].height);
2357         if (mInterpr->mViVBuff.buff == NULL) {
2358             mInterpr->mViVBuff.buff =
2359                 (void *)malloc(mInterpr->mViVBuff.buffSize);
2360         }
2361         mInterpr->mViVVid.sourceCameraID = 1;
2362         mInterpr->mViVVid.destinationCameraID = 0;
2363 
2364     } else {
2365         mInterpr->mViVBuff.buffSize = calcBufferSize(
2366             mInterpr->mViVVid.VideoSizes[0].width,
2367             mInterpr->mViVVid.VideoSizes[0].height);
2368         if (mInterpr->mViVBuff.buff == NULL) {
2369             mInterpr->mViVBuff.buff =
2370                 (void *)malloc(mInterpr->mViVBuff.buffSize);
2371         }
2372         mInterpr->mViVVid.sourceCameraID = 0;
2373         mInterpr->mViVVid.destinationCameraID = 1;
2374     }
2375 
2376     ret = mCamera->startRecording();
2377 
2378     signalFinished();
2379     return ret;
2380 }
2381 
2382 /*===========================================================================
2383  * FUNCTION   : stopViVRecording
2384  *
2385  * DESCRIPTION: Stops video in video recording
2386  *
2387  * PARAMETERS : None
2388  *
2389  * RETURN     : status_t type of status
2390  *              NO_ERROR  -- success
2391  *              none-zero failure code
2392  *==========================================================================*/
stopViVRecording()2393 status_t CameraContext::stopViVRecording()
2394 {
2395     useLock();
2396     status_t ret = NO_ERROR;
2397 
2398     mCamera->stopRecording();
2399 
2400     signalFinished();
2401     return ret;
2402 }
2403 
2404 /*===========================================================================
2405  * FUNCTION   : stopPreview
2406  *
2407  * DESCRIPTION: stops camera preview
2408  *
2409  * PARAMETERS : None
2410  *
2411  * RETURN     : status_t type of status
2412  *              NO_ERROR  -- success
2413  *              none-zero failure code
2414  *==========================================================================*/
stopPreview()2415 status_t CameraContext::stopPreview()
2416 {
2417     useLock();
2418     status_t ret = NO_ERROR;
2419 
2420     if ( mHardwareActive ) {
2421         mCamera->stopPreview();
2422         ret = destroyPreviewSurface();
2423     }
2424 
2425     mPreviewRunning  = false;
2426     mResizePreview = true;
2427 
2428     signalFinished();
2429 
2430     return ret;
2431 }
2432 
2433 /*===========================================================================
2434  * FUNCTION   : resumePreview
2435  *
2436  * DESCRIPTION: resumes camera preview after image capture
2437  *
2438  * PARAMETERS : None
2439  *
2440  * RETURN     : status_t type of status
2441  *              NO_ERROR  -- success
2442  *              none-zero failure code
2443  *==========================================================================*/
resumePreview()2444 status_t CameraContext::resumePreview()
2445 {
2446     useLock();
2447     status_t ret = NO_ERROR;
2448 
2449     if ( mHardwareActive ) {
2450         ret = mCamera->startPreview();
2451         mPreviewRunning = true;
2452     } else {
2453         ret = NO_INIT;
2454     }
2455 
2456     signalFinished();
2457     return ret;
2458 }
2459 
2460 /*===========================================================================
2461  * FUNCTION   : nextPreviewSize
2462  *
2463  * DESCRIPTION: Iterates through all supported preview sizes.
2464  *
2465  * PARAMETERS : None
2466  *
2467  * RETURN     : status_t type of status
2468  *              NO_ERROR  -- success
2469  *              none-zero failure code
2470  *==========================================================================*/
nextPreviewSize()2471 status_t CameraContext::nextPreviewSize()
2472 {
2473     useLock();
2474     if ( mHardwareActive ) {
2475         mCurrentPreviewSizeIdx += 1;
2476         mCurrentPreviewSizeIdx %= mSupportedPreviewSizes.size();
2477         Size previewSize = mSupportedPreviewSizes.itemAt(
2478             mCurrentPreviewSizeIdx);
2479         mParams.setPreviewSize(previewSize.width,
2480                                previewSize.height);
2481         mResizePreview = true;
2482 
2483         if ( mPreviewRunning ) {
2484             mCamera->stopPreview();
2485             mCamera->setParameters(mParams.flatten());
2486             mCamera->startPreview();
2487         } else {
2488             mCamera->setParameters(mParams.flatten());
2489         }
2490     }
2491 
2492     signalFinished();
2493     return NO_ERROR;
2494 }
2495 
2496 
2497 /*===========================================================================
2498  * FUNCTION   : setPreviewSize
2499  *
2500  * DESCRIPTION: Sets exact preview size if supported
2501  *
2502  * PARAMETERS : format size in the form of WIDTHxHEIGHT
2503  *
2504  * RETURN     : status_t type of status
2505  *              NO_ERROR  -- success
2506  *              none-zero failure code
2507  *==========================================================================*/
setPreviewSize(const char * format)2508 status_t CameraContext::setPreviewSize(const char *format)
2509 {
2510     useLock();
2511     if ( mHardwareActive ) {
2512         int newHeight;
2513         int newWidth;
2514         sscanf(format, "%dx%d", &newWidth, &newHeight);
2515 
2516         unsigned int i;
2517         for (i = 0; i < mSupportedPreviewSizes.size(); ++i) {
2518             Size previewSize = mSupportedPreviewSizes.itemAt(i);
2519             if ( newWidth == previewSize.width &&
2520                  newHeight == previewSize.height )
2521             {
2522                 break;
2523             }
2524 
2525         }
2526         if ( i == mSupportedPreviewSizes.size())
2527         {
2528             printf("Preview size %dx%d not supported !\n",
2529                 newWidth, newHeight);
2530             return INVALID_OPERATION;
2531         }
2532 
2533         mParams.setPreviewSize(newWidth,
2534                                newHeight);
2535         mResizePreview = true;
2536 
2537         if ( mPreviewRunning ) {
2538             mCamera->stopPreview();
2539             mCamera->setParameters(mParams.flatten());
2540             mCamera->startPreview();
2541         } else {
2542             mCamera->setParameters(mParams.flatten());
2543         }
2544     }
2545 
2546     signalFinished();
2547     return NO_ERROR;
2548 }
2549 
2550 /*===========================================================================
2551  * FUNCTION   : getCurrentPreviewSize
2552  *
2553  * DESCRIPTION: queries the currently configured preview size
2554  *
2555  * PARAMETERS :
2556  *  @previewSize : preview size currently configured
2557  *
2558  * RETURN     : status_t type of status
2559  *              NO_ERROR  -- success
2560  *              none-zero failure code
2561  *==========================================================================*/
getCurrentPreviewSize(Size & previewSize)2562 status_t CameraContext::getCurrentPreviewSize(Size &previewSize)
2563 {
2564     useLock();
2565     if ( mHardwareActive ) {
2566         previewSize = mSupportedPreviewSizes.itemAt(mCurrentPreviewSizeIdx);
2567     }
2568     signalFinished();
2569     return NO_ERROR;
2570 }
2571 
2572 /*===========================================================================
2573  * FUNCTION   : nextPictureSize
2574  *
2575  * DESCRIPTION: Iterates through all supported picture sizes.
2576  *
2577  * PARAMETERS : None
2578  *
2579  * RETURN     : status_t type of status
2580  *              NO_ERROR  -- success
2581  *              none-zero failure code
2582  *==========================================================================*/
nextPictureSize()2583 status_t CameraContext::nextPictureSize()
2584 {
2585     useLock();
2586     if ( mHardwareActive ) {
2587         mCurrentPictureSizeIdx += 1;
2588         mCurrentPictureSizeIdx %= mSupportedPictureSizes.size();
2589         Size pictureSize = mSupportedPictureSizes.itemAt(
2590             mCurrentPictureSizeIdx);
2591         mParams.setPictureSize(pictureSize.width,
2592             pictureSize.height);
2593         mCamera->setParameters(mParams.flatten());
2594     }
2595     signalFinished();
2596     return NO_ERROR;
2597 }
2598 
2599 /*===========================================================================
2600  * FUNCTION   : setPictureSize
2601  *
2602  * DESCRIPTION: Sets exact preview size if supported
2603  *
2604  * PARAMETERS : format size in the form of WIDTHxHEIGHT
2605  *
2606  * RETURN     : status_t type of status
2607  *              NO_ERROR  -- success
2608  *              none-zero failure code
2609  *==========================================================================*/
setPictureSize(const char * format)2610 status_t CameraContext::setPictureSize(const char *format)
2611 {
2612     useLock();
2613     if ( mHardwareActive ) {
2614         int newHeight;
2615         int newWidth;
2616         sscanf(format, "%dx%d", &newWidth, &newHeight);
2617 
2618         unsigned int i;
2619         for (i = 0; i < mSupportedPictureSizes.size(); ++i) {
2620             Size PictureSize = mSupportedPictureSizes.itemAt(i);
2621             if ( newWidth == PictureSize.width &&
2622                  newHeight == PictureSize.height )
2623             {
2624                 break;
2625             }
2626 
2627         }
2628         if ( i == mSupportedPictureSizes.size())
2629         {
2630             printf("Preview size %dx%d not supported !\n",
2631                 newWidth, newHeight);
2632             return INVALID_OPERATION;
2633         }
2634 
2635         mParams.setPictureSize(newWidth,
2636                                newHeight);
2637         mCamera->setParameters(mParams.flatten());
2638     }
2639 
2640     signalFinished();
2641     return NO_ERROR;
2642 }
2643 
2644 /*===========================================================================
2645  * FUNCTION   : nextVideoSize
2646  *
2647  * DESCRIPTION: Select the next available video size
2648  *
2649  * PARAMETERS : none
2650  *
2651  * RETURN     : status_t type of status
2652  *              NO_ERROR  -- success
2653  *              none-zero failure code
2654  *==========================================================================*/
nextVideoSize()2655 status_t CameraContext::nextVideoSize()
2656 {
2657     useLock();
2658     if ( mHardwareActive ) {
2659         mCurrentVideoSizeIdx += 1;
2660         mCurrentVideoSizeIdx %= mSupportedVideoSizes.size();
2661         Size videoSize = mSupportedVideoSizes.itemAt(mCurrentVideoSizeIdx);
2662         mParams.setVideoSize(videoSize.width,
2663                              videoSize.height);
2664         mCamera->setParameters(mParams.flatten());
2665         mInterpr->setViVSize((Size) mSupportedVideoSizes.itemAt(
2666             mCurrentVideoSizeIdx), mCameraIndex);
2667     }
2668     signalFinished();
2669     return NO_ERROR;
2670 }
2671 
2672 /*===========================================================================
2673  * FUNCTION   : setVideoSize
2674  *
2675  * DESCRIPTION: Set video size
2676  *
2677  * PARAMETERS :
2678  *   @format  : format
2679  *
2680  * RETURN     : status_t type of status
2681  *              NO_ERROR  -- success
2682  *              none-zero failure code
2683  *==========================================================================*/
setVideoSize(const char * format)2684 status_t CameraContext::setVideoSize(const char *format)
2685 {
2686     useLock();
2687     if ( mHardwareActive ) {
2688         int newHeight;
2689         int newWidth;
2690         sscanf(format, "%dx%d", &newWidth, &newHeight);
2691 
2692         unsigned int i;
2693         for (i = 0; i < mSupportedVideoSizes.size(); ++i) {
2694             Size PictureSize = mSupportedVideoSizes.itemAt(i);
2695             if ( newWidth == PictureSize.width &&
2696                  newHeight == PictureSize.height )
2697             {
2698                 break;
2699             }
2700 
2701         }
2702         if ( i == mSupportedVideoSizes.size())
2703         {
2704             printf("Preview size %dx%d not supported !\n",
2705                 newWidth, newHeight);
2706             return INVALID_OPERATION;
2707         }
2708 
2709         mParams.setVideoSize(newWidth,
2710                              newHeight);
2711         mCamera->setParameters(mParams.flatten());
2712     }
2713 
2714     signalFinished();
2715     return NO_ERROR;
2716 }
2717 
2718 /*===========================================================================
2719  * FUNCTION    : getCurrentVideoSize
2720  *
2721  * DESCRIPTION : Get current video size
2722  *
2723  * PARAMETERS  :
2724  *   @videoSize: video Size
2725  *
2726  * RETURN      : status_t type of status
2727  *               NO_ERROR  -- success
2728  *               none-zero failure code
2729  *==========================================================================*/
getCurrentVideoSize(Size & videoSize)2730 status_t CameraContext::getCurrentVideoSize(Size &videoSize)
2731 {
2732     useLock();
2733     if ( mHardwareActive ) {
2734         videoSize = mSupportedVideoSizes.itemAt(mCurrentVideoSizeIdx);
2735     }
2736     signalFinished();
2737     return NO_ERROR;
2738 }
2739 
2740 /*===========================================================================
2741  * FUNCTION   : getCurrentPictureSize
2742  *
2743  * DESCRIPTION: queries the currently configured picture size
2744  *
2745  * PARAMETERS :
2746  *  @pictureSize : picture size currently configured
2747  *
2748  * RETURN     : status_t type of status
2749  *              NO_ERROR  -- success
2750  *              none-zero failure code
2751  *==========================================================================*/
getCurrentPictureSize(Size & pictureSize)2752 status_t CameraContext::getCurrentPictureSize(Size &pictureSize)
2753 {
2754     useLock();
2755     if ( mHardwareActive ) {
2756         pictureSize = mSupportedPictureSizes.itemAt(mCurrentPictureSizeIdx);
2757     }
2758     signalFinished();
2759     return NO_ERROR;
2760 }
2761 
2762 }; //namespace qcamera ends here
2763 
2764 using namespace qcamera;
2765 
2766 /*===========================================================================
2767  * FUNCTION   : printMenu
2768  *
2769  * DESCRIPTION: prints the available camera options
2770  *
2771  * PARAMETERS :
2772  *  @currentCamera : camera context currently being used
2773  *
2774  * RETURN     : None
2775  *==========================================================================*/
printMenu(sp<CameraContext> currentCamera)2776 void CameraContext::printMenu(sp<CameraContext> currentCamera)
2777 {
2778     if ( !mDoPrintMenu ) return;
2779     Size currentPictureSize, currentPreviewSize, currentVideoSize;
2780     const char *zsl_mode = mParams.get(CameraContext::KEY_ZSL);
2781 
2782     assert(currentCamera.get());
2783 
2784     currentCamera->getCurrentPictureSize(currentPictureSize);
2785     currentCamera->getCurrentPreviewSize(currentPreviewSize);
2786     currentCamera->getCurrentVideoSize(currentVideoSize);
2787 
2788     printf("\n\n=========== FUNCTIONAL TEST MENU ===================\n\n");
2789 
2790     printf(" \n\nSTART / STOP / GENERAL SERVICES \n");
2791     printf(" -----------------------------\n");
2792     printf("   %c. Switch camera - Current Index: %d\n",
2793             Interpreter::SWITCH_CAMERA_CMD,
2794             currentCamera->getCameraIndex());
2795     printf("   %c. Resume Preview after capture \n",
2796             Interpreter::RESUME_PREVIEW_CMD);
2797     printf("   %c. Quit \n",
2798             Interpreter::EXIT_CMD);
2799     printf("   %c. Camera Capability Dump",
2800             Interpreter::DUMP_CAPS_CMD);
2801 
2802     printf(" \n\n PREVIEW SUB MENU \n");
2803     printf(" -----------------------------\n");
2804     printf("   %c. Start Preview\n",
2805             Interpreter::START_PREVIEW_CMD);
2806     printf("   %c. Stop Preview\n",
2807             Interpreter::STOP_PREVIEW_CMD);
2808     printf("   %c. Preview size:  %dx%d\n",
2809             Interpreter::CHANGE_PREVIEW_SIZE_CMD,
2810             currentPreviewSize.width,
2811             currentPreviewSize.height);
2812     printf("   %c. Video size:  %dx%d\n",
2813             Interpreter::CHANGE_VIDEO_SIZE_CMD,
2814             currentVideoSize.width,
2815             currentVideoSize.height);
2816     printf("   %c. Start Recording\n",
2817             Interpreter::START_RECORD_CMD);
2818     printf("   %c. Stop Recording\n",
2819             Interpreter::STOP_RECORD_CMD);
2820     printf("   %c. Start ViV Recording\n",
2821             Interpreter::START_VIV_RECORD_CMD);
2822     printf("   %c. Stop ViV Recording\n",
2823             Interpreter::STOP_VIV_RECORD_CMD);
2824     printf("   %c. Enable preview frames\n",
2825             Interpreter::ENABLE_PRV_CALLBACKS_CMD);
2826     printf("   %c. Trigger autofocus \n",
2827             Interpreter::AUTOFOCUS_CMD);
2828 
2829     printf(" \n\n IMAGE CAPTURE SUB MENU \n");
2830     printf(" -----------------------------\n");
2831     printf("   %c. Take picture/Full Press\n",
2832             Interpreter::TAKEPICTURE_CMD);
2833     printf("   %c. Take picture in picture\n",
2834             Interpreter::TAKEPICTURE_IN_PICTURE_CMD);
2835     printf("   %c. Picture size:  %dx%d\n",
2836             Interpreter::CHANGE_PICTURE_SIZE_CMD,
2837             currentPictureSize.width,
2838             currentPictureSize.height);
2839     printf("   %c. zsl:  %s\n", Interpreter::ZSL_CMD,
2840         (zsl_mode != NULL) ? zsl_mode : "NULL");
2841 
2842     printf("\n   Choice: ");
2843 }
2844 
2845 /*===========================================================================
2846  * FUNCTION   : enablePrintPreview
2847  *
2848  * DESCRIPTION: Enables printing the preview
2849  *
2850  * PARAMETERS : None
2851  *
2852  * RETURN     : None
2853  *==========================================================================*/
enablePrintPreview()2854 void CameraContext::enablePrintPreview()
2855 {
2856     mDoPrintMenu = true;
2857 }
2858 
2859 /*===========================================================================
2860  * FUNCTION   : disablePrintPreview
2861  *
2862  * DESCRIPTION: Disables printing the preview
2863  *
2864  * PARAMETERS : None
2865  *
2866  * RETURN     : None
2867  *==========================================================================*/
disablePrintPreview()2868 void CameraContext::disablePrintPreview()
2869 {
2870     mDoPrintMenu = false;
2871 }
2872 
2873 /*===========================================================================
2874  * FUNCTION   : enablePiPCapture
2875  *
2876  * DESCRIPTION: Enables picture in picture capture
2877  *
2878  * PARAMETERS : None
2879  *
2880  * RETURN     : None
2881  *==========================================================================*/
enablePiPCapture()2882 void CameraContext::enablePiPCapture()
2883 {
2884     mPiPCapture = true;
2885 }
2886 
2887 /*===========================================================================
2888  * FUNCTION   : disablePiPCapture
2889  *
2890  * DESCRIPTION: Disables picture in picture capture
2891  *
2892  * PARAMETERS : None
2893  *
2894  * RETURN     : None
2895  *==========================================================================*/
disablePiPCapture()2896 void CameraContext::disablePiPCapture()
2897 {
2898     mPiPCapture = false;
2899 }
2900 
2901 /*===========================================================================
2902  * FUNCTION   : getZSL
2903  *
2904  * DESCRIPTION: get ZSL value of current camera
2905  *
2906  * PARAMETERS : None
2907  *
2908  * RETURN     : current zsl value
2909  *==========================================================================*/
getZSL()2910 const char *CameraContext::getZSL()
2911 {
2912     return mParams.get(CameraContext::KEY_ZSL);
2913 }
2914 
2915 /*===========================================================================
2916  * FUNCTION   : setZSL
2917  *
2918  * DESCRIPTION: set ZSL value of current camera
2919  *
2920  * PARAMETERS : zsl value to be set
2921  *
2922  * RETURN     : None
2923  *==========================================================================*/
setZSL(const char * value)2924 void CameraContext::setZSL(const char *value)
2925 {
2926     mParams.set(CameraContext::KEY_ZSL, value);
2927     mCamera->setParameters(mParams.flatten());
2928 }
2929 
2930 /*===========================================================================
2931  * FUNCTION   : configureViVCodec
2932  *
2933  * DESCRIPTION: Configures video in video codec
2934  *
2935  * PARAMETERS : none
2936  *
2937  * RETURN     : status_t type of status
2938  *              NO_ERROR  -- success
2939  *              none-zero failure code
2940  *==========================================================================*/
configureViVCodec()2941 status_t Interpreter::configureViVCodec()
2942 {
2943     status_t ret = NO_ERROR;
2944     char fileName[100];
2945     sp<AMessage> format = new AMessage;
2946     sp<ALooper> looper = new ALooper;
2947 
2948     if (mTestContext->mViVVid.VideoSizes[0].width *
2949             mTestContext->mViVVid.VideoSizes[0].height >=
2950             mTestContext->mViVVid.VideoSizes[1].width *
2951             mTestContext->mViVVid.VideoSizes[1].height) {
2952         snprintf(fileName, sizeof(fileName) / sizeof(char), "/sdcard/ViV_vid_%dx%d_%d.mp4",
2953             mTestContext->mViVVid.VideoSizes[0].width,
2954             mTestContext->mViVVid.VideoSizes[0].height,
2955             mTestContext->mViVVid.ViVIdx++);
2956         format->setInt32("width", mTestContext->mViVVid.VideoSizes[0].width);
2957         format->setInt32("height", mTestContext->mViVVid.VideoSizes[0].height);
2958     } else {
2959         snprintf(fileName, sizeof(fileName) / sizeof(char), "/sdcard/ViV_vid_%dx%d_%d.mp4",
2960             mTestContext->mViVVid.VideoSizes[1].width,
2961             mTestContext->mViVVid.VideoSizes[1].height,
2962             mTestContext->mViVVid.ViVIdx++);
2963         format->setInt32("width", mTestContext->mViVVid.VideoSizes[1].width);
2964         format->setInt32("height", mTestContext->mViVVid.VideoSizes[1].height);
2965     }
2966     int fd = open(fileName, O_CREAT | O_RDWR );
2967     if (fd < 0) {
2968         LOGE("Error opening file");
2969         return UNKNOWN_ERROR;
2970     }
2971     mTestContext->mViVVid.muxer = new MediaMuxer(
2972         fd, MediaMuxer::OUTPUT_FORMAT_MPEG_4);
2973 
2974     format->setString("mime", "video/avc");
2975     format->setInt32("color-format", OMX_COLOR_FormatAndroidOpaque);
2976 
2977     format->setInt32("bitrate", 1000000);
2978     format->setFloat("frame-rate", 30);
2979     format->setInt32("i-frame-interval", 10);
2980 
2981     looper->setName("ViV_recording_looper");
2982     looper->start();
2983     ALOGV("Creating codec");
2984     mTestContext->mViVVid.codec = MediaCodec::CreateByType(
2985         looper, "video/avc", true);
2986     if (mTestContext->mViVVid.codec == NULL) {
2987         fprintf(stderr, "ERROR: unable to create video/avc codec instance\n");
2988         return UNKNOWN_ERROR;
2989     }
2990     ret = mTestContext->mViVVid.codec->configure(format, NULL, NULL,
2991             MediaCodec::CONFIGURE_FLAG_ENCODE);
2992     if (ret != NO_ERROR) {
2993         mTestContext->mViVVid.codec->release();
2994         mTestContext->mViVVid.codec.clear();
2995 
2996         fprintf(stderr, "ERROR: unable to configure codec (err=%d)\n", ret);
2997         return ret;
2998     }
2999 
3000     ALOGV("Creating buffer producer");
3001     ret = mTestContext->mViVVid.codec->createInputSurface(
3002         &mTestContext->mViVVid.bufferProducer);
3003     if (ret != NO_ERROR) {
3004         mTestContext->mViVVid.codec->release();
3005         mTestContext->mViVVid.codec.clear();
3006 
3007         fprintf(stderr,
3008             "ERROR: unable to create encoder input surface (err=%d)\n", ret);
3009         return ret;
3010     }
3011 
3012     ret = mTestContext->mViVVid.codec->start();
3013     if (ret != NO_ERROR) {
3014         mTestContext->mViVVid.codec->release();
3015         mTestContext->mViVVid.codec.clear();
3016 
3017         fprintf(stderr, "ERROR: unable to start codec (err=%d)\n", ret);
3018         return ret;
3019     }
3020     ALOGV("Codec prepared");
3021 
3022     mTestContext->mViVVid.surface = new Surface(
3023         mTestContext->mViVVid.bufferProducer);
3024     mTestContext->mViVVid.ANW = mTestContext->mViVVid.surface;
3025     ret = native_window_api_connect(mTestContext->mViVVid.ANW.get(),
3026         NATIVE_WINDOW_API_CPU);
3027     if (mTestContext->mViVVid.VideoSizes[0].width *
3028         mTestContext->mViVVid.VideoSizes[0].height >=
3029         mTestContext->mViVVid.VideoSizes[1].width *
3030         mTestContext->mViVVid.VideoSizes[1].height) {
3031         native_window_set_buffers_format(mTestContext->mViVVid.ANW.get(),
3032                 HAL_PIXEL_FORMAT_NV12_ENCODEABLE);
3033         native_window_set_buffers_dimensions(mTestContext->mViVVid.ANW.get(),
3034                 mTestContext->mViVVid.VideoSizes[0].width,
3035                 mTestContext->mViVVid.VideoSizes[0].height);
3036     } else {
3037         native_window_set_buffers_format(mTestContext->mViVVid.ANW.get(),
3038                 HAL_PIXEL_FORMAT_NV12_ENCODEABLE);
3039         native_window_set_buffers_dimensions(mTestContext->mViVVid.ANW.get(),
3040                 mTestContext->mViVVid.VideoSizes[1].width,
3041                 mTestContext->mViVVid.VideoSizes[1].height);
3042     }
3043     native_window_set_usage(mTestContext->mViVVid.ANW.get(),
3044         GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
3045     native_window_set_buffer_count(mTestContext->mViVVid.ANW.get(),
3046         mTestContext->mViVVid.buff_cnt);
3047 
3048     ViVEncoderThread();
3049 
3050     return ret;
3051 }
3052 
3053 /*===========================================================================
3054  * FUNCTION   : unconfigureViVCodec
3055  *
3056  * DESCRIPTION: Unconfigures video in video codec
3057  *
3058  * PARAMETERS : none
3059  *
3060  * RETURN     : status_t type of status
3061  *              NO_ERROR  -- success
3062  *              none-zero failure code
3063  *==========================================================================*/
unconfigureViVCodec()3064 status_t Interpreter::unconfigureViVCodec()
3065 {
3066     status_t ret = NO_ERROR;
3067 
3068     ret = native_window_api_disconnect(mTestContext->mViVVid.ANW.get(),
3069         NATIVE_WINDOW_API_CPU);
3070     mTestContext->mViVVid.bufferProducer = NULL;
3071     mTestContext->mViVVid.codec->stop();
3072     pthread_join(mViVEncThread, NULL);
3073     mTestContext->mViVVid.muxer->stop();
3074     mTestContext->mViVVid.codec->release();
3075     mTestContext->mViVVid.codec.clear();
3076     mTestContext->mViVVid.muxer.clear();
3077     mTestContext->mViVVid.surface.clear();
3078   return ret;
3079 }
3080 
3081 /*===========================================================================
3082  * FUNCTION   : Interpreter
3083  *
3084  * DESCRIPTION: Interpreter constructor
3085  *
3086  * PARAMETERS : none
3087  *
3088  * RETURN     : none
3089  *==========================================================================*/
Interpreter(const char * file)3090 Interpreter::Interpreter(const char *file)
3091     : mCmdIndex(0)
3092     , mScript(NULL)
3093 {
3094     if (!file){
3095         printf("no File Given\n");
3096         mUseScript = false;
3097         return;
3098     }
3099 
3100     FILE *fh = fopen(file, "r");
3101     if ( !fh ) {
3102         printf("Could not open file %s\n", file);
3103         mUseScript = false;
3104         return;
3105     }
3106 
3107     fseek(fh, 0, SEEK_END);
3108     size_t len = (size_t)ftell(fh);
3109     rewind(fh);
3110 
3111     if( !len ) {
3112         printf("Script file %s is empty !\n", file);
3113         fclose(fh);
3114         return;
3115     }
3116 
3117     mScript = new char[len + 1];
3118     if ( !mScript ) {
3119         fclose(fh);
3120         return;
3121     }
3122 
3123     fread(mScript, sizeof(char), len, fh);
3124     mScript[len] = '\0'; // ensure null terminated;
3125     fclose(fh);
3126 
3127 
3128     char *p1;
3129     char *p2;
3130     p1 = p2 = mScript;
3131 
3132     do {
3133         switch (*p1) {
3134         case '\0':
3135         case '|':
3136             p1++;
3137             break;
3138         case SWITCH_CAMERA_CMD:
3139         case RESUME_PREVIEW_CMD:
3140         case START_PREVIEW_CMD:
3141         case STOP_PREVIEW_CMD:
3142         case CHANGE_PREVIEW_SIZE_CMD:
3143         case CHANGE_PICTURE_SIZE_CMD:
3144         case START_RECORD_CMD:
3145         case STOP_RECORD_CMD:
3146         case START_VIV_RECORD_CMD:
3147         case STOP_VIV_RECORD_CMD:
3148         case DUMP_CAPS_CMD:
3149         case AUTOFOCUS_CMD:
3150         case TAKEPICTURE_CMD:
3151         case TAKEPICTURE_IN_PICTURE_CMD:
3152         case ENABLE_PRV_CALLBACKS_CMD:
3153         case EXIT_CMD:
3154         case ZSL_CMD:
3155         case DELAY:
3156             p2 = p1;
3157             while( (p2 != (mScript + len)) && (*p2 != '|')) {
3158                 p2++;
3159             }
3160             *p2 = '\0';
3161             if (p2 == (p1 + 1))
3162                 mCommands.push_back(Command(
3163                     static_cast<Interpreter::Commands_e>(*p1)));
3164             else
3165                 mCommands.push_back(Command(
3166                     static_cast<Interpreter::Commands_e>(*p1), (p1 + 1)));
3167             p1 = p2;
3168             break;
3169         default:
3170             printf("Invalid cmd %c \n", *p1);
3171             do {
3172                 p1++;
3173 
3174             } while(*p1 != '|' && p1 != (mScript + len));
3175 
3176         }
3177     } while(p1 != (mScript + len));
3178     mUseScript = true;
3179 }
3180 
3181 /*===========================================================================
3182  * FUNCTION   : ~Interpreter
3183  *
3184  * DESCRIPTION: Interpreter destructor
3185  *
3186  * PARAMETERS : none
3187  *
3188  * RETURN     : none
3189  *==========================================================================*/
~Interpreter()3190 Interpreter::~Interpreter()
3191 {
3192     if ( mScript )
3193         delete[] mScript;
3194 
3195     mCommands.clear();
3196 }
3197 
3198 /*===========================================================================
3199  * FUNCTION        : getCommand
3200  *
3201  * DESCRIPTION     : Get a command from interpreter
3202  *
3203  * PARAMETERS      :
3204  *   @currentCamera: Current camera context
3205  *
3206  * RETURN          : command
3207  *==========================================================================*/
getCommand(sp<CameraContext> currentCamera)3208 Interpreter::Command Interpreter::getCommand(
3209     sp<CameraContext> currentCamera)
3210 {
3211     if( mUseScript ) {
3212         return mCommands[mCmdIndex++];
3213     } else {
3214         currentCamera->printMenu(currentCamera);
3215         return Interpreter::Command(
3216             static_cast<Interpreter::Commands_e>(getchar()));
3217     }
3218 }
3219 
3220 /*===========================================================================
3221  * FUNCTION        : TestContext
3222  *
3223  * DESCRIPTION     : TestContext constructor
3224  *
3225  * PARAMETERS      : None
3226  *
3227  * RETURN          : None
3228  *==========================================================================*/
TestContext()3229 TestContext::TestContext()
3230 {
3231     int i = 0;
3232     mTestRunning = false;
3233     mInterpreter = NULL;
3234     mViVVid.ViVIdx = 0;
3235     mViVVid.buff_cnt = 9;
3236     mViVVid.graphBuf = 0;
3237     mViVVid.mappedBuff = NULL;
3238     mViVVid.isBuffValid = false;
3239     mViVVid.sourceCameraID = -1;
3240     mViVVid.destinationCameraID = -1;
3241     mPiPinUse = false;
3242     mViVinUse = false;
3243     mIsZSLOn = false;
3244     memset(&mViVBuff, 0, sizeof(ViVBuff_t));
3245 
3246     ProcessState::self()->startThreadPool();
3247 
3248     do {
3249         camera[i] = new CameraContext(i);
3250         if ( NULL == camera[i].get() ) {
3251             break;
3252         }
3253         camera[i]->setTestCtxInstance(this);
3254 
3255         //by default open only back camera
3256         if (i==0) {
3257             status_t stat = camera[i]->openCamera();
3258             if ( NO_ERROR != stat ) {
3259                 printf("Error encountered Openging camera id : %d\n", i);
3260                 break;
3261             }
3262         }
3263         mAvailableCameras.add(camera[i]);
3264         i++;
3265     } while ( i < camera[0]->getNumberOfCameras() ) ;
3266 
3267     if (i < camera[0]->getNumberOfCameras() ) {
3268         for (size_t j = 0; j < mAvailableCameras.size(); j++) {
3269             camera[j] = mAvailableCameras.itemAt(j);
3270             camera[j]->closeCamera();
3271             camera[j].clear();
3272         }
3273 
3274         mAvailableCameras.clear();
3275     }
3276 }
3277 
3278 /*===========================================================================
3279  * FUNCTION        : ~TestContext
3280  *
3281  * DESCRIPTION     : TestContext destructor
3282  *
3283  * PARAMETERS      : None
3284  *
3285  * RETURN          : None
3286  *==========================================================================*/
~TestContext()3287 TestContext::~TestContext()
3288 {
3289     delete mInterpreter;
3290 
3291     for (size_t j = 0; j < mAvailableCameras.size(); j++) {
3292         camera[j] = mAvailableCameras.itemAt(j);
3293         camera[j]->closeCamera();
3294         camera[j].clear();
3295     }
3296 
3297     mAvailableCameras.clear();
3298 }
3299 
3300 /*===========================================================================
3301  * FUNCTION        : GetCamerasNum
3302  *
3303  * DESCRIPTION     : Get the number of available cameras
3304  *
3305  * PARAMETERS      : None
3306  *
3307  * RETURN          : Number of cameras
3308  *==========================================================================*/
GetCamerasNum()3309 size_t TestContext::GetCamerasNum()
3310 {
3311     return mAvailableCameras.size();
3312 }
3313 
3314 /*===========================================================================
3315  * FUNCTION        : AddScriptFromFile
3316  *
3317  * DESCRIPTION     : Add script from file
3318  *
3319  * PARAMETERS      :
3320  *   @scriptFile   : Script file
3321  *
3322  * RETURN          : status_t type of status
3323  *                   NO_ERROR  -- success
3324  *                   none-zero failure code
3325  *==========================================================================*/
AddScriptFromFile(const char * scriptFile)3326 status_t TestContext::AddScriptFromFile(const char *scriptFile)
3327 {
3328     mInterpreter = new Interpreter(scriptFile);
3329     mInterpreter->setTestCtxInst(this);
3330 
3331     return NO_ERROR;
3332 }
3333 
3334 /*===========================================================================
3335  * FUNCTION        : releasePiPBuff
3336  *
3337  * DESCRIPTION     : Release video in video temp buffer
3338  *
3339  * PARAMETERS      : None
3340  *
3341  * RETURN          : None
3342  *==========================================================================*/
releasePiPBuff()3343 void Interpreter::releasePiPBuff() {
3344     free(mTestContext->mViVBuff.buff);
3345     mTestContext->mViVBuff.buff = NULL;
3346 }
3347 
3348 /*===========================================================================
3349  * FUNCTION   : functionalTest
3350  *
3351  * DESCRIPTION: queries and executes client supplied commands for testing a
3352  *              particular camera.
3353  *
3354  * PARAMETERS :
3355  *  @availableCameras : List with all cameras supported
3356  *
3357  * RETURN     : status_t type of status
3358  *              NO_ERROR  -- continue testing
3359  *              none-zero -- quit test
3360  *==========================================================================*/
FunctionalTest()3361 status_t TestContext::FunctionalTest()
3362 {
3363     status_t stat = NO_ERROR;
3364     const char *ZSLStr = NULL;
3365     size_t ZSLStrSize = 0;
3366 
3367     assert(mAvailableCameras.size());
3368 
3369     if ( !mInterpreter ) {
3370         mInterpreter = new Interpreter();
3371         mInterpreter->setTestCtxInst(this);
3372     }
3373 
3374     if (mAvailableCameras.size() == 0) {
3375         printf("no cameras supported... exiting test app\n");
3376     } else {
3377         mTestRunning = true;
3378     }
3379 
3380     while (mTestRunning) {
3381         sp<CameraContext> currentCamera =
3382             mAvailableCameras.itemAt(mCurrentCameraIndex);
3383         Interpreter::Command command =
3384             mInterpreter->getCommand(currentCamera);
3385         currentCamera->enablePrintPreview();
3386 
3387         switch (command.cmd) {
3388         case Interpreter::SWITCH_CAMERA_CMD:
3389         {
3390             mCurrentCameraIndex++;
3391             mCurrentCameraIndex %= mAvailableCameras.size();
3392             currentCamera = mAvailableCameras.itemAt(mCurrentCameraIndex);
3393             stat = currentCamera->openCamera();
3394         }
3395             break;
3396 
3397         case Interpreter::RESUME_PREVIEW_CMD:
3398         {
3399             stat = currentCamera->resumePreview();
3400         }
3401             break;
3402 
3403         case Interpreter::START_PREVIEW_CMD:
3404         {
3405             stat = currentCamera->startPreview();
3406         }
3407             break;
3408 
3409         case Interpreter::STOP_PREVIEW_CMD:
3410         {
3411             stat = currentCamera->stopPreview();
3412         }
3413             break;
3414 
3415         case Interpreter::CHANGE_VIDEO_SIZE_CMD:
3416         {
3417             if ( command.arg )
3418                 stat = currentCamera->setVideoSize(command.arg);
3419             else
3420                 stat = currentCamera->nextVideoSize();
3421         }
3422         break;
3423 
3424         case Interpreter::CHANGE_PREVIEW_SIZE_CMD:
3425         {
3426             if ( command.arg )
3427                 stat = currentCamera->setPreviewSize(command.arg);
3428             else
3429                 stat = currentCamera->nextPreviewSize();
3430         }
3431             break;
3432 
3433         case Interpreter::CHANGE_PICTURE_SIZE_CMD:
3434         {
3435             if ( command.arg )
3436                 stat = currentCamera->setPictureSize(command.arg);
3437             else
3438                 stat = currentCamera->nextPictureSize();
3439         }
3440             break;
3441 
3442         case Interpreter::DUMP_CAPS_CMD:
3443         {
3444             currentCamera->printSupportedParams();
3445         }
3446             break;
3447 
3448         case Interpreter::AUTOFOCUS_CMD:
3449         {
3450             stat = currentCamera->autoFocus();
3451         }
3452             break;
3453 
3454         case Interpreter::TAKEPICTURE_CMD:
3455         {
3456             stat = currentCamera->takePicture();
3457         }
3458             break;
3459 
3460         case Interpreter::TAKEPICTURE_IN_PICTURE_CMD:
3461         {
3462             if (mAvailableCameras.size() == 2) {
3463                 mSaveCurrentCameraIndex = mCurrentCameraIndex;
3464                 for (size_t i = 0; i < mAvailableCameras.size(); i++) {
3465                     mCurrentCameraIndex = i;
3466                     currentCamera = mAvailableCameras.itemAt(mCurrentCameraIndex);
3467                     currentCamera->enablePiPCapture();
3468                     stat = currentCamera->takePicture();
3469                 }
3470                 mCurrentCameraIndex = mSaveCurrentCameraIndex;
3471             } else {
3472                 printf("Number of available sensors should be 2\n");
3473             }
3474         }
3475         break;
3476 
3477         case Interpreter::ENABLE_PRV_CALLBACKS_CMD:
3478         {
3479             stat = currentCamera->enablePreviewCallbacks();
3480         }
3481             break;
3482 
3483         case Interpreter::START_RECORD_CMD:
3484         {
3485             stat = currentCamera->stopPreview();
3486             stat = currentCamera->configureRecorder();
3487             stat = currentCamera->startPreview();
3488             stat = currentCamera->startRecording();
3489         }
3490             break;
3491 
3492         case Interpreter::STOP_RECORD_CMD:
3493         {
3494             stat = currentCamera->stopRecording();
3495 
3496             stat = currentCamera->stopPreview();
3497             stat = currentCamera->unconfigureRecorder();
3498             stat = currentCamera->startPreview();
3499         }
3500             break;
3501 
3502         case Interpreter::START_VIV_RECORD_CMD:
3503         {
3504 
3505             if (mAvailableCameras.size() == 2) {
3506                 mSaveCurrentCameraIndex = mCurrentCameraIndex;
3507                 stat = mInterpreter->configureViVCodec();
3508                 for ( size_t i = 0; i < mAvailableCameras.size(); i++ ) {
3509                     mCurrentCameraIndex = i;
3510                     currentCamera = mAvailableCameras.itemAt(
3511                         mCurrentCameraIndex);
3512                     stat = currentCamera->stopPreview();
3513                     stat = currentCamera->configureViVRecording();
3514                     stat = currentCamera->startPreview();
3515                     stat = currentCamera->startViVRecording();
3516                 }
3517                 mCurrentCameraIndex = mSaveCurrentCameraIndex;
3518             } else {
3519                 printf("Number of available sensors should be 2\n");
3520             }
3521 
3522         }
3523             break;
3524 
3525         case Interpreter::STOP_VIV_RECORD_CMD:
3526         {
3527             if (mAvailableCameras.size() == 2) {
3528                 mSaveCurrentCameraIndex = mCurrentCameraIndex;
3529                 for ( size_t i = 0; i < mAvailableCameras.size(); i++ ) {
3530                     mCurrentCameraIndex = i;
3531                     currentCamera = mAvailableCameras.itemAt(
3532                         mCurrentCameraIndex);
3533                     stat = currentCamera->stopViVRecording();
3534                     stat = currentCamera->stopPreview();
3535                     stat = currentCamera->unconfigureRecorder();
3536                     stat = currentCamera->startPreview();
3537                 }
3538                 stat = mInterpreter->unconfigureViVCodec();
3539                 mCurrentCameraIndex = mSaveCurrentCameraIndex;
3540 
3541                 mInterpreter->releasePiPBuff();
3542             } else {
3543                 printf("Number of available sensors should be 2\n");
3544             }
3545         }
3546         break;
3547 
3548         case Interpreter::EXIT_CMD:
3549         {
3550             currentCamera->stopPreview();
3551             mTestRunning = false;
3552         }
3553             break;
3554 
3555         case Interpreter::DELAY:
3556         {
3557             if ( command.arg ) {
3558                 int delay = atoi(command.arg);
3559                 if (0 < delay) {
3560                     usleep(1000U * (unsigned int)delay);
3561                 }
3562             }
3563         }
3564             break;
3565 
3566         case Interpreter::ZSL_CMD:
3567         {
3568             currentCamera = mAvailableCameras.itemAt(
3569                     mCurrentCameraIndex);
3570             ZSLStr = currentCamera->getZSL();
3571 
3572             if (NULL != ZSLStr) {
3573                 ZSLStrSize = strlen(ZSLStr);
3574                 if (!strncmp(ZSLStr, "off", ZSLStrSize)) {
3575                     currentCamera->setZSL("on");
3576                     mIsZSLOn = true;
3577                 } else if (!strncmp(ZSLStr, "on", ZSLStrSize)) {
3578                     currentCamera->setZSL("off");
3579                     mIsZSLOn = false;
3580                 } else {
3581                     printf("Set zsl failed!\n");
3582                 }
3583             } else {
3584                 printf("zsl is NULL\n");
3585             }
3586         }
3587             break;
3588 
3589         default:
3590         {
3591             currentCamera->disablePrintPreview();
3592         }
3593             break;
3594         }
3595         printf("Command status 0x%x \n", stat);
3596     }
3597 
3598     return NO_ERROR;
3599 }
3600 
3601 /*===========================================================================
3602  * FUNCTION   : PiPLock
3603  *
3604  * DESCRIPTION: Mutex lock for PiP capture
3605  *
3606  * PARAMETERS : none
3607  *
3608  * RETURN     : none
3609  *==========================================================================*/
PiPLock()3610 void TestContext::PiPLock()
3611 {
3612     Mutex::Autolock l(mPiPLock);
3613     while (mPiPinUse) {
3614         mPiPCond.wait(mPiPLock);
3615     }
3616     mPiPinUse = true;
3617 }
3618 
3619 /*===========================================================================
3620  * FUNCTION   : PiPUnLock
3621  *
3622  * DESCRIPTION: Mutex unlock for PiP capture
3623  *
3624  * PARAMETERS : none
3625  *
3626  * RETURN     : none
3627  *==========================================================================*/
PiPUnlock()3628 void TestContext::PiPUnlock()
3629 {
3630     Mutex::Autolock l(mPiPLock);
3631     mPiPinUse = false;
3632     mPiPCond.signal();
3633 }
3634 
3635 /*===========================================================================
3636  * FUNCTION   : ViVLock
3637  *
3638  * DESCRIPTION: Mutex lock for ViV Video
3639  *
3640  * PARAMETERS : none
3641  *
3642  * RETURN     : none
3643  *==========================================================================*/
ViVLock()3644 void TestContext::ViVLock()
3645 {
3646     Mutex::Autolock l(mViVLock);
3647     while (mViVinUse) {
3648         mViVCond.wait(mViVLock);
3649     }
3650     mViVinUse = true;
3651 }
3652 
3653 /*===========================================================================
3654  * FUNCTION   : ViVUnlock
3655  *
3656  * DESCRIPTION: Mutex unlock for ViV Video
3657  *
3658  * PARAMETERS : none
3659  *
3660  * RETURN     : none
3661  *==========================================================================*/
ViVUnlock()3662 void TestContext::ViVUnlock()
3663 {
3664     Mutex::Autolock l(mViVLock);
3665     mViVinUse = false;
3666     mViVCond.signal();
3667 }
3668 
3669 /*===========================================================================
3670  * FUNCTION     : setViVSize
3671  *
3672  * DESCRIPTION  : Set video in video size
3673  *
3674  * PARAMETERS   :
3675  *   @VideoSize : video size
3676  *   @camIndex  : camera index
3677  *
3678  * RETURN       : none
3679  *==========================================================================*/
setViVSize(Size VideoSize,int camIndex)3680 void TestContext::setViVSize(Size VideoSize, int camIndex)
3681 {
3682     mViVVid.VideoSizes[camIndex] = VideoSize;
3683 }
3684 
3685 /*===========================================================================
3686  * FUNCTION     : main
3687  *
3688  * DESCRIPTION  : main function
3689  *
3690  * PARAMETERS   :
3691  *   @argc      : argc
3692  *   @argv      : argv
3693  *
3694  * RETURN       : int status
3695  *==========================================================================*/
main(int argc,char * argv[])3696 int main(int argc, char *argv[])
3697 {
3698     TestContext ctx;
3699 
3700     if (argc > 1) {
3701         if ( ctx.AddScriptFromFile((const char *)argv[1]) ) {
3702             printf("Could not add script file... "
3703                 "continuing in normal menu mode! \n");
3704         }
3705     }
3706 
3707     ctx.FunctionalTest();
3708 
3709     return 0;
3710 }
3711