camera/OMXCameraAdapter/OMXFD.cpp - platform/hardware/ti/omap4xxx - Git at Google

 /*
  * 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 OMXFD.cpp
 *
 * This file contains functionality for handling face detection.
 *
 */

 #undef LOG_TAG

 #define LOG_TAG "CameraHAL"

 #include "CameraHal.h"
 #include "OMXCameraAdapter.h"

 #define FACE_DETECTION_THRESHOLD 80

 // constants used for face smooth filtering
 static const int HorizontalFilterThreshold = 40;
 static const int VerticalFilterThreshold = 40;
 static const int HorizontalFaceSizeThreshold = 30;
 static const int VerticalFaceSizeThreshold = 30;


 namespace android {

 status_t OMXCameraAdapter::setParametersFD(const CameraParameters &params,
                                            BaseCameraAdapter::AdapterState state)
 {
     status_t ret = NO_ERROR;

     LOG_FUNCTION_NAME;

     LOG_FUNCTION_NAME_EXIT;

     return ret;
 }

 status_t OMXCameraAdapter::startFaceDetection()
 {
     status_t ret = NO_ERROR;

     Mutex::Autolock lock(mFaceDetectionLock);

     ret = setFaceDetection(true, mDeviceOrientation);
     if (ret != NO_ERROR) {
         goto out;
     }

     if ( mFaceDetectionRunning )
         {
         //Disable region priority and enable face priority for AF
         setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
         setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO , true);

         //Disable Region priority and enable Face priority
         setAlgoPriority(REGION_PRIORITY, EXPOSURE_ALGO, false);
         setAlgoPriority(FACE_PRIORITY, EXPOSURE_ALGO, true);
         }

     // Note: White balance will not be face prioritized, since
     // the algorithm needs full frame statistics, and not face
     // regions alone.

     faceDetectionNumFacesLastOutput = 0;
  out:
     return ret;
 }

 status_t OMXCameraAdapter::stopFaceDetection()
 {
     status_t ret = NO_ERROR;
     const char *str = NULL;
     BaseCameraAdapter::AdapterState state;
     BaseCameraAdapter::getState(state);

     Mutex::Autolock lock(mFaceDetectionLock);

     ret = setFaceDetection(false, mDeviceOrientation);
     if (ret != NO_ERROR) {
         goto out;
     }

     // Reset 3A settings
     ret = setParameters3A(mParams, state);
     if (ret != NO_ERROR) {
         goto out;
     }

     if (mPending3Asettings) {
         apply3Asettings(mParameters3A);
     }

     faceDetectionNumFacesLastOutput = 0;
  out:
     return ret;
 }

 void OMXCameraAdapter::pauseFaceDetection(bool pause)
 {
     Mutex::Autolock lock(mFaceDetectionLock);
     // pausing will only take affect if fd is already running
     if (mFaceDetectionRunning) {
         mFaceDetectionPaused = pause;
         faceDetectionNumFacesLastOutput = 0;
     }
 }

 status_t OMXCameraAdapter::setFaceDetection(bool enable, OMX_U32 orientation)
 {
     status_t ret = NO_ERROR;
     OMX_ERRORTYPE eError = OMX_ErrorNone;
     OMX_CONFIG_OBJDETECTIONTYPE objDetection;

     LOG_FUNCTION_NAME;

     if ( OMX_StateInvalid == mComponentState )
         {
         CAMHAL_LOGEA("OMX component is in invalid state");
         ret = -EINVAL;
         }

     if ( NO_ERROR == ret )
         {
         if ( orientation > 270 ) {
             orientation = 0;
         }

         OMX_INIT_STRUCT_PTR (&objDetection, OMX_CONFIG_OBJDETECTIONTYPE);
         objDetection.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
         objDetection.nDeviceOrientation = orientation;
         if  ( enable )
             {
             objDetection.bEnable = OMX_TRUE;
             }
         else
             {
             objDetection.bEnable = OMX_FALSE;
             }

         eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
                                 ( OMX_INDEXTYPE ) OMX_IndexConfigImageFaceDetection,
                                 &objDetection);
         if ( OMX_ErrorNone != eError )
             {
             CAMHAL_LOGEB("Error while configuring face detection 0x%x", eError);
             ret = -1;
             }
         else
             {
             CAMHAL_LOGDA("Face detection configured successfully");
             }
         }

     if ( NO_ERROR == ret )
         {
         ret = setExtraData(enable, mCameraAdapterParameters.mPrevPortIndex, OMX_FaceDetection);

         if ( NO_ERROR != ret )
             {
             CAMHAL_LOGEA("Error while configuring face detection extra data");
             }
         else
             {
             CAMHAL_LOGDA("Face detection extra data configured successfully");
             }
         }

     if ( NO_ERROR == ret )
         {
         mFaceDetectionRunning = enable;
         mFaceDetectionPaused = !enable;
         }

     LOG_FUNCTION_NAME_EXIT;

     return ret;
 }

 status_t OMXCameraAdapter::detectFaces(OMX_BUFFERHEADERTYPE* pBuffHeader,
                                        sp<CameraFDResult> &result,
                                        size_t previewWidth,
                                        size_t previewHeight)
 {
     status_t ret = NO_ERROR;
     OMX_ERRORTYPE eError = OMX_ErrorNone;
     OMX_TI_FACERESULT *faceResult;
     OMX_OTHER_EXTRADATATYPE *extraData;
     OMX_FACEDETECTIONTYPE *faceData;
     OMX_TI_PLATFORMPRIVATE *platformPrivate;
     camera_frame_metadata_t *faces;

     LOG_FUNCTION_NAME;

     if ( OMX_StateExecuting != mComponentState ) {
         CAMHAL_LOGEA("OMX component is not in executing state");
         return NO_INIT;
     }

     if ( NULL == pBuffHeader ) {
         CAMHAL_LOGEA("Invalid Buffer header");
         return-EINVAL;
     }

     platformPrivate = (OMX_TI_PLATFORMPRIVATE *) (pBuffHeader->pPlatformPrivate);
     if ( NULL != platformPrivate ) {
         if ( sizeof(OMX_TI_PLATFORMPRIVATE) == platformPrivate->nSize ) {
             CAMHAL_LOGVB("Size = %d, sizeof = %d, pAuxBuf = 0x%x, pAuxBufSize= %d, pMetaDataBufer = 0x%x, nMetaDataSize = %d",
                          platformPrivate->nSize,
                          sizeof(OMX_TI_PLATFORMPRIVATE),
                          platformPrivate->pAuxBuf1,
                          platformPrivate->pAuxBufSize1,
                          platformPrivate->pMetaDataBuffer,
                          platformPrivate->nMetaDataSize);
         } else {
             CAMHAL_LOGDB("OMX_TI_PLATFORMPRIVATE size mismatch: expected = %d, received = %d",
                          ( unsigned int ) sizeof(OMX_TI_PLATFORMPRIVATE),
                          ( unsigned int ) platformPrivate->nSize);
             return -EINVAL;
         }
     }  else {
         CAMHAL_LOGDA("Invalid OMX_TI_PLATFORMPRIVATE");
         return-EINVAL;
     }


     if ( 0 >= platformPrivate->nMetaDataSize ) {
         CAMHAL_LOGDB("OMX_TI_PLATFORMPRIVATE nMetaDataSize is size is %d",
                      ( unsigned int ) platformPrivate->nMetaDataSize);
         return -EINVAL;
     }

     extraData = getExtradata((OMX_OTHER_EXTRADATATYPE *) (platformPrivate->pMetaDataBuffer),
             (OMX_EXTRADATATYPE)OMX_FaceDetection);

     if ( NULL != extraData ) {
         CAMHAL_LOGVB("Size = %d, sizeof = %d, eType = 0x%x, nDataSize= %d, nPortIndex = 0x%x, nVersion = 0x%x",
                      extraData->nSize,
                      sizeof(OMX_OTHER_EXTRADATATYPE),
                      extraData->eType,
                      extraData->nDataSize,
                      extraData->nPortIndex,
                      extraData->nVersion);
     } else {
         CAMHAL_LOGDA("Invalid OMX_OTHER_EXTRADATATYPE");
         return -EINVAL;
     }

     faceData = ( OMX_FACEDETECTIONTYPE * ) extraData->data;
     if ( NULL != faceData ) {
         if ( sizeof(OMX_FACEDETECTIONTYPE) == faceData->nSize ) {
             CAMHAL_LOGVB("Faces detected %d",
                          faceData->ulFaceCount,
                          faceData->nSize,
                          sizeof(OMX_FACEDETECTIONTYPE),
                          faceData->eCameraView,
                          faceData->nPortIndex,
                          faceData->nVersion);
         } else {
             CAMHAL_LOGDB("OMX_FACEDETECTIONTYPE size mismatch: expected = %d, received = %d",
                          ( unsigned int ) sizeof(OMX_FACEDETECTIONTYPE),
                          ( unsigned int ) faceData->nSize);
             return -EINVAL;
         }
     } else {
         CAMHAL_LOGEA("Invalid OMX_FACEDETECTIONTYPE");
         return -EINVAL;
     }

     ret = encodeFaceCoordinates(faceData, &faces, previewWidth, previewHeight);

     if ( NO_ERROR == ret ) {
         result = new CameraFDResult(faces);
     } else {
         result.clear();
         result = NULL;
     }

     LOG_FUNCTION_NAME_EXIT;

     return ret;
 }

 status_t OMXCameraAdapter::encodeFaceCoordinates(const OMX_FACEDETECTIONTYPE *faceData,
                                                  camera_frame_metadata_t **pFaces,
                                                  size_t previewWidth,
                                                  size_t previewHeight)
 {
     status_t ret = NO_ERROR;
     camera_face_t *faces;
     camera_frame_metadata_t *faceResult;
     size_t hRange, vRange;
     double tmp;

     LOG_FUNCTION_NAME;

     if ( NULL == faceData ) {
         CAMHAL_LOGEA("Invalid OMX_FACEDETECTIONTYPE parameter");
         return EINVAL;
     }

     LOG_FUNCTION_NAME

     hRange = CameraFDResult::RIGHT - CameraFDResult::LEFT;
     vRange = CameraFDResult::BOTTOM - CameraFDResult::TOP;

     faceResult = ( camera_frame_metadata_t * ) malloc(sizeof(camera_frame_metadata_t));
     if ( NULL == faceResult ) {
         return -ENOMEM;
     }

     if ( 0 < faceData->ulFaceCount ) {
         int orient_mult;
         int trans_left, trans_top, trans_right, trans_bot;

         faces = ( camera_face_t * ) malloc(sizeof(camera_face_t)*faceData->ulFaceCount);
         if ( NULL == faces ) {
             return -ENOMEM;
         }

         /**
         / * When device is 180 degrees oriented to the sensor, need to translate
         / * the output from Ducati to what Android expects
         / * Ducati always gives face coordinates in this form, irrespective of
         / * rotation, i.e (l,t) always represents the point towards the left eye
         / * and top of hair.
         / * (l, t)
         / *   ---------------
         / *   -   ,,,,,,,   -
         / *   -  |       |  -
         / *   -  |<a   <a|  -
         / *   - (|   ^   |) -
         / *   -  |  -=-  |  -
         / *   -   \_____/   -
         / *   ---------------
         / *               (r, b)
         / *
         / * However, Android expects the coords to be in respect with what the
         / * sensor is viewing, i.e Android expects sensor to see this with (l,t)
         / * and (r,b) like so:
         / * (l, t)
         / *   ---------------
         / *   -    _____    -
         / *   -   /     \   -
         / *   -  |  -=-  |  -
         / *   - (|   ^   |) -
         / *   -  |a>   a>|  -
         / *   -  |       |  -
         / *   -   ,,,,,,,   -
         / *   ---------------
         / *               (r, b)
           */

         if (mDeviceOrientation == 180) {
             orient_mult = -1;
             trans_left = 2; // right is now left
             trans_top = 3; // bottom is now top
             trans_right = 0; // left is now right
             trans_bot = 1; // top is not bottom
         } else {
             orient_mult = 1;
             trans_left = 0; // left
             trans_top = 1; // top
             trans_right = 2; // right
             trans_bot = 3; // bottom
         }

         int j = 0, i = 0;
         for ( ; j < faceData->ulFaceCount ; j++)
             {
              OMX_S32 nLeft = 0;
              OMX_S32 nTop = 0;
              //Face filtering
              //For real faces, it is seen that the h/w passes a score >=80
              //For false faces, we seem to get even a score of 70 sometimes.
              //In order to avoid any issue at application level, we filter
              //<=70 score here.
             if(faceData->tFacePosition[j].nScore <= FACE_DETECTION_THRESHOLD)
              continue;

             if (mDeviceOrientation == 180) {
                 // from sensor pov, the left pos is the right corner of the face in pov of frame
                 nLeft = faceData->tFacePosition[j].nLeft + faceData->tFacePosition[j].nWidth;
                 nTop =  faceData->tFacePosition[j].nTop + faceData->tFacePosition[j].nHeight;
             } else {
                 nLeft = faceData->tFacePosition[j].nLeft;
                 nTop =  faceData->tFacePosition[j].nTop;
             }

             tmp = ( double ) nLeft / ( double ) previewWidth;
             tmp *= hRange;
             tmp -= hRange/2;
             faces[i].rect[trans_left] = tmp;

             tmp = ( double ) nTop / ( double )previewHeight;
             tmp *= vRange;
             tmp -= vRange/2;
             faces[i].rect[trans_top] = tmp;

             tmp = ( double ) faceData->tFacePosition[j].nWidth / ( double ) previewWidth;
             tmp *= hRange;
             tmp *= orient_mult;
             faces[i].rect[trans_right] = faces[i].rect[trans_left] + tmp;

             tmp = ( double ) faceData->tFacePosition[j].nHeight / ( double ) previewHeight;
             tmp *= vRange;
             tmp *= orient_mult;
             faces[i].rect[trans_bot] = faces[i].rect[trans_top] + tmp;

             faces[i].score = faceData->tFacePosition[j].nScore;
             faces[i].id = 0;
             faces[i].left_eye[0] = CameraFDResult::INVALID_DATA;
             faces[i].left_eye[1] = CameraFDResult::INVALID_DATA;
             faces[i].right_eye[0] = CameraFDResult::INVALID_DATA;
             faces[i].right_eye[1] = CameraFDResult::INVALID_DATA;
             faces[i].mouth[0] = CameraFDResult::INVALID_DATA;
             faces[i].mouth[1] = CameraFDResult::INVALID_DATA;
             i++;
             }

         faceResult->number_of_faces = i;
         faceResult->faces = faces;

         for (int i = 0; i  < faceResult->number_of_faces; i++)
         {
             int centerX = (faces[i].rect[trans_left] + faces[i].rect[trans_right] ) / 2;
             int centerY = (faces[i].rect[trans_top] + faces[i].rect[trans_bot] ) / 2;

             int sizeX = (faces[i].rect[trans_right] - faces[i].rect[trans_left] ) ;
             int sizeY = (faces[i].rect[trans_bot] - faces[i].rect[trans_top] ) ;

             for (int j = 0; j < faceDetectionNumFacesLastOutput; j++)
             {
                 int tempCenterX = (faceDetectionLastOutput[j].rect[trans_left] +
                                   faceDetectionLastOutput[j].rect[trans_right] ) / 2;
                 int tempCenterY = (faceDetectionLastOutput[j].rect[trans_top] +
                                   faceDetectionLastOutput[j].rect[trans_bot] ) / 2;
                 int tempSizeX = (faceDetectionLastOutput[j].rect[trans_right] -
                                 faceDetectionLastOutput[j].rect[trans_left] ) ;
                 int tempSizeY = (faceDetectionLastOutput[j].rect[trans_bot] -
                                 faceDetectionLastOutput[j].rect[trans_top] ) ;

                 if ( (abs(tempCenterX - centerX) < HorizontalFilterThreshold) &&
                      (abs(tempCenterY - centerY) < VerticalFilterThreshold) )
                 {
                     // Found Face. It did not move too far.
                     // Now check size of rectangle compare to last output
                     if ( (abs (tempSizeX -sizeX) < HorizontalFaceSizeThreshold) &&
                          (abs (tempSizeY -sizeY) < VerticalFaceSizeThreshold) )
                     {
                         // Rectangle is almost same as last time
                         // Output exactly what was done for this face last time.
                         faces[i] = faceDetectionLastOutput[j];
                     }
                     else
                     {
                         // TODO(XXX): Rectangle size changed but position is same.
                         // Possibly we can apply just positional correctness.
                     }
                 }
             }
         }

         // Save this output for next iteration
         for (int i = 0; i  < faceResult->number_of_faces; i++)
         {
             faceDetectionLastOutput[i] = faces[i];
         }
         faceDetectionNumFacesLastOutput = faceResult->number_of_faces;
     } else {
         faceResult->number_of_faces = 0;
         faceResult->faces = NULL;
     }

     *pFaces = faceResult;

     LOG_FUNCTION_NAME_EXIT;

     return ret;
 }

 };
	/*
	* 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 OMXFD.cpp
	*
	* This file contains functionality for handling face detection.
	*
	*/

	#undef LOG_TAG

	#define LOG_TAG "CameraHAL"

	#include "CameraHal.h"
	#include "OMXCameraAdapter.h"

	#define FACE_DETECTION_THRESHOLD 80

	// constants used for face smooth filtering
	static const int HorizontalFilterThreshold = 40;
	static const int VerticalFilterThreshold = 40;
	static const int HorizontalFaceSizeThreshold = 30;
	static const int VerticalFaceSizeThreshold = 30;


	namespace android {

	status_t OMXCameraAdapter::setParametersFD(const CameraParameters &params,
	BaseCameraAdapter::AdapterState state)
	{
	status_t ret = NO_ERROR;

	LOG_FUNCTION_NAME;

	LOG_FUNCTION_NAME_EXIT;

	return ret;
	}

	status_t OMXCameraAdapter::startFaceDetection()
	{
	status_t ret = NO_ERROR;

	Mutex::Autolock lock(mFaceDetectionLock);

	ret = setFaceDetection(true, mDeviceOrientation);
	if (ret != NO_ERROR) {
	goto out;
	}

	if ( mFaceDetectionRunning )
	{
	//Disable region priority and enable face priority for AF
	setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
	setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO , true);

	//Disable Region priority and enable Face priority
	setAlgoPriority(REGION_PRIORITY, EXPOSURE_ALGO, false);
	setAlgoPriority(FACE_PRIORITY, EXPOSURE_ALGO, true);
	}

	// Note: White balance will not be face prioritized, since
	// the algorithm needs full frame statistics, and not face
	// regions alone.

	faceDetectionNumFacesLastOutput = 0;
	out:
	return ret;
	}

	status_t OMXCameraAdapter::stopFaceDetection()
	{
	status_t ret = NO_ERROR;
	const char *str = NULL;
	BaseCameraAdapter::AdapterState state;
	BaseCameraAdapter::getState(state);

	Mutex::Autolock lock(mFaceDetectionLock);

	ret = setFaceDetection(false, mDeviceOrientation);
	if (ret != NO_ERROR) {
	goto out;
	}

	// Reset 3A settings
	ret = setParameters3A(mParams, state);
	if (ret != NO_ERROR) {
	goto out;
	}

	if (mPending3Asettings) {
	apply3Asettings(mParameters3A);
	}

	faceDetectionNumFacesLastOutput = 0;
	out:
	return ret;
	}

	void OMXCameraAdapter::pauseFaceDetection(bool pause)
	{
	Mutex::Autolock lock(mFaceDetectionLock);
	// pausing will only take affect if fd is already running
	if (mFaceDetectionRunning) {
	mFaceDetectionPaused = pause;
	faceDetectionNumFacesLastOutput = 0;
	}
	}

	status_t OMXCameraAdapter::setFaceDetection(bool enable, OMX_U32 orientation)
	{
	status_t ret = NO_ERROR;
	OMX_ERRORTYPE eError = OMX_ErrorNone;
	OMX_CONFIG_OBJDETECTIONTYPE objDetection;

	LOG_FUNCTION_NAME;

	if ( OMX_StateInvalid == mComponentState )
	{
	CAMHAL_LOGEA("OMX component is in invalid state");
	ret = -EINVAL;
	}

	if ( NO_ERROR == ret )
	{
	if ( orientation > 270 ) {
	orientation = 0;
	}

	OMX_INIT_STRUCT_PTR (&objDetection, OMX_CONFIG_OBJDETECTIONTYPE);
	objDetection.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
	objDetection.nDeviceOrientation = orientation;
	if ( enable )
	{
	objDetection.bEnable = OMX_TRUE;
	}
	else
	{
	objDetection.bEnable = OMX_FALSE;
	}

	eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
	( OMX_INDEXTYPE ) OMX_IndexConfigImageFaceDetection,
	&objDetection);
	if ( OMX_ErrorNone != eError )
	{
	CAMHAL_LOGEB("Error while configuring face detection 0x%x", eError);
	ret = -1;
	}
	else
	{
	CAMHAL_LOGDA("Face detection configured successfully");
	}
	}

	if ( NO_ERROR == ret )
	{
	ret = setExtraData(enable, mCameraAdapterParameters.mPrevPortIndex, OMX_FaceDetection);

	if ( NO_ERROR != ret )
	{
	CAMHAL_LOGEA("Error while configuring face detection extra data");
	}
	else
	{
	CAMHAL_LOGDA("Face detection extra data configured successfully");
	}
	}

	if ( NO_ERROR == ret )
	{
	mFaceDetectionRunning = enable;
	mFaceDetectionPaused = !enable;
	}

	LOG_FUNCTION_NAME_EXIT;

	return ret;
	}

	status_t OMXCameraAdapter::detectFaces(OMX_BUFFERHEADERTYPE* pBuffHeader,
	sp<CameraFDResult> &result,
	size_t previewWidth,
	size_t previewHeight)
	{
	status_t ret = NO_ERROR;
	OMX_ERRORTYPE eError = OMX_ErrorNone;
	OMX_TI_FACERESULT *faceResult;
	OMX_OTHER_EXTRADATATYPE *extraData;
	OMX_FACEDETECTIONTYPE *faceData;
	OMX_TI_PLATFORMPRIVATE *platformPrivate;
	camera_frame_metadata_t *faces;

	LOG_FUNCTION_NAME;

	if ( OMX_StateExecuting != mComponentState ) {
	CAMHAL_LOGEA("OMX component is not in executing state");
	return NO_INIT;
	}

	if ( NULL == pBuffHeader ) {
	CAMHAL_LOGEA("Invalid Buffer header");
	return-EINVAL;
	}

	platformPrivate = (OMX_TI_PLATFORMPRIVATE *) (pBuffHeader->pPlatformPrivate);
	if ( NULL != platformPrivate ) {
	if ( sizeof(OMX_TI_PLATFORMPRIVATE) == platformPrivate->nSize ) {
	CAMHAL_LOGVB("Size = %d, sizeof = %d, pAuxBuf = 0x%x, pAuxBufSize= %d, pMetaDataBufer = 0x%x, nMetaDataSize = %d",
	platformPrivate->nSize,
	sizeof(OMX_TI_PLATFORMPRIVATE),
	platformPrivate->pAuxBuf1,
	platformPrivate->pAuxBufSize1,
	platformPrivate->pMetaDataBuffer,
	platformPrivate->nMetaDataSize);
	} else {
	CAMHAL_LOGDB("OMX_TI_PLATFORMPRIVATE size mismatch: expected = %d, received = %d",
	( unsigned int ) sizeof(OMX_TI_PLATFORMPRIVATE),
	( unsigned int ) platformPrivate->nSize);
	return -EINVAL;
	}
	} else {
	CAMHAL_LOGDA("Invalid OMX_TI_PLATFORMPRIVATE");
	return-EINVAL;
	}


	if ( 0 >= platformPrivate->nMetaDataSize ) {
	CAMHAL_LOGDB("OMX_TI_PLATFORMPRIVATE nMetaDataSize is size is %d",
	( unsigned int ) platformPrivate->nMetaDataSize);
	return -EINVAL;
	}

	extraData = getExtradata((OMX_OTHER_EXTRADATATYPE *) (platformPrivate->pMetaDataBuffer),
	(OMX_EXTRADATATYPE)OMX_FaceDetection);

	if ( NULL != extraData ) {
	CAMHAL_LOGVB("Size = %d, sizeof = %d, eType = 0x%x, nDataSize= %d, nPortIndex = 0x%x, nVersion = 0x%x",
	extraData->nSize,
	sizeof(OMX_OTHER_EXTRADATATYPE),
	extraData->eType,
	extraData->nDataSize,
	extraData->nPortIndex,
	extraData->nVersion);
	} else {
	CAMHAL_LOGDA("Invalid OMX_OTHER_EXTRADATATYPE");
	return -EINVAL;
	}

	faceData = ( OMX_FACEDETECTIONTYPE * ) extraData->data;
	if ( NULL != faceData ) {
	if ( sizeof(OMX_FACEDETECTIONTYPE) == faceData->nSize ) {
	CAMHAL_LOGVB("Faces detected %d",
	faceData->ulFaceCount,
	faceData->nSize,
	sizeof(OMX_FACEDETECTIONTYPE),
	faceData->eCameraView,
	faceData->nPortIndex,
	faceData->nVersion);
	} else {
	CAMHAL_LOGDB("OMX_FACEDETECTIONTYPE size mismatch: expected = %d, received = %d",
	( unsigned int ) sizeof(OMX_FACEDETECTIONTYPE),
	( unsigned int ) faceData->nSize);
	return -EINVAL;
	}
	} else {
	CAMHAL_LOGEA("Invalid OMX_FACEDETECTIONTYPE");
	return -EINVAL;
	}

	ret = encodeFaceCoordinates(faceData, &faces, previewWidth, previewHeight);

	if ( NO_ERROR == ret ) {
	result = new CameraFDResult(faces);
	} else {
	result.clear();
	result = NULL;
	}

	LOG_FUNCTION_NAME_EXIT;

	return ret;
	}

	status_t OMXCameraAdapter::encodeFaceCoordinates(const OMX_FACEDETECTIONTYPE *faceData,
	camera_frame_metadata_t **pFaces,
	size_t previewWidth,
	size_t previewHeight)
	{
	status_t ret = NO_ERROR;
	camera_face_t *faces;
	camera_frame_metadata_t *faceResult;
	size_t hRange, vRange;
	double tmp;

	LOG_FUNCTION_NAME;

	if ( NULL == faceData ) {
	CAMHAL_LOGEA("Invalid OMX_FACEDETECTIONTYPE parameter");
	return EINVAL;
	}

	LOG_FUNCTION_NAME

	hRange = CameraFDResult::RIGHT - CameraFDResult::LEFT;
	vRange = CameraFDResult::BOTTOM - CameraFDResult::TOP;

	faceResult = ( camera_frame_metadata_t * ) malloc(sizeof(camera_frame_metadata_t));
	if ( NULL == faceResult ) {
	return -ENOMEM;
	}

	if ( 0 < faceData->ulFaceCount ) {
	int orient_mult;
	int trans_left, trans_top, trans_right, trans_bot;

	faces = ( camera_face_t * ) malloc(sizeof(camera_face_t)*faceData->ulFaceCount);
	if ( NULL == faces ) {
	return -ENOMEM;
	}

	/**
	/ * When device is 180 degrees oriented to the sensor, need to translate
	/ * the output from Ducati to what Android expects
	/ * Ducati always gives face coordinates in this form, irrespective of
	/ * rotation, i.e (l,t) always represents the point towards the left eye
	/ * and top of hair.
	/ * (l, t)
	/ * ---------------
	/ * - ,,,,,,, -
	/ * - \| \| -
	/ * - \|<a <a\| -
	/ * - (\| ^ \|) -
	/ * - \| -=- \| -
	/ * - \_____/ -
	/ * ---------------
	/ * (r, b)
	/ *
	/ * However, Android expects the coords to be in respect with what the
	/ * sensor is viewing, i.e Android expects sensor to see this with (l,t)
	/ * and (r,b) like so:
	/ * (l, t)
	/ * ---------------
	/ * - _____ -
	/ * - / \ -
	/ * - \| -=- \| -
	/ * - (\| ^ \|) -
	/ * - \|a> a>\| -
	/ * - \| \| -
	/ * - ,,,,,,, -
	/ * ---------------
	/ * (r, b)
	*/

	if (mDeviceOrientation == 180) {
	orient_mult = -1;
	trans_left = 2; // right is now left
	trans_top = 3; // bottom is now top
	trans_right = 0; // left is now right
	trans_bot = 1; // top is not bottom
	} else {
	orient_mult = 1;
	trans_left = 0; // left
	trans_top = 1; // top
	trans_right = 2; // right
	trans_bot = 3; // bottom
	}

	int j = 0, i = 0;
	for ( ; j < faceData->ulFaceCount ; j++)
	{
	OMX_S32 nLeft = 0;
	OMX_S32 nTop = 0;
	//Face filtering
	//For real faces, it is seen that the h/w passes a score >=80
	//For false faces, we seem to get even a score of 70 sometimes.
	//In order to avoid any issue at application level, we filter
	//<=70 score here.
	if(faceData->tFacePosition[j].nScore <= FACE_DETECTION_THRESHOLD)
	continue;

	if (mDeviceOrientation == 180) {
	// from sensor pov, the left pos is the right corner of the face in pov of frame
	nLeft = faceData->tFacePosition[j].nLeft + faceData->tFacePosition[j].nWidth;
	nTop = faceData->tFacePosition[j].nTop + faceData->tFacePosition[j].nHeight;
	} else {
	nLeft = faceData->tFacePosition[j].nLeft;
	nTop = faceData->tFacePosition[j].nTop;
	}

	tmp = ( double ) nLeft / ( double ) previewWidth;
	tmp *= hRange;
	tmp -= hRange/2;
	faces[i].rect[trans_left] = tmp;

	tmp = ( double ) nTop / ( double )previewHeight;
	tmp *= vRange;
	tmp -= vRange/2;
	faces[i].rect[trans_top] = tmp;

	tmp = ( double ) faceData->tFacePosition[j].nWidth / ( double ) previewWidth;
	tmp *= hRange;
	tmp *= orient_mult;
	faces[i].rect[trans_right] = faces[i].rect[trans_left] + tmp;

	tmp = ( double ) faceData->tFacePosition[j].nHeight / ( double ) previewHeight;
	tmp *= vRange;
	tmp *= orient_mult;
	faces[i].rect[trans_bot] = faces[i].rect[trans_top] + tmp;

	faces[i].score = faceData->tFacePosition[j].nScore;
	faces[i].id = 0;
	faces[i].left_eye[0] = CameraFDResult::INVALID_DATA;
	faces[i].left_eye[1] = CameraFDResult::INVALID_DATA;
	faces[i].right_eye[0] = CameraFDResult::INVALID_DATA;
	faces[i].right_eye[1] = CameraFDResult::INVALID_DATA;
	faces[i].mouth[0] = CameraFDResult::INVALID_DATA;
	faces[i].mouth[1] = CameraFDResult::INVALID_DATA;
	i++;
	}

	faceResult->number_of_faces = i;
	faceResult->faces = faces;

	for (int i = 0; i < faceResult->number_of_faces; i++)
	{
	int centerX = (faces[i].rect[trans_left] + faces[i].rect[trans_right] ) / 2;
	int centerY = (faces[i].rect[trans_top] + faces[i].rect[trans_bot] ) / 2;

	int sizeX = (faces[i].rect[trans_right] - faces[i].rect[trans_left] ) ;
	int sizeY = (faces[i].rect[trans_bot] - faces[i].rect[trans_top] ) ;

	for (int j = 0; j < faceDetectionNumFacesLastOutput; j++)
	{
	int tempCenterX = (faceDetectionLastOutput[j].rect[trans_left] +
	faceDetectionLastOutput[j].rect[trans_right] ) / 2;
	int tempCenterY = (faceDetectionLastOutput[j].rect[trans_top] +
	faceDetectionLastOutput[j].rect[trans_bot] ) / 2;
	int tempSizeX = (faceDetectionLastOutput[j].rect[trans_right] -
	faceDetectionLastOutput[j].rect[trans_left] ) ;
	int tempSizeY = (faceDetectionLastOutput[j].rect[trans_bot] -
	faceDetectionLastOutput[j].rect[trans_top] ) ;

	if ( (abs(tempCenterX - centerX) < HorizontalFilterThreshold) &&
	(abs(tempCenterY - centerY) < VerticalFilterThreshold) )
	{
	// Found Face. It did not move too far.
	// Now check size of rectangle compare to last output
	if ( (abs (tempSizeX -sizeX) < HorizontalFaceSizeThreshold) &&
	(abs (tempSizeY -sizeY) < VerticalFaceSizeThreshold) )
	{
	// Rectangle is almost same as last time
	// Output exactly what was done for this face last time.
	faces[i] = faceDetectionLastOutput[j];
	}
	else
	{
	// TODO(XXX): Rectangle size changed but position is same.
	// Possibly we can apply just positional correctness.
	}
	}
	}
	}

	// Save this output for next iteration
	for (int i = 0; i < faceResult->number_of_faces; i++)
	{
	faceDetectionLastOutput[i] = faces[i];
	}
	faceDetectionNumFacesLastOutput = faceResult->number_of_faces;
	} else {
	faceResult->number_of_faces = 0;
	faceResult->faces = NULL;
	}

	*pFaces = faceResult;

	LOG_FUNCTION_NAME_EXIT;

	return ret;
	}

	};