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

@return The size of this class.

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

*/

EXPORT_C TUint CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::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::TImageBufferInfo::Version() const

	{

	return iVersion;

	}

/** 

Indicates whether the streamed image scheme or sub-frame scheme is being used.

@return Whether the sub-frame scheme is being used or not.

@see CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::iIsSubFrameUsed

*/

EXPORT_C TBool CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::IsSubFrameUsed() const

	{

	if (iIsSubFrameUsed)

		{

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

/** 

Sets the state to inform whether the streamed image scheme or sub-frame scheme is being used.

@param  aIsSubFrameUsed

		ETrue implies sub-frame scheme is being used.

		EFalse implies sub-frame scheme is not being used. 

@note   The set method will be used by the ECAM implementation in order to provide necessary information to the

		clients when they receive the image buffers.

@see CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::iIsSubFrameUsed

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::SetSubFrameState(TBool aIsSubFrameUsed)

	{

	iIsSubFrameUsed = static_cast<TUint>(aIsSubFrameUsed);

	}

/**

Indicates whether the parallel buffering is being used by the implementation in order to speed up the streamed 

image operation, as a whole.

@return Whether the parallel buffer option is being used by the implementation under the sub-frame scheme.

@note   Parallel buffering indicates that implementation is using more than one buffer to handle the various 

		sub-frames; hence speeding up the operation.

@see CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::iIsParallelBufferUsed

*/

EXPORT_C TBool CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::IsParallelStreamedBufferUsed() const

	{

	if (iIsParallelBufferUsed)

		{

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

/** 

Sets the state to inform whether the parallel buffering is being used by the implementation in order to speed up 

the streamed image operation, as a whole.

@param  aParallelStreamedBufferUsed

		ETrue implies sub-frame scheme is being used.

		EFalse implies sub-frame scheme is not being used. 

@note   The set method will be used by the ECAM implementation in order to provide necessary information to the

		clients when they receive the image buffers.

@see CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::iIsParallelBufferUsed

*/

EXPORT_C void CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::SetParallelStreamedBufferState(TBool aParallelStreamedBufferUsed)

	{

	iIsParallelBufferUsed = static_cast<TUint>(aParallelStreamedBufferUsed);

	}

/**

Sequence number of the sub-frame.

@return Sequence number of the sub-frame.

@see CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::iSubFrameSequenceNumber

*/

EXPORT_C TUint CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::SubFrameSequenceNumber() const

	{

	return iSubFrameSequenceNumber;

	}

/**

Sets the sequence number of the sub-frame.

@param aSubFrameSequenceNumber

	   The sequence number of the sub-frame. 

@return  The error code

@note 	9 bits used for sequence no. assuming that KECamMaxTotalSubFrames sub-frames would be used at max. Sequence number for sub-frames 

        lies between 0 to KECamMaxTotalSubFrames-1 inclusive.

@note   The set method will be used by the ECAM implementation in order to provide necessary information to the

		clients when they receive the image buffers.

@see CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::iSubFrameSequenceNumber

*/

EXPORT_C TInt CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::SetSubFrameSequenceNumber(TUint aSubFrameSequenceNumber)

	{

	if (aSubFrameSequenceNumber > (KECamMaxTotalSubFrames-1) )

		{

		return KErrOverflow;	

		}

	else 

		{

		iSubFrameSequenceNumber = aSubFrameSequenceNumber;

		return KErrNone;

		}

	}

/**

Total number of sub-frames needed in order to properly reconstruct the actual image.

@return Total number of sub-frames which can reconstruct the actual image.

@note 	It does not give the number of outstanding sub-frames needed to reconstruct the image. 

		This value will be same for every sub-frames needed to re-construct the actual image. 

		Maximum no. of total sub-frames is KECamMaxTotalSubFrames.

@see CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::iTotalSubFrames

*/

EXPORT_C TUint CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::TotalSubFrames() const

	{

	return iTotalSubFrames;

	}

/**

Sets the total number of sub-frames needed in order to properly reconstruct the actual image.

@param  aTotalSubFrames

		Total number of sub-frames which can reconstruct the actual image.

@return error code

@note 	It does not give the number of outstanding sub-frames needed to reconstruct the image. 

		This value will be same for every sub-frames needed to re-construct the actual image. 

		Maximum no. of total sub-frames is KECamMaxTotalSubFrames.

@note   The set method will be used by the ECAM implementation in order to provide necessary information to the

		clients when they receive the image buffers.

@see CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::iTotalSubFrames

*/

EXPORT_C TInt CCamera::CCameraPreImageCaptureControl::TImageBufferInfo::SetTotalSubFrames(TUint aTotalSubFrames)

	{

	if (aTotalSubFrames > KECamMaxTotalSubFrames)

		{

		return KErrOverflow;	

		}

	else 

		{

		iTotalSubFrames = aTotalSubFrames;

		return KErrNone;

		}

	}

/**

Retrieves the maximum number of spots present from where the camera hardware collects the focussing information.

@param  aFocusMode

		The focus mode for which the number of spots have to be retrieved.

@param  aMaximumSpots

		Retrieves the maximum number of spots for the given focus mode.

@leave  May leave with any error code.

@note   The maximum number of spots is supposed to be less than or equal to KMaxNumberOfFocusSpots.

@see    CCameraViewFinder::GetSpotsPositionL

*/

void CCamera::CCameraPreImageCaptureControl::GetMaximumSpotsL(CCamera::CCameraAdvancedSettings::TFocusMode /*aFocusMode*/, TInt& /*aMaximumSpots*/) const

	{

	User::Leave(KErrNotSupported);

	}

/**

Retrieves the supported spot combinations for the given focus mode.

@param  aFocusMode

		The focus mode for which the supported spot combinations have to be retrieved.

@param  aPossibleSpotCombinations

		Each member of this array is of type TUint and is a bit field where every bit represents presence or absence of

		a particular spot.

@leave  May leave with any error code.

@note   Since maximum number of spots can go up to KMaxNumberOfFocusSpots, it can be easily known which spots are present

		in a particular array entry (every array entry is a bit field and every bit represents presence or absence of a 

		particular spot). For example,if KMaxNumberOfFocusSpots is 32 and if a particular array entry is 0x07001000. This 

		means that spot number 13,25,26 and 27 are being represented. 

@see    CCameraViewFinder::GetSpotsPositionL

*/

void CCamera::CCameraPreImageCaptureControl::GetSupportedSpotsCombinationL(CCamera::CCameraAdvancedSettings::TFocusMode /*aFocusMode*/, RArray<TUint>& /*aPossibleSpotCombinations*/) const

	{

	User::Leave(KErrNotSupported);	

	}

/**

Retrieves the focussing spot combination which is used to provide focussing feedback in a particular focussing mode.

@param  aFocusMode

		The focussing mode in which the spot combination has to be used for retrieving feedback.

@param  aSpotsCombination

		The retrieved spot combination. It is a bitfield marking the presence or absence of spots.

		This is dependent on the focusssing mode.

@leave  May leave with any error code. 

@see    CCameraViewFinder::GetSpotsPositionL

*/

void CCamera::CCameraPreImageCaptureControl::GetSpotsCombinationL(CCamera::CCameraAdvancedSettings::TFocusMode /*aFocusMode*/, TUint& /*aSpotsCombination*/) const

	{

	User::Leave(KErrNotSupported);

	}

/**

Sets a particular spot combination which can be used to provide focussing feedback in a particular focussing mode.

@param  aFocusMode

		The focussing mode in which the spot combination has to be used for retrieving feedback.

@param  aSpotsCombination

		The spot combination to be set. It is a bitfield marking the presence or absence of spots.

@note   Event KUidECamEvent2ImageCaptureControlSpotCombination is used to notify the requesting client about setting of a particular

		spot combination.

@note   Event KUidECamEvent2ImageCaptureControlFocussingInformation is used to provide the focussing feedback, whenever applicable.

@see    CCameraViewFinder::GetSpotsPositionL

*/

void CCamera::CCameraPreImageCaptureControl::SetSpotsCombination(CCamera::CCameraAdvancedSettings::TFocusMode /*aFocusMode*/, TUint /*aSpotsCombination*/)

	{

	return;	

	}

/**

Retrieves whether the streamed image is supported or not. Sub-frames are used if streamed image output is used.

@param  aIsStreamedImageSupported

		ETrue indicates that streamed image is supported.

		EFalse indicates that streamed image is not supported.

@leave  May leave with any error code.	

*/

void CCamera::CCameraPreImageCaptureControl::GetStreamedImageSupportInfoL(TBool& /*aIsStreamedImageSupported*/) const

	{

	User::Leave(KErrNotSupported);	

	}

/**

Enables the streamed image output and hence the use of sub-frames to collect image data. MCameraImageBuffer will be 

used in place of MCameraBuffer in order to provide sub-frames details. Every MCaptureImageObserver::ImageBufferReady() 

will retrieve only one sub-frame. Full image will be reconstructed after receiving all the sub-frames.

@leave  May leave with any error code.

@note   The corresponding image capture call is considered to be complete only when every sub-frame has been received.

*/

void CCamera::CCameraPreImageCaptureControl::EnableSubFramesL()

	{

	User::Leave(KErrNotSupported);	

	}

/**

Disable the streamed image output and hence the use of sub-frames to collect image data. Every 

MCaptureImageObserver::ImageBufferReady() will retrieve one full still image.

@leave  May leave with any error code.

*/

void CCamera::CCameraPreImageCaptureControl::DisableSubFramesL()

	{

	User::Leave(KErrNotSupported);

	}

/**

Retrieves the current state about streamed image option or sub-frame usage.

@param  iIsSubFrameEnabled

		ETrue indicates that streamed image option is currently being used. 

		EFalse indicates that streamed image option is currently not being used.

@leave  May leave with any error code.

*/	

void CCamera::CCameraPreImageCaptureControl::GetSubFramesStateL(TBool& /*aIsSubFrameEnabled*/) const

	{

	User::Leave(KErrNotSupported);

	}

/**

Retrieves the list of transformations (image processing) available in case streamed image is used.

@param  aStreamedImageSupportedTransformations

		Retrieves an array of uids which represents those image processing attributes which are supported for streamed 

		image.

@leave  May leave with any error code.

*/

void CCamera::CCameraPreImageCaptureControl::GetStreamedImageSupportedTransformationsL(RArray<TUid>& /*aStreamedImageSupportedTransformations*/) const

	{

	User::Leave(KErrNotSupported);	

	}

/**

Retrieves the panorama mode support.

@param  aIsPanoModeSupported

		Informs whether the pano mode is supported or not.

@param  aSupportedStitchingOption

		Retrieves the supported image stitching option available with the ECAM implementation for the images captured

		under panorama mode. It is a TInt represepesting bitfield for supported TStitchingOption 

		If pano mode is not supported, this has to be 0.

@leave  May leave with any error code.			

*/

void CCamera::CCameraPreImageCaptureControl::GetPanoModeSupportInfoL(TBool& /*aIsPanoModeSupported*/, TInt& /*aSupportedStitchingOption*/) const

	{

	User::Leave(KErrNotSupported);	

	}

/**

Starts panning the viewfinder. Any image captured under pano mode gets overlaid on top of viewfinder and in a 

particular direction.

This method starts panorama mode for every viewfinder screen.

@param  aStitchingOption

		Enum value EStitchingOptionEnable instructs implementation to perform stitching of images captured under pano mode.

		So only one completion feedback will be given to the client regarding image being ready.(either through  

		MCaptureImageObserver::ImageBufferReady() or through MCaptureImageObserver::ImageDirectSavingCompleted())

		Enum value EStitchingOptionDisable instructs implemenation to provide the images unstitched.

		Enum value EStitchingOptionNone should be passed only when stitching option is not supported by the 

		implementation.

@note   Event KUidECamEventImageCaptureControlStartPanoMode is used to notify clients about the start of panorama mode.

@note   Calling the StartPanoMode twice and without stopping it will result in an error.

*/

void CCamera::CCameraPreImageCaptureControl::StartPanoMode(CCamera::CCameraPreImageCaptureControl::TStitchingOption /*aStitchingOption*/)

	{

	return;	

	}

/**

Starts panning the viewfinder. Any image captured under pano mode gets overlaid on top of viewfinder and in a 

particular direction.

This method starts panorama mode only on few specified viewfinder screens.

@param  aStitchingOption

		Enum value EStitchingOptionEnable instructs implementation to perform stitching of images captured under pano mode. So 

		only one completion feedback will be given to the client regarding image being ready.(either through  

		MCaptureImageObserver::ImageBufferReady() or through MCaptureImageObserver::ImageDirectSavingCompleted())

		Enum value EStitchingOptionDisable instructs implemenation to provide the images unstitched.

		Enum value EStitchingOptionNone should be passed only when stitching option is not supported by the 

		implementation.

@param  aVFHandles

		The array of viewfinder handles on which the panorama will run. Every member of this array is a valid viewfinder 

		handle.

@note   Event KUidECamEventImageCaptureControlStartPanoMode is used to notify clients about the start of panorama mode.		

@note   Calling the StartPanoMode twice and without stopping it will result in an error.		

*/

void CCamera::CCameraPreImageCaptureControl::StartPanoMode(CCamera::CCameraPreImageCaptureControl::TStitchingOption /*aStitchingOption*/, const RArray<TInt>& /*aVFHandles*/)

	{

	return;

	}

/**

Retrieves the direction of panning.

@param  aPanoDirection

		The currently used panning direction.

@leave  May leave with any error code.

@note   When the image is captured, the cropped version of the captured image covering a full rectangle is overlaid at 

		the left hand side of the display screen (if TPanoDirection is EPanoRight) and viewfinder runs below that. 	

@note   If the method leaves, the reference to CCamera::CCameraPreImageCaptureControl::TPanoDirection i.e. aPanoDirection is 

		not guaranteed to be valid.	

*/

void CCamera::CCameraPreImageCaptureControl::GetPanoDirectionL(CCamera::CCameraPreImageCaptureControl::TPanoDirection& /*aPanoDirection*/) const

	{

	User::Leave(KErrNotSupported);	

	}

/**

Sets the direction of panning

@param  aPanoDirection

		The desired panning direction. 

@note   Event KUidECamEventImageCaptureControlPanoDirection is used to notify the requesting client about setting of the 

		panning direction.

*/

void CCamera::CCameraPreImageCaptureControl::SetPanoDirection(CCamera::CCameraPreImageCaptureControl::TPanoDirection /*aPanoDirection*/)

	{

	return;	

	}

/**

Stop the panorama mode.

@param  aStitchedImageRetrieval

		Enum value EStitchedImageRetrieve indicates that images has to be stitched if initially image stitching was 

		enabled.

		Enum value EStitchedImageDiscard indicates that images should not be stitched (discarded) if initially image 

		stitching was enabled. No image ready notification returned to the client in this case. This may happen when 

		client is not happy with the panned images captured so far. 

@leave  May leave with any error code. 

@note   If image stitching option was not enabled while starting the pano mode, the 'aStitchedImageRetrieval' parameter is 

		ignored by the implementation.

*/

void CCamera::CCameraPreImageCaptureControl::StopPanoModeL(CCamera::CCameraPreImageCaptureControl::TStitchedImageRetrieval /*aStitchedImageRetrieval*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

Retrieves the supported color space.