// 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 the License "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:
// its implementation.
// 
//

/**
 @file Kernel side interfaces to example camera device driver which uses Shared Chunks in
 @publishedPartner
 @prototype 9.1
*/

#ifndef __CAMERA1_DEV_H__
#define __CAMERA1_DEV_H__

/**
  Logical Device (factory class) for 'Camera1'
*/
class DCamera1Factory : public DLogicalDevice
	{
public:
	DCamera1Factory();
	~DCamera1Factory();
	//	Inherited from DLogicalDevice
	virtual TInt Install();
	virtual void GetCaps(TDes8& aDes) const;
	virtual TInt Create(DLogicalChannelBase*& aChannel);
	};

/**
  Class representing a single image buffer
*/
class DImageBuffer
	{
public:
	DImageBuffer();
	~DImageBuffer();
	TInt Create(DChunk* aChunk, TInt aOffset, TInt aSize);
public:
	TInt iChunkOffset;			/**< Offset, in bytes, of buffer start within the chunk */
	TInt iSize;					/**< Size of buffer n bytes */
	TPhysAddr iPhysicalAddress;	/**< Physical address of buffer. KPhysAddrInvalid if buffer not physically contiguous */
	TPhysAddr* iPhysicalPages;	/**< List of physical addresses for buffer pages. 0 if buffer is physically contiguous */
	};

/**
  Class representing all of the image buffers
*/
class DCaptureBuffers : public DBase
	{
public:
	static DCaptureBuffers* New(TInt aNumBuffers,TInt aBufferSize);
	void Open();
	void Close();
	void Reset();
	void Purge(DImageBuffer* aBuffer);
	DImageBuffer* ImageForClient();
	DImageBuffer* ImageCaptured();
	DImageBuffer* ImageRelease(TInt aChunkOffset);
	DImageBuffer* InUseImage(TInt aChunkOffset);
private:
	DCaptureBuffers();
	~DCaptureBuffers();
	TInt Create(TInt aNumBuffers,TInt aBufferSize);
	static DImageBuffer* Remove(DImageBuffer** aList);
	static DImageBuffer* Add(DImageBuffer** aList,DImageBuffer* aBuffer);
public:
	DChunk* iChunk;				/**< The chunk which contains the buffers */
	TLinAddr iChunkBase;		/**< Linear address in kernel process for the start of the chunk  */
	TUint32 iChunkMapAttr;		/**< MMU mapping attributes for chunk */
	TInt iNumBuffers;			/**< Number of buffers */
	DImageBuffer* iImageBuffer;	/**< Array of iNumBuffers buffer objects */
	//
	DImageBuffer* iCurrentBuffer;		/**< The buffer currently being filled by image capture */
	DImageBuffer* iNextBuffer;			/**< The buffer to use for next image capture */
	DImageBuffer** iFreeBuffers;		/**< NULL terminated list of free buffers */
	DImageBuffer** iCompletedBuffers;	/**< NULL terminated list of buffers containing captured images */
	DImageBuffer** iInUseBuffers;		/**< NULL terminated list of buffers currently being used by client */
private:
	TInt iAccessCount;			/**< Access count for this object */
	TAny* iBufferLists;			/**< Memory holding lists iFreeBuffers, iCompletedBuffers and iInUseBuffers */
	};

/**
  Logical Channel class for 'Camera1'
*/
class DCamera1Channel : public DLogicalChannelBase
	{
public:
	DCamera1Channel();
	virtual ~DCamera1Channel();
	// Inherited from DLogicalChannelBase
	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);
private:
	// Implementation for the differnt kinds of messages sent through RBusLogicalChannel
	TInt DoControl(TInt aFunction, TAny* a1, TAny* a2);
	TInt DoRequest(TInt aNotReqNo, TAny* a1, TAny* a2);
	TInt DoCancel(TUint aMask);
	// Methods for configuration
	TInt GetConfig(TDes8* aConfigBuf);
	TInt SetConfig(const TDesC8* aConfigBuf);
	// Methods for capturing images
	TInt StartCapture();
	TInt EndCapture();
	void CaptureImage(TRequestStatus* aRequestStatus,TInt aReleaseImage);
	void CaptureImageCancel();
	TInt ImageRelease(TInt aChunkOffset);
	static void CaptureDfcTrampoline(TAny* aSelf);
	void CaptureDfc();
	void StateChange(TBool aNewState);
	static void StateChangeDfcTrampoline(TAny* aSelf);
	void StateChangeDfc();
	// Methods which program the camera hardware
	void DoStartCapture();
	void DoEndCapture();
	void DoNextCapture();
private:
	NFastMutex iCaptureMutex;	/**< Mutex to protect access to driver state */

	DCaptureBuffers* iCaptureBuffers;		/**< The image buffers */

	TRequestStatus* iCaptureRequestStatus;	/**< The request status for client CaptureImage request */
	DThread* iCaptureRequestThread;			/**< The client thread which issued a CaptureImage request */

	TDfcQue* iDfcQ;				/**< The DFC queue used for driver functions */
	TDfc iStateChangeDfc;		/**< DFC queued when Start/EndCapture requests are performed */
	TBool iNewState;			/**< True if state change DFC should start image capture, false to stop capture */
	DMutex* iStateChangeMutex;	/**< Mutex which protect Start/EndCapture requests from reenty */
	NFastSemaphore iStateChangeSemaphore;	/**< Semaphore signaled when state change DFC completes */

	RCamera1::TConfig iConfig;	/**< The driver configuration information */
	TBool iCapturing;			/**< Flag which is True when image capture is in progress */

	TInt iCaptureCounter;		/**< Frame counter incremented on each image captured */
	NTimer iCaptureTimer;		/**< Timer used to emulate image capture hardware */
	TInt iCaptureRateTicks;		/**< Number of timer ticks for iCaptureTimer */
	};

#endif