/*
 * 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.
 */

#include "BaseCameraAdapter.h"

const int EVENT_MASK = 0xffff;

namespace Ti {
namespace Camera {

const LUT cameraCommandsUserToHAL[] = {
    { "CAMERA_START_PREVIEW",                   CameraAdapter::CAMERA_START_PREVIEW },
    { "CAMERA_STOP_PREVIEW",                    CameraAdapter::CAMERA_STOP_PREVIEW },
    { "CAMERA_START_VIDEO",                     CameraAdapter::CAMERA_START_VIDEO },
    { "CAMERA_STOP_VIDEO",                      CameraAdapter::CAMERA_STOP_VIDEO },
    { "CAMERA_START_IMAGE_CAPTURE",             CameraAdapter::CAMERA_START_IMAGE_CAPTURE },
    { "CAMERA_STOP_IMAGE_CAPTURE",              CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE },
    { "CAMERA_PERFORM_AUTOFOCUS",               CameraAdapter::CAMERA_PERFORM_AUTOFOCUS },
    { "CAMERA_CANCEL_AUTOFOCUS",                CameraAdapter::CAMERA_CANCEL_AUTOFOCUS },
    { "CAMERA_PREVIEW_FLUSH_BUFFERS",           CameraAdapter::CAMERA_PREVIEW_FLUSH_BUFFERS },
    { "CAMERA_START_SMOOTH_ZOOM",               CameraAdapter::CAMERA_START_SMOOTH_ZOOM },
    { "CAMERA_STOP_SMOOTH_ZOOM",                CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM },
    { "CAMERA_USE_BUFFERS_PREVIEW",             CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW },
    { "CAMERA_SET_TIMEOUT",                     CameraAdapter::CAMERA_SET_TIMEOUT },
    { "CAMERA_CANCEL_TIMEOUT",                  CameraAdapter::CAMERA_CANCEL_TIMEOUT },
    { "CAMERA_START_BRACKET_CAPTURE",           CameraAdapter::CAMERA_START_BRACKET_CAPTURE },
    { "CAMERA_STOP_BRACKET_CAPTURE",            CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE },
    { "CAMERA_QUERY_RESOLUTION_PREVIEW",        CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW },
    { "CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE", CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE },
    { "CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA",  CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA },
    { "CAMERA_USE_BUFFERS_IMAGE_CAPTURE",       CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE },
    { "CAMERA_USE_BUFFERS_PREVIEW_DATA",        CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA },
    { "CAMERA_TIMEOUT_EXPIRED",                 CameraAdapter::CAMERA_TIMEOUT_EXPIRED },
    { "CAMERA_START_FD",                        CameraAdapter::CAMERA_START_FD },
    { "CAMERA_STOP_FD",                         CameraAdapter::CAMERA_STOP_FD },
    { "CAMERA_SWITCH_TO_EXECUTING",             CameraAdapter::CAMERA_SWITCH_TO_EXECUTING },
    { "CAMERA_USE_BUFFERS_VIDEO_CAPTURE",       CameraAdapter::CAMERA_USE_BUFFERS_VIDEO_CAPTURE },
#ifdef OMAP_ENHANCEMENT_CPCAM
    { "CAMERA_USE_BUFFERS_REPROCESS",           CameraAdapter::CAMERA_USE_BUFFERS_REPROCESS },
    { "CAMERA_START_REPROCESS",                 CameraAdapter::CAMERA_START_REPROCESS },
#endif
};

const LUTtypeHAL CamCommandsLUT = {
    sizeof(cameraCommandsUserToHAL)/sizeof(cameraCommandsUserToHAL[0]),
    cameraCommandsUserToHAL
};

/*--------------------Camera Adapter Class STARTS here-----------------------------*/

BaseCameraAdapter::BaseCameraAdapter()
{
    mReleaseImageBuffersCallback = NULL;
    mEndImageCaptureCallback = NULL;
    mErrorNotifier = NULL;
    mEndCaptureData = NULL;
    mReleaseData = NULL;
    mRecording = false;

    mPreviewBuffers = NULL;
    mPreviewBufferCount = 0;
    mPreviewBuffersLength = 0;

    mVideoBuffers = NULL;
    mVideoBuffersCount = 0;
    mVideoBuffersLength = 0;

    mCaptureBuffers = NULL;
    mCaptureBuffersCount = 0;
    mCaptureBuffersLength = 0;

    mPreviewDataBuffers = NULL;
    mPreviewDataBuffersCount = 0;
    mPreviewDataBuffersLength = 0;

    mAdapterState = INTIALIZED_STATE;

    mSharedAllocator = NULL;

#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
    mStartFocus.tv_sec = 0;
    mStartFocus.tv_usec = 0;
    mStartCapture.tv_sec = 0;
    mStartCapture.tv_usec = 0;
#endif

}

BaseCameraAdapter::~BaseCameraAdapter()
{
     LOG_FUNCTION_NAME;

     android::AutoMutex lock(mSubscriberLock);

     mFrameSubscribers.clear();
     mImageSubscribers.clear();
     mRawSubscribers.clear();
     mVideoSubscribers.clear();
     mVideoInSubscribers.clear();
     mFocusSubscribers.clear();
     mShutterSubscribers.clear();
     mZoomSubscribers.clear();
     mSnapshotSubscribers.clear();
     mMetadataSubscribers.clear();

     LOG_FUNCTION_NAME_EXIT;
}

status_t BaseCameraAdapter::registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    mReleaseImageBuffersCallback = callback;
    mReleaseData = user_data;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::registerEndCaptureCallback(end_image_capture_callback callback, void *user_data)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    mEndImageCaptureCallback= callback;
    mEndCaptureData = user_data;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::setErrorHandler(ErrorNotifier *errorNotifier)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    if ( NULL == errorNotifier )
        {
        CAMHAL_LOGEA("Invalid Error Notifier reference");
        ret = -EINVAL;
        }

