/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "xacameraitf.h"
#include "xacameraitfadaptation.h"
#include "xathreadsafety.h"
/* XACameraItfImpl* GetImpl(XACameraItf self)
* Description: Validate interface pointer and cast it to implementation pointer.
*/
static XACameraItfImpl* GetImpl(XACameraItf self)
{
if( self )
{
XACameraItfImpl* impl = (XACameraItfImpl*)(*self);
if( impl && (impl == impl->self) )
{
return impl;
}
}
return NULL;
}
/*****************************************************************************
* Base interface XACameraItf implementation
*****************************************************************************/
/**
* XAresult XACameraItfImpl_RegisterCallback( XACameraItf self,
* xaCameraCallback callback,
* void *pContext )
* Description: Sets callback for camera event notification.
**/
XAresult XACameraItfImpl_RegisterCallback( XACameraItf self,
xaCameraCallback callback,
void *pContext )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_RegisterCallback");
if( !impl )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_RegisterCallback");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
impl->callback = callback;
impl->context = pContext;
impl->cbPtrToSelf = self;
DEBUG_API("<-XACameraItfImpl_RegisterCallback");
return ret;
}
/**
* XAresult XACameraItfImpl_SetFlashMode( XACameraItf self, XAuint32 flashMode )
* Description: Sets the camera flash setting.
**/
XAresult XACameraItfImpl_SetFlashMode( XACameraItf self, XAuint32 flashMode )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_SetFlashMode");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
if( !impl || flashMode > XA_CAMERA_FLASHMODE_TORCH || flashMode < XA_CAMERA_FLASHMODE_OFF )
{
/* invalid parameter */
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_SetFlashMode");
return XA_RESULT_PARAMETER_INVALID;
}
/* check is flash mode changed */
if( impl->flashMode != flashMode )
{
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_SetFlashMode( (XAAdaptationGstCtx*)impl->adapCtx, flashMode );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
if ( ret == XA_RESULT_SUCCESS )
{
impl->flashMode = flashMode;
}
/* wait for adaptation */
impl->flashReady = XA_BOOLEAN_FALSE;
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_API("<-XACameraItfImpl_SetFlashMode");
return ret;
}
/**
* XAresult XACameraItfImpl_GetFlashMode( XACameraItf self, XAuint32 *pFlashMode )
* Description: Gets the camera flash setting.
**/
XAresult XACameraItfImpl_GetFlashMode( XACameraItf self, XAuint32 *pFlashMode )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_GetFlashMode");
if( !impl || !pFlashMode )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetFlashMode");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pFlashMode = impl->flashMode;
DEBUG_API("<-XACameraItfImpl_GetFlashMode");
return ret;
}
/**
* XAresult XACameraItfImpl_IsFlashReady( XACameraItf self, XAboolean *pReady )
* Description: Queries whether the flash is ready for use.
**/
XAresult XACameraItfImpl_IsFlashReady( XACameraItf self, XAboolean *pReady )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_IsFlashReady");
if( !impl || !pReady )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_IsFlashReady");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pReady = impl->flashReady;
DEBUG_API("<-XACameraItfImpl_IsFlashReady");
return ret;
}
/**
* XAresult XACameraItfImpl_SetFocusMode( XACameraItf self, XAuint32 focusMode,
* XAmillimeter manualSetting,
* XAboolean macroEnabled )
* Description: Sets the camera focus mode.
**/
XAresult XACameraItfImpl_SetFocusMode( XACameraItf self, XAuint32 focusMode,
XAmillimeter manualSetting,
XAboolean macroEnabled )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_SetFocusMode");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
if( !impl || focusMode < XA_CAMERA_FOCUSMODE_MANUAL || focusMode > XA_CAMERA_FOCUSMODE_CONTINUOUS_CENTROID )
{
/* invalid parameter */
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_SetFocusMode");
return XA_RESULT_PARAMETER_INVALID;
}
/* check is focus mode changed */
if( impl->focusMode != focusMode )
{
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_SetFocusMode( (XAAdaptationGstCtx*)impl->adapCtx, focusMode, manualSetting, macroEnabled );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
if ( ret == XA_RESULT_SUCCESS )
{
impl->focusMode = focusMode;
impl->focusManualSetting = manualSetting;
impl->macroEnabled = macroEnabled;
}
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_API("<-XACameraItfImpl_SetFocusMode");
return ret;
}
/**
* XAresult XACameraItfImpl_GetFocusMode( XACameraItf self,
* XAuint32 *pFocusMode,
* XAmillimeter *pManualSetting,
* XAboolean *pMacroEnabled )
* Description: Gets the camera focus mode.
**/
XAresult XACameraItfImpl_GetFocusMode( XACameraItf self,
XAuint32 *pFocusMode,
XAmillimeter *pManualSetting,
XAboolean *pMacroEnabled )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_GetFocusMode");
if( !impl || !pFocusMode || !pManualSetting || !pMacroEnabled )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetFocusMode");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pFocusMode = impl->focusMode;
*pMacroEnabled = impl->macroEnabled;
if( impl->focusMode & XA_CAMERA_FOCUSMODE_MANUAL )
{
*pManualSetting = impl->focusManualSetting;
}
DEBUG_API("<-XACameraItfImpl_GetFocusMode");
return ret;
}
/**
* XAresult XACameraItfImpl_SetFocusRegionPattern( XACameraItf self,
* XAuint32 focusPattern,
* XAuint32 activePoints1,
* XAuint32 activePoints2 )
* Description: Set the camera focus region pattern.
**/
XAresult XACameraItfImpl_SetFocusRegionPattern( XACameraItf self,
XAuint32 focusPattern,
XAuint32 activePoints1,
XAuint32 activePoints2 )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_SetFocusRegionPattern");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
if( !impl || focusPattern < XA_FOCUSPOINTS_ONE || focusPattern > XA_FOCUSPOINTS_CUSTOM )
{
/* invalid parameter */
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_SetFocusRegionPattern");
return XA_RESULT_PARAMETER_INVALID;
}
/* check is focus pattern changed */
if( focusPattern == impl->focusPattern )
{
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_SetFocusRegionPattern( (XAAdaptationGstCtx*)impl->adapCtx, focusPattern, activePoints1, activePoints2 );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
if (ret == XA_RESULT_SUCCESS)
{
impl->focusPattern = focusPattern;
if( !(impl->focusMode & XA_CAMERA_FOCUSMODE_MANUAL) )
{
impl->activePoints1 = activePoints1;
impl->activePoints2 = activePoints2;
}
}
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_API("<-XACameraItfImpl_SetFocusRegionPattern");
return ret;
}
/**
* XAresult XACameraItfImpl_GetFocusRegionPattern( XACameraItf self,
* XAuint32 *pFocusPattern,
* XAuint32 *pActivePoints1,
* XAuint32 *pActivePoints2 )
* Description: Gets the camera focus region pattern.
**/
XAresult XACameraItfImpl_GetFocusRegionPattern( XACameraItf self,
XAuint32 *pFocusPattern,
XAuint32 *pActivePoints1,
XAuint32 *pActivePoints2 )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_GetFocusRegionPattern");
if( !impl || !pFocusPattern || !pActivePoints1 || !pActivePoints2 )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetFocusRegionPattern");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pFocusPattern = impl->focusPattern;
if( !(impl->focusMode & XA_CAMERA_FOCUSMODE_MANUAL) &&
(impl->focusPattern == XA_FOCUSPOINTS_CUSTOM) )
{
*pActivePoints1 = impl->activePoints1;
*pActivePoints2 = impl->activePoints2;
}
DEBUG_API("<-XACameraItfImpl_GetFocusRegionPattern");
return ret;
}
/**
* XAresult XACameraItfImpl_GetFocusRegionPositions( XACameraItf self,
* XAuint32 *pNumPositionEntries,
* XAFocusPointPosition *pFocusPosition )
* Description: Get the camera focus region pattern's positioning and size for each
* point in the active focus pattern.
**/
XAresult XACameraItfImpl_GetFocusRegionPositions( XACameraItf self,
XAuint32 *pNumPositionEntries,
XAFocusPointPosition *pFocusPosition )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_GetFocusRegionPositions");
if( !impl || !pNumPositionEntries || !pFocusPosition )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetFocusRegionPositions");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_GetFocusRegionPositions( (XAAdaptationGstCtx*)impl->adapCtx, pNumPositionEntries,
pFocusPosition );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
DEBUG_API("<-XACameraItfImpl_GetFocusRegionPositions");
return ret;
}
/**
* XAresult XACameraItfImpl_GetFocusModeStatus( XACameraItf self,
* XAuint32 *pFocusStatus,
* XAuint32 *pRegionStatus1,
* XAuint32 *pRegionStatus2 )
* Description: Gets the camera focus status.
**/
XAresult XACameraItfImpl_GetFocusModeStatus( XACameraItf self,
XAuint32 *pFocusStatus,
XAuint32 *pRegionStatus1,
XAuint32 *pRegionStatus2 )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_GetFocusModeStatus");
if( !impl || !*pFocusStatus )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetFocusModeStatus");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pFocusStatus = impl->focusStatus;
DEBUG_API("<-XACameraItfImpl_GetFocusModeStatus");
return ret;
}
/**
* XAresult XACameraItfImpl_SetMeteringMode( XACameraItf self, XAuint32 meteringMode )
* Description: Sets the camera metering mode for exposure.
**/
XAresult XACameraItfImpl_SetMeteringMode( XACameraItf self, XAuint32 meteringMode )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_SetMeteringMode");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
if( !impl || meteringMode < XA_CAMERA_METERINGMODE_AVERAGE || meteringMode >XA_CAMERA_METERINGMODE_MATRIX )
{
/* invalid parameter */
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_SetMeteringMode");
return XA_RESULT_PARAMETER_INVALID;
}
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_SetMeteringMode( (XAAdaptationGstCtx*)impl->adapCtx, meteringMode );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
if ( ret == XA_RESULT_SUCCESS )
{
impl->meteringMode = meteringMode;
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_API("<-XACameraItfImpl_SetMeteringMode");
return ret;
}
/**
* XAresult XACameraItfImpl_GetMeteringMode( XACameraItf self, XAuint32 *pMeteringMode )
* Description: Gets the camera metering mode for exposure.
**/
XAresult XACameraItfImpl_GetMeteringMode( XACameraItf self, XAuint32 *pMeteringMode )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = GetImpl(self);
DEBUG_API("->XACameraItfImpl_GetMeteringMode");
if( !impl || !pMeteringMode )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetMeteringMode");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pMeteringMode = impl->meteringMode;
DEBUG_API("<-XACameraItfImpl_GetMeteringMode");
return ret;
}
/**
* XAresult XACameraItfImpl_SetExposureMode( XACameraItf self, XAuint32 exposure,
* XAuint32 compensation )
* Description: Sets the camera exposure mode.
**/
XAresult XACameraItfImpl_SetExposureMode( XACameraItf self, XAuint32 exposure,
XAuint32 compensation )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_SetExposureMode");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
impl = GetImpl(self);
if( !impl || exposure < XA_CAMERA_EXPOSUREMODE_MANUAL || exposure > XA_CAMERA_EXPOSUREMODE_NIGHTPORTRAIT )
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_SetExposureMode");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
/* check is focus mode changed */
if( impl->exposureMode != exposure || impl->compensation != compensation )
{
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_SetExposureMode( (XAAdaptationGstCtx*)impl->adapCtx, exposure, exposure );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
if ( ret == XA_RESULT_SUCCESS )
{
impl->exposureMode = exposure;
impl->compensation = compensation;
}
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_API("<-XACameraItfImpl_SetExposureMode");
return ret;
}
/**
* XAresult XACameraItfImpl_GetExposureMode( XACameraItf self, XAuint32 *pExposure,
* XAuint32 *pCompensation )
* Description: Gets the camera exposure mode.
**/
XAresult XACameraItfImpl_GetExposureMode( XACameraItf self, XAuint32 *pExposure,
XAuint32 *pCompensation )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_GetExposureMode");
impl = GetImpl(self);
if( !impl || !pExposure || !pCompensation )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetExposureMode");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pExposure = impl->exposureMode;
*pCompensation = impl->compensation;
DEBUG_API("<-XACameraItfImpl_GetExposureMode");
return ret;
}
/**
* XAresult XACameraItfImpl_SetISOSensitivity( XACameraItf self, XAuint32 isoSensitivity,
* XAuint32 manualSetting )
* Description: Sets the camera ISO sensitivity.
**/
XAresult XACameraItfImpl_SetISOSensitivity( XACameraItf self, XAuint32 isoSensitivity,
XAuint32 manualSetting )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_SetISOSensitivity");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
impl = GetImpl(self);
if( !impl || isoSensitivity<XA_CAMERA_ISOSENSITIVITYMODE_MANUAL || isoSensitivity>XA_CAMERA_ISOSENSITIVITYMODE_AUTO )
{
/* invalid parameter */
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_SetISOSensitivity");
return XA_RESULT_PARAMETER_INVALID;
}
/* check is focus mode changed */
if( impl->isoSensitivity != isoSensitivity || impl->isoManualSetting != manualSetting )
{
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_SetISOSensitivity((XAAdaptationGstCtx*)impl->adapCtx, isoSensitivity, manualSetting );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
if ( ret == XA_RESULT_SUCCESS )
{
impl->isoSensitivity = isoSensitivity;
impl->isoManualSetting = manualSetting;
}
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_API("<-XACameraItfImpl_SetISOSensitivity");
return ret;
}
/**
* XAresult XACameraItfImpl_GetISOSensitivity( XACameraItf self, XAuint32 *pIsoSensitivity,
* XAuint32 *pManualSetting )
* Description: Gets the camera ISO sensitivity.
**/
XAresult XACameraItfImpl_GetISOSensitivity( XACameraItf self, XAuint32 *pIsoSensitivity,
XAuint32 *pManualSetting )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_GetISOSensitivity");
impl = GetImpl(self);
if( !impl || !pIsoSensitivity || !pManualSetting )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetISOSensitivity");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pIsoSensitivity = impl->isoSensitivity;
if( impl->isoSensitivity == XA_CAMERA_ISOSENSITIVITYMODE_MANUAL )
{
*pManualSetting = impl->isoManualSetting;
}
if( impl->isoSensitivity == XA_CAMERA_ISOSENSITIVITYMODE_AUTO )
{
*pManualSetting = 0;
}
DEBUG_API("<-XACameraItfImpl_GetISOSensitivity");
return ret;
}
/**
* XAresult XACameraItfImpl_SetAperture( XACameraItf self, XAuint32 aperture,
* XAuint32 manualSetting )
* Description: Sets the camera aperture.
**/
XAresult XACameraItfImpl_SetAperture( XACameraItf self, XAuint32 aperture,
XAuint32 manualSetting )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_SetAperture");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
impl = GetImpl(self);
if( !impl || aperture<XA_CAMERA_APERTUREMODE_MANUAL || aperture>XA_CAMERA_APERTUREMODE_AUTO )
{
/* invalid parameter */
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_SetAperture");
return XA_RESULT_PARAMETER_INVALID;
}
/* check is aperture mode or value changed */
if( impl->aperture != aperture || impl->apertureManualSetting != manualSetting )
{
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_SetAperture( (XAAdaptationGstCtx*)impl->adapCtx, aperture, manualSetting );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
if ( ret == XA_RESULT_SUCCESS )
{
impl->aperture = aperture;
impl->apertureManualSetting = manualSetting;
}
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_API("<-XACameraItfImpl_SetAperture");
return ret;
}
/**
* XAresult XACameraItfImpl_GetAperture( XACameraItf self, XAuint32 *pAperture,
* XAuint32 *pManualSetting )
* Description: Gets the camera aperture.
**/
XAresult XACameraItfImpl_GetAperture( XACameraItf self, XAuint32 *pAperture,
XAuint32 *pManualSetting )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_GetAperture");
impl = GetImpl(self);
if( !impl || !pAperture || !pManualSetting )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetAperture");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pAperture = impl->aperture;
if( impl->aperture == XA_CAMERA_APERTUREMODE_MANUAL )
{
*pManualSetting = impl->apertureManualSetting;
}
if( impl->aperture == XA_CAMERA_APERTUREMODE_AUTO )
{
*pManualSetting = 0;
}
DEBUG_API("<-XACameraItfImpl_GetAperture");
return ret;
}
/**
* XAresult XACameraItfImpl_SetShutterSpeed( XACameraItf self, XAuint32 shutterSpeed,
* XAmicrosecond manualSetting )
* Description: Sets the camera shutter speed.
**/
XAresult XACameraItfImpl_SetShutterSpeed( XACameraItf self, XAuint32 shutterSpeed,
XAmicrosecond manualSetting )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_SetShutterSpeed");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
impl = GetImpl(self);
if( !impl || shutterSpeed < XA_CAMERA_SHUTTERSPEEDMODE_MANUAL || shutterSpeed > XA_CAMERA_SHUTTERSPEEDMODE_AUTO )
{
/* invalid parameter */
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_SetShutterSpeed");
return XA_RESULT_PARAMETER_INVALID;
}
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_SetShutterSpeed( (XAAdaptationGstCtx*)impl->adapCtx, shutterSpeed, manualSetting );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
if ( ret == XA_RESULT_SUCCESS )
{
impl->shutterManualSetting = manualSetting;
impl->shutterSpeed = shutterSpeed;
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_API("<-XACameraItfImpl_SetShutterSpeed");
return ret;
}
/**
* XAresult XACameraItfImpl_GetShutterSpeed( XACameraItf self, XAuint32 *pShutterSpeed,
* XAmicrosecond *pManualSetting )
* Description: Gets the camera shutter speed.
**/
XAresult XACameraItfImpl_GetShutterSpeed( XACameraItf self, XAuint32 *pShutterSpeed,
XAmicrosecond *pManualSetting )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_GetShutterSpeed");
impl = GetImpl(self);
if( !impl || !pShutterSpeed || !pManualSetting )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetShutterSpeed");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pShutterSpeed = impl->shutterSpeed;
if( impl->shutterSpeed == XA_CAMERA_SHUTTERSPEEDMODE_MANUAL )
{
*pManualSetting = impl->shutterManualSetting;
}
if( impl->shutterSpeed == XA_CAMERA_SHUTTERSPEEDMODE_AUTO )
{
*pManualSetting = 0;
}
DEBUG_API("<-XACameraItfImpl_GetShutterSpeed");
return ret;
}
/**
* XAresult XACameraItfImpl_SetWhiteBalance( XACameraItf self, XAuint32 whiteBalance,
* XAuint32 manualSetting )
* Description: Sets the camera white balance.
**/
XAresult XACameraItfImpl_SetWhiteBalance( XACameraItf self, XAuint32 whiteBalance,
XAuint32 manualSetting )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_SetWhiteBalance");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
impl = GetImpl(self);
if( !impl )
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_SetWhiteBalance");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
/* check is whitebalance mode or value changed */
if( impl->whiteBalance != whiteBalance || impl->whiteBalManualSetting != manualSetting )
{
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_SetWhiteBalance( (XAAdaptationGstCtx*)impl->adapCtx, whiteBalance, manualSetting );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
if ( ret == XA_RESULT_SUCCESS )
{
impl->whiteBalance = whiteBalance;
impl->whiteBalManualSetting = manualSetting;
}
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_API("<-XACameraItfImpl_SetWhiteBalance");
return ret;
}
/**
* XAresult XACameraItfImpl_GetWhiteBalance( XACameraItf self, XAuint32 *pWhiteBalance,
* XAuint32 *pManualSetting )
* Description: Gets the camera white balance.
**/
XAresult XACameraItfImpl_GetWhiteBalance( XACameraItf self, XAuint32 *pWhiteBalance,
XAuint32 *pManualSetting )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_GetWhiteBalance");
impl = GetImpl(self);
if( !impl || !pWhiteBalance || !pManualSetting )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetWhiteBalance");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pWhiteBalance = impl->whiteBalance;
if( impl->whiteBalance == XA_CAMERA_WHITEBALANCEMODE_MANUAL )
{
*pManualSetting = impl->whiteBalManualSetting;
}
DEBUG_API("<-XACameraItfImpl_GetWhiteBalance");
return ret;
}
/**
* XAresult XACameraItfImpl_SetAutoLocks( XACameraItf self, XAuint32 locks )
* Description: Locks the given automatic camera settings. This method is typically
* called when the camera trigger is half-pressed.
**/
XAresult XACameraItfImpl_SetAutoLocks( XACameraItf self, XAuint32 locks )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
DEBUG_API("->XACameraItfImpl_SetAutoLocks");
impl = GetImpl(self);
if( !impl || locks < XA_CAMERA_LOCK_AUTOFOCUS ||
(locks > ( XA_CAMERA_LOCK_AUTOFOCUS & XA_CAMERA_LOCK_AUTOEXPOSURE & XA_CAMERA_LOCK_AUTOWHITEBALANCE )))
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_SetAutoLocks");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_SetAutoLocks( (XAAdaptationGstCtx*)impl->adapCtx, locks );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
if ( ret == XA_RESULT_SUCCESS )
{
impl->locks = locks;
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_API("<-XACameraItfImpl_SetAutoLocks");
return ret;
}
/**
* XAresult XACameraItfImpl_GetAutoLocks( XACameraItf self, XAuint32 *locks )
* Description: Gets the current state of the automatic camera settings locks.
**/
XAresult XACameraItfImpl_GetAutoLocks( XACameraItf self, XAuint32 *locks )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_GetAutoLocks");
impl = GetImpl(self);
if( !impl || !locks )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetAutoLocks");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*locks = impl->locks;
DEBUG_API("<-XACameraItfImpl_GetAutoLocks");
return ret;
}
/**
* XAresult XACameraItfImpl_SetZoom( XACameraItf self, XAuint32 zoom,
* XAboolean digitalEnabled, XAuint32 speed,
* XAboolean async )
* Description: Sets the new zoom factor.
**/
XAresult XACameraItfImpl_SetZoom( XACameraItf self, XApermille zoom,
XAboolean digitalEnabled, XAuint32 speed,
XAboolean async )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_SetZoom");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);
impl = GetImpl(self);
if( !impl || !( speed == XA_CAMERA_ZOOM_FASTEST || speed == XA_CAMERA_ZOOM_FAST
|| speed == XA_CAMERA_ZOOM_NORMAL || speed == XA_CAMERA_ZOOM_SLOW ) )
{
/* invalid parameter */
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_SetZoom");
return XA_RESULT_PARAMETER_INVALID;
}
if(impl->adapCtx->fwtype == FWMgrFWGST)
{
ret = XACameraItfAdapt_SetZoom( (XAAdaptationGstCtx*)impl->adapCtx, zoom, digitalEnabled, speed, async );
}
else
{
DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
}
if ( ret == XA_RESULT_SUCCESS )
{
impl->zoom = zoom;
impl->digitalEnabled = digitalEnabled;
impl->speed = speed;
impl->async = async;
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);
DEBUG_API("<-XACameraItfImpl_SetZoom");
return ret;
}
/**
* XAresult XACameraItfImpl_GetZoom( XACameraItf self, XAuint32 *pZoom,
* XAboolean *pDigital )
* Description: Gets the current zoom factor.
**/
XAresult XACameraItfImpl_GetZoom( XACameraItf self, XApermille *pZoom,
XAboolean *pDigital )
{
XAresult ret = XA_RESULT_SUCCESS;
XACameraItfImpl* impl = NULL;
DEBUG_API("->XACameraItfImpl_GetZoom");
impl = GetImpl(self);
if( !impl || !pZoom || !pDigital )
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XACameraItfImpl_GetZoom");
/* invalid parameter */
return XA_RESULT_PARAMETER_INVALID;
}
*pZoom = impl->zoom;
*pDigital = impl->digitalEnabled;
DEBUG_API("<-XACameraItfImpl_GetZoom");
return ret;
}
/*****************************************************************************
* XACameraItfImpl -specific methods
*****************************************************************************/
/* XACameraItfImpl* XACameraItfImpl_Create()
* Description: Allocate and initialize CameraItfImpl
*/
XACameraItfImpl* XACameraItfImpl_Create( XAAdaptationBaseCtx *adapCtx )
{
XACameraItfImpl* self = (XACameraItfImpl*)
calloc(1,sizeof(XACameraItfImpl));
DEBUG_API("->XACameraItfImpl_Create");
if( self )
{
/* init itf default implementation */
self->itf.RegisterCallback = XACameraItfImpl_RegisterCallback;
self->itf.SetFlashMode = XACameraItfImpl_SetFlashMode;
self->itf.GetFlashMode = XACameraItfImpl_GetFlashMode;
self->itf.IsFlashReady = XACameraItfImpl_IsFlashReady;
self->itf.SetFocusMode = XACameraItfImpl_SetFocusMode;
self->itf.GetFocusMode = XACameraItfImpl_GetFocusMode;
self->itf.SetFocusRegionPattern = XACameraItfImpl_SetFocusRegionPattern;
self->itf.GetFocusRegionPattern = XACameraItfImpl_GetFocusRegionPattern;
self->itf.GetFocusRegionPositions = XACameraItfImpl_GetFocusRegionPositions;
self->itf.GetFocusModeStatus = XACameraItfImpl_GetFocusModeStatus;
self->itf.SetMeteringMode = XACameraItfImpl_SetMeteringMode;
self->itf.GetMeteringMode = XACameraItfImpl_GetMeteringMode;
self->itf.SetExposureMode = XACameraItfImpl_SetExposureMode;
self->itf.GetExposureMode = XACameraItfImpl_GetExposureMode;
self->itf.SetISOSensitivity = XACameraItfImpl_SetISOSensitivity;
self->itf.GetISOSensitivity = XACameraItfImpl_GetISOSensitivity;
self->itf.SetAperture = XACameraItfImpl_SetAperture;
self->itf.GetAperture = XACameraItfImpl_GetAperture;
self->itf.SetShutterSpeed = XACameraItfImpl_SetShutterSpeed;
self->itf.GetShutterSpeed = XACameraItfImpl_GetShutterSpeed;
self->itf.SetWhiteBalance = XACameraItfImpl_SetWhiteBalance;
self->itf.GetWhiteBalance = XACameraItfImpl_GetWhiteBalance;
self->itf.SetAutoLocks = XACameraItfImpl_SetAutoLocks;
self->itf.GetAutoLocks = XACameraItfImpl_GetAutoLocks;
self->itf.SetZoom = XACameraItfImpl_SetZoom;
self->itf.GetZoom = XACameraItfImpl_GetZoom;
/* init variables */
self->flashReady = XA_BOOLEAN_TRUE;
self->adapCtx = adapCtx;
self->cbPtrToSelf = NULL;
XAAdaptationBase_AddEventHandler( adapCtx, &XACameraItfImp_AdaptCb, XA_CAMERAITFEVENTS, self );
self->self = self;
}
DEBUG_API("<-XACameraItfImpl_Create");
return self;
}
/* void XACameraItfImpl_Free(XACameraItfImpl* self)
* Description: Free all resources reserved at XACameraItfImpl_Create
*/
void XACameraItfImpl_Free(XACameraItfImpl* self)
{
DEBUG_API("->XACameraItfImpl_Free");
assert( self==self->self );
XAAdaptationBase_RemoveEventHandler( self->adapCtx, &XACameraItfImp_AdaptCb );
free( self );
DEBUG_API("<-XACameraItfImpl_Free");
}
/* void XACameraItfAdapt_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )
* @param void *pHandlerCtx - pointer to cb context (XACameraItfImpl)
* @param XAAdaptEvent *event - Event
* Description: Event handler for adaptation events
*/
void XACameraItfImp_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )
{
XACameraItfImpl* impl =(XACameraItfImpl*)pHandlerCtx;
XAuint32 eventData=0;
DEBUG_API("->XACameraItfImp_AdaptCb");
if(!impl)
{
DEBUG_ERR("XACameraItfAdapt_AdaptCb, invalid context pointer!");
DEBUG_API("<-XACameraItfImp_AdaptCb");
return;
}
assert(event);
if( event->data )
{
eventData = *(XAuint32*)event->data;
}
switch( event->eventid )
{
case XA_CAMERACBEVENT_FOCUSSTATUS:
impl->focusStatus = eventData;
break;
case XA_CAMERACBEVENT_ZOOMSTATUS:
impl->zoom = eventData;
break;
case XA_CAMERACBEVENT_EXPOSURESTATUS:
impl->focusStatus = eventData;
break;
case XA_CAMERACBEVENT_FLASHREADY:
impl->flashReady = XA_BOOLEAN_TRUE;
break;
case XA_CAMERACBEVENT_WHITEBALANCELOCKED:
case XA_CAMERACBEVENT_ROTATION:
default:
break;
}
if( impl->callback )
{
impl->callback( impl->cbPtrToSelf, impl->context, event->eventid, eventData );
}
DEBUG_API("<-XACameraItfImp_AdaptCb");
}