// Copyright (c) 2005-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 <ecam/ecamcapturecontrolintf.h>

#include <ecam/implementationfactoryintf.h>

#include <ecamimageprocessing.h>

#include <ecam/camerahistogram.h>

#include "ecamversion.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <ecamcapturecontrolconst.h>

#endif

const TInt KECamVideoCaptureBit0 = 0x00;

const TInt KECamClientVideoCaptureBit1 = 0x01;

const TInt KECamDirectVideoCaptureBit2 = 0x02;

/**

Factory function for creating the CCameraPreImageCaptureControl object.

@param aCamera 

	   a reference to a CCamera object providing the settings.

@param aPreImageCaptureControlObserver

	   Reference to the pre image capture control observer.

@return a pointer to a fully constructed CCameraPreImageCaptureControl object.

@leave KErrNoMemory Out of memory Or any other system-wide error code.

@leave KErrExtensionNotSupported When NewL/NewDuplicateL used instead of New2L/NewDuplicate2L.

*/

EXPORT_C CCamera::CCameraPreImageCaptureControl* CCamera::CCameraPreImageCaptureControl::NewL(CCamera& aCamera, MPreImageCaptureControlObserver& aPreImageCaptureControlObserver)

	{

 	if(aCamera.CameraVersion() == KCameraDefaultVersion)

 		{

 		User::Leave(KErrExtensionNotSupported);

 		}

	CCamera::CCameraPreImageCaptureControl* self = new (ELeave)CCamera::CCameraPreImageCaptureControl(aCamera); 

	CleanupStack::PushL(self);

	self->ConstructL(aPreImageCaptureControlObserver);

	CleanupStack::Pop(self);

	return self; 

	}

/**	

CCameraPreImageCaptureControl Constructor.

@param aOwner

       a reference to a CCamera object. 

*/

CCamera::CCameraPreImageCaptureControl::CCameraPreImageCaptureControl(CCamera& aOwner):iOwner(aOwner), iImpl(NULL)

	{

	}

/**

CCameraPreImageCaptureControl second phase constructor. 

Function used to initialise internal state of the object. Uses reference to the camera to retrieve 

PreImageCaptureControl interface pointer.

@param aPreImageCaptureControlObserver

	   Reference to the pre image capture control observer.

@leave KErrNoMemory Out of memory Or any other system-wide error code.

*/ 

void CCamera::CCameraPreImageCaptureControl::ConstructL(MPreImageCaptureControlObserver& aPreImageCaptureControlObserver) 

	{

	iImpl = static_cast<MCameraPreImageCaptureControl*>(iOwner.CustomInterface(KECamMCameraPreImageCaptureControlUid));

	if (iImpl == NULL)

		{

		User::Leave(KErrNotSupported);

		}

	iImpl->SetPreImageCaptureControlObserver(aPreImageCaptureControlObserver);

	}

/**

Destructor

*/	

EXPORT_C CCamera::CCameraPreImageCaptureControl::~CCameraPreImageCaptureControl()

	{

	if (iImpl != NULL)

		{

		iImpl->Release();	

		}

	}	