    if ( NO_ERROR == ret )
        {
        mErrorNotifier = errorNotifier;
        }

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

void BaseCameraAdapter::enableMsgType(int32_t msgs, frame_callback callback, event_callback eventCb, void* cookie)
{
    android::AutoMutex lock(mSubscriberLock);

    LOG_FUNCTION_NAME;

    int32_t frameMsg = ((msgs >> MessageNotifier::FRAME_BIT_FIELD_POSITION) & EVENT_MASK);
    int32_t eventMsg = ((msgs >> MessageNotifier::EVENT_BIT_FIELD_POSITION) & EVENT_MASK);

    if ( frameMsg != 0 )
        {
        CAMHAL_LOGVB("Frame message type id=0x%x subscription request", frameMsg);
        switch ( frameMsg )
            {
            case CameraFrame::PREVIEW_FRAME_SYNC:
                mFrameSubscribers.add((int) cookie, callback);
                break;
            case CameraFrame::FRAME_DATA_SYNC:
                mFrameDataSubscribers.add((int) cookie, callback);
                break;
            case CameraFrame::SNAPSHOT_FRAME:
                mSnapshotSubscribers.add((int) cookie, callback);
                break;
            case CameraFrame::IMAGE_FRAME:
                mImageSubscribers.add((int) cookie, callback);
                break;
            case CameraFrame::RAW_FRAME:
                mRawSubscribers.add((int) cookie, callback);
                break;
            case CameraFrame::VIDEO_FRAME_SYNC:
                mVideoSubscribers.add((int) cookie, callback);
                break;
            case CameraFrame::REPROCESS_INPUT_FRAME:
                mVideoInSubscribers.add((int) cookie, callback);
                break;
            default:
                CAMHAL_LOGEA("Frame message type id=0x%x subscription no supported yet!", frameMsg);
                break;
            }
        }

    if ( eventMsg != 0)
        {
        CAMHAL_LOGVB("Event message type id=0x%x subscription request", eventMsg);
        if ( CameraHalEvent::ALL_EVENTS == eventMsg )
            {
            mFocusSubscribers.add((int) cookie, eventCb);
            mShutterSubscribers.add((int) cookie, eventCb);
            mZoomSubscribers.add((int) cookie, eventCb);
            mMetadataSubscribers.add((int) cookie, eventCb);
            }
        else
            {
            CAMHAL_LOGEA("Event message type id=0x%x subscription no supported yet!", eventMsg);
            }
        }

    LOG_FUNCTION_NAME_EXIT;
}

void BaseCameraAdapter::disableMsgType(int32_t msgs, void* cookie)
{
    android::AutoMutex lock(mSubscriberLock);

    LOG_FUNCTION_NAME;

    int32_t frameMsg = ((msgs >> MessageNotifier::FRAME_BIT_FIELD_POSITION) & EVENT_MASK);
    int32_t eventMsg = ((msgs >> MessageNotifier::EVENT_BIT_FIELD_POSITION) & EVENT_MASK);

    if ( frameMsg != 0 )
        {
        CAMHAL_LOGVB("Frame message type id=0x%x remove subscription request", frameMsg);
        switch ( frameMsg )
            {
            case CameraFrame::PREVIEW_FRAME_SYNC:
                mFrameSubscribers.removeItem((int) cookie);
                break;
            case CameraFrame::FRAME_DATA_SYNC:
                mFrameDataSubscribers.removeItem((int) cookie);
                break;
            case CameraFrame::SNAPSHOT_FRAME:
                mSnapshotSubscribers.removeItem((int) cookie);
                break;
            case CameraFrame::IMAGE_FRAME:
                mImageSubscribers.removeItem((int) cookie);
                break;
            case CameraFrame::RAW_FRAME:
                mRawSubscribers.removeItem((int) cookie);
                break;
            case CameraFrame::VIDEO_FRAME_SYNC:
                mVideoSubscribers.removeItem((int) cookie);
                break;
            case CameraFrame::REPROCESS_INPUT_FRAME:
                mVideoInSubscribers.removeItem((int) cookie);
                break;
            case CameraFrame::ALL_FRAMES:
                mFrameSubscribers.removeItem((int) cookie);
                mFrameDataSubscribers.removeItem((int) cookie);
                mSnapshotSubscribers.removeItem((int) cookie);
                mImageSubscribers.removeItem((int) cookie);
                mRawSubscribers.removeItem((int) cookie);
                mVideoSubscribers.removeItem((int) cookie);
                mVideoInSubscribers.removeItem((int) cookie);
                break;
            default:
                CAMHAL_LOGEA("Frame message type id=0x%x subscription remove not supported yet!", frameMsg);
                break;
            }
        }

    if ( eventMsg != 0 )
        {
        CAMHAL_LOGVB("Event message type id=0x%x remove subscription request", eventMsg);
        if ( CameraHalEvent::ALL_EVENTS == eventMsg)
            {
            //TODO: Process case by case
            mFocusSubscribers.removeItem((int) cookie);
            mShutterSubscribers.removeItem((int) cookie);
            mZoomSubscribers.removeItem((int) cookie);
            mMetadataSubscribers.removeItem((int) cookie);
            }
        else
            {
            CAMHAL_LOGEA("Event message type id=0x%x subscription remove not supported yet!", eventMsg);
            }
        }

    LOG_FUNCTION_NAME_EXIT;
}

void BaseCameraAdapter::addFramePointers(CameraBuffer *frameBuf, void *buf)
{
  unsigned int *pBuf = (unsigned int *)buf;
  android::AutoMutex lock(mSubscriberLock);

  if ((frameBuf != NULL) && ( pBuf != NULL) )
    {
      CameraFrame *frame = new CameraFrame;
      frame->mBuffer = frameBuf;
      frame->mYuv[0] = pBuf[0];
      frame->mYuv[1] = pBuf[1];
      mFrameQueue.add(frameBuf, frame);

      CAMHAL_LOGVB("Adding Frame=0x%x Y=0x%x UV=0x%x", frame->mBuffer, frame->mYuv[0], frame->mYuv[1]);
    }
}

void BaseCameraAdapter::removeFramePointers()
{
  android::AutoMutex lock(mSubscriberLock);

  int size = mFrameQueue.size();
  CAMHAL_LOGVB("Removing %d Frames = ", size);
  for (int i = 0; i < size; i++)
    {
      CameraFrame *frame = (CameraFrame *)mFrameQueue.valueAt(i);
      CAMHAL_LOGVB("Free Frame=0x%x Y=0x%x UV=0x%x", frame->mBuffer, frame->mYuv[0], frame->mYuv[1]);
      delete frame;
    }
  mFrameQueue.clear();
}

void BaseCameraAdapter::returnFrame(CameraBuffer * frameBuf, CameraFrame::FrameType frameType)
{
    status_t res = NO_ERROR;
    size_t subscriberCount = 0;
    int refCount = -1;

    if ( NULL == frameBuf )
        {
        CAMHAL_LOGEA("Invalid frameBuf");
        return;
        }

    if ( NO_ERROR == res)
        {
        android::AutoMutex lock(mReturnFrameLock);

        refCount = getFrameRefCount(frameBuf,  frameType);

        if(frameType == CameraFrame::PREVIEW_FRAME_SYNC)
            {
            mFramesWithDisplay--;
            }
        else if(frameType == CameraFrame::VIDEO_FRAME_SYNC)
            {
            mFramesWithEncoder--;
            }

        if ( 0 < refCount )
            {

            refCount--;
            setFrameRefCount(frameBuf, frameType, refCount);


            if ( mRecording && (CameraFrame::VIDEO_FRAME_SYNC == frameType) ) {
                refCount += getFrameRefCount(frameBuf, CameraFrame::PREVIEW_FRAME_SYNC);
            } else if ( mRecording && (CameraFrame::PREVIEW_FRAME_SYNC == frameType) ) {
                refCount += getFrameRefCount(frameBuf, CameraFrame::VIDEO_FRAME_SYNC);
            } else if ( mRecording && (CameraFrame::SNAPSHOT_FRAME == frameType) ) {
                refCount += getFrameRefCount(frameBuf, CameraFrame::VIDEO_FRAME_SYNC);
            }


            }
        else
            {
            CAMHAL_LOGDA("Frame returned when ref count is already zero!!");
            return;
            }
        }

    CAMHAL_LOGVB("REFCOUNT 0x%x %d", frameBuf, refCount);

    if ( NO_ERROR == res )
        {
        //check if someone is holding this buffer
        if ( 0 == refCount )
            {
#ifdef CAMERAHAL_DEBUG
            if((mBuffersWithDucati.indexOfKey((int)camera_buffer_get_omx_ptr(frameBuf)) >= 0) &&
               ((CameraFrame::PREVIEW_FRAME_SYNC == frameType) ||
                 (CameraFrame::SNAPSHOT_FRAME == frameType)))
                {
                CAMHAL_LOGE("Buffer already with Ducati!! 0x%x", frameBuf);
                for(int i=0;i<mBuffersWithDucati.size();i++) CAMHAL_LOGE("0x%x", mBuffersWithDucati.keyAt(i));
                }
            mBuffersWithDucati.add((int)camera_buffer_get_omx_ptr(frameBuf),1);
#endif
            res = fillThisBuffer(frameBuf, frameType);
            }
        }

}

status_t BaseCameraAdapter::sendCommand(CameraCommands operation, int value1, int value2, int value3, int value4) {
    status_t ret = NO_ERROR;
    struct timeval *refTimestamp;
    BuffersDescriptor *desc = NULL;
    CameraFrame *frame = NULL;

    LOG_FUNCTION_NAME;

    switch ( operation ) {
        case CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW:
                CAMHAL_LOGDA("Use buffers for preview");
                desc = ( BuffersDescriptor * ) value1;

                if ( NULL == desc )
                    {
                    CAMHAL_LOGEA("Invalid preview buffers!");
                    return -EINVAL;
                    }

                if ( ret == NO_ERROR )
                    {
                    ret = setState(operation);
                    }

                if ( ret == NO_ERROR )
                    {
                    android::AutoMutex lock(mPreviewBufferLock);
                    mPreviewBuffers = desc->mBuffers;
                    mPreviewBuffersLength = desc->mLength;
                    mPreviewBuffersAvailable.clear();
                    mSnapshotBuffersAvailable.clear();
                    for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ )
                        {
                        mPreviewBuffersAvailable.add(&mPreviewBuffers[i], 0);
                        }
                    // initial ref count for undeqeueued buffers is 1 since buffer provider
                    // is still holding on to it
                    for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ )
                        {
                        mPreviewBuffersAvailable.add(&mPreviewBuffers[i], 1);
                        }
                    }

