361 lines
9.8 KiB
C++
361 lines
9.8 KiB
C++
/*
|
|
* Copyright (C) Texas Instruments - http://www.ti.com/
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/**
|
|
* @file CameraHalUtilClasses.cpp
|
|
*
|
|
* This file maps the CameraHardwareInterface to the Camera interfaces on OMAP4 (mainly OMX).
|
|
*
|
|
*/
|
|
|
|
#include "CameraHal.h"
|
|
|
|
namespace Ti {
|
|
namespace Camera {
|
|
|
|
/*--------------------FrameProvider Class STARTS here-----------------------------*/
|
|
|
|
int FrameProvider::enableFrameNotification(int32_t frameTypes)
|
|
{
|
|
LOG_FUNCTION_NAME;
|
|
status_t ret = NO_ERROR;
|
|
|
|
///Enable the frame notification to CameraAdapter (which implements FrameNotifier interface)
|
|
mFrameNotifier->enableMsgType(frameTypes<<MessageNotifier::FRAME_BIT_FIELD_POSITION
|
|
, mFrameCallback
|
|
, NULL
|
|
, mCookie
|
|
);
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
return ret;
|
|
}
|
|
|
|
int FrameProvider::disableFrameNotification(int32_t frameTypes)
|
|
{
|
|
LOG_FUNCTION_NAME;
|
|
status_t ret = NO_ERROR;
|
|
|
|
mFrameNotifier->disableMsgType(frameTypes<<MessageNotifier::FRAME_BIT_FIELD_POSITION
|
|
, mCookie
|
|
);
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
return ret;
|
|
}
|
|
|
|
int FrameProvider::returnFrame(CameraBuffer *frameBuf, CameraFrame::FrameType frameType)
|
|
{
|
|
status_t ret = NO_ERROR;
|
|
|
|
mFrameNotifier->returnFrame(frameBuf, frameType);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void FrameProvider::addFramePointers(CameraBuffer *frameBuf, void *buf)
|
|
{
|
|
mFrameNotifier->addFramePointers(frameBuf, buf);
|
|
return;
|
|
}
|
|
|
|
void FrameProvider::removeFramePointers()
|
|
{
|
|
mFrameNotifier->removeFramePointers();
|
|
return;
|
|
}
|
|
|
|
/*--------------------FrameProvider Class ENDS here-----------------------------*/
|
|
|
|
/*--------------------EventProvider Class STARTS here-----------------------------*/
|
|
|
|
int EventProvider::enableEventNotification(int32_t frameTypes)
|
|
{
|
|
LOG_FUNCTION_NAME;
|
|
status_t ret = NO_ERROR;
|
|
|
|
///Enable the frame notification to CameraAdapter (which implements FrameNotifier interface)
|
|
mEventNotifier->enableMsgType(frameTypes<<MessageNotifier::EVENT_BIT_FIELD_POSITION
|
|
, NULL
|
|
, mEventCallback
|
|
, mCookie
|
|
);
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
return ret;
|
|
}
|
|
|
|
int EventProvider::disableEventNotification(int32_t frameTypes)
|
|
{
|
|
LOG_FUNCTION_NAME;
|
|
status_t ret = NO_ERROR;
|
|
|
|
mEventNotifier->disableMsgType(frameTypes<<MessageNotifier::EVENT_BIT_FIELD_POSITION
|
|
, mCookie
|
|
);
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
return ret;
|
|
}
|
|
|
|
/*--------------------EventProvider Class ENDS here-----------------------------*/
|
|
|
|
/*--------------------CameraArea Class STARTS here-----------------------------*/
|
|
|
|
status_t CameraArea::transfrom(size_t width,
|
|
size_t height,
|
|
size_t &top,
|
|
size_t &left,
|
|
size_t &areaWidth,
|
|
size_t &areaHeight)
|
|
{
|
|
status_t ret = NO_ERROR;
|
|
size_t hRange, vRange;
|
|
double hScale, vScale;
|
|
|
|
LOG_FUNCTION_NAME
|
|
|
|
hRange = CameraArea::RIGHT - CameraArea::LEFT;
|
|
vRange = CameraArea::BOTTOM - CameraArea::TOP;
|
|
hScale = ( double ) width / ( double ) hRange;
|
|
vScale = ( double ) height / ( double ) vRange;
|
|
|
|
top = ( mTop + vRange / 2 ) * vScale;
|
|
left = ( mLeft + hRange / 2 ) * hScale;
|
|
areaHeight = ( mBottom + vRange / 2 ) * vScale;
|
|
areaHeight -= top;
|
|
areaWidth = ( mRight + hRange / 2) * hScale;
|
|
areaWidth -= left;
|
|
|
|
LOG_FUNCTION_NAME_EXIT
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t CameraArea::checkArea(ssize_t top,
|
|
ssize_t left,
|
|
ssize_t bottom,
|
|
ssize_t right,
|
|
ssize_t weight)
|
|
{
|
|
|
|
//Handles the invalid regin corner case.
|
|
if ( ( 0 == top ) && ( 0 == left ) && ( 0 == bottom ) && ( 0 == right ) && ( 0 == weight ) ) {
|
|
return NO_ERROR;
|
|
}
|
|
|
|
if ( ( CameraArea::WEIGHT_MIN > weight ) || ( CameraArea::WEIGHT_MAX < weight ) ) {
|
|
CAMHAL_LOGEB("Camera area weight is invalid %d", weight);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if ( ( CameraArea::TOP > top ) || ( CameraArea::BOTTOM < top ) ) {
|
|
CAMHAL_LOGEB("Camera area top coordinate is invalid %d", top );
|
|
return -EINVAL;
|
|
}
|
|
|
|
if ( ( CameraArea::TOP > bottom ) || ( CameraArea::BOTTOM < bottom ) ) {
|
|
CAMHAL_LOGEB("Camera area bottom coordinate is invalid %d", bottom );
|
|
return -EINVAL;
|
|
}
|
|
|
|
if ( ( CameraArea::LEFT > left ) || ( CameraArea::RIGHT < left ) ) {
|
|
CAMHAL_LOGEB("Camera area left coordinate is invalid %d", left );
|
|
return -EINVAL;
|
|
}
|
|
|
|
if ( ( CameraArea::LEFT > right ) || ( CameraArea::RIGHT < right ) ) {
|
|
CAMHAL_LOGEB("Camera area right coordinate is invalid %d", right );
|
|
return -EINVAL;
|
|
}
|
|
|
|
if ( left >= right ) {
|
|
CAMHAL_LOGEA("Camera area left larger than right");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if ( top >= bottom ) {
|
|
CAMHAL_LOGEA("Camera area top larger than bottom");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t CameraArea::parseAreas(const char *area,
|
|
size_t areaLength,
|
|
android::Vector<android::sp<CameraArea> > &areas)
|
|
{
|
|
status_t ret = NO_ERROR;
|
|
char *ctx;
|
|
char *pArea = NULL;
|
|
char *pStart = NULL;
|
|
char *pEnd = NULL;
|
|
const char *startToken = "(";
|
|
const char endToken = ')';
|
|
const char sep = ',';
|
|
ssize_t top, left, bottom, right, weight;
|
|
char *tmpBuffer = NULL;
|
|
android::sp<CameraArea> currentArea;
|
|
|
|
LOG_FUNCTION_NAME
|
|
|
|
if ( ( NULL == area ) ||
|
|
( 0 >= areaLength ) )
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
tmpBuffer = ( char * ) malloc(areaLength);
|
|
if ( NULL == tmpBuffer )
|
|
{
|
|
return -ENOMEM;
|
|
}
|
|
|
|
memcpy(tmpBuffer, area, areaLength);
|
|
|
|
pArea = strtok_r(tmpBuffer, startToken, &ctx);
|
|
|
|
do
|
|
{
|
|
|
|
pStart = pArea;
|
|
if ( NULL == pStart )
|
|
{
|
|
CAMHAL_LOGEA("Parsing of the left area coordinate failed!");
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
left = static_cast<ssize_t>(strtol(pStart, &pEnd, 10));
|
|
}
|
|
|
|
if ( sep != *pEnd )
|
|
{
|
|
CAMHAL_LOGEA("Parsing of the top area coordinate failed!");
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
top = static_cast<ssize_t>(strtol(pEnd+1, &pEnd, 10));
|
|
}
|
|
|
|
if ( sep != *pEnd )
|
|
{
|
|
CAMHAL_LOGEA("Parsing of the right area coordinate failed!");
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
right = static_cast<ssize_t>(strtol(pEnd+1, &pEnd, 10));
|
|
}
|
|
|
|
if ( sep != *pEnd )
|
|
{
|
|
CAMHAL_LOGEA("Parsing of the bottom area coordinate failed!");
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
bottom = static_cast<ssize_t>(strtol(pEnd+1, &pEnd, 10));
|
|
}
|
|
|
|
if ( sep != *pEnd )
|
|
{
|
|
CAMHAL_LOGEA("Parsing of the weight area coordinate failed!");
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
weight = static_cast<ssize_t>(strtol(pEnd+1, &pEnd, 10));
|
|
}
|
|
|
|
if ( endToken != *pEnd )
|
|
{
|
|
CAMHAL_LOGEA("Malformed area!");
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
ret = checkArea(top, left, bottom, right, weight);
|
|
if ( NO_ERROR != ret ) {
|
|
break;
|
|
}
|
|
|
|
currentArea = new CameraArea(top, left, bottom, right, weight);
|
|
CAMHAL_LOGDB("Area parsed [%dx%d, %dx%d] %d",
|
|
( int ) top,
|
|
( int ) left,
|
|
( int ) bottom,
|
|
( int ) right,
|
|
( int ) weight);
|
|
if ( NULL != currentArea.get() )
|
|
{
|
|
areas.add(currentArea);
|
|
}
|
|
else
|
|
{
|
|
ret = -ENOMEM;
|
|
break;
|
|
}
|
|
|
|
pArea = strtok_r(NULL, startToken, &ctx);
|
|
|
|
}
|
|
while ( NULL != pArea );
|
|
|
|
if ( NULL != tmpBuffer )
|
|
{
|
|
free(tmpBuffer);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME_EXIT
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool CameraArea::areAreasDifferent(android::Vector< android::sp<CameraArea> > &area1,
|
|
android::Vector< android::sp<CameraArea> > &area2) {
|
|
if (area1.size() != area2.size()) {
|
|
return true;
|
|
}
|
|
|
|
// not going to care about sorting order for now
|
|
for (int i = 0; i < area1.size(); i++) {
|
|
if (!area1.itemAt(i)->compare(area2.itemAt(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CameraArea::compare(const android::sp<CameraArea> &area) {
|
|
return ((mTop == area->mTop) && (mLeft == area->mLeft) &&
|
|
(mBottom == area->mBottom) && (mRight == area->mRight) &&
|
|
(mWeight == area->mWeight));
|
|
}
|
|
|
|
|
|
/*--------------------CameraArea Class ENDS here-----------------------------*/
|
|
|
|
} // namespace Camera
|
|
} // namespace Ti
|