/**

Retrieves information regarding the direct snapshot feature support. Direct Snapshot, if supported, can be created

out of version2 direct viewfinder object only.

@param  aDirectSnapshotSupportInfo

		This is a bit field providing supported direct snapshot of type TDirectSnapshotType

@leave  May leave with any error code.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::GetDirectSnapshotSupportInfoL(TUint& aDirectSnapshotSupportInfo) const

	{

	iImpl->GetDirectSnapshotSupportInfoL(aDirectSnapshotSupportInfo);	

	}

/**

Retrieves the settings supported for embedded still captures. Possibilty exists that not all the settings supported for

normal still image captures are supported for embedded still captures as well.

@param  aSupportedEmbeddedStillCaptureSettings

		Array of TUid which retrieves the supported embedded still captures. Empty list indicated that no settings are

		supported for embedded still captures.

@leave  May leave with any error code.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::GetSupportedEmbeddedStillCaptureSettingsL(RArray<TUid>& aSupportedEmbeddedStillCaptureSettings) const

	{

	iImpl->GetSupportedEmbeddedStillCaptureSettingsL(aSupportedEmbeddedStillCaptureSettings);	

	}

/**

Retrieves information regarding the supported direct saving state. If used, still images are saved in files rather than 

providing clients the MCameraImageBuffer. Direct saving to file will continue even if the client application gets closed

for any reasons.

@param  aSupportedDirectSavingType

		Retrieves the enum specifying supported TDirectSavingType.

		If EDirectSavingNotUsed, direct saving not supported. Images will be received in buffer MCameraImageBuffer.

		If EDirectSavingHighResolutionFileOnly, direct saving to file is supported. But no cut down version of the image 

		will be saved to file. Callback used is MCaptureImageObserver::ImageDirectSavingCompleted().

		If EDirectSavingWithLowerResolutionFile, Direct saving to file is supported. Also, a cut down version of the image 

		will be saved to another specified file. Callbacks used are MCaptureImageObserver::ImageDirectSavingCompleted() for 

		actual image and MCaptureImageObserver::CutDownImageDirectSavingCompleted() for lower resolution image.

@leave  May leave with any error code.	

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::GetSupportedDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl

															::TDirectSavingType& aSupportedDirectSavingType) const

	{

	iImpl->GetSupportedDirectSavingTypeL(aSupportedDirectSavingType);	

	}

/**

Provides the base name for file used to save images. If there are sequential images, files will be created by 

implementation with names appearing as base name and appended by increasing integers which would start from 

aStartingSequenceNumber. This is used for the original image only, but not for the cut down version of the original

image.

@param  aFilename

		A const TDesC8&: Base name for files which ECam implementation needs to create in order to collect every sequential

		image.

@param  aStartingSequenceNumber

		The starting sequence number which will be appended to the base name 'aFilename'. The sequence number will keep

		on increasing for every individual still image capture.

@leave  May leave with any error code.

@note   It is upto the implementation how many digits it uses for sequence number. Accordingly, padding will be done with 

		zeroes.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::SetSequentialImageFilenameL(const TDesC8& aFilename, TInt aStartingSequenceNumber)

	{

	iImpl->SetSequentialImageFilenameL(aFilename, aStartingSequenceNumber);

	}

/**

Provides the base name for file used to save cut down version of the original images. If there are sequential images, 

files will be created by implementation with names appearing as base name and appended by increasing integers which would 

start from aStartingSequenceNumber. This is used for the cut down version of the original image.

@param  aLowerResolutionFilename

		A const TDesC8&: Base name for files which ECam implementation needs to create in order to collect the cut down version

		of every sequential image.

@param  aStartingSequenceNumber

		The starting sequence number which will be appended to the base name 'aFilename'. The sequence number will keep

		on increasing for every individual still image capture.

@leave  May leave with any error code.

@note   It is upto the implementation how many digits it uses for sequence number. Accordingly, padding will be done with 

		zeroes.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::SetLowerResolutionSequentialImageFilenameL(const TDesC8& aLowerResolutionFilename, 

																							TInt aStartingSequenceNumber)

	{

	iImpl->SetLowerResolutionSequentialImageFilenameL(aLowerResolutionFilename, aStartingSequenceNumber);

	}

/**

Retrieves the type of direct saving currently used. This will be represented as a direct saving state as given by 

TDirectSavingType. 

Whether or not the direct saving option is used, client will receive the MCaptureImageObserver::ImageCaptureComplete() 

callback to mark the completion of the image capture operation.

@param  aDirectSavingType

		Current type of the direct saving. 

		If EDirectSavingNotUsed, direct saving is not used. Images will be received in buffer MCameraImageBuffer through

		callback MCaptureImageObserver::ImageBufferReady().

		If EDirectSavingHighResolutionFileOnly, direct saving to file option is currently used. But no cut down version of

		the image will be saved to file. Callback used is MCaptureImageObserver::ImageDirectSavingCompleted().

		If EDirectSavingWithLowerResolutionFile, apart from direct saving to file option for the actual image, a cut down 

		version of the image will be saved to another specified file. Callbacks used are MCaptureImageObserver::

		ImageDirectSavingCompleted() for actual image and MCaptureImageObserver::CutDownImageDirectSavingCompleted() for 

		lower resolution image.

@leave  May leave with any error code.

@note   Direct saving to file will continue even if the client application gets closed for any reasons.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::GetDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl::

																			TDirectSavingType& aDirectSavingType) const

	{

	iImpl->GetDirectSavingTypeL(aDirectSavingType);	

	}			

/**

Instructs the ECam implementation to use the desired type of direct saving option as specifed by its state.

Whether or not the direct saving option is used, client will receive the MCaptureImageObserver::ImageCaptureComplete() 

callback to mark the completion of the image capture operation.

@param  aDirectSavingType

		The desired type of the direct saving. 

		If EDirectSavingNotUsed, direct saving will not be used. Images will be received in buffer MCameraImageBuffer 

		through	callback MCaptureImageObserver::ImageBufferReady().

		If EDirectSavingHighResolutionFileOnly, direct saving to file option will be used. But no cut down version of

		the image will be saved to file. Callback to be used is MCaptureImageObserver::ImageDirectSavingCompleted().

		If EDirectSavingWithLowerResolutionFile, apart from direct saving to file option for the actual image, a cut down 

		version of the image will be saved to another specified file. Callbacks to be used are MCaptureImageObserver::

		ImageDirectSavingCompleted() for actual image and MCaptureImageObserver::CutDownImageDirectSavingCompleted() for 

		lower resolution image.

@leave  May leave with any error code.

@note   Clients need to provide the filename before capturing still images under direct saving option. Callback 

		MCaptureImageObserver::ImageDirectSavingCompleted() may provide error KErrNotReady if filenames are not 

		provided before images are captured for direct saving. Similarly, if cut down version of image is also to be saved

		to file, MCaptureImageObserver::CutDownImageDirectSavingCompleted() may provide error KErrNotReady if filenames are 

		not provided before hand. 

@note   Direct saving to file will continue even if the client application gets closed for any reasons.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::SetDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl::

															TDirectSavingType aDirectSavingType)

	{

	iImpl->SetDirectSavingTypeL(aDirectSavingType);

	}

/**

Retrieves whether the camera device is capable of providing capture event notification to the client. Client may take

the responsibility of playing the capture sound after receiving the notification. 

@param  aSupportedDriveModes

		A reference to bit-field of TUint which indicates the drive modes in which the capture event notification is

		supported. If aSupportedDriveModes =0, capture event notification is not supported.

@note   If capture event notification is supported, ECam implementation will use KUidECamEventImageCaptureEvent to notify 

		clients that the image has been exposed to the camera sensor. Clients may play capture sound if they desire to do so.

@leave  May leave with any error code.	

@see    CCamera::CCameraAdvancedSettings::TDriveMode

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::GetCaptureEventSupportInfoL(TUint& aSupportedDriveModes) const

	{

	iImpl->GetCaptureEventSupportInfoL(aSupportedDriveModes);	

	}

/**

Retrieves the supported image formats for a given resolution.

@param  aImageFormatsSupported

		A bit field which retrieves the supported image formats for a given resolution.

		Formats have been defined as CCamera::TFormat

@param  aSize

		The resolution (or size) for which the total number of supported image formats have to be retrieved.

@leave  May leave with any error code.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::GetImageFormatsSupportedL(TUint& aImageFormatsSupported, const TSize& aSize) const

	{

	iImpl->GetImageFormatsSupportedL(aImageFormatsSupported, aSize);		

	}

/**

Retrieves the supported pixel aspect ratio for a given resolution in case of still image.

@param  aPixelAspectsSupported

		A bit field which retrieves the supported pixel aspect ratio for a given resolution.

		Pixel aspect ratio have been defined as CCamera::CCameraAdvancedSettings::TPixelAspectRatio

@param  aImageFormat

		The image format for which the supported pixel aspect ratio have to be retrieved.

@param  aSize

		The resolution (or size) for which the supported pixel aspect ratio have to be retrieved.

@leave  May leave with any error code.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::GetPixelAspectsSupportedL(TUint& aPixelAspectsSupported, CCamera::TFormat aImageFormat, const TSize& aSize) const

	{

	iImpl->GetPixelAspectsSupportedL(aPixelAspectsSupported, aImageFormat, aSize);		

	}

/**

Performs setup and allocation of memory for image capture operation. Implementation creates a new CCameraImageCapture*

object which reflects the prepare image parameters passed by the client. The callback MPreImageCaptureControlObserver::

PrepareImageComplete() passes the ownership of the CCameraImageCapture* object to the client.

This needs to be called every time client wishes to change prepare image parameters or if the client wishes to create

a new CCameraImageCapture* object. 

@param  aPrepareImageParameters 

        The desired image parameters to be used for capturing still images using the CCameraImageCapture instance

        which would be passed by the implementation.

@param  aCaptureImageObserver

		The Capture image observer which is needed by the implementation in order to pass it to the CCameraImageCapture 

		while creating it.

@note 	Next PrepareImageCapture can be called only after receiving the notification KUidECamEventReadyForNextPrepare.

@note	If drive mode is EDriveModeTimeNudgeCapture, when the client initiates image capture the total amount of images

		requested by the client	(specified in TDriveModeDependentAttributes) will be returned to the client

		(via MCaptureImageObserver::ImageBufferReady())	or saved to file. No other instance of CCameraImageCapture can be

		created whilst using this drive mode until the first instance is destroyed.

@see 	CCamera::PrepareImageCaptureL(TFormat aImageFormat,TInt aSizeIndex)

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::PrepareImageCapture(const CCamera::CCameraPreImageCaptureControl::

			TPrepareImageParameters& aPrepareImageParameters, MCaptureImageObserver& aCaptureImageObserver)

	{

	// MCameraPreImageCaptureControl concrete implementation will call CCameraImageCapture::CreateL(CCamera& aCamera, 

	// MCaptureImageObserver& aCaptureImageObserver) method and pass the CCameraImageCapture* to the client through 

	// the MPreImageCaptureControlObserver::PrepareImageComplete() callback.

	iImpl->PrepareImageCapture(aPrepareImageParameters, aCaptureImageObserver);	

	}

/**

Informs whether or not the setting of maximum memory size when encoding to the current format is supported.

@param  aIsImageMaxMemorySizeSettingSupported

		ETrue indicates that setting of maximum memory size is supported.

		EFalse indicates that setting of maximum memory size is not supported.

@leave  May leave with any error code.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::GetImageMaxMemorySizeSettingSupportInfoL(TBool& aIsImageMaxMemorySizeSettingSupported) const

	{

	iImpl->GetImageMaxMemorySizeSettingSupportInfoL(aIsImageMaxMemorySizeSettingSupported);	

	}

/**

Get the maximum memory size in kilo bytes when encoding to the current format.

@param  aMemorySize

		Retrieves the maximum memory size in kilo bytes.

@note   In case of JPEG, the maximum memory size will take preference over JPEG quality if the maximum memory size is 

		not sufficient to achieve the desired quality. Refer CCamera::JpegQuality()

@leave  May leave with any error code.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::GetImageMaxMemorySizeL(TUint& aMemorySize) const

	{

	iImpl->GetImageMaxMemorySizeL(aMemorySize);

	}

/**

Retrieves the supported processing options.

@param  aEcamProcessingOptionsSupported

		Bitfield containing the available processing options.

@leave May leave with any error code.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::GetSupportedProcessingOptionsL(TUint& aECamProcessingOptionsSupported) const

	{

	iImpl->GetSupportedProcessingOptionsL(aECamProcessingOptionsSupported);

	}

/**

Constructor for the TPrepareImageParameters class.

Sets the size and version of this class.

*/