                if ( NULL != desc )
                    {
                    ret = useBuffers(CameraAdapter::CAMERA_PREVIEW,
                                     desc->mBuffers,
                                     desc->mCount,
                                     desc->mLength,
                                     desc->mMaxQueueable);
                    }

                if ( ret == NO_ERROR )
                    {
                    ret = commitState();
                    }
                else
                    {
                    ret |= rollbackState();
                    }

                break;

        case CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA:
                    CAMHAL_LOGDA("Use buffers for preview data");
                    desc = ( BuffersDescriptor * ) value1;

                    if ( NULL == desc )
                        {
                        CAMHAL_LOGEA("Invalid preview data buffers!");
                        return -EINVAL;
                        }

                    if ( ret == NO_ERROR )
                        {
                        ret = setState(operation);
                        }

                    if ( ret == NO_ERROR )
                        {
                        android::AutoMutex lock(mPreviewDataBufferLock);
                        mPreviewDataBuffers = desc->mBuffers;
                        mPreviewDataBuffersLength = desc->mLength;
                        mPreviewDataBuffersAvailable.clear();
                        for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ )
                            {
                            mPreviewDataBuffersAvailable.add(&mPreviewDataBuffers[i], 0);
                            }
                        // initial ref count for undeqeueued buffers is 1 since buffer provider
                        // is still holding on to it
                        for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ )
                            {
                            mPreviewDataBuffersAvailable.add(&mPreviewDataBuffers[i], 1);
                            }
                        }

                    if ( NULL != desc )
                        {
                        ret = useBuffers(CameraAdapter::CAMERA_MEASUREMENT,
                                         desc->mBuffers,
                                         desc->mCount,
                                         desc->mLength,
                                         desc->mMaxQueueable);
                        }

                    if ( ret == NO_ERROR )
                        {
                        ret = commitState();
                        }
                    else
                        {
                        ret |= rollbackState();
                        }

                    break;

        case CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE:
                CAMHAL_LOGDA("Use buffers for image capture");
                desc = ( BuffersDescriptor * ) value1;

                if ( NULL == desc )
                    {
                    CAMHAL_LOGEA("Invalid capture buffers!");
                    return -EINVAL;
                    }

                if ( ret == NO_ERROR )
                    {
                    ret = setState(operation);
                    }

                if ( ret == NO_ERROR )
                    {
                    android::AutoMutex lock(mCaptureBufferLock);
                    mCaptureBuffers = desc->mBuffers;
                    mCaptureBuffersLength = desc->mLength;
                    }

                if ( NULL != desc )
                    {
                    ret = useBuffers(CameraAdapter::CAMERA_IMAGE_CAPTURE,
                                     desc->mBuffers,
                                     desc->mCount,
                                     desc->mLength,
                                     desc->mMaxQueueable);
                    }

                if ( ret == NO_ERROR )
                    {
                    ret = commitState();
                    }
                else
                    {
                    ret |= rollbackState();
                    }

                break;

#ifdef OMAP_ENHANCEMENT_CPCAM
        case CameraAdapter::CAMERA_USE_BUFFERS_REPROCESS:
            CAMHAL_LOGDA("Use buffers for reprocessing");
            desc = (BuffersDescriptor *) value1;

            if (NULL == desc) {
                CAMHAL_LOGEA("Invalid capture buffers!");
                return -EINVAL;
            }

            if (ret == NO_ERROR) {
                ret = setState(operation);
            }

            if (ret == NO_ERROR) {
                android::AutoMutex lock(mVideoInBufferLock);
                mVideoInBuffers = desc->mBuffers;
                mVideoInBuffersAvailable.clear();
                for (uint32_t i = 0 ; i < desc->mMaxQueueable ; i++) {
                    mVideoInBuffersAvailable.add(&mVideoInBuffers[i], 0);
                }
                // initial ref count for undeqeueued buffers is 1 since buffer provider
                // is still holding on to it
                for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ ) {
                    mVideoInBuffersAvailable.add(&mVideoInBuffers[i], 1);
                }
                ret = useBuffers(CameraAdapter::CAMERA_REPROCESS,
                                 desc->mBuffers,
                                 desc->mCount,
                                 desc->mLength,
                                 desc->mMaxQueueable);
            }

            if ( ret == NO_ERROR ) {
                ret = commitState();
            } else {
                ret |= rollbackState();
            }

            break;
#endif

        case CameraAdapter::CAMERA_START_SMOOTH_ZOOM:
            {

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = startSmoothZoom(value1);
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

            }

        case CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM:
            {

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = stopSmoothZoom();
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

            }

        case CameraAdapter::CAMERA_START_PREVIEW:
            {

                CAMHAL_LOGDA("Start Preview");

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = startPreview();
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

            }

        case CameraAdapter::CAMERA_STOP_PREVIEW:
            {

            CAMHAL_LOGDA("Stop Preview");

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = stopPreview();
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

            }

        case CameraAdapter::CAMERA_START_VIDEO:
            {

            CAMHAL_LOGDA("Start video recording");

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = startVideoCapture();
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

            }

        case CameraAdapter::CAMERA_STOP_VIDEO:
            {

            CAMHAL_LOGDA("Stop video recording");

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = stopVideoCapture();
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

            }

        case CameraAdapter::CAMERA_START_IMAGE_CAPTURE:
            {

#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS

            refTimestamp = ( struct timeval * ) value1;
            if ( NULL != refTimestamp )
                {
                memcpy( &mStartCapture, refTimestamp, sizeof( struct timeval ));
                }

#endif

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = takePicture();
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

            }

        case CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE:
            {

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = stopImageCapture();
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

            }

        case CameraAdapter::CAMERA_START_BRACKET_CAPTURE:
            {

#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS

            refTimestamp = ( struct timeval * ) value2;
            if ( NULL != refTimestamp )
                {
                memcpy( &mStartCapture, refTimestamp, sizeof( struct timeval ));
                }

#endif

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = startBracketing(value1);
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

            }

        case CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE:
            {

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = stopBracketing();
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

            }

        case CameraAdapter::CAMERA_PERFORM_AUTOFOCUS:

#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS

            refTimestamp = ( struct timeval * ) value1;
            if ( NULL != refTimestamp )
                {
                memcpy( &mStartFocus, refTimestamp, sizeof( struct timeval ));
                }

