| /* |
| * 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). |
| * |
| */ |
| |
| #define LOG_TAG "CameraHAL" |
| |
| |
| #include "CameraHal.h" |
| |
| namespace android { |
| |
| /*--------------------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(void *frameBuf, CameraFrame::FrameType frameType) |
| { |
| status_t ret = NO_ERROR; |
| |
| mFrameNotifier->returnFrame(frameBuf, frameType); |
| |
| return ret; |
| } |
| |
| void FrameProvider::addFramePointers(void *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::FRAME_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, |
| Vector< 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; |
| 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(Vector< sp<CameraArea> > &area1, |
| Vector< 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 sp<CameraArea> &area) { |
| return ((mTop == area->mTop) && (mLeft == area->mLeft) && |
| (mBottom == area->mBottom) && (mRight == area->mRight) && |
| (mWeight == area->mWeight)); |
| } |
| |
| |
| /*--------------------CameraArea Class ENDS here-----------------------------*/ |
| |
| }; |