EXPORT_C CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters::TPrepareImageParameters()

	{

	iSize = sizeof(CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters);

	iVersion = KECamPrepareImageParametersCurrentVersion;

	iImageMaxMemorySize = KECamNoSpecificMaxMemorySize;

	iImageProcessingOptions = 0;

	}

/**	

Returns the size of the class. Used for extensibility by deriving from this base class and adding new member variables.

Intended to be used for implementation of methods where this class reference is passed as function arguments. 

Implementation of such methods can find out the whether the actual class passed is base or the derived one. So, if a new application 

is made to run on an old implementation, an error may occur in such cases after the old implementation detects this by getting 

the size information of the T class passed. Also, if old application is made to run on a new implementation, this could be 

properly handled if the derived class variables handling is done in a proper 'if-else' statement.

@return The size of this class.

@note The size will be modified when the T-class gets updated.

*/

EXPORT_C TUint CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters::Size() const

	{

	return iSize;

	}

/**	

Returns the version of the class. Used for extensibility specially when the class members are not added but the Reserved 

members get used at a later stage.

@return The version of this class.

@note The version will be modified when the T-class gets updated.

*/

EXPORT_C TUint CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters::Version() const

	{

	return iVersion;

	}

/**

Sets the image processing options to be used during image capture.

@param  aImageProcessingOptions

	     Bitfield of image processing options to be used during image capture.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters::SetImageProcessingOptions(TUint aImageProcessingOptions)

	{

	iImageProcessingOptions = aImageProcessingOptions;

	}

/**

Gets the current image processing options to be used during image capture.

@param  aImageProcessingOptions

	     Bitfield of current image processing options to be used during image capture.

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters::GetImageProcessingOptions(TUint& aImageProcessingOptions) const

	{

	aImageProcessingOptions = iImageProcessingOptions;

	}

/**

Constructor for the TDriveModeDependentAttributes class.

Sets the size and version of this class.

*/