#endif

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = autoFocus();
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

        case CameraAdapter::CAMERA_CANCEL_AUTOFOCUS:

            if ( ret == NO_ERROR )
                {
                ret = setState(operation);
                }

            if ( ret == NO_ERROR )
                {
                ret = cancelAutoFocus();
                }

            if ( ret == NO_ERROR )
                {
                ret = commitState();
                }
            else
                {
                ret |= rollbackState();
                }

            break;

        case CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW:

             if ( ret == NO_ERROR )
                 {
                 ret = setState(operation);
                 }

             if ( ret == NO_ERROR )
                 {
                 frame = ( CameraFrame * ) value1;

                 if ( NULL != frame )
                     {
                     ret = getFrameSize(frame->mWidth, frame->mHeight);
                     }
                 else
                     {
                     ret = -EINVAL;
                     }
                 }

             if ( ret == NO_ERROR )
                 {
                 ret = commitState();
                 }
             else
                 {
                 ret |= rollbackState();
                 }

             break;

         case CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:

             if ( ret == NO_ERROR )
                 {
                 ret = setState(operation);
                 }

             if ( ret == NO_ERROR )
                 {
                 frame = ( CameraFrame * ) value1;

                 if ( NULL != frame )
                     {
                     ret = getPictureBufferSize(*frame, value2);
                     }
                 else
                     {
                     ret = -EINVAL;
                     }
                 }

             if ( ret == NO_ERROR )
                 {
                 ret = commitState();
                 }
             else
                 {
                 ret |= rollbackState();
                 }

             break;

         case CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA:

             if ( ret == NO_ERROR )
                 {
                 ret = setState(operation);
                 }

             if ( ret == NO_ERROR )
                 {
                 frame = ( CameraFrame * ) value1;

                 if ( NULL != frame )
                     {
                     ret = getFrameDataSize(frame->mLength, value2);
                     }
                 else
                     {
                     ret = -EINVAL;
                     }
                 }

             if ( ret == NO_ERROR )
                 {
                 ret = commitState();
                 }
             else
                 {
                 ret |= rollbackState();
                 }

             break;

         case CameraAdapter::CAMERA_START_FD:

             ret = startFaceDetection();

             break;

         case CameraAdapter::CAMERA_STOP_FD:

             ret = stopFaceDetection();

             break;

         case CameraAdapter::CAMERA_USE_BUFFERS_VIDEO_CAPTURE:

             CAMHAL_LOGDA("Use buffers for video (RAW + JPEG) capture");
             desc = ( BuffersDescriptor * ) value1;

             if ( NULL == desc ) {
                 CAMHAL_LOGEA("Invalid capture buffers!");
                 return -EINVAL;
             }

             if ( ret == NO_ERROR ) {
                 ret = setState(operation);
             }

             if ( ret == NO_ERROR ) {
                 android::AutoMutex lock(mVideoBufferLock);
                 mVideoBuffers = desc->mBuffers;
                 mVideoBuffersLength = desc->mLength;
                 mVideoBuffersAvailable.clear();
                 for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ ) {
                     mVideoBuffersAvailable.add(&mVideoBuffers[i], 1);
                 }
                 // initial ref count for undeqeueued buffers is 1 since buffer provider
                 // is still holding on to it
                 for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ ) {
                     mVideoBuffersAvailable.add(&mVideoBuffers[i], 1);
                 }
             }

             if ( NULL != desc ) {
                 ret = useBuffers(CameraAdapter::CAMERA_VIDEO,
                         desc->mBuffers,
                         desc->mCount,
                         desc->mLength,
                         desc->mMaxQueueable);
             }

             if ( ret == NO_ERROR ) {
                 ret = commitState();
             } else {
                 ret |= rollbackState();
             }

             break;

        case CameraAdapter::CAMERA_SWITCH_TO_EXECUTING:
            ret = switchToExecuting();
            break;

#ifdef OMAP_ENHANCEMENT_VTC
        case CameraAdapter::CAMERA_SETUP_TUNNEL:
            ret = setupTunnel(value1, value2, value3, value4);
            break;

        case CameraAdapter::CAMERA_DESTROY_TUNNEL:
            ret = destroyTunnel();
            break;
#endif

        case CameraAdapter::CAMERA_PREVIEW_INITIALIZATION:
            ret = cameraPreviewInitialization();
            break;

        default:
            CAMHAL_LOGEB("Command 0x%x unsupported!", operation);
            break;
    };

    LOG_FUNCTION_NAME_EXIT;
    return ret;
}

