/*
* 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 ¶ms,
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 ) {
mFDSwitchAlgoPriority = 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;
}
};