EXPORT_C CCamera::CCameraPreImageCaptureControl::TDriveModeDependentAttributes::TDriveModeDependentAttributes()

	{

	iSize = sizeof(CCamera::CCameraPreImageCaptureControl::TDriveModeDependentAttributes);

	iVersion = KECamDriveModeDependentAttributesCurrentVersion;

	iParam1 = -1;

	iParam2 = -1;

	}

/**	

Returns the size of the class. Used for extensibility by deriving from this base class and adding new member variables.

Intended to be used for implementation of methods where this class reference is passed as function arguments. 

Implementation of such methods can find out the whether the actual class passed is base or the derived one. So, if a new application 

is made to run on an old implementation, an error may occur in such cases after the old implementation detects this by getting 

the size information of the T class passed. Also, if old application is made to run on a new implementation, this could be 

properly handled if the derived class variables handling is done in a proper 'if-else' statement.

@return The size of this class.

@note The size will be modified when the T-class gets updated.

*/

EXPORT_C TUint CCamera::CCameraPreImageCaptureControl::TDriveModeDependentAttributes::Size() const

	{

	return iSize;

	}

/**	

Returns the version of the class. Used for extensibility specially when the class members are not added but the Reserved 

members get used at a later stage.

@return The version of this class.

@note The version will be modified when the T-class gets updated.

*/

EXPORT_C TUint CCamera::CCameraPreImageCaptureControl::TDriveModeDependentAttributes::Version() const

	{

	return iVersion;

	}

/**

Constructor for the TImageBufferInfo class.

Sets the size and version of this class.

*/

EXPORT_C CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::TImageBufferInfo()

	{

	iSize = sizeof(CCamera::CCameraPreImageCaptureControl::TImageBufferInfo);

	iVersion = KECamImageBufferInfoCurrentVersion;

	}

/**	

Returns the size of the class. Used for extensibility by deriving from this base class and adding new member variables.

Intended to be used for implementation of methods where this class reference is passed as function arguments. 

Implementation of such methods can find out the whether the actual class passed is base or the derived one. So, if a new application 

is made to run on an old implementation, an error may occur in such cases after the old implementation detects this by getting 

the size information of the T class passed. Also, if old application is made to run on a new implementation, this could be 

properly handled if the derived class variables handling is done in a proper 'if-else' statement.