status_t BaseCameraAdapter::notifyFocusSubscribers(CameraHalEvent::FocusStatus status)
{
    event_callback eventCb;
    CameraHalEvent focusEvent;
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    if ( mFocusSubscribers.size() == 0 ) {
        CAMHAL_LOGDA("No Focus Subscribers!");
        return NO_INIT;
    }

#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
    if (status == CameraHalEvent::FOCUS_STATUS_PENDING) {
        gettimeofday(&mStartFocus, NULL);
    } else {
        //dump the AF latency
        CameraHal::PPM("Focus finished in: ", &mStartFocus);
    }
#endif

    focusEvent.mEventData = new CameraHalEvent::CameraHalEventData();
    if ( NULL == focusEvent.mEventData.get() ) {
        return -ENOMEM;
    }

    focusEvent.mEventType = CameraHalEvent::EVENT_FOCUS_LOCKED;
    focusEvent.mEventData->focusEvent.focusStatus = status;

    for (unsigned int i = 0 ; i < mFocusSubscribers.size(); i++ )
        {
        focusEvent.mCookie = (void *) mFocusSubscribers.keyAt(i);
        eventCb = (event_callback) mFocusSubscribers.valueAt(i);
        eventCb ( &focusEvent );
        }

    focusEvent.mEventData.clear();

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::notifyShutterSubscribers()
{
    CameraHalEvent shutterEvent;
    event_callback eventCb;
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    if ( mShutterSubscribers.size() == 0 )
        {
        CAMHAL_LOGEA("No shutter Subscribers!");
        return NO_INIT;
        }

    shutterEvent.mEventData = new CameraHalEvent::CameraHalEventData();
    if ( NULL == shutterEvent.mEventData.get() ) {
        return -ENOMEM;
    }

    shutterEvent.mEventType = CameraHalEvent::EVENT_SHUTTER;
    shutterEvent.mEventData->shutterEvent.shutterClosed = true;

    for (unsigned int i = 0 ; i < mShutterSubscribers.size() ; i++ ) {
        shutterEvent.mCookie = ( void * ) mShutterSubscribers.keyAt(i);
        eventCb = ( event_callback ) mShutterSubscribers.valueAt(i);

        CAMHAL_LOGD("Sending shutter callback");

        eventCb ( &shutterEvent );
    }

    shutterEvent.mEventData.clear();

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::notifyZoomSubscribers(int zoomIdx, bool targetReached)
{
    event_callback eventCb;
    CameraHalEvent zoomEvent;
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    if ( mZoomSubscribers.size() == 0 ) {
        CAMHAL_LOGDA("No zoom Subscribers!");
        return NO_INIT;
    }

    zoomEvent.mEventData = new CameraHalEvent::CameraHalEventData();
    if ( NULL == zoomEvent.mEventData.get() ) {
        return -ENOMEM;
    }

    zoomEvent.mEventType = CameraHalEvent::EVENT_ZOOM_INDEX_REACHED;
    zoomEvent.mEventData->zoomEvent.currentZoomIndex = zoomIdx;
    zoomEvent.mEventData->zoomEvent.targetZoomIndexReached = targetReached;

    for (unsigned int i = 0 ; i < mZoomSubscribers.size(); i++ ) {
        zoomEvent.mCookie = (void *) mZoomSubscribers.keyAt(i);
        eventCb = (event_callback) mZoomSubscribers.valueAt(i);

        eventCb ( &zoomEvent );
    }

    zoomEvent.mEventData.clear();

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::notifyMetadataSubscribers(android::sp<CameraMetadataResult> &meta)
{
    event_callback eventCb;
    CameraHalEvent metaEvent;
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    if ( mMetadataSubscribers.size() == 0 ) {
        CAMHAL_LOGDA("No preview metadata subscribers!");
        return NO_INIT;
    }

    metaEvent.mEventData = new CameraHalEvent::CameraHalEventData();
    if ( NULL == metaEvent.mEventData.get() ) {
        return -ENOMEM;
    }

    metaEvent.mEventType = CameraHalEvent::EVENT_METADATA;
    metaEvent.mEventData->metadataEvent = meta;

    for (unsigned int i = 0 ; i < mMetadataSubscribers.size(); i++ ) {
        metaEvent.mCookie = (void *) mMetadataSubscribers.keyAt(i);
        eventCb = (event_callback) mMetadataSubscribers.valueAt(i);

        eventCb ( &metaEvent );
    }

    metaEvent.mEventData.clear();

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::sendFrameToSubscribers(CameraFrame *frame)
{
    status_t ret = NO_ERROR;
    unsigned int mask;

    if ( NULL == frame )
        {
        CAMHAL_LOGEA("Invalid CameraFrame");
        return -EINVAL;
        }

    for( mask = 1; mask < CameraFrame::ALL_FRAMES; mask <<= 1){
      if( mask & frame->mFrameMask ){
        switch( mask ){

        case CameraFrame::IMAGE_FRAME:
          {
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
            CameraHal::PPM("Shot to Jpeg: ", &mStartCapture);
#endif
            ret = __sendFrameToSubscribers(frame, &mImageSubscribers, CameraFrame::IMAGE_FRAME);
          }
          break;
        case CameraFrame::RAW_FRAME:
          {
            ret = __sendFrameToSubscribers(frame, &mRawSubscribers, CameraFrame::RAW_FRAME);
          }
          break;
        case CameraFrame::PREVIEW_FRAME_SYNC:
          {
            ret = __sendFrameToSubscribers(frame, &mFrameSubscribers, CameraFrame::PREVIEW_FRAME_SYNC);
          }
          break;
        case CameraFrame::SNAPSHOT_FRAME:
          {
            ret = __sendFrameToSubscribers(frame, &mSnapshotSubscribers, CameraFrame::SNAPSHOT_FRAME);
          }
          break;
        case CameraFrame::VIDEO_FRAME_SYNC:
          {
            ret = __sendFrameToSubscribers(frame, &mVideoSubscribers, CameraFrame::VIDEO_FRAME_SYNC);
          }
          break;
        case CameraFrame::FRAME_DATA_SYNC:
          {
            ret = __sendFrameToSubscribers(frame, &mFrameDataSubscribers, CameraFrame::FRAME_DATA_SYNC);
          }
          break;
        case CameraFrame::REPROCESS_INPUT_FRAME:
          {
            ret = __sendFrameToSubscribers(frame, &mVideoInSubscribers, CameraFrame::REPROCESS_INPUT_FRAME);
          }
          break;
        default:
          CAMHAL_LOGEB("FRAMETYPE NOT SUPPORTED 0x%x", mask);
        break;
        }//SWITCH
        frame->mFrameMask &= ~mask;

        if (ret != NO_ERROR) {
            goto EXIT;
        }
      }//IF
    }//FOR

 EXIT:
    return ret;
}

status_t BaseCameraAdapter::__sendFrameToSubscribers(CameraFrame* frame,
                                                     android::KeyedVector<int, frame_callback> *subscribers,
                                                     CameraFrame::FrameType frameType)
{
    size_t refCount = 0;
    status_t ret = NO_ERROR;
    frame_callback callback = NULL;

    frame->mFrameType = frameType;

    if ( (frameType == CameraFrame::PREVIEW_FRAME_SYNC) ||
         (frameType == CameraFrame::VIDEO_FRAME_SYNC) ||
         (frameType == CameraFrame::SNAPSHOT_FRAME) ){
        if (mFrameQueue.size() > 0){
          CameraFrame *lframe = (CameraFrame *)mFrameQueue.valueFor(frame->mBuffer);
          frame->mYuv[0] = lframe->mYuv[0];
          frame->mYuv[1] = frame->mYuv[0] + (frame->mLength + frame->mOffset)*2/3;
        }
        else{
          CAMHAL_LOGDA("Empty Frame Queue");
          return -EINVAL;
        }
      }

    if (NULL != subscribers) {
        refCount = getFrameRefCount(frame->mBuffer, frameType);

        if (refCount == 0) {
            CAMHAL_LOGDA("Invalid ref count of 0");
            return -EINVAL;
        }

        if (refCount > subscribers->size()) {
            CAMHAL_LOGEB("Invalid ref count for frame type: 0x%x", frameType);
            return -EINVAL;
        }

        CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
                     frame->mFrameType,
                     ( uint32_t ) frame->mBuffer,
                     refCount);

        for ( unsigned int i = 0 ; i < refCount; i++ ) {
            frame->mCookie = ( void * ) subscribers->keyAt(i);
            callback = (frame_callback) subscribers->valueAt(i);

            if (!callback) {
                CAMHAL_LOGEB("callback not set for frame type: 0x%x", frameType);
                return -EINVAL;
            }

            callback(frame);
        }
    } else {
        CAMHAL_LOGEA("Subscribers is null??");
        return -EINVAL;
    }

    return ret;
}

int BaseCameraAdapter::setInitFrameRefCount(CameraBuffer * buf, unsigned int mask)
{
  int ret = NO_ERROR;
  unsigned int lmask;

  LOG_FUNCTION_NAME;

  if (buf == NULL)
    {
      return -EINVAL;
    }

  for( lmask = 1; lmask < CameraFrame::ALL_FRAMES; lmask <<= 1){
    if( lmask & mask ){
      switch( lmask ){

      case CameraFrame::IMAGE_FRAME:
        {
          setFrameRefCount(buf, CameraFrame::IMAGE_FRAME, (int) mImageSubscribers.size());
        }
        break;
      case CameraFrame::RAW_FRAME:
        {
          setFrameRefCount(buf, CameraFrame::RAW_FRAME, mRawSubscribers.size());
        }
        break;
      case CameraFrame::PREVIEW_FRAME_SYNC:
        {
          setFrameRefCount(buf, CameraFrame::PREVIEW_FRAME_SYNC, mFrameSubscribers.size());
        }
        break;
      case CameraFrame::SNAPSHOT_FRAME:
        {
          setFrameRefCount(buf, CameraFrame::SNAPSHOT_FRAME, mSnapshotSubscribers.size());
        }
        break;
      case CameraFrame::VIDEO_FRAME_SYNC:
        {
          setFrameRefCount(buf,CameraFrame::VIDEO_FRAME_SYNC, mVideoSubscribers.size());
        }
        break;
      case CameraFrame::FRAME_DATA_SYNC:
        {
          setFrameRefCount(buf, CameraFrame::FRAME_DATA_SYNC, mFrameDataSubscribers.size());
        }
        break;
      case CameraFrame::REPROCESS_INPUT_FRAME:
        {
          setFrameRefCount(buf,CameraFrame::REPROCESS_INPUT_FRAME, mVideoInSubscribers.size());
        }
        break;
      default:
        CAMHAL_LOGEB("FRAMETYPE NOT SUPPORTED 0x%x", lmask);
        break;
      }//SWITCH
      mask &= ~lmask;
    }//IF
  }//FOR
  LOG_FUNCTION_NAME_EXIT;
  return ret;
}

int BaseCameraAdapter::getFrameRefCount(CameraBuffer * frameBuf, CameraFrame::FrameType frameType)
{
    int res = -1;

    LOG_FUNCTION_NAME;

    switch ( frameType )
        {
        case CameraFrame::IMAGE_FRAME:
        case CameraFrame::RAW_FRAME:
                {
                android::AutoMutex lock(mCaptureBufferLock);
                res = mCaptureBuffersAvailable.valueFor(frameBuf );
                }
            break;
        case CameraFrame::SNAPSHOT_FRAME:
                {
                android::AutoMutex lock(mSnapshotBufferLock);
                res = mSnapshotBuffersAvailable.valueFor( ( unsigned int ) frameBuf );
                }
            break;
        case CameraFrame::PREVIEW_FRAME_SYNC:
                {
                android::AutoMutex lock(mPreviewBufferLock);
                res = mPreviewBuffersAvailable.valueFor(frameBuf );
                }
            break;
        case CameraFrame::FRAME_DATA_SYNC:
                {
                android::AutoMutex lock(mPreviewDataBufferLock);
                res = mPreviewDataBuffersAvailable.valueFor(frameBuf );
                }
            break;
        case CameraFrame::VIDEO_FRAME_SYNC:
                {
                android::AutoMutex lock(mVideoBufferLock);
                res = mVideoBuffersAvailable.valueFor(frameBuf );
                }
            break;
        case CameraFrame::REPROCESS_INPUT_FRAME: {
            android::AutoMutex lock(mVideoInBufferLock);
            res = mVideoInBuffersAvailable.valueFor(frameBuf );
        }
            break;
        default:
            break;
        };

    LOG_FUNCTION_NAME_EXIT;

    return res;
}

void BaseCameraAdapter::setFrameRefCount(CameraBuffer * frameBuf, CameraFrame::FrameType frameType, int refCount)
{

    LOG_FUNCTION_NAME;

    switch ( frameType )
        {
        case CameraFrame::IMAGE_FRAME:
        case CameraFrame::RAW_FRAME:
                {
                android::AutoMutex lock(mCaptureBufferLock);
                mCaptureBuffersAvailable.replaceValueFor(frameBuf, refCount);
                }
            break;
        case CameraFrame::SNAPSHOT_FRAME:
                {
                android::AutoMutex lock(mSnapshotBufferLock);
                mSnapshotBuffersAvailable.replaceValueFor(  ( unsigned int ) frameBuf, refCount);
                }
            break;
        case CameraFrame::PREVIEW_FRAME_SYNC:
                {
                android::AutoMutex lock(mPreviewBufferLock);
                mPreviewBuffersAvailable.replaceValueFor(frameBuf, refCount);
                }
            break;
        case CameraFrame::FRAME_DATA_SYNC:
                {
                android::AutoMutex lock(mPreviewDataBufferLock);
                mPreviewDataBuffersAvailable.replaceValueFor(frameBuf, refCount);
                }
            break;
        case CameraFrame::VIDEO_FRAME_SYNC:
                {
                android::AutoMutex lock(mVideoBufferLock);
                mVideoBuffersAvailable.replaceValueFor(frameBuf, refCount);
                }
            break;
        case CameraFrame::REPROCESS_INPUT_FRAME: {
            android::AutoMutex lock(mVideoInBufferLock);
            mVideoInBuffersAvailable.replaceValueFor(frameBuf, refCount);
        }
            break;
        default:
            break;
        };

    LOG_FUNCTION_NAME_EXIT;

}

status_t BaseCameraAdapter::startVideoCapture()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    android::AutoMutex lock(mVideoBufferLock);

    //If the capture is already ongoing, return from here.
    if ( mRecording )
        {
        ret = NO_INIT;
        }


    if ( NO_ERROR == ret )
        {

        for ( unsigned int i = 0 ; i < mPreviewBuffersAvailable.size() ; i++ )
            {
            mVideoBuffersAvailable.add(mPreviewBuffersAvailable.keyAt(i), 0);
            }

        mRecording = true;
        }

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::stopVideoCapture()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    if ( !mRecording )
        {
        ret = NO_INIT;
        }

    if ( NO_ERROR == ret )
        {
        for ( unsigned int i = 0 ; i < mVideoBuffersAvailable.size() ; i++ )
            {
            CameraBuffer *frameBuf = mVideoBuffersAvailable.keyAt(i);
            if( getFrameRefCount(frameBuf,  CameraFrame::VIDEO_FRAME_SYNC) > 0)
                {
                returnFrame(frameBuf, CameraFrame::VIDEO_FRAME_SYNC);
                }
            }

        mVideoBuffersAvailable.clear();

        mRecording = false;
        }

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

//-----------------Stub implementation of the interface ------------------------------

status_t BaseCameraAdapter::takePicture()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::stopImageCapture()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::startBracketing(int range)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::stopBracketing()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::autoFocus()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    notifyFocusSubscribers(CameraHalEvent::FOCUS_STATUS_FAIL);

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::cancelAutoFocus()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::startSmoothZoom(int targetIdx)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::stopSmoothZoom()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::startPreview()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::stopPreview()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::useBuffers(CameraMode mode, CameraBuffer* bufArr, int num, size_t length, unsigned int queueable)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::fillThisBuffer(CameraBuffer * frameBuf, CameraFrame::FrameType frameType)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::getFrameSize(size_t &width, size_t &height)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t bufferCount)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::getPictureBufferSize(CameraFrame &frame, size_t bufferCount)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

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

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::stopFaceDetection()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::switchToExecuting()
{
  status_t ret = NO_ERROR;
  LOG_FUNCTION_NAME;
  LOG_FUNCTION_NAME_EXIT;
  return ret;
}

const char* BaseCameraAdapter::getLUTvalue_translateHAL(int Value, LUTtypeHAL LUT) {
    int LUTsize = LUT.size;
    for(int i = 0; i < LUTsize; i++)
        if( LUT.Table[i].halDefinition == Value )
            return LUT.Table[i].userDefinition;

    return NULL;
}

status_t BaseCameraAdapter::setupTunnel(uint32_t SliceHeight, uint32_t EncoderHandle, uint32_t width, uint32_t height) {
  status_t ret = NO_ERROR;
  LOG_FUNCTION_NAME;
  LOG_FUNCTION_NAME_EXIT;
  return ret;
}

status_t BaseCameraAdapter::destroyTunnel() {
  status_t ret = NO_ERROR;
  LOG_FUNCTION_NAME;
  LOG_FUNCTION_NAME_EXIT;
  return ret;
}

status_t BaseCameraAdapter::cameraPreviewInitialization() {
  status_t ret = NO_ERROR;
  LOG_FUNCTION_NAME;
  LOG_FUNCTION_NAME_EXIT;
  return ret;
}

status_t BaseCameraAdapter::setState(CameraCommands operation)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    const char *printState = getLUTvalue_translateHAL(operation, CamCommandsLUT);

    mLock.lock();

    switch ( mAdapterState )
        {

        case INTIALIZED_STATE:

            switch ( operation )
                {

                case CAMERA_USE_BUFFERS_PREVIEW:
                    CAMHAL_LOGDB("Adapter state switch INTIALIZED_STATE->LOADED_PREVIEW_STATE event = %s",
                            printState);
                    mNextState = LOADED_PREVIEW_STATE;
                    break;

                //These events don't change the current state
                case CAMERA_QUERY_RESOLUTION_PREVIEW:
                case CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA:
                    CAMHAL_LOGDB("Adapter state switch INTIALIZED_STATE->INTIALIZED_STATE event  = %s",
                            printState);
                    mNextState = INTIALIZED_STATE;
                    break;
                case CAMERA_STOP_BRACKET_CAPTURE:
                case CAMERA_STOP_IMAGE_CAPTURE:
                    ret = INVALID_OPERATION;
                    break;
                case CAMERA_CANCEL_AUTOFOCUS:
                    ret = INVALID_OPERATION;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch INTIALIZED_STATE Invalid Op! event  = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case LOADED_PREVIEW_STATE:

            switch ( operation )
                {

                case CAMERA_START_PREVIEW:
                    CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->PREVIEW_STATE event = %s",
                            printState);
                    mNextState = PREVIEW_STATE;
                    break;

                case CAMERA_STOP_PREVIEW:
                    CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->INTIALIZED_STATE event = 0x%x",
                                 operation);
                    mNextState = INTIALIZED_STATE;
                    break;

                //These events don't change the current state
                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
                case CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA:
                case CAMERA_USE_BUFFERS_PREVIEW_DATA:
                    CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->LOADED_PREVIEW_STATE event = %s",
                            printState);
                    mNextState = LOADED_PREVIEW_STATE;
                    break;

                default:
                    CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case PREVIEW_STATE:

            switch ( operation )
                {

                case CAMERA_STOP_PREVIEW:
                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->INTIALIZED_STATE event = %s",
                            printState);
                    mNextState = INTIALIZED_STATE;
                    break;

                case CAMERA_PERFORM_AUTOFOCUS:
                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->AF_STATE event = %s",
                            printState);
                    mNextState = AF_STATE;
                    break;

                case CAMERA_START_SMOOTH_ZOOM:
                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->ZOOM_STATE event = %s",
                            printState);
                    mNextState = ZOOM_STATE;
                    break;

                case CAMERA_USE_BUFFERS_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->LOADED_CAPTURE_STATE event = %s",
                            printState);
                    mNextState = LOADED_CAPTURE_STATE;
                    break;

