C++程序
|
3705行
|
110.23 KB
/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of The Linux Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <semaphore.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <ui/DisplayInfo.h>
#include <gui/Surface.h>
#include <gui/SurfaceComposerClient.h>
#include <gui/ISurfaceComposer.h>
#include <system/camera.h>
#include <camera/Camera.h>
#include <camera/ICamera.h>
#include <camera/CameraParameters.h>
#include <media/mediarecorder.h>
#include <utils/RefBase.h>
#include <utils/Mutex.h>
#include <utils/Condition.h>
#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <cutils/properties.h>
#include <cutils/memory.h>
#include <SkImageDecoder.h>
#include <SkImageEncoder.h>
#include <MediaCodec.h>
#include <OMX_IVCommon.h>
#include <foundation/AMessage.h>
#include <media/ICrypto.h>
#include <MediaMuxer.h>
#include <foundation/ABuffer.h>
#include <MediaErrors.h>
#include <gralloc_priv.h>
#include <math.h>
#include "qcamera_test.h"
#include "cam_types.h"
#include "mm_camera_dbg.h"
#define VIDEO_BUF_ALLIGN(size, allign) \
(((size) + (allign-1)) & (typeof(size))(~(allign-1)))
namespace qcamera {
using namespace android;
int CameraContext::JpegIdx = 0;
int CameraContext::mPiPIdx = 0;
const char CameraContext::KEY_ZSL[] = "zsl";
/*===========================================================================
* FUNCTION : previewCallback
*
* DESCRIPTION: preview callback preview mesages are enabled
*
* PARAMETERS :
* @mem : preview buffer
*
* RETURN : None
*==========================================================================*/
void CameraContext::previewCallback(const sp<IMemory>& mem)
{
printf("PREVIEW Callback %p", mem->pointer());
uint8_t *ptr = (uint8_t*) mem->pointer();
if (NULL != ptr) {
printf("PRV_CB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x",
ptr[0],
ptr[1],
ptr[2],
ptr[3],
ptr[4],
ptr[5],
ptr[6],
ptr[7],
ptr[8],
ptr[9]);
} else {
ALOGE(" no preview for NULL CB\n");
}
}
/*===========================================================================
* FUNCTION : useLock
*
* DESCRIPTION: Mutex lock for CameraContext
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void CameraContext::useLock()
{
Mutex::Autolock l(mLock);
while (mInUse) {
mCond.wait(mLock);
}
mInUse = true;
}
/*===========================================================================
* FUNCTION : signalFinished
*
* DESCRIPTION: Mutex unlock CameraContext
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void CameraContext::signalFinished()
{
Mutex::Autolock l(mLock);
mInUse = false;
mCond.signal();
}
/*===========================================================================
* FUNCTION : saveFile
*
* DESCRIPTION: helper function for saving buffers on filesystem
*
* PARAMETERS :
* @mem : buffer to save to filesystem
* @path: File path
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::saveFile(const sp<IMemory>& mem, String8 path)
{
unsigned char *buff = NULL;
ssize_t size;
int fd = -1;
if (mem == NULL) {
return BAD_VALUE;
}
fd = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0655);
if(fd < 0) {
printf("Unable to open file %s %s\n", path.string(), strerror(fd));
return -errno;
}
size = (ssize_t)mem->size();
if (size <= 0) {
printf("IMemory object is of zero size\n");
close(fd);
return BAD_VALUE;
}
buff = (unsigned char *)mem->pointer();
if (!buff) {
printf("Buffer pointer is invalid\n");
close(fd);
return BAD_VALUE;
}
if (size != write(fd, buff, (size_t)size)) {
printf("Bad Write error (%d)%s\n", errno, strerror(errno));
close(fd);
return INVALID_OPERATION;
}
printf("%s: buffer=%p, size=%lld stored at %s\n",
__FUNCTION__, buff, (long long int) size, path.string());
if (fd >= 0)
close(fd);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : PiPCopyToOneFile
*
* DESCRIPTION: Copy the smaller picture to the bigger one
*
* PARAMETERS :
* @bitmap0 : Decoded image buffer 0
* @bitmap1 : Decoded image buffer 1
*
* RETURN : decoded picture in picture in SkBitmap
*==========================================================================*/
SkBitmap * CameraContext::PiPCopyToOneFile(
SkBitmap *bitmap0, SkBitmap *bitmap1)
{
size_t size0;
size_t size1;
SkBitmap *src;
SkBitmap *dst;
unsigned int dstOffset;
unsigned int srcOffset;
if (bitmap0 == NULL || bitmap1 == NULL) {
ALOGE(" bitmap0 : %p, bitmap1 : %p\n", bitmap0, bitmap1);
return NULL;
}
size0 = bitmap0->getSize();
if (size0 <= 0) {
printf("Decoded image 0 is of zero size\n");
return NULL;
}
size1 = bitmap1->getSize();
if (size1 <= 0) {
printf("Decoded image 1 is of zero size\n");
return NULL;
}
if (size0 > size1) {
dst = bitmap0;
src = bitmap1;
} else if (size1 > size0){
dst = bitmap1;
src = bitmap0;
} else {
printf("Picture size should be with different size!\n");
return NULL;
}
for (unsigned int i = 0; i < (unsigned int)src->height(); i++) {
dstOffset = i * (unsigned int)dst->width() * mfmtMultiplier;
srcOffset = i * (unsigned int)src->width() * mfmtMultiplier;
memcpy(((unsigned char *)dst->getPixels()) + dstOffset,
((unsigned char *)src->getPixels()) + srcOffset,
(unsigned int)src->width() * mfmtMultiplier);
}
return dst;
}
/*===========================================================================
* FUNCTION : decodeJPEG
*
* DESCRIPTION: decode jpeg input buffer.
*
* PARAMETERS :
* @mem : buffer to decode
* @skBM : decoded buffer
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::decodeJPEG(const sp<IMemory>& mem, SkBitmap *skBM)
{
#ifndef USE_SDK_20_OR_HIGHER
SkBitmap::Config prefConfig = SkBitmap::kARGB_8888_Config;
const void *buff = NULL;
size_t size;
buff = (const void *)mem->pointer();
size= mem->size();
switch(prefConfig) {
case SkBitmap::kARGB_8888_Config:
{
mfmtMultiplier = 4;
}
break;
case SkBitmap::kARGB_4444_Config:
{
mfmtMultiplier = 2;
}
break;
case SkBitmap::kRGB_565_Config:
{
mfmtMultiplier = 2;
}
break;
case SkBitmap::kIndex8_Config:
{
mfmtMultiplier = 4;
}
break;
case SkBitmap::kA8_Config:
{
mfmtMultiplier = 4;
}
break;
default:
{
mfmtMultiplier = 0;
printf("Decode format is not correct!\n");
}
break;
}
if (SkImageDecoder::DecodeMemory(buff, size, skBM, prefConfig,
SkImageDecoder::kDecodePixels_Mode) == false) {
printf("%s():%d:: Failed during jpeg decode\n",__FUNCTION__,__LINE__);
return BAD_VALUE;
}
#else
SkColorType prefConfig = kRGBA_8888_SkColorType;
const void *buff = NULL;
size_t size;
buff = (const void *)mem->pointer();
size= mem->size();
switch(prefConfig) {
case kRGBA_8888_SkColorType:
{
mfmtMultiplier = 4;
}
break;
case kBGRA_8888_SkColorType:
{
mfmtMultiplier = 4;
}
break;
case kARGB_4444_SkColorType:
{
mfmtMultiplier = 2;
}
break;
case kRGB_565_SkColorType:
{
mfmtMultiplier = 2;
}
break;
case kIndex_8_SkColorType:
{
mfmtMultiplier = 4;
}
break;
case kAlpha_8_SkColorType:
{
mfmtMultiplier = 4;
}
break;
default:
{
mfmtMultiplier = 0;
printf("Decode format is not correct!\n");
}
break;
}
if (SkImageDecoder::DecodeMemory(buff, size, skBM, prefConfig,
SkImageDecoder::kDecodePixels_Mode) == false) {
printf("%s():%d:: Failed during jpeg decode\n",__FUNCTION__,__LINE__);
return BAD_VALUE;
}
#endif
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : encodeJPEG
*
* DESCRIPTION: encode the decoded input buffer.
*
* PARAMETERS :
* @stream : SkWStream
* @bitmap : SkBitmap decoded image to encode
* @path : File path
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::encodeJPEG(SkWStream * stream,
const SkBitmap *bitmap, String8 path)
{
int qFactor = 100;
if (!SkEncodeImage(stream, *bitmap, SkEncodedImageFormat::kJPEG, qFactor) {
return BAD_VALUE;
}
FILE *fh = fopen(path.string(), "r+");
if ( !fh ) {
printf("Could not open file %s\n", path.string());
return BAD_VALUE;
}
fseek(fh, 0, SEEK_END);
size_t len = (size_t)ftell(fh);
rewind(fh);
if( !len ) {
printf("File %s is empty !\n", path.string());
fclose(fh);
return BAD_VALUE;
}
unsigned char *buff = (unsigned char*)malloc(len);
if (!buff) {
printf("Cannot allocate memory for buffer reading!\n");
return BAD_VALUE;
}
size_t readSize = fread(buff, 1, len, fh);
if (readSize != len) {
printf("Reading error\n");
return BAD_VALUE;
}
status_t ret = ReadSectionsFromBuffer(buff, len, READ_ALL);
if (ret != NO_ERROR) {
printf("Cannot read sections from buffer\n");
DiscardData();
DiscardSections();
return BAD_VALUE;
}
free(buff);
rewind(fh);
unsigned char temp = 0xff;
size_t writeSize = fwrite(&temp, sizeof(unsigned char), 1, fh);
if (1 != writeSize) {
printf("Writing error\n");
}
temp = 0xd8;
fwrite(&temp, sizeof(unsigned char), 1, fh);
for (size_t i = 0; i < mSectionsRead; i++) {
switch((mSections[i].Type)) {
case 0x123:
fwrite(mSections[i].Data, sizeof(unsigned char),
mSections[i].Size, fh);
break;
case 0xe0:
temp = 0xff;
fwrite(&temp, sizeof(unsigned char), 1, fh);
temp = 0xe1;
fwrite(&temp, sizeof(unsigned char), 1, fh);
fwrite(mJEXIFSection.Data, sizeof(unsigned char),
mJEXIFSection.Size, fh);
break;
default:
temp = 0xff;
fwrite(&temp, sizeof(unsigned char), 1, fh);
fwrite(&mSections[i].Type, sizeof(unsigned char), 1, fh);
fwrite(mSections[i].Data, sizeof(unsigned char),
mSections[i].Size, fh);
break;
}
}
fseek(fh, 0, SEEK_END);
len = (size_t)ftell(fh);
rewind(fh);
printf("%s: buffer=%p, size=%zu stored at %s\n",
__FUNCTION__, bitmap->getPixels(), len, path.string());
free(mJEXIFSection.Data);
DiscardData();
DiscardSections();
fclose(fh);
ret = NO_ERROR;
return ret;
}
/*===========================================================================
* FUNCTION : readSectionsFromBuffer
*
* DESCRIPTION: read all jpeg sections of input buffer.
*
* PARAMETERS :
* @mem : buffer to read from Metadata Sections
* @buffer_size: buffer size
* @ReadMode: Read mode - all, jpeg or exif
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::ReadSectionsFromBuffer (unsigned char *buffer,
size_t buffer_size, ReadMode_t ReadMode)
{
int a;
size_t pos = 0;
int HaveCom = 0;
mSectionsAllocated = 10;
mSections = (Sections_t *)malloc(sizeof(Sections_t) * mSectionsAllocated);
if (!mSections) {
printf(" not enough memory\n");
return BAD_VALUE;
}
if (!buffer) {
printf("Input buffer is null\n");
return BAD_VALUE;
}
if (buffer_size < 1) {
printf("Input size is 0\n");
return BAD_VALUE;
}
a = (int) buffer[pos++];
if (a != 0xff || buffer[pos++] != M_SOI){
printf("No valid image\n");
return BAD_VALUE;
}
for(;;){
size_t itemlen;
int marker = 0;
size_t ll,lh;
unsigned char * Data;
CheckSectionsAllocated();
// The call to CheckSectionsAllocated() may reallocate mSections
// so need to check for NULL again.
if (mSections == NULL) {
printf(" not enough memory\n");
return BAD_VALUE;
}
for (a = 0; a <= 16; a++){
marker = buffer[pos++];
if (marker != 0xff) break;
if (a >= 16){
fprintf(stderr,"too many padding bytes\n");
return BAD_VALUE;
}
}
mSections[mSectionsRead].Type = marker;
// Read the length of the section.
lh = buffer[pos++];
ll = buffer[pos++];
itemlen = (lh << 8) | ll;
if (itemlen < 2) {
ALOGE("invalid marker");
return BAD_VALUE;
}
mSections[mSectionsRead].Size = itemlen;
Data = (unsigned char *)malloc(itemlen);
if (Data == NULL) {
ALOGE("Could not allocate memory");
return NO_MEMORY;
}
mSections[mSectionsRead].Data = Data;
// Store first two pre-read bytes.
Data[0] = (unsigned char)lh;
Data[1] = (unsigned char)ll;
if (pos+itemlen-2 > buffer_size) {
ALOGE("Premature end of file?");
return BAD_VALUE;
}
memcpy(Data+2, buffer+pos, itemlen-2); // Read the whole section.
pos += itemlen-2;
mSectionsRead += 1;
switch(marker){
case M_SOS: // stop before hitting compressed data
// If reading entire image is requested, read the rest of the
// data.
if (ReadMode & READ_IMAGE){
size_t size;
// Determine how much file is left.
size = buffer_size - pos;
if (size < 1) {
ALOGE("could not read the rest of the image");
return BAD_VALUE;
}
Data = (unsigned char *)malloc(size);
if (Data == NULL) {
ALOGE("%d: could not allocate data for entire "
"image size: %d", __LINE__, size);
return BAD_VALUE;
}
memcpy(Data, buffer+pos, size);
CheckSectionsAllocated();
// The call to CheckSectionsAllocated()
// may reallocate mSections
// so need to check for NULL again.
if (mSections == NULL) {
printf(" not enough memory\n");
return BAD_VALUE;
}
mSections[mSectionsRead].Data = Data;
mSections[mSectionsRead].Size = size;
mSections[mSectionsRead].Type = PSEUDO_IMAGE_MARKER;
mSectionsRead ++;
mHaveAll = 1;
}
return NO_ERROR;
case M_EOI: // in case it's a tables-only JPEG stream
ALOGE("No image in jpeg!\n");
return BAD_VALUE;
case M_COM: // Comment section
if (HaveCom || ((ReadMode & READ_METADATA) == 0)){
// Discard this section.
free(mSections[--mSectionsRead].Data);
}
break;
case M_JFIF:
// Regular jpegs always have this tag, exif images have the
// exif marker instead, althogh ACDsee will write images
// with both markers.
// this program will re-create this marker on absence of exif
// marker.
// hence no need to keep the copy from the file.
if (ReadMode & READ_METADATA){
if (memcmp(Data+2, "JFIF", 4) == 0) {
break;
}
free(mSections[--mSectionsRead].Data);
}
break;
case M_EXIF:
// There can be different section using the same marker.
if (ReadMode & READ_METADATA){
if (memcmp(Data+2, "Exif", 4) == 0){
break;
}else if (memcmp(Data+2, "http:", 5) == 0){
// Change tag for internal purposes.
mSections[mSectionsRead-1].Type = M_XMP;
break;
}
}
// Oterwise, discard this section.
free(mSections[--mSectionsRead].Data);
break;
case M_IPTC:
if (ReadMode & READ_METADATA){
// Note: We just store the IPTC section.
// Its relatively straightforward
// and we don't act on any part of it,
// so just display it at parse time.
}else{
free(mSections[--mSectionsRead].Data);
}
break;
case M_SOF0:
case M_SOF1:
case M_SOF2:
case M_SOF3:
case M_SOF5:
case M_SOF6:
case M_SOF7:
case M_SOF9:
case M_SOF10:
case M_SOF11:
case M_SOF13:
case M_SOF14:
case M_SOF15:
break;
default:
// Skip any other sections.
break;
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : CheckSectionsAllocated
*
* DESCRIPTION: Check allocated jpeg sections.
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void CameraContext::CheckSectionsAllocated(void)
{
if (mSectionsRead > mSectionsAllocated){
ALOGE("allocation screw up");
}
if (mSectionsRead >= mSectionsAllocated){
mSectionsAllocated += mSectionsAllocated +1;
mSections = (Sections_t *)realloc(mSections,
sizeof(Sections_t) * mSectionsAllocated);
if (mSections == NULL){
ALOGE("could not allocate data for entire image");
}
}
}
/*===========================================================================
* FUNCTION : findSection
*
* DESCRIPTION: find the desired Section of the JPEG buffer.
*
* PARAMETERS :
* @SectionType: Section type
*
* RETURN : return the found section
*==========================================================================*/
CameraContext::Sections_t *CameraContext::FindSection(int SectionType)
{
for (unsigned int a = 0; a < mSectionsRead; a++) {
if (mSections[a].Type == SectionType){
return &mSections[a];
}
}
// Could not be found.
return NULL;
}
/*===========================================================================
* FUNCTION : DiscardData
*
* DESCRIPTION: DiscardData
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void CameraContext::DiscardData()
{
for (unsigned int a = 0; a < mSectionsRead; a++) {
free(mSections[a].Data);
}
mSectionsRead = 0;
mHaveAll = 0;
}
/*===========================================================================
* FUNCTION : DiscardSections
*
* DESCRIPTION: Discard allocated sections
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void CameraContext::DiscardSections()
{
free(mSections);
mSectionsAllocated = 0;
mHaveAll = 0;
}
/*===========================================================================
* FUNCTION : notify
*
* DESCRIPTION: notify callback
*
* PARAMETERS :
* @msgType : type of callback
* @ext1: extended parameters
* @ext2: extended parameters
*
* RETURN : None
*==========================================================================*/
void CameraContext::notify(int32_t msgType, int32_t ext1, int32_t ext2)
{
printf("Notify cb: %d %d %d\n", msgType, ext1, ext2);
if (( msgType & CAMERA_MSG_PREVIEW_FRAME)
#ifndef VANILLA_HAL
&& (ext1 == CAMERA_FRAME_DATA_FD)
#endif
)
{
int fd = dup(ext2);
printf("notify Preview Frame fd: %d dup fd: %d\n", ext2, fd);
close(fd);
}
if ( msgType & CAMERA_MSG_FOCUS ) {
printf("AutoFocus %s \n",
(ext1) ? "OK" : "FAIL");
}
if ( msgType & CAMERA_MSG_SHUTTER ) {
printf("Shutter done \n");
}
if ( msgType & CAMERA_MSG_ERROR) {
printf("Camera Test CAMERA_MSG_ERROR\n");
stopPreview();
closeCamera();
}
}
/*===========================================================================
* FUNCTION : postData
*
* DESCRIPTION: handles data callbacks
*
* PARAMETERS :
* @msgType : type of callback
* @dataPtr: buffer data
* @metadata: additional metadata where available
*
* RETURN : None
*==========================================================================*/
void CameraContext::postData(int32_t msgType,
const sp<IMemory>& dataPtr,
camera_frame_metadata_t *metadata)
{
mInterpr->PiPLock();
Size currentPictureSize = mSupportedPictureSizes.itemAt(
mCurrentPictureSizeIdx);
unsigned char *buff = NULL;
size_t size;
status_t ret = 0;
memset(&mJEXIFSection, 0, sizeof(mJEXIFSection)),
printf("Data cb: %d\n", msgType);
if ( msgType & CAMERA_MSG_PREVIEW_FRAME ) {
previewCallback(dataPtr);
}
if ( msgType & CAMERA_MSG_RAW_IMAGE ) {
printf("RAW done \n");
}
if (msgType & CAMERA_MSG_POSTVIEW_FRAME) {
printf("Postview frame \n");
}
if (msgType & CAMERA_MSG_COMPRESSED_IMAGE ) {
String8 jpegPath;
jpegPath = jpegPath.format(QCAMERA_DUMP_FRM_LOCATION"img_%d.jpg",
JpegIdx);
if (!mPiPCapture) {
// Normal capture case
printf("JPEG done\n");
saveFile(dataPtr, jpegPath);
JpegIdx++;
} else {
// PiP capture case
SkFILEWStream *wStream;
ret = decodeJPEG(dataPtr, &skBMtmp);
if (NO_ERROR != ret) {
printf("Error in decoding JPEG!\n");
mInterpr->PiPUnlock();
return;
}
mWidthTmp = currentPictureSize.width;
mHeightTmp = currentPictureSize.height;
PiPPtrTmp = dataPtr;
// If there are two jpeg buffers
if (mPiPIdx == 1) {
printf("PiP done\n");
// Find the the capture with higher width and height and read
// its jpeg sections
if ((mInterpr->camera[0]->mWidthTmp * mInterpr->camera[0]->mHeightTmp) >
(mInterpr->camera[1]->mWidthTmp * mInterpr->camera[1]->mHeightTmp)) {
buff = (unsigned char *)PiPPtrTmp->pointer();
size= PiPPtrTmp->size();
} else if ((mInterpr->camera[0]->mWidthTmp * mInterpr->camera[0]->mHeightTmp) <
(mInterpr->camera[1]->mWidthTmp * mInterpr->camera[1]->mHeightTmp)) {
buff = (unsigned char *)PiPPtrTmp->pointer();
size= PiPPtrTmp->size();
} else {
printf("Cannot take PiP. Images are with the same width"
" and height size!!!\n");
mInterpr->PiPUnlock();
return;
}
if (buff != NULL && size != 0) {
ret = ReadSectionsFromBuffer(buff, size, READ_ALL);
if (ret != NO_ERROR) {
printf("Cannot read sections from buffer\n");
DiscardData();
DiscardSections();
mInterpr->PiPUnlock();
return;
}
mJEXIFTmp = FindSection(M_EXIF);
if (!mJEXIFTmp) {
ALOGE("skBMDec is null\n");
DiscardData();
DiscardSections();
return;
}
mJEXIFSection = *mJEXIFTmp;
mJEXIFSection.Data = (unsigned char*)malloc(mJEXIFTmp->Size);
if (!mJEXIFSection.Data) {
ALOGE(" Not enough memory\n");
DiscardData();
DiscardSections();
return;
}
memcpy(mJEXIFSection.Data,
mJEXIFTmp->Data, mJEXIFTmp->Size);
DiscardData();
DiscardSections();
wStream = new SkFILEWStream(jpegPath.string());
skBMDec = PiPCopyToOneFile(&mInterpr->camera[0]->skBMtmp,
&mInterpr->camera[1]->skBMtmp);
if (!skBMDec) {
ALOGE("skBMDec is null\n");
delete wStream;
return;
}
if (encodeJPEG(wStream, skBMDec, jpegPath) != false) {
printf("%s():%d:: Failed during jpeg encode\n",
__FUNCTION__,__LINE__);
mInterpr->PiPUnlock();
return;
}
mPiPIdx = 0;
JpegIdx++;
delete wStream;
}
} else {
mPiPIdx++;
}
disablePiPCapture();
}
}
if ((msgType & CAMERA_MSG_PREVIEW_METADATA) && (NULL != metadata)) {
printf("Face detected %d \n", metadata->number_of_faces);
}
mInterpr->PiPUnlock();
}
/*===========================================================================
* FUNCTION : postDataTimestamp
*
* DESCRIPTION: handles recording callbacks
*
* PARAMETERS :
* @timestamp : timestamp of buffer
* @msgType : type of buffer
* @dataPtr : buffer data
*
* RETURN : None
*==========================================================================*/
void CameraContext::postDataTimestamp(nsecs_t timestamp,
int32_t msgType,
const sp<IMemory>& dataPtr)
{
printf("Recording cb: %d %lld %p\n",
msgType, (long long int)timestamp, dataPtr.get());
}
/*===========================================================================
* FUNCTION : dataCallbackTimestamp
*
* DESCRIPTION: handles recording callbacks. Used for ViV recording
*
* PARAMETERS :
* @timestamp : timestamp of buffer
* @msgType : type of buffer
* @dataPtr : buffer data
*
* RETURN : None
*==========================================================================*/
void CameraContext::dataCallbackTimestamp(nsecs_t timestamp,
int32_t msgType,
const sp<IMemory>& dataPtr)
{
mInterpr->ViVLock();
// Not needed check. Just avoiding warnings of not used variables.
if (timestamp > 0)
timestamp = 0;
// Not needed check. Just avoiding warnings of not used variables.
if (msgType > 0)
msgType = 0;
size_t i = 0;
void * srcBuff = NULL;
void * dstBuff = NULL;
size_t srcYStride = 0, dstYStride = 0;
size_t srcUVStride = 0, dstUVStride = 0;
size_t srcYScanLines = 0, dstYScanLines = 0;
size_t srcUVScanLines = 0, dstUVScanLines = 0;
size_t srcOffset = 0, dstOffset = 0;
size_t srcBaseOffset = 0;
size_t dstBaseOffset = 0;
Size currentVideoSize = mSupportedVideoSizes.itemAt(mCurrentVideoSizeIdx);
status_t err = NO_ERROR;
ANativeWindowBuffer* anb = NULL;
dstBuff = (void *) dataPtr->pointer();
if (NULL == dstBuff) {
printf("Cannot access destination buffer!!!\n");
mInterpr->ViVUnlock();
return;
}
if (mCameraIndex == mInterpr->mViVVid.sourceCameraID) {
srcYStride = calcStride(currentVideoSize.width);
srcUVStride = calcStride(currentVideoSize.width);
srcYScanLines = calcYScanLines(currentVideoSize.height);
srcUVScanLines = calcUVScanLines(currentVideoSize.height);
mInterpr->mViVBuff.srcWidth = (size_t)currentVideoSize.width;
mInterpr->mViVBuff.srcHeight = (size_t)currentVideoSize.height;
mInterpr->mViVBuff.YStride = srcYStride;
mInterpr->mViVBuff.UVStride = srcUVStride;
mInterpr->mViVBuff.YScanLines = srcYScanLines;
mInterpr->mViVBuff.UVScanLines = srcUVScanLines;
memcpy( mInterpr->mViVBuff.buff, dstBuff,
mInterpr->mViVBuff.buffSize);
mInterpr->mViVVid.isBuffValid = true;
} else if (mCameraIndex == mInterpr->mViVVid.destinationCameraID) {
if(mInterpr->mViVVid.isBuffValid == true) {
dstYStride = calcStride(currentVideoSize.width);
dstUVStride = calcStride(currentVideoSize.width);
dstYScanLines = calcYScanLines(currentVideoSize.height);
dstUVScanLines = calcUVScanLines(currentVideoSize.height);
srcYStride = mInterpr->mViVBuff.YStride;
srcUVStride = mInterpr->mViVBuff.UVStride;
srcYScanLines = mInterpr->mViVBuff.YScanLines;
srcUVScanLines = mInterpr->mViVBuff.UVScanLines;
for (i = 0; i < mInterpr->mViVBuff.srcHeight; i++) {
srcOffset = i*srcYStride;
dstOffset = i*dstYStride;
memcpy((unsigned char *) dstBuff + dstOffset,
(unsigned char *) mInterpr->mViVBuff.buff +
srcOffset, mInterpr->mViVBuff.srcWidth);
}
srcBaseOffset = srcYStride * srcYScanLines;
dstBaseOffset = dstYStride * dstYScanLines;
for (i = 0; i < mInterpr->mViVBuff.srcHeight / 2; i++) {
srcOffset = i*srcUVStride + srcBaseOffset;
dstOffset = i*dstUVStride + dstBaseOffset;
memcpy((unsigned char *) dstBuff + dstOffset,
(unsigned char *) mInterpr->mViVBuff.buff +
srcOffset, mInterpr->mViVBuff.srcWidth);
}
err = native_window_dequeue_buffer_and_wait(
mInterpr->mViVVid.ANW.get(),&anb);
if (err != NO_ERROR) {
printf("Cannot dequeue anb for sensor %d!!!\n", mCameraIndex);
mInterpr->ViVUnlock();
return;
}
mInterpr->mViVVid.graphBuf = GraphicBuffer::from(anb);
if(NULL == mInterpr->mViVVid.graphBuf.get()) {
printf("Invalid Graphic buffer\n");
mInterpr->ViVUnlock();
return;
}
err = mInterpr->mViVVid.graphBuf->lock(
GRALLOC_USAGE_SW_WRITE_OFTEN,
(void**)(&mInterpr->mViVVid.mappedBuff));
if (err != NO_ERROR) {
printf("Graphic buffer could not be locked %d!!!\n", err);
mInterpr->ViVUnlock();
return;
}
srcYStride = dstYStride;
srcUVStride = dstUVStride;
srcYScanLines = dstYScanLines;
srcUVScanLines = dstUVScanLines;
srcBuff = dstBuff;
for (i = 0; i < (size_t)currentVideoSize.height; i++) {
srcOffset = i*srcYStride;
dstOffset = i*dstYStride;
memcpy((unsigned char *) mInterpr->mViVVid.mappedBuff +
dstOffset, (unsigned char *) srcBuff +
srcOffset, (size_t)currentVideoSize.width);
}
srcBaseOffset = srcYStride * srcYScanLines;
dstBaseOffset = dstUVStride * (size_t)currentVideoSize.height;
for (i = 0; i < (size_t)currentVideoSize.height / 2; i++) {
srcOffset = i*srcUVStride + srcBaseOffset;
dstOffset = i*dstUVStride + dstBaseOffset;
memcpy((unsigned char *) mInterpr->mViVVid.mappedBuff +
dstOffset, (unsigned char *) srcBuff +
srcOffset, (size_t)currentVideoSize.width);
}
mInterpr->mViVVid.graphBuf->unlock();
err = mInterpr->mViVVid.ANW->queueBuffer(
mInterpr->mViVVid.ANW.get(), anb, -1);
if(err)
printf("Failed to enqueue buffer to recorder!!!\n");
}
}
mCamera->releaseRecordingFrame(dataPtr);
mInterpr->ViVUnlock();
}
/*===========================================================================
* FUNCTION : ViVEncoderThread
*
* DESCRIPTION: Creates a separate thread for ViV recording
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
status_t Interpreter::ViVEncoderThread()
{
int ret = NO_ERROR;
pthread_attr_t attr;
pthread_attr_init(&attr);
ret = pthread_create(&mViVEncThread, &attr, ThreadWrapper, this);
ret = pthread_attr_destroy(&attr);
return ret;
}
/*===========================================================================
* FUNCTION : ThreadWrapper
*
* DESCRIPTION: Helper function for for ViV recording thread
*
* PARAMETERS : Interpreter context
*
* RETURN : None
*==========================================================================*/
void *Interpreter::ThreadWrapper(void *context) {
Interpreter *writer = static_cast<Interpreter *>(context);
writer->ViVEncode();
return NULL;
}
/*===========================================================================
* FUNCTION : ViVEncode
*
* DESCRIPTION: Thread for ViV encode. Buffers from video codec are sent to
* muxer and saved in a file.
*
* PARAMETERS : Interpreter context
*
* RETURN : None
*==========================================================================*/
void Interpreter::ViVEncode()
{
status_t err = NO_ERROR;
ssize_t trackIdx = -1;
uint32_t debugNumFrames = 0;
size_t bufIndex, offset, size;
int64_t ptsUsec;
uint32_t flags;
bool DoRecording = true;
err = mTestContext->mViVVid.codec->getOutputBuffers(
&mTestContext->mViVVid.buffers);
if (err != NO_ERROR) {
printf("Unable to get output buffers (err=%d)\n", err);
}
while (DoRecording) {
err = mTestContext->mViVVid.codec->dequeueOutputBuffer(
&bufIndex,
&offset,
&size,
&ptsUsec,
&flags, -1);
switch (err) {
case NO_ERROR:
// got a buffer
if ((flags & MediaCodec::BUFFER_FLAG_CODECCONFIG) != 0) {
// ignore this -- we passed the CSD into MediaMuxer when
// we got the format change notification
size = 0;
}
if (size != 0) {
// If the virtual display isn't providing us with timestamps,
// use the current time.
if (ptsUsec == 0) {
ptsUsec = systemTime(SYSTEM_TIME_MONOTONIC) / 1000;
}
// The MediaMuxer docs are unclear, but it appears that we
// need to pass either the full set of BufferInfo flags, or
// (flags & BUFFER_FLAG_SYNCFRAME).
err = mTestContext->mViVVid.muxer->writeSampleData(
mTestContext->mViVVid.buffers[bufIndex],
(size_t)trackIdx,
ptsUsec,
flags);
if (err != NO_ERROR) {
fprintf(stderr, "Failed writing data to muxer (err=%d)\n",
err);
}
debugNumFrames++;
}
err = mTestContext->mViVVid.codec->releaseOutputBuffer(bufIndex);
if (err != NO_ERROR) {
fprintf(stderr, "Unable to release output buffer (err=%d)\n",
err);
}
if ((flags & MediaCodec::BUFFER_FLAG_EOS) != 0) {
// Not expecting EOS from SurfaceFlinger. Go with it.
printf("Received end-of-stream\n");
//DoRecording = false;
}
break;
case -EAGAIN: // INFO_TRY_AGAIN_LATER
ALOGV("Got -EAGAIN, looping");
break;
case INFO_FORMAT_CHANGED: // INFO_OUTPUT_FORMAT_CHANGED
{
// format includes CSD, which we must provide to muxer
sp<AMessage> newFormat;
mTestContext->mViVVid.codec->getOutputFormat(&newFormat);
trackIdx = mTestContext->mViVVid.muxer->addTrack(newFormat);
err = mTestContext->mViVVid.muxer->start();
if (err != NO_ERROR) {
printf("Unable to start muxer (err=%d)\n", err);
}
}
break;
case INFO_OUTPUT_BUFFERS_CHANGED: // INFO_OUTPUT_BUFFERS_CHANGED
// not expected for an encoder; handle it anyway
ALOGV("Encoder buffers changed");
err = mTestContext->mViVVid.codec->getOutputBuffers(
&mTestContext->mViVVid.buffers);
if (err != NO_ERROR) {
printf("Unable to get new output buffers (err=%d)\n", err);
}
break;
case INVALID_OPERATION:
DoRecording = false;
break;
default:
printf("Got weird result %d from dequeueOutputBuffer\n", err);
break;
}
}
return;
}
/*===========================================================================
* FUNCTION : calcBufferSize
*
* DESCRIPTION: Temp buffer size calculation. Temp buffer is used to store
* the buffer from the camera with smaller resolution. It is
* copied to the buffer from camera with higher resolution.
*
* PARAMETERS :
* @width : video size width
* @height : video size height
*
* RETURN : size_t
*==========================================================================*/
size_t CameraContext::calcBufferSize(int width, int height)
{
size_t size = 0;
size_t UVAlignment;
size_t YPlane, UVPlane, YStride, UVStride, YScanlines, UVScanlines;
if (!width || !height) {
return size;
}
UVAlignment = 4096;
YStride = calcStride(width);
UVStride = calcStride(width);
YScanlines = calcYScanLines(height);
UVScanlines = calcUVScanLines(height);
YPlane = YStride * YScanlines;
UVPlane = UVStride * UVScanlines + UVAlignment;
size = YPlane + UVPlane;
size = VIDEO_BUF_ALLIGN(size, 4096);
return size;
}
/*===========================================================================
* FUNCTION : calcStride
*
* DESCRIPTION: Temp buffer stride calculation.
*
* PARAMETERS :
* @width : video size width
*
* RETURN : size_t
*==========================================================================*/
size_t CameraContext::calcStride(int width)
{
size_t alignment, stride = 0;
if (!width) {
return stride;
}
alignment = 128;
stride = VIDEO_BUF_ALLIGN((size_t)width, alignment);
return stride;
}
/*===========================================================================
* FUNCTION : calcYScanLines
*
* DESCRIPTION: Temp buffer scanlines calculation for Y plane.
*
* PARAMETERS :
* @width : video size height
*
* RETURN : size_t
*==========================================================================*/
size_t CameraContext::calcYScanLines(int height)
{
size_t alignment, scanlines = 0;
if (!height) {
return scanlines;
}
alignment = 32;
scanlines = VIDEO_BUF_ALLIGN((size_t)height, alignment);
return scanlines;
}
/*===========================================================================
* FUNCTION : calcUVScanLines
*
* DESCRIPTION: Temp buffer scanlines calculation for UV plane.
*
* PARAMETERS :
* @width : video size height
*
* RETURN : size_t
*==========================================================================*/
size_t CameraContext::calcUVScanLines(int height)
{
size_t alignment, scanlines = 0;
if (!height) {
return scanlines;
}
alignment = 16;
scanlines = VIDEO_BUF_ALLIGN((size_t)((height + 1) >> 1), alignment);
return scanlines;
}
/*===========================================================================
* FUNCTION : printSupportedParams
*
* DESCRIPTION: dump common supported parameters
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
void CameraContext::printSupportedParams()
{
const char *camera_ids = mParams.get("camera-indexes");
const char *pic_sizes = mParams.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES);
const char *pic_formats = mParams.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS);
const char *preview_sizes = mParams.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES);
const char *video_sizes = mParams.get(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES);
const char *preview_formats = mParams.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS);
const char *frame_rates = mParams.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES);
const char *thumb_sizes = mParams.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES);
const char *wb_modes = mParams.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE);
const char *effects = mParams.get(CameraParameters::KEY_SUPPORTED_EFFECTS);
const char *scene_modes = mParams.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES);
const char *focus_modes = mParams.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES);
const char *antibanding_modes = mParams.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING);
const char *flash_modes = mParams.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
int focus_areas = mParams.getInt(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS);
const char *fps_ranges = mParams.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE);
const char *focus_distances = mParams.get(CameraParameters::KEY_FOCUS_DISTANCES);
printf("\n\r\tSupported Cameras: %s",
(camera_ids != NULL)? camera_ids : "NULL");
printf("\n\r\tSupported Picture Sizes: %s",
(pic_sizes != NULL)? pic_sizes : "NULL");
printf("\n\r\tSupported Picture Formats: %s",
(pic_formats != NULL)? pic_formats : "NULL");
printf("\n\r\tSupported Preview Sizes: %s",
(preview_sizes != NULL)? preview_sizes : "NULL");
printf("\n\r\tSupported Video Sizes: %s",
(video_sizes != NULL)? video_sizes : "NULL");
printf("\n\r\tSupported Preview Formats: %s",
(preview_formats != NULL)? preview_formats : "NULL");
printf("\n\r\tSupported Preview Frame Rates: %s",
(frame_rates != NULL)? frame_rates : "NULL");
printf("\n\r\tSupported Thumbnail Sizes: %s",
(thumb_sizes != NULL)? thumb_sizes : "NULL");
printf("\n\r\tSupported Whitebalance Modes: %s",
(wb_modes != NULL)? wb_modes : "NULL");
printf("\n\r\tSupported Effects: %s",
(effects != NULL)? effects : "NULL");
printf("\n\r\tSupported Scene Modes: %s",
(scene_modes != NULL)? scene_modes : "NULL");
printf("\n\r\tSupported Focus Modes: %s",
(focus_modes != NULL)? focus_modes : "NULL");
printf("\n\r\tSupported Antibanding Options: %s",
(antibanding_modes != NULL)? antibanding_modes : "NULL");
printf("\n\r\tSupported Flash Modes: %s",
(flash_modes != NULL)? flash_modes : "NULL");
printf("\n\r\tSupported Focus Areas: %d", focus_areas);
printf("\n\r\tSupported FPS ranges : %s",
(fps_ranges != NULL)? fps_ranges : "NULL");
printf("\n\r\tFocus Distances: %s \n",
(focus_distances != NULL)? focus_distances : "NULL");
}
/*===========================================================================
* FUNCTION : createPreviewSurface
*
* DESCRIPTION: helper function for creating preview surfaces
*
* PARAMETERS :
* @width : preview width
* @height: preview height
* @pixFormat : surface pixelformat
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::createPreviewSurface(int width, int height, int32_t pixFormat)
{
int ret = NO_ERROR;
DisplayInfo dinfo;
sp<IBinder> display(SurfaceComposerClient::getBuiltInDisplay(
ISurfaceComposer::eDisplayIdMain));
SurfaceComposerClient::getDisplayInfo(display, &dinfo);
uint32_t previewWidth, previewHeight;
if ((0 >= width) || (0 >= height)) {
printf("Bad preview surface size %dx%d\n", width, height);
return BAD_VALUE;
}
if ((int)dinfo.w < width) {
previewWidth = dinfo.w;
} else {
previewWidth = (unsigned int)width;
}
if ((int)dinfo.h < height) {
previewHeight = dinfo.h;
} else {
previewHeight = (unsigned int)height;
}
mClient = new SurfaceComposerClient();
if ( NULL == mClient.get() ) {
printf("Unable to establish connection to Surface Composer \n");
return NO_INIT;
}
mSurfaceControl = mClient->createSurface(String8("QCamera_Test"),
previewWidth,
previewHeight,
pixFormat,
0);
if ( NULL == mSurfaceControl.get() ) {
printf("Unable to create preview surface \n");
return NO_INIT;
}
mPreviewSurface = mSurfaceControl->getSurface();
if ( NULL != mPreviewSurface.get() ) {
mClient->openGlobalTransaction();
ret |= mSurfaceControl->setLayer(0x7fffffff);
if ( mCameraIndex == 0 )
ret |= mSurfaceControl->setPosition(0, 0);
else
ret |= mSurfaceControl->setPosition((float)(dinfo.w - previewWidth),
(float)(dinfo.h - previewHeight));
ret |= mSurfaceControl->setSize(previewWidth, previewHeight);
ret |= mSurfaceControl->show();
mClient->closeGlobalTransaction();
if ( NO_ERROR != ret ) {
printf("Preview surface configuration failed! \n");
}
} else {
ret = NO_INIT;
}
return ret;
}
/*===========================================================================
* FUNCTION : destroyPreviewSurface
*
* DESCRIPTION: closes previously open preview surface
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::destroyPreviewSurface()
{
if ( NULL != mPreviewSurface.get() ) {
mPreviewSurface.clear();
}
if ( NULL != mSurfaceControl.get() ) {
mSurfaceControl->clear();
mSurfaceControl.clear();
}
if ( NULL != mClient.get() ) {
mClient->dispose();
mClient.clear();
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : CameraContext
*
* DESCRIPTION: camera context constructor
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
CameraContext::CameraContext(int cameraIndex) :
mCameraIndex(cameraIndex),
mResizePreview(true),
mHardwareActive(false),
mPreviewRunning(false),
mRecordRunning(false),
mVideoFd(-1),
mVideoIdx(0),
mRecordingHint(false),
mDoPrintMenu(true),
mPiPCapture(false),
mfmtMultiplier(1),
mSectionsRead(false),
mSectionsAllocated(0),
mSections(NULL),
mJEXIFTmp(NULL),
mHaveAll(false),
mCamera(NULL),
mClient(NULL),
mSurfaceControl(NULL),
mPreviewSurface(NULL),
mInUse(false)
{
mRecorder = new MediaRecorder(String16("camera"));
}
/*===========================================================================
* FUNCTION : setTestCtxInstance
*
* DESCRIPTION : Sends TestContext instance to CameraContext
*
* PARAMETERS :
* @instance : TestContext instance
*
* RETURN : None
*==========================================================================*/
void CameraContext::setTestCtxInstance(TestContext *instance)
{
mInterpr = instance;
}
/*===========================================================================
* FUNCTION : setTestCtxInst
*
* DESCRIPTION : Sends TestContext instance to Interpreter
*
* PARAMETERS :
* @instance : TestContext instance
*
* RETURN : None
*==========================================================================*/
void Interpreter::setTestCtxInst(TestContext *instance)
{
mTestContext = instance;
}
/*===========================================================================
* FUNCTION : ~CameraContext
*
* DESCRIPTION: camera context destructor
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
CameraContext::~CameraContext()
{
stopPreview();
closeCamera();
}
/*===========================================================================
* FUNCTION : openCamera
*
* DESCRIPTION: connects to and initializes camera
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::openCamera()
{
useLock();
const char *ZSLStr = NULL;
size_t ZSLStrSize = 0;
if ( NULL != mCamera.get() ) {
printf("Camera already open! \n");
signalFinished();
return NO_ERROR;
}
printf("openCamera(camera_index=%d)\n", mCameraIndex);
#ifndef USE_JB_MR1
String16 packageName("CameraTest");
mCamera = Camera::connect(mCameraIndex,
packageName,
Camera::USE_CALLING_UID);
#else
mCamera = Camera::connect(mCameraIndex);
#endif
if ( NULL == mCamera.get() ) {
printf("Unable to connect to CameraService\n");
signalFinished();
return NO_INIT;
}
mParams = mCamera->getParameters();
mParams.getSupportedPreviewSizes(mSupportedPreviewSizes);
mParams.getSupportedPictureSizes(mSupportedPictureSizes);
mParams.getSupportedVideoSizes(mSupportedVideoSizes);
mCurrentPictureSizeIdx = mSupportedPictureSizes.size() / 2;
mCurrentPreviewSizeIdx = mSupportedPreviewSizes.size() / 2;
mCurrentVideoSizeIdx = mSupportedVideoSizes.size() / 2;
mCamera->setListener(this);
mHardwareActive = true;
mInterpr->setViVSize((Size) mSupportedVideoSizes.itemAt(
mCurrentVideoSizeIdx),
mCameraIndex);
ZSLStr = mParams.get(CameraContext::KEY_ZSL);
if (NULL != ZSLStr) {
ZSLStrSize = strlen(ZSLStr);
if (!strncmp(ZSLStr, "on", ZSLStrSize)) {
mInterpr->mIsZSLOn = true;
} else if (!strncmp(ZSLStr, "off", ZSLStrSize)) {
mInterpr->mIsZSLOn = false;
} else {
printf("zsl value is not valid!\n");
}
} else {
printf("zsl is NULL\n");
}
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : onAsBinder
*
* DESCRIPTION: onAsBinder
*
* PARAMETERS : None
*
* RETURN : Pointer to IBinder
*==========================================================================*/
IBinder* CameraContext::onAsBinder() {
return NULL;
}
/*===========================================================================
* FUNCTION : getNumberOfCameras
*
* DESCRIPTION: returns the number of supported camera by the system
*
* PARAMETERS : None
*
* RETURN : supported camera count
*==========================================================================*/
int CameraContext::getNumberOfCameras()
{
int ret = -1;
if ( NULL != mCamera.get() ) {
ret = mCamera->getNumberOfCameras();
}
return ret;
}
/*===========================================================================
* FUNCTION : closeCamera
*
* DESCRIPTION: closes a previously the initialized camera reference
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::closeCamera()
{
useLock();
if ( NULL == mCamera.get() ) {
return NO_INIT;
}
mCamera->disconnect();
mCamera.clear();
mRecorder->init();
mRecorder->close();
mRecorder->release();
mRecorder.clear();
mHardwareActive = false;
mPreviewRunning = false;
mRecordRunning = false;
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : startPreview
*
* DESCRIPTION: starts camera preview
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::startPreview()
{
useLock();
int ret = NO_ERROR;
int previewWidth, previewHeight;
Size calculatedPreviewSize;
Size currentPreviewSize = mSupportedPreviewSizes.itemAt(
mCurrentPreviewSizeIdx);
Size currentPictureSize = mSupportedPictureSizes.itemAt(
mCurrentPictureSizeIdx);
Size currentVideoSize = mSupportedVideoSizes.itemAt(
mCurrentVideoSizeIdx);
#ifndef USE_JB_MR1
sp<IGraphicBufferProducer> gbp;
#endif
if (!mHardwareActive ) {
printf("Camera not active! \n");
return NO_INIT;
}
if (mPreviewRunning) {
printf("Preview is already running! \n");
signalFinished();
return NO_ERROR;
}
if (mResizePreview) {
mPreviewRunning = false;
if ( mRecordingHint ) {
calculatedPreviewSize =
getPreviewSizeFromVideoSizes(currentVideoSize);
previewWidth = calculatedPreviewSize.width;
previewHeight = calculatedPreviewSize.height;
} else {
previewWidth = currentPreviewSize.width;
previewHeight = currentPreviewSize.height;
}
ret = createPreviewSurface(previewWidth,
previewHeight,
HAL_PIXEL_FORMAT_YCrCb_420_SP);
if ( NO_ERROR != ret ) {
printf("Error while creating preview surface\n");
return ret;
}
// set rdi mode if system prop is set for front camera
if (mCameraIndex == 1) {
char value[32];
property_get("persist.camera.rdimode", value, "0");
int rdimode = atoi(value);
printf("rdi mode = %d\n", rdimode);
if (rdimode == 1) {
mParams.set("rdi-mode", "enable");
} else {
mParams.set("rdi-mode", "disable");
}
} else {
mParams.set("rdi-mode", "disable");
}
//mParams.set("rdi-mode", "enable");
mParams.set("recording-hint", "true");
mParams.setPreviewSize(previewWidth, previewHeight);
mParams.setPictureSize(currentPictureSize.width,
currentPictureSize.height);
mParams.setVideoSize(
currentVideoSize.width, currentVideoSize.height);
ret |= mCamera->setParameters(mParams.flatten());
#ifndef USE_JB_MR1
gbp = mPreviewSurface->getIGraphicBufferProducer();
ret |= mCamera->setPreviewTarget(gbp);
#else
ret |= mCamera->setPreviewDisplay(mPreviewSurface);
#endif
mResizePreview = false;
}
if ( !mPreviewRunning ) {
ret |= mCamera->startPreview();
if ( NO_ERROR != ret ) {
printf("Preview start failed! \n");
return ret;
}
mPreviewRunning = true;
}
signalFinished();
return ret;
}
/*===========================================================================
* FUNCTION : getPreviewSizeFromVideoSizes
*
* DESCRIPTION: Get the preview size from video size. Find all resolutions with
* the same aspect ratio and choose the same or the closest
* from them.
*
* PARAMETERS :
* @currentVideoSize: current video size
*
* RETURN : PreviewSize
*==========================================================================*/
Size CameraContext::getPreviewSizeFromVideoSizes(Size currentVideoSize)
{
Size tmpPreviewSize;
Size PreviewSize;
Size PreviewSizes[mSupportedPreviewSizes.size()];
double tolerance = 0.00001;
double videoRatio;
double previewRatio;
size_t i = 0;
size_t j = 0;
int delta;
// Find all the resolutions with the same aspect ratio and choose the
// same or the closest resolution from them. Choose the closest resolution
// in case same aspect ratio is not found
if (currentVideoSize.width * currentVideoSize.height > 0 &&
mSupportedPreviewSizes.size() > 0) {
videoRatio = (float)currentVideoSize.width /
(float)currentVideoSize.height;
for (i=0; i<mSupportedPreviewSizes.size(); i++) {
tmpPreviewSize = mSupportedPreviewSizes.itemAt(i);
previewRatio = (float)tmpPreviewSize.width /
(float)tmpPreviewSize.height;
if (fabs(videoRatio - previewRatio) < tolerance) {
PreviewSizes[j] = tmpPreviewSize;
j++;
}
}
if ( j > 0 ) {
delta = abs((currentVideoSize.width *currentVideoSize.height)-
(PreviewSizes[0].width * PreviewSizes[0].height));
PreviewSize = PreviewSizes[0];
for (i=0; i<j; i++) {
if(abs(currentVideoSize.width * currentVideoSize.height) -
(PreviewSizes[i].width * PreviewSizes[i].height) <
delta) {
PreviewSize = PreviewSizes[i];
delta = abs((currentVideoSize.width *
currentVideoSize.height) -
(PreviewSizes[i].width * PreviewSizes[i].height));
}
}
} else {
// Choose the closest resolution in case same aspect ratio is
// not found
tmpPreviewSize = mSupportedPreviewSizes.itemAt(j);
PreviewSize = tmpPreviewSize;
delta = abs(
(currentVideoSize.width * currentVideoSize.height)-
(tmpPreviewSize.width * tmpPreviewSize.height));
for (i=0; i<mSupportedPreviewSizes.size(); i++) {
tmpPreviewSize = mSupportedPreviewSizes.itemAt(i);
if(abs(
(currentVideoSize.width * currentVideoSize.height)-
(tmpPreviewSize.width * tmpPreviewSize.height)) <
delta) {
PreviewSize = tmpPreviewSize;
delta = abs(
(currentVideoSize.width * currentVideoSize.height)-
(tmpPreviewSize.width * tmpPreviewSize.height));
}
}
}
} else {
memset(&PreviewSize, 0, sizeof(PreviewSize));
}
return PreviewSize;
}
/*===========================================================================
* FUNCTION : autoFocus
*
* DESCRIPTION: Triggers autofocus
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::autoFocus()
{
useLock();
status_t ret = NO_ERROR;
if ( mPreviewRunning ) {
ret = mCamera->autoFocus();
}
signalFinished();
return ret;
}
/*===========================================================================
* FUNCTION : enablePreviewCallbacks
*
* DESCRIPTION: Enables preview callback messages
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::enablePreviewCallbacks()
{
useLock();
if ( mHardwareActive ) {
mCamera->setPreviewCallbackFlags(
CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
}
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : takePicture
*
* DESCRIPTION: triggers image capture
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::takePicture()
{
status_t ret = NO_ERROR;
useLock();
if ( mPreviewRunning ) {
ret = mCamera->takePicture(
CAMERA_MSG_COMPRESSED_IMAGE|
CAMERA_MSG_RAW_IMAGE);
if (!mRecordingHint && !mInterpr->mIsZSLOn) {
mPreviewRunning = false;
}
} else {
printf("Please resume/start the preview before taking a picture!\n");
}
signalFinished();
return ret;
}
/*===========================================================================
* FUNCTION : configureRecorder
*
* DESCRIPTION: Configure video recorder
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::configureRecorder()
{
useLock();
status_t ret = NO_ERROR;
mResizePreview = true;
mParams.set("recording-hint", "true");
mRecordingHint = true;
mCamera->setParameters(mParams.flatten());
Size videoSize = mSupportedVideoSizes.itemAt(mCurrentVideoSizeIdx);
ret = mRecorder->setParameters(
String8("video-param-encoding-bitrate=64000"));
if ( ret != NO_ERROR ) {
LOGE("Could not configure recorder (%d)", ret);
return ret;
}
ret = mRecorder->setCamera(
mCamera->remote(), mCamera->getRecordingProxy());
if ( ret != NO_ERROR ) {
LOGE("Could not set camera (%d)", ret);
return ret;
}
ret = mRecorder->setVideoSource(VIDEO_SOURCE_CAMERA);
if ( ret != NO_ERROR ) {
LOGE("Could not set video soruce (%d)", ret);
return ret;
}
ret = mRecorder->setAudioSource(AUDIO_SOURCE_DEFAULT);
if ( ret != NO_ERROR ) {
LOGE("Could not set audio source (%d)", ret);
return ret;
}
ret = mRecorder->setOutputFormat(OUTPUT_FORMAT_DEFAULT);
if ( ret != NO_ERROR ) {
LOGE("Could not set output format (%d)", ret);
return ret;
}
ret = mRecorder->setVideoEncoder(VIDEO_ENCODER_DEFAULT);
if ( ret != NO_ERROR ) {
LOGE("Could not set video encoder (%d)", ret);
return ret;
}
char fileName[100];
snprintf(fileName, sizeof(fileName) / sizeof(char),
"/sdcard/vid_cam%d_%dx%d_%d.mpeg", mCameraIndex,
videoSize.width, videoSize.height, mVideoIdx++);
if ( mVideoFd < 0 ) {
mVideoFd = open(fileName, O_CREAT | O_RDWR );
}
if ( mVideoFd < 0 ) {
LOGE("Could not open video file for writing %s!", fileName);
return UNKNOWN_ERROR;
}
ret = mRecorder->setOutputFile(mVideoFd, 0, 0);
if ( ret != NO_ERROR ) {
LOGE("Could not set output file (%d)", ret);
return ret;
}
ret = mRecorder->setVideoSize(videoSize.width, videoSize.height);
if ( ret != NO_ERROR ) {
LOGE("Could not set video size %dx%d", videoSize.width,
videoSize.height);
return ret;
}
ret = mRecorder->setVideoFrameRate(30);
if ( ret != NO_ERROR ) {
LOGE("Could not set video frame rate (%d)", ret);
return ret;
}
ret = mRecorder->setAudioEncoder(AUDIO_ENCODER_DEFAULT);
if ( ret != NO_ERROR ) {
LOGE("Could not set audio encoder (%d)", ret);
return ret;
}
signalFinished();
return ret;
}
/*===========================================================================
* FUNCTION : unconfigureViVRecording
*
* DESCRIPTION: Unconfigures video in video recording
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::unconfigureRecorder()
{
useLock();
if ( !mRecordRunning ) {
mResizePreview = true;
mParams.set("recording-hint", "false");
mRecordingHint = false;
mCamera->setParameters(mParams.flatten());
}
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : configureViVRecording
*
* DESCRIPTION: Configures video in video recording
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::configureViVRecording()
{
status_t ret = NO_ERROR;
mResizePreview = true;
mParams.set("recording-hint", "true");
mRecordingHint = true;
mCamera->setParameters(mParams.flatten());
mCamera->setRecordingProxyListener(this);
signalFinished();
return ret;
}
/*===========================================================================
* FUNCTION : startRecording
*
* DESCRIPTION: triggers start recording
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::startRecording()
{
useLock();
status_t ret = NO_ERROR;
if ( mPreviewRunning ) {
mCamera->unlock();
ret = mRecorder->prepare();
if ( ret != NO_ERROR ) {
LOGE("Could not prepare recorder");
return ret;
}
ret = mRecorder->start();
if ( ret != NO_ERROR ) {
LOGE("Could not start recorder");
return ret;
}
mRecordRunning = true;
}
signalFinished();
return ret;
}
/*===========================================================================
* FUNCTION : stopRecording
*
* DESCRIPTION: triggers start recording
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::stopRecording()
{
useLock();
status_t ret = NO_ERROR;
if ( mRecordRunning ) {
mRecorder->stop();
close(mVideoFd);
mVideoFd = -1;
mRecordRunning = false;
}
signalFinished();
return ret;
}
/*===========================================================================
* FUNCTION : startViVRecording
*
* DESCRIPTION: Starts video in video recording
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::startViVRecording()
{
useLock();
status_t ret;
if (mInterpr->mViVVid.VideoSizes[0].width *
mInterpr->mViVVid.VideoSizes[0].height >=
mInterpr->mViVVid.VideoSizes[1].width *
mInterpr->mViVVid.VideoSizes[1].height) {
mInterpr->mViVBuff.buffSize = calcBufferSize(
mInterpr->mViVVid.VideoSizes[1].width,
mInterpr->mViVVid.VideoSizes[1].height);
if (mInterpr->mViVBuff.buff == NULL) {
mInterpr->mViVBuff.buff =
(void *)malloc(mInterpr->mViVBuff.buffSize);
}
mInterpr->mViVVid.sourceCameraID = 1;
mInterpr->mViVVid.destinationCameraID = 0;
} else {
mInterpr->mViVBuff.buffSize = calcBufferSize(
mInterpr->mViVVid.VideoSizes[0].width,
mInterpr->mViVVid.VideoSizes[0].height);
if (mInterpr->mViVBuff.buff == NULL) {
mInterpr->mViVBuff.buff =
(void *)malloc(mInterpr->mViVBuff.buffSize);
}
mInterpr->mViVVid.sourceCameraID = 0;
mInterpr->mViVVid.destinationCameraID = 1;
}
ret = mCamera->startRecording();
signalFinished();
return ret;
}
/*===========================================================================
* FUNCTION : stopViVRecording
*
* DESCRIPTION: Stops video in video recording
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::stopViVRecording()
{
useLock();
status_t ret = NO_ERROR;
mCamera->stopRecording();
signalFinished();
return ret;
}
/*===========================================================================
* FUNCTION : stopPreview
*
* DESCRIPTION: stops camera preview
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::stopPreview()
{
useLock();
status_t ret = NO_ERROR;
if ( mHardwareActive ) {
mCamera->stopPreview();
ret = destroyPreviewSurface();
}
mPreviewRunning = false;
mResizePreview = true;
signalFinished();
return ret;
}
/*===========================================================================
* FUNCTION : resumePreview
*
* DESCRIPTION: resumes camera preview after image capture
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::resumePreview()
{
useLock();
status_t ret = NO_ERROR;
if ( mHardwareActive ) {
ret = mCamera->startPreview();
mPreviewRunning = true;
} else {
ret = NO_INIT;
}
signalFinished();
return ret;
}
/*===========================================================================
* FUNCTION : nextPreviewSize
*
* DESCRIPTION: Iterates through all supported preview sizes.
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::nextPreviewSize()
{
useLock();
if ( mHardwareActive ) {
mCurrentPreviewSizeIdx += 1;
mCurrentPreviewSizeIdx %= mSupportedPreviewSizes.size();
Size previewSize = mSupportedPreviewSizes.itemAt(
mCurrentPreviewSizeIdx);
mParams.setPreviewSize(previewSize.width,
previewSize.height);
mResizePreview = true;
if ( mPreviewRunning ) {
mCamera->stopPreview();
mCamera->setParameters(mParams.flatten());
mCamera->startPreview();
} else {
mCamera->setParameters(mParams.flatten());
}
}
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setPreviewSize
*
* DESCRIPTION: Sets exact preview size if supported
*
* PARAMETERS : format size in the form of WIDTHxHEIGHT
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::setPreviewSize(const char *format)
{
useLock();
if ( mHardwareActive ) {
int newHeight;
int newWidth;
sscanf(format, "%dx%d", &newWidth, &newHeight);
unsigned int i;
for (i = 0; i < mSupportedPreviewSizes.size(); ++i) {
Size previewSize = mSupportedPreviewSizes.itemAt(i);
if ( newWidth == previewSize.width &&
newHeight == previewSize.height )
{
break;
}
}
if ( i == mSupportedPreviewSizes.size())
{
printf("Preview size %dx%d not supported !\n",
newWidth, newHeight);
return INVALID_OPERATION;
}
mParams.setPreviewSize(newWidth,
newHeight);
mResizePreview = true;
if ( mPreviewRunning ) {
mCamera->stopPreview();
mCamera->setParameters(mParams.flatten());
mCamera->startPreview();
} else {
mCamera->setParameters(mParams.flatten());
}
}
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getCurrentPreviewSize
*
* DESCRIPTION: queries the currently configured preview size
*
* PARAMETERS :
* @previewSize : preview size currently configured
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::getCurrentPreviewSize(Size &previewSize)
{
useLock();
if ( mHardwareActive ) {
previewSize = mSupportedPreviewSizes.itemAt(mCurrentPreviewSizeIdx);
}
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : nextPictureSize
*
* DESCRIPTION: Iterates through all supported picture sizes.
*
* PARAMETERS : None
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::nextPictureSize()
{
useLock();
if ( mHardwareActive ) {
mCurrentPictureSizeIdx += 1;
mCurrentPictureSizeIdx %= mSupportedPictureSizes.size();
Size pictureSize = mSupportedPictureSizes.itemAt(
mCurrentPictureSizeIdx);
mParams.setPictureSize(pictureSize.width,
pictureSize.height);
mCamera->setParameters(mParams.flatten());
}
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setPictureSize
*
* DESCRIPTION: Sets exact preview size if supported
*
* PARAMETERS : format size in the form of WIDTHxHEIGHT
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::setPictureSize(const char *format)
{
useLock();
if ( mHardwareActive ) {
int newHeight;
int newWidth;
sscanf(format, "%dx%d", &newWidth, &newHeight);
unsigned int i;
for (i = 0; i < mSupportedPictureSizes.size(); ++i) {
Size PictureSize = mSupportedPictureSizes.itemAt(i);
if ( newWidth == PictureSize.width &&
newHeight == PictureSize.height )
{
break;
}
}
if ( i == mSupportedPictureSizes.size())
{
printf("Preview size %dx%d not supported !\n",
newWidth, newHeight);
return INVALID_OPERATION;
}
mParams.setPictureSize(newWidth,
newHeight);
mCamera->setParameters(mParams.flatten());
}
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : nextVideoSize
*
* DESCRIPTION: Select the next available video size
*
* PARAMETERS : none
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::nextVideoSize()
{
useLock();
if ( mHardwareActive ) {
mCurrentVideoSizeIdx += 1;
mCurrentVideoSizeIdx %= mSupportedVideoSizes.size();
Size videoSize = mSupportedVideoSizes.itemAt(mCurrentVideoSizeIdx);
mParams.setVideoSize(videoSize.width,
videoSize.height);
mCamera->setParameters(mParams.flatten());
mInterpr->setViVSize((Size) mSupportedVideoSizes.itemAt(
mCurrentVideoSizeIdx), mCameraIndex);
}
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setVideoSize
*
* DESCRIPTION: Set video size
*
* PARAMETERS :
* @format : format
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::setVideoSize(const char *format)
{
useLock();
if ( mHardwareActive ) {
int newHeight;
int newWidth;
sscanf(format, "%dx%d", &newWidth, &newHeight);
unsigned int i;
for (i = 0; i < mSupportedVideoSizes.size(); ++i) {
Size PictureSize = mSupportedVideoSizes.itemAt(i);
if ( newWidth == PictureSize.width &&
newHeight == PictureSize.height )
{
break;
}
}
if ( i == mSupportedVideoSizes.size())
{
printf("Preview size %dx%d not supported !\n",
newWidth, newHeight);
return INVALID_OPERATION;
}
mParams.setVideoSize(newWidth,
newHeight);
mCamera->setParameters(mParams.flatten());
}
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getCurrentVideoSize
*
* DESCRIPTION : Get current video size
*
* PARAMETERS :
* @videoSize: video Size
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::getCurrentVideoSize(Size &videoSize)
{
useLock();
if ( mHardwareActive ) {
videoSize = mSupportedVideoSizes.itemAt(mCurrentVideoSizeIdx);
}
signalFinished();
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getCurrentPictureSize
*
* DESCRIPTION: queries the currently configured picture size
*
* PARAMETERS :
* @pictureSize : picture size currently configured
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t CameraContext::getCurrentPictureSize(Size &pictureSize)
{
useLock();
if ( mHardwareActive ) {
pictureSize = mSupportedPictureSizes.itemAt(mCurrentPictureSizeIdx);
}
signalFinished();
return NO_ERROR;
}
}; //namespace qcamera ends here
using namespace qcamera;
/*===========================================================================
* FUNCTION : printMenu
*
* DESCRIPTION: prints the available camera options
*
* PARAMETERS :
* @currentCamera : camera context currently being used
*
* RETURN : None
*==========================================================================*/
void CameraContext::printMenu(sp<CameraContext> currentCamera)
{
if ( !mDoPrintMenu ) return;
Size currentPictureSize, currentPreviewSize, currentVideoSize;
const char *zsl_mode = mParams.get(CameraContext::KEY_ZSL);
assert(currentCamera.get());
currentCamera->getCurrentPictureSize(currentPictureSize);
currentCamera->getCurrentPreviewSize(currentPreviewSize);
currentCamera->getCurrentVideoSize(currentVideoSize);
printf("\n\n=========== FUNCTIONAL TEST MENU ===================\n\n");
printf(" \n\nSTART / STOP / GENERAL SERVICES \n");
printf(" -----------------------------\n");
printf(" %c. Switch camera - Current Index: %d\n",
Interpreter::SWITCH_CAMERA_CMD,
currentCamera->getCameraIndex());
printf(" %c. Resume Preview after capture \n",
Interpreter::RESUME_PREVIEW_CMD);
printf(" %c. Quit \n",
Interpreter::EXIT_CMD);
printf(" %c. Camera Capability Dump",
Interpreter::DUMP_CAPS_CMD);
printf(" \n\n PREVIEW SUB MENU \n");
printf(" -----------------------------\n");
printf(" %c. Start Preview\n",
Interpreter::START_PREVIEW_CMD);
printf(" %c. Stop Preview\n",
Interpreter::STOP_PREVIEW_CMD);
printf(" %c. Preview size: %dx%d\n",
Interpreter::CHANGE_PREVIEW_SIZE_CMD,
currentPreviewSize.width,
currentPreviewSize.height);
printf(" %c. Video size: %dx%d\n",
Interpreter::CHANGE_VIDEO_SIZE_CMD,
currentVideoSize.width,
currentVideoSize.height);
printf(" %c. Start Recording\n",
Interpreter::START_RECORD_CMD);
printf(" %c. Stop Recording\n",
Interpreter::STOP_RECORD_CMD);
printf(" %c. Start ViV Recording\n",
Interpreter::START_VIV_RECORD_CMD);
printf(" %c. Stop ViV Recording\n",
Interpreter::STOP_VIV_RECORD_CMD);
printf(" %c. Enable preview frames\n",
Interpreter::ENABLE_PRV_CALLBACKS_CMD);
printf(" %c. Trigger autofocus \n",
Interpreter::AUTOFOCUS_CMD);
printf(" \n\n IMAGE CAPTURE SUB MENU \n");
printf(" -----------------------------\n");
printf(" %c. Take picture/Full Press\n",
Interpreter::TAKEPICTURE_CMD);
printf(" %c. Take picture in picture\n",
Interpreter::TAKEPICTURE_IN_PICTURE_CMD);
printf(" %c. Picture size: %dx%d\n",
Interpreter::CHANGE_PICTURE_SIZE_CMD,
currentPictureSize.width,
currentPictureSize.height);
printf(" %c. zsl: %s\n", Interpreter::ZSL_CMD,
(zsl_mode != NULL) ? zsl_mode : "NULL");
printf("\n Choice: ");
}
/*===========================================================================
* FUNCTION : enablePrintPreview
*
* DESCRIPTION: Enables printing the preview
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
void CameraContext::enablePrintPreview()
{
mDoPrintMenu = true;
}
/*===========================================================================
* FUNCTION : disablePrintPreview
*
* DESCRIPTION: Disables printing the preview
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
void CameraContext::disablePrintPreview()
{
mDoPrintMenu = false;
}
/*===========================================================================
* FUNCTION : enablePiPCapture
*
* DESCRIPTION: Enables picture in picture capture
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
void CameraContext::enablePiPCapture()
{
mPiPCapture = true;
}
/*===========================================================================
* FUNCTION : disablePiPCapture
*
* DESCRIPTION: Disables picture in picture capture
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
void CameraContext::disablePiPCapture()
{
mPiPCapture = false;
}
/*===========================================================================
* FUNCTION : getZSL
*
* DESCRIPTION: get ZSL value of current camera
*
* PARAMETERS : None
*
* RETURN : current zsl value
*==========================================================================*/
const char *CameraContext::getZSL()
{
return mParams.get(CameraContext::KEY_ZSL);
}
/*===========================================================================
* FUNCTION : setZSL
*
* DESCRIPTION: set ZSL value of current camera
*
* PARAMETERS : zsl value to be set
*
* RETURN : None
*==========================================================================*/
void CameraContext::setZSL(const char *value)
{
mParams.set(CameraContext::KEY_ZSL, value);
mCamera->setParameters(mParams.flatten());
}
/*===========================================================================
* FUNCTION : configureViVCodec
*
* DESCRIPTION: Configures video in video codec
*
* PARAMETERS : none
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t Interpreter::configureViVCodec()
{
status_t ret = NO_ERROR;
char fileName[100];
sp<AMessage> format = new AMessage;
sp<ALooper> looper = new ALooper;
if (mTestContext->mViVVid.VideoSizes[0].width *
mTestContext->mViVVid.VideoSizes[0].height >=
mTestContext->mViVVid.VideoSizes[1].width *
mTestContext->mViVVid.VideoSizes[1].height) {
snprintf(fileName, sizeof(fileName) / sizeof(char), "/sdcard/ViV_vid_%dx%d_%d.mp4",
mTestContext->mViVVid.VideoSizes[0].width,
mTestContext->mViVVid.VideoSizes[0].height,
mTestContext->mViVVid.ViVIdx++);
format->setInt32("width", mTestContext->mViVVid.VideoSizes[0].width);
format->setInt32("height", mTestContext->mViVVid.VideoSizes[0].height);
} else {
snprintf(fileName, sizeof(fileName) / sizeof(char), "/sdcard/ViV_vid_%dx%d_%d.mp4",
mTestContext->mViVVid.VideoSizes[1].width,
mTestContext->mViVVid.VideoSizes[1].height,
mTestContext->mViVVid.ViVIdx++);
format->setInt32("width", mTestContext->mViVVid.VideoSizes[1].width);
format->setInt32("height", mTestContext->mViVVid.VideoSizes[1].height);
}
int fd = open(fileName, O_CREAT | O_RDWR );
if (fd < 0) {
LOGE("Error opening file");
return UNKNOWN_ERROR;
}
mTestContext->mViVVid.muxer = new MediaMuxer(
fd, MediaMuxer::OUTPUT_FORMAT_MPEG_4);
format->setString("mime", "video/avc");
format->setInt32("color-format", OMX_COLOR_FormatAndroidOpaque);
format->setInt32("bitrate", 1000000);
format->setFloat("frame-rate", 30);
format->setInt32("i-frame-interval", 10);
looper->setName("ViV_recording_looper");
looper->start();
ALOGV("Creating codec");
mTestContext->mViVVid.codec = MediaCodec::CreateByType(
looper, "video/avc", true);
if (mTestContext->mViVVid.codec == NULL) {
fprintf(stderr, "ERROR: unable to create video/avc codec instance\n");
return UNKNOWN_ERROR;
}
ret = mTestContext->mViVVid.codec->configure(format, NULL, NULL,
MediaCodec::CONFIGURE_FLAG_ENCODE);
if (ret != NO_ERROR) {
mTestContext->mViVVid.codec->release();
mTestContext->mViVVid.codec.clear();
fprintf(stderr, "ERROR: unable to configure codec (err=%d)\n", ret);
return ret;
}
ALOGV("Creating buffer producer");
ret = mTestContext->mViVVid.codec->createInputSurface(
&mTestContext->mViVVid.bufferProducer);
if (ret != NO_ERROR) {
mTestContext->mViVVid.codec->release();
mTestContext->mViVVid.codec.clear();
fprintf(stderr,
"ERROR: unable to create encoder input surface (err=%d)\n", ret);
return ret;
}
ret = mTestContext->mViVVid.codec->start();
if (ret != NO_ERROR) {
mTestContext->mViVVid.codec->release();
mTestContext->mViVVid.codec.clear();
fprintf(stderr, "ERROR: unable to start codec (err=%d)\n", ret);
return ret;
}
ALOGV("Codec prepared");
mTestContext->mViVVid.surface = new Surface(
mTestContext->mViVVid.bufferProducer);
mTestContext->mViVVid.ANW = mTestContext->mViVVid.surface;
ret = native_window_api_connect(mTestContext->mViVVid.ANW.get(),
NATIVE_WINDOW_API_CPU);
if (mTestContext->mViVVid.VideoSizes[0].width *
mTestContext->mViVVid.VideoSizes[0].height >=
mTestContext->mViVVid.VideoSizes[1].width *
mTestContext->mViVVid.VideoSizes[1].height) {
native_window_set_buffers_format(mTestContext->mViVVid.ANW.get(),
HAL_PIXEL_FORMAT_NV12_ENCODEABLE);
native_window_set_buffers_dimensions(mTestContext->mViVVid.ANW.get(),
mTestContext->mViVVid.VideoSizes[0].width,
mTestContext->mViVVid.VideoSizes[0].height);
} else {
native_window_set_buffers_format(mTestContext->mViVVid.ANW.get(),
HAL_PIXEL_FORMAT_NV12_ENCODEABLE);
native_window_set_buffers_dimensions(mTestContext->mViVVid.ANW.get(),
mTestContext->mViVVid.VideoSizes[1].width,
mTestContext->mViVVid.VideoSizes[1].height);
}
native_window_set_usage(mTestContext->mViVVid.ANW.get(),
GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
native_window_set_buffer_count(mTestContext->mViVVid.ANW.get(),
mTestContext->mViVVid.buff_cnt);
ViVEncoderThread();
return ret;
}
/*===========================================================================
* FUNCTION : unconfigureViVCodec
*
* DESCRIPTION: Unconfigures video in video codec
*
* PARAMETERS : none
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t Interpreter::unconfigureViVCodec()
{
status_t ret = NO_ERROR;
ret = native_window_api_disconnect(mTestContext->mViVVid.ANW.get(),
NATIVE_WINDOW_API_CPU);
mTestContext->mViVVid.bufferProducer = NULL;
mTestContext->mViVVid.codec->stop();
pthread_join(mViVEncThread, NULL);
mTestContext->mViVVid.muxer->stop();
mTestContext->mViVVid.codec->release();
mTestContext->mViVVid.codec.clear();
mTestContext->mViVVid.muxer.clear();
mTestContext->mViVVid.surface.clear();
return ret;
}
/*===========================================================================
* FUNCTION : Interpreter
*
* DESCRIPTION: Interpreter constructor
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
Interpreter::Interpreter(const char *file)
: mCmdIndex(0)
, mScript(NULL)
{
if (!file){
printf("no File Given\n");
mUseScript = false;
return;
}
FILE *fh = fopen(file, "r");
if ( !fh ) {
printf("Could not open file %s\n", file);
mUseScript = false;
return;
}
fseek(fh, 0, SEEK_END);
size_t len = (size_t)ftell(fh);
rewind(fh);
if( !len ) {
printf("Script file %s is empty !\n", file);
fclose(fh);
return;
}
mScript = new char[len + 1];
if ( !mScript ) {
fclose(fh);
return;
}
fread(mScript, sizeof(char), len, fh);
mScript[len] = '\0'; // ensure null terminated;
fclose(fh);
char *p1;
char *p2;
p1 = p2 = mScript;
do {
switch (*p1) {
case '\0':
case '|':
p1++;
break;
case SWITCH_CAMERA_CMD:
case RESUME_PREVIEW_CMD:
case START_PREVIEW_CMD:
case STOP_PREVIEW_CMD:
case CHANGE_PREVIEW_SIZE_CMD:
case CHANGE_PICTURE_SIZE_CMD:
case START_RECORD_CMD:
case STOP_RECORD_CMD:
case START_VIV_RECORD_CMD:
case STOP_VIV_RECORD_CMD:
case DUMP_CAPS_CMD:
case AUTOFOCUS_CMD:
case TAKEPICTURE_CMD:
case TAKEPICTURE_IN_PICTURE_CMD:
case ENABLE_PRV_CALLBACKS_CMD:
case EXIT_CMD:
case ZSL_CMD:
case DELAY:
p2 = p1;
while( (p2 != (mScript + len)) && (*p2 != '|')) {
p2++;
}
*p2 = '\0';
if (p2 == (p1 + 1))
mCommands.push_back(Command(
static_cast<Interpreter::Commands_e>(*p1)));
else
mCommands.push_back(Command(
static_cast<Interpreter::Commands_e>(*p1), (p1 + 1)));
p1 = p2;
break;
default:
printf("Invalid cmd %c \n", *p1);
do {
p1++;
} while(*p1 != '|' && p1 != (mScript + len));
}
} while(p1 != (mScript + len));
mUseScript = true;
}
/*===========================================================================
* FUNCTION : ~Interpreter
*
* DESCRIPTION: Interpreter destructor
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
Interpreter::~Interpreter()
{
if ( mScript )
delete[] mScript;
mCommands.clear();
}
/*===========================================================================
* FUNCTION : getCommand
*
* DESCRIPTION : Get a command from interpreter
*
* PARAMETERS :
* @currentCamera: Current camera context
*
* RETURN : command
*==========================================================================*/
Interpreter::Command Interpreter::getCommand(
sp<CameraContext> currentCamera)
{
if( mUseScript ) {
return mCommands[mCmdIndex++];
} else {
currentCamera->printMenu(currentCamera);
return Interpreter::Command(
static_cast<Interpreter::Commands_e>(getchar()));
}
}
/*===========================================================================
* FUNCTION : TestContext
*
* DESCRIPTION : TestContext constructor
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
TestContext::TestContext()
{
int i = 0;
mTestRunning = false;
mInterpreter = NULL;
mViVVid.ViVIdx = 0;
mViVVid.buff_cnt = 9;
mViVVid.graphBuf = 0;
mViVVid.mappedBuff = NULL;
mViVVid.isBuffValid = false;
mViVVid.sourceCameraID = -1;
mViVVid.destinationCameraID = -1;
mPiPinUse = false;
mViVinUse = false;
mIsZSLOn = false;
memset(&mViVBuff, 0, sizeof(ViVBuff_t));
ProcessState::self()->startThreadPool();
do {
camera[i] = new CameraContext(i);
if ( NULL == camera[i].get() ) {
break;
}
camera[i]->setTestCtxInstance(this);
//by default open only back camera
if (i==0) {
status_t stat = camera[i]->openCamera();
if ( NO_ERROR != stat ) {
printf("Error encountered Openging camera id : %d\n", i);
break;
}
}
mAvailableCameras.add(camera[i]);
i++;
} while ( i < camera[0]->getNumberOfCameras() ) ;
if (i < camera[0]->getNumberOfCameras() ) {
for (size_t j = 0; j < mAvailableCameras.size(); j++) {
camera[j] = mAvailableCameras.itemAt(j);
camera[j]->closeCamera();
camera[j].clear();
}
mAvailableCameras.clear();
}
}
/*===========================================================================
* FUNCTION : ~TestContext
*
* DESCRIPTION : TestContext destructor
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
TestContext::~TestContext()
{
delete mInterpreter;
for (size_t j = 0; j < mAvailableCameras.size(); j++) {
camera[j] = mAvailableCameras.itemAt(j);
camera[j]->closeCamera();
camera[j].clear();
}
mAvailableCameras.clear();
}
/*===========================================================================
* FUNCTION : GetCamerasNum
*
* DESCRIPTION : Get the number of available cameras
*
* PARAMETERS : None
*
* RETURN : Number of cameras
*==========================================================================*/
size_t TestContext::GetCamerasNum()
{
return mAvailableCameras.size();
}
/*===========================================================================
* FUNCTION : AddScriptFromFile
*
* DESCRIPTION : Add script from file
*
* PARAMETERS :
* @scriptFile : Script file
*
* RETURN : status_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
status_t TestContext::AddScriptFromFile(const char *scriptFile)
{
mInterpreter = new Interpreter(scriptFile);
mInterpreter->setTestCtxInst(this);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : releasePiPBuff
*
* DESCRIPTION : Release video in video temp buffer
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
void Interpreter::releasePiPBuff() {
free(mTestContext->mViVBuff.buff);
mTestContext->mViVBuff.buff = NULL;
}
/*===========================================================================
* FUNCTION : functionalTest
*
* DESCRIPTION: queries and executes client supplied commands for testing a
* particular camera.
*
* PARAMETERS :
* @availableCameras : List with all cameras supported
*
* RETURN : status_t type of status
* NO_ERROR -- continue testing
* none-zero -- quit test
*==========================================================================*/
status_t TestContext::FunctionalTest()
{
status_t stat = NO_ERROR;
const char *ZSLStr = NULL;
size_t ZSLStrSize = 0;
assert(mAvailableCameras.size());
if ( !mInterpreter ) {
mInterpreter = new Interpreter();
mInterpreter->setTestCtxInst(this);
}
if (mAvailableCameras.size() == 0) {
printf("no cameras supported... exiting test app\n");
} else {
mTestRunning = true;
}
while (mTestRunning) {
sp<CameraContext> currentCamera =
mAvailableCameras.itemAt(mCurrentCameraIndex);
Interpreter::Command command =
mInterpreter->getCommand(currentCamera);
currentCamera->enablePrintPreview();
switch (command.cmd) {
case Interpreter::SWITCH_CAMERA_CMD:
{
mCurrentCameraIndex++;
mCurrentCameraIndex %= mAvailableCameras.size();
currentCamera = mAvailableCameras.itemAt(mCurrentCameraIndex);
stat = currentCamera->openCamera();
}
break;
case Interpreter::RESUME_PREVIEW_CMD:
{
stat = currentCamera->resumePreview();
}
break;
case Interpreter::START_PREVIEW_CMD:
{
stat = currentCamera->startPreview();
}
break;
case Interpreter::STOP_PREVIEW_CMD:
{
stat = currentCamera->stopPreview();
}
break;
case Interpreter::CHANGE_VIDEO_SIZE_CMD:
{
if ( command.arg )
stat = currentCamera->setVideoSize(command.arg);
else
stat = currentCamera->nextVideoSize();
}
break;
case Interpreter::CHANGE_PREVIEW_SIZE_CMD:
{
if ( command.arg )
stat = currentCamera->setPreviewSize(command.arg);
else
stat = currentCamera->nextPreviewSize();
}
break;
case Interpreter::CHANGE_PICTURE_SIZE_CMD:
{
if ( command.arg )
stat = currentCamera->setPictureSize(command.arg);
else
stat = currentCamera->nextPictureSize();
}
break;
case Interpreter::DUMP_CAPS_CMD:
{
currentCamera->printSupportedParams();
}
break;
case Interpreter::AUTOFOCUS_CMD:
{
stat = currentCamera->autoFocus();
}
break;
case Interpreter::TAKEPICTURE_CMD:
{
stat = currentCamera->takePicture();
}
break;
case Interpreter::TAKEPICTURE_IN_PICTURE_CMD:
{
if (mAvailableCameras.size() == 2) {
mSaveCurrentCameraIndex = mCurrentCameraIndex;
for (size_t i = 0; i < mAvailableCameras.size(); i++) {
mCurrentCameraIndex = i;
currentCamera = mAvailableCameras.itemAt(mCurrentCameraIndex);
currentCamera->enablePiPCapture();
stat = currentCamera->takePicture();
}
mCurrentCameraIndex = mSaveCurrentCameraIndex;
} else {
printf("Number of available sensors should be 2\n");
}
}
break;
case Interpreter::ENABLE_PRV_CALLBACKS_CMD:
{
stat = currentCamera->enablePreviewCallbacks();
}
break;
case Interpreter::START_RECORD_CMD:
{
stat = currentCamera->stopPreview();
stat = currentCamera->configureRecorder();
stat = currentCamera->startPreview();
stat = currentCamera->startRecording();
}
break;
case Interpreter::STOP_RECORD_CMD:
{
stat = currentCamera->stopRecording();
stat = currentCamera->stopPreview();
stat = currentCamera->unconfigureRecorder();
stat = currentCamera->startPreview();
}
break;
case Interpreter::START_VIV_RECORD_CMD:
{
if (mAvailableCameras.size() == 2) {
mSaveCurrentCameraIndex = mCurrentCameraIndex;
stat = mInterpreter->configureViVCodec();
for ( size_t i = 0; i < mAvailableCameras.size(); i++ ) {
mCurrentCameraIndex = i;
currentCamera = mAvailableCameras.itemAt(
mCurrentCameraIndex);
stat = currentCamera->stopPreview();
stat = currentCamera->configureViVRecording();
stat = currentCamera->startPreview();
stat = currentCamera->startViVRecording();
}
mCurrentCameraIndex = mSaveCurrentCameraIndex;
} else {
printf("Number of available sensors should be 2\n");
}
}
break;
case Interpreter::STOP_VIV_RECORD_CMD:
{
if (mAvailableCameras.size() == 2) {
mSaveCurrentCameraIndex = mCurrentCameraIndex;
for ( size_t i = 0; i < mAvailableCameras.size(); i++ ) {
mCurrentCameraIndex = i;
currentCamera = mAvailableCameras.itemAt(
mCurrentCameraIndex);
stat = currentCamera->stopViVRecording();
stat = currentCamera->stopPreview();
stat = currentCamera->unconfigureRecorder();
stat = currentCamera->startPreview();
}
stat = mInterpreter->unconfigureViVCodec();
mCurrentCameraIndex = mSaveCurrentCameraIndex;
mInterpreter->releasePiPBuff();
} else {
printf("Number of available sensors should be 2\n");
}
}
break;
case Interpreter::EXIT_CMD:
{
currentCamera->stopPreview();
mTestRunning = false;
}
break;
case Interpreter::DELAY:
{
if ( command.arg ) {
int delay = atoi(command.arg);
if (0 < delay) {
usleep(1000U * (unsigned int)delay);
}
}
}
break;
case Interpreter::ZSL_CMD:
{
currentCamera = mAvailableCameras.itemAt(
mCurrentCameraIndex);
ZSLStr = currentCamera->getZSL();
if (NULL != ZSLStr) {
ZSLStrSize = strlen(ZSLStr);
if (!strncmp(ZSLStr, "off", ZSLStrSize)) {
currentCamera->setZSL("on");
mIsZSLOn = true;
} else if (!strncmp(ZSLStr, "on", ZSLStrSize)) {
currentCamera->setZSL("off");
mIsZSLOn = false;
} else {
printf("Set zsl failed!\n");
}
} else {
printf("zsl is NULL\n");
}
}
break;
default:
{
currentCamera->disablePrintPreview();
}
break;
}
printf("Command status 0x%x \n", stat);
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : PiPLock
*
* DESCRIPTION: Mutex lock for PiP capture
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void TestContext::PiPLock()
{
Mutex::Autolock l(mPiPLock);
while (mPiPinUse) {
mPiPCond.wait(mPiPLock);
}
mPiPinUse = true;
}
/*===========================================================================
* FUNCTION : PiPUnLock
*
* DESCRIPTION: Mutex unlock for PiP capture
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void TestContext::PiPUnlock()
{
Mutex::Autolock l(mPiPLock);
mPiPinUse = false;
mPiPCond.signal();
}
/*===========================================================================
* FUNCTION : ViVLock
*
* DESCRIPTION: Mutex lock for ViV Video
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void TestContext::ViVLock()
{
Mutex::Autolock l(mViVLock);
while (mViVinUse) {
mViVCond.wait(mViVLock);
}
mViVinUse = true;
}
/*===========================================================================
* FUNCTION : ViVUnlock
*
* DESCRIPTION: Mutex unlock for ViV Video
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void TestContext::ViVUnlock()
{
Mutex::Autolock l(mViVLock);
mViVinUse = false;
mViVCond.signal();
}
/*===========================================================================
* FUNCTION : setViVSize
*
* DESCRIPTION : Set video in video size
*
* PARAMETERS :
* @VideoSize : video size
* @camIndex : camera index
*
* RETURN : none
*==========================================================================*/
void TestContext::setViVSize(Size VideoSize, int camIndex)
{
mViVVid.VideoSizes[camIndex] = VideoSize;
}
/*===========================================================================
* FUNCTION : main
*
* DESCRIPTION : main function
*
* PARAMETERS :
* @argc : argc
* @argv : argv
*
* RETURN : int status
*==========================================================================*/
int main(int argc, char *argv[])
{
TestContext ctx;
if (argc > 1) {
if ( ctx.AddScriptFromFile((const char *)argv[1]) ) {
printf("Could not add script file... "
"continuing in normal menu mode! \n");
}
}
ctx.FunctionalTest();
return 0;
}