#ifdef OMAP_ENHANCEMENT_CPCAM
                case CAMERA_USE_BUFFERS_REPROCESS:
                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->LOADED_REPROCESS_STATE event = %s",
                                 printState);
                    mNextState = LOADED_REPROCESS_STATE;
                    break;
#endif

                case CAMERA_START_VIDEO:
                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->VIDEO_STATE event = %s",
                            printState);
                    mNextState = VIDEO_STATE;
                    break;

                case CAMERA_CANCEL_AUTOFOCUS:
                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
                case CAMERA_STOP_SMOOTH_ZOOM:
                    CAMHAL_LOGDB("Adapter state switch PREVIEW_ACTIVE->PREVIEW_ACTIVE event = %s",
                            printState);
                    mNextState = PREVIEW_STATE;
                    break;

                case CAMERA_STOP_IMAGE_CAPTURE:
                case CAMERA_STOP_BRACKET_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch PREVIEW_ACTIVE->PREVIEW_ACTIVE event = %s",
                                 printState);
                    ret = INVALID_OPERATION;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch PREVIEW_ACTIVE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

#ifdef OMAP_ENHANCEMENT_CPCAM
        case LOADED_REPROCESS_STATE:
            switch (operation) {
                case CAMERA_USE_BUFFERS_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch LOADED_REPROCESS_STATE->LOADED_REPROCESS_CAPTURE_STATE event = %s",
                                 printState);
                    mNextState = LOADED_REPROCESS_CAPTURE_STATE;
                    break;
                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch LOADED_REPROCESS_STATE->LOADED_REPROCESS_STATE event = %s",
                                 printState);
                    mNextState = LOADED_REPROCESS_STATE;
                    break;
                default:
                    CAMHAL_LOGEB("Adapter state switch LOADED_REPROCESS_STATE Invalid Op! event = %s",
                                 printState);
                    ret = INVALID_OPERATION;
                    break;
                }

            break;

        case LOADED_REPROCESS_CAPTURE_STATE:
            switch (operation) {
                case CAMERA_START_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch LOADED_REPROCESS_CAPTURE_STATE->REPROCESS_STATE event = %s",
                                 printState);
                    mNextState = REPROCESS_STATE;
                    break;
                default:
                    CAMHAL_LOGEB("Adapter state switch LOADED_REPROCESS_CAPTURE_STATE Invalid Op! event = %s",
                                 printState);
                    ret = INVALID_OPERATION;
                    break;
            }
            break;
#endif

        case LOADED_CAPTURE_STATE:

            switch ( operation )
                {

                case CAMERA_START_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->CAPTURE_STATE event = %s",
                            printState);
                    mNextState = CAPTURE_STATE;
                    break;

                case CAMERA_START_BRACKET_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->BRACKETING_STATE event = %s",
                            printState);
                    mNextState = BRACKETING_STATE;
                    break;

                case CAMERA_USE_BUFFERS_VIDEO_CAPTURE:
                    //Hadnle this state for raw capture path.
                    //Just need to keep the same state.
                    //The next CAMERA_START_IMAGE_CAPTURE command will assign the mNextState.
                    CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->LOADED_CAPTURE_STATE event = %s",
                            printState);
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch LOADED_CAPTURE_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case CAPTURE_STATE:

            switch ( operation )
                {
                case CAMERA_STOP_IMAGE_CAPTURE:
                case CAMERA_STOP_BRACKET_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch CAPTURE_STATE->PREVIEW_STATE event = %s",
                            printState);
                    mNextState = PREVIEW_STATE;
                    break;

                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
                case CAMERA_START_IMAGE_CAPTURE:
                     CAMHAL_LOGDB("Adapter state switch CAPTURE_STATE->CAPTURE_STATE event = %s",
                                 printState);
                    mNextState = CAPTURE_STATE;
                    break;

#ifdef OMAP_ENHANCEMENT_CPCAM
                case CAMERA_USE_BUFFERS_REPROCESS:
                    CAMHAL_LOGDB("Adapter state switch CAPTURE_STATE->->LOADED_REPROCESS_STATE event = %s",
                                 printState);
                    mNextState = LOADED_REPROCESS_STATE;
                    break;
#endif

                default:
                    CAMHAL_LOGEB("Adapter state switch CAPTURE_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case BRACKETING_STATE:

            switch ( operation )
                {

                case CAMERA_STOP_IMAGE_CAPTURE:
                case CAMERA_STOP_BRACKET_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch BRACKETING_STATE->PREVIEW_STATE event = %s",
                            printState);
                    mNextState = PREVIEW_STATE;
                    break;

                case CAMERA_START_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch BRACKETING_STATE->CAPTURE_STATE event = %s",
                            printState);
                    mNextState = CAPTURE_STATE;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch BRACKETING_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case AF_STATE:

            switch ( operation )
                {

                case CAMERA_CANCEL_AUTOFOCUS:
                    CAMHAL_LOGDB("Adapter state switch AF_STATE->PREVIEW_STATE event = %s",
                            printState);
                    mNextState = PREVIEW_STATE;
                    break;

                case CAMERA_START_SMOOTH_ZOOM:
                    CAMHAL_LOGDB("Adapter state switch AF_STATE->AF_ZOOM_STATE event = %s",
                            printState);
                    mNextState = AF_ZOOM_STATE;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch AF_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case ZOOM_STATE:

            switch ( operation )
                {

                case CAMERA_CANCEL_AUTOFOCUS:
                    CAMHAL_LOGDB("Adapter state switch AF_STATE->PREVIEW_STATE event = %s",
                            printState);
                    mNextState = ZOOM_STATE;
                    break;

                case CAMERA_STOP_SMOOTH_ZOOM:
                    CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->PREVIEW_STATE event = %s",
                            printState);
                    mNextState = PREVIEW_STATE;
                    break;

                case CAMERA_PERFORM_AUTOFOCUS:
                    CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->AF_ZOOM_STATE event = %s",
                            printState);
                    mNextState = AF_ZOOM_STATE;
                    break;

                case CAMERA_START_VIDEO:
                    CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->VIDEO_ZOOM_STATE event = %s",
                            printState);
                    mNextState = VIDEO_ZOOM_STATE;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch ZOOM_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case VIDEO_STATE:

            switch ( operation )
                {

                case CAMERA_STOP_VIDEO:
                    CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->PREVIEW_STATE event = %s",
                            printState);
                    mNextState = PREVIEW_STATE;
                    break;

                case CAMERA_PERFORM_AUTOFOCUS:
                    CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_AF_STATE event = %s",
                            printState);
                    mNextState = VIDEO_AF_STATE;
                    break;

                case CAMERA_START_SMOOTH_ZOOM:
                    CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_ZOOM_STATE event = %s",
                            printState);
                    mNextState = VIDEO_ZOOM_STATE;
                    break;

                case CAMERA_USE_BUFFERS_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_LOADED_CAPTURE_STATE event = %s",
                            printState);
                    mNextState = VIDEO_LOADED_CAPTURE_STATE;
                    break;

                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_STATE event = %s",
                            printState);
                    mNextState = VIDEO_STATE;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch VIDEO_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case VIDEO_AF_STATE:

            switch ( operation )
                {

                case CAMERA_CANCEL_AUTOFOCUS:
                    CAMHAL_LOGDB("Adapter state switch VIDEO_AF_STATE->VIDEO_STATE event = %s",
                            printState);
                    mNextState = VIDEO_STATE;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch VIDEO_AF_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case VIDEO_LOADED_CAPTURE_STATE:

            switch ( operation )
                {

                case CAMERA_START_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->CAPTURE_STATE event = %s",
                            printState);
                    mNextState = VIDEO_CAPTURE_STATE;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch LOADED_CAPTURE_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case VIDEO_CAPTURE_STATE:

            switch ( operation )
                {
                case CAMERA_STOP_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch CAPTURE_STATE->PREVIEW_STATE event = %s",
                            printState);
                    mNextState = VIDEO_STATE;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch CAPTURE_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case AF_ZOOM_STATE:

            switch ( operation )
                {

                case CAMERA_STOP_SMOOTH_ZOOM:
                    CAMHAL_LOGDB("Adapter state switch AF_ZOOM_STATE->AF_STATE event = %s",
                            printState);
                    mNextState = AF_STATE;
                    break;

                case CAMERA_CANCEL_AUTOFOCUS:
                    CAMHAL_LOGDB("Adapter state switch AF_ZOOM_STATE->ZOOM_STATE event = %s",
                            printState);
                    mNextState = ZOOM_STATE;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch AF_ZOOM_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case VIDEO_ZOOM_STATE:

            switch ( operation )
                {

                case CAMERA_STOP_SMOOTH_ZOOM:
                    CAMHAL_LOGDB("Adapter state switch VIDEO_ZOOM_STATE->VIDEO_STATE event = %s",
                            printState);
                    mNextState = VIDEO_STATE;
                    break;

                case CAMERA_STOP_VIDEO:
                    CAMHAL_LOGDB("Adapter state switch VIDEO_ZOOM_STATE->ZOOM_STATE event = %s",
                            printState);
                    mNextState = ZOOM_STATE;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch VIDEO_ZOOM_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

        case BRACKETING_ZOOM_STATE:

            switch ( operation )
                {

                case CAMERA_STOP_SMOOTH_ZOOM:
                    CAMHAL_LOGDB("Adapter state switch BRACKETING_ZOOM_STATE->BRACKETING_STATE event = %s",
                            printState);
                    mNextState = BRACKETING_STATE;
                    break;

                default:
                    CAMHAL_LOGEB("Adapter state switch BRACKETING_ZOOM_STATE Invalid Op! event = %s",
                            printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;

#ifdef OMAP_ENHANCEMENT_CPCAM
        case REPROCESS_STATE:
            switch (operation) {
                case CAMERA_STOP_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch REPROCESS_STATE->PREVIEW_STATE event = %s",
                                 printState);
                    mNextState = PREVIEW_STATE;
                    break;
                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
                case CAMERA_START_IMAGE_CAPTURE:
                     CAMHAL_LOGDB("Adapter state switch REPROCESS_STATE->REPROCESS_STATE event = %s",
                                 printState);
                    mNextState = REPROCESS_STATE;
                    break;
                case CAMERA_USE_BUFFERS_REPROCESS:
                     CAMHAL_LOGDB("Adapter state switch REPROCESS_STATE->REPROCESS_STATE event = %s",
                                 printState);
                    mNextState = LOADED_REPROCESS_STATE;
                    break;

                case CAMERA_USE_BUFFERS_IMAGE_CAPTURE:
                    CAMHAL_LOGDB("Adapter state switch REPROCESS_STATE->LOADED_CAPTURE_STATE event = %s",
                            printState);
                    mNextState = LOADED_CAPTURE_STATE;
                    break;
                default:
                    CAMHAL_LOGEB("Adapter state switch REPROCESS_STATE Invalid Op! event = %s",
                                 printState);
                    ret = INVALID_OPERATION;
                    break;

                }

            break;
#endif


        default:
            CAMHAL_LOGEA("Invalid Adapter state!");
            ret = INVALID_OPERATION;
        }

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::rollbackToInitializedState()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    while ((getState() != INTIALIZED_STATE) && (ret == NO_ERROR)) {
        ret = rollbackToPreviousState();
    }

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::rollbackToPreviousState()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    CameraAdapter::AdapterState currentState = getState();

    switch (currentState) {
        case INTIALIZED_STATE:
            return NO_ERROR;

        case PREVIEW_STATE:
            ret = sendCommand(CAMERA_STOP_PREVIEW);
            break;

        case CAPTURE_STATE:
#ifdef OMAP_ENHANCEMENT_CPCAM
        case REPROCESS_STATE:
#endif
            ret = sendCommand(CAMERA_STOP_IMAGE_CAPTURE);
            break;

        case BRACKETING_STATE:
            ret = sendCommand(CAMERA_STOP_BRACKET_CAPTURE);
            break;

        case AF_STATE:
            ret = sendCommand(CAMERA_CANCEL_AUTOFOCUS);
            break;

        case ZOOM_STATE:
            ret = sendCommand(CAMERA_STOP_SMOOTH_ZOOM);
            break;

        case VIDEO_STATE:
            ret = sendCommand(CAMERA_STOP_VIDEO);
            break;

        case VIDEO_AF_STATE:
            ret = sendCommand(CAMERA_CANCEL_AUTOFOCUS);
            break;

        case VIDEO_CAPTURE_STATE:
            ret = sendCommand(CAMERA_STOP_IMAGE_CAPTURE);
            break;

        case AF_ZOOM_STATE:
            ret = sendCommand(CAMERA_STOP_SMOOTH_ZOOM);
            break;

        case VIDEO_ZOOM_STATE:
            ret = sendCommand(CAMERA_STOP_SMOOTH_ZOOM);
            break;

        case BRACKETING_ZOOM_STATE:
            ret = sendCommand(CAMERA_STOP_SMOOTH_ZOOM);
            break;

        default:
            CAMHAL_LOGEA("Invalid Adapter state!");
            ret = INVALID_OPERATION;
    }

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

//State transition finished successfully.
//Commit the state and unlock the adapter state.
status_t BaseCameraAdapter::commitState()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    mAdapterState = mNextState;

    mLock.unlock();

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::rollbackState()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    mNextState = mAdapterState;

    mLock.unlock();

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

// getNextState() and getState()
// publicly exposed functions to retrieve the adapter states
// please notice that these functions are locked
CameraAdapter::AdapterState BaseCameraAdapter::getState()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    android::AutoMutex lock(mLock);

    LOG_FUNCTION_NAME_EXIT;

    return mAdapterState;
}

CameraAdapter::AdapterState BaseCameraAdapter::getNextState()
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    android::AutoMutex lock(mLock);

    LOG_FUNCTION_NAME_EXIT;

    return mNextState;
}

// getNextState() and getState()
// internal protected functions to retrieve the adapter states
// please notice that these functions are NOT locked to help
// internal functions query state in the middle of state
// transition
status_t BaseCameraAdapter::getState(AdapterState &state)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    state = mAdapterState;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

status_t BaseCameraAdapter::getNextState(AdapterState &state)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    state = mNextState;

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

void BaseCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt)
{
    LOG_FUNCTION_NAME;
    LOG_FUNCTION_NAME_EXIT;
}

//-----------------------------------------------------------------------------

extern "C" status_t OMXCameraAdapter_Capabilities(
        CameraProperties::Properties * const properties_array,
        const int starting_camera, const int max_camera, int & supportedCameras);
extern "C" status_t V4LCameraAdapter_Capabilities(
        CameraProperties::Properties * const properties_array,
        const int starting_camera, const int max_camera, int & supportedCameras);

extern "C" status_t CameraAdapter_Capabilities(
        CameraProperties::Properties * const properties_array,
        const int starting_camera, const int max_camera, int & supportedCameras)
{

    status_t ret = NO_ERROR;
    status_t err = NO_ERROR;
    int num_cameras_supported = 0;

    LOG_FUNCTION_NAME;

    supportedCameras = 0;
#ifdef OMX_CAMERA_ADAPTER
    //Query OMX cameras
    err = OMXCameraAdapter_Capabilities( properties_array, starting_camera,
                                         max_camera, supportedCameras);
    if(err != NO_ERROR) {
        CAMHAL_LOGEA("error while getting OMXCameraAdapter capabilities");
        ret = UNKNOWN_ERROR;
    }
#endif
#ifdef V4L_CAMERA_ADAPTER
    //Query V4L cameras
    err = V4LCameraAdapter_Capabilities( properties_array, (const int) supportedCameras,
                                         max_camera, num_cameras_supported);
    if(err != NO_ERROR) {
        CAMHAL_LOGEA("error while getting V4LCameraAdapter capabilities");
        ret = UNKNOWN_ERROR;
    }
#endif

    supportedCameras += num_cameras_supported;
    CAMHAL_LOGEB("supportedCameras= %d\n", supportedCameras);
    LOG_FUNCTION_NAME_EXIT;
    return ret;
}

//-----------------------------------------------------------------------------

} // namespace Camera
} // namespace Ti

/*--------------------Camera Adapter Class ENDS here-----------------------------*/