// Copyright (c) 2006-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:

 // template\template_variant\camerasc\camerasc_sensor.cpp

 // Implementation of the template shared chunk camera physical device driver (PDD).

 // This file is part of the Template Base port

 // 

 //

 /**

  @file

 */

 #include "camerasc_plat.h"

 #include <kernel/cache.h>

 // XXX - Temporary structure containing a logo to be displayed.  Remove this when

 //       changing this template into a "real" camera driver

 #include "logoyuv2.cpp"

 #define RGBtoBGR565(red, green, blue) (((blue & 0xf8) << 8) | ((green & 0xfc) << 3) | ((red & 0xf8) >> 3));

 #define YUVtoYUV565(luma, blueC, redC) (((luma & 0xf8) << 8) | ((blueC & 0xfc) << 3) | ((redC & 0xf8) >> 3));

 // Frame sizes and their associated frame rates supported by the Template sensor.  This selection was

 // obtained by observation of typical formats supported by phones already on the market;  It is arbitrary

 // and can be easily added to if desired

 static const SDevCamFrameSize FrameSizes[] =

 	{

 		{ 320, 240, 1, 30 }	,		// QVGA - 0.075 MP

 		// XXX: Although not used in this template driver, the following are suggested standard frame sizes

 		// that should be implemented in your camera driver, as well as 320 x 240 above.  Remember to change

 		// KNumFrameSizes below if you change the number of sizes defined in here!

 		{ 640, 480, 1, 30 },		// VGA - 0.3 MP

 		{ 800, 600, 1, 30 },		// SVGA - 0.5 MP

 		{ 1024, 768, 1, 30 },		// XGA - 0.8 MP

 		{ 2048, 1536, 1, 15 },	// QXGA - 3 MP

 		//{ 2560, 1600, 1, 30 }		// WQXGA - 4.1 MP

 	};

 // This constant must be updated if the number of frame sizes listed above changes

 static const TInt KNumFrameSizes = sizeof(FrameSizes) / sizeof(SDevCamFrameSize);

 // Pixel formats supported by the three different capture modes.  These are mapped onto the appropriate

 // array of supported frame rates by the FrameSizeCaps() function

 static const SDevCamPixelFormat PixelFormats[] =

 	{

 		// Image pixel formats

 		{ EUidPixelFormatYUV_422Interleaved, KNumFrameSizes, 2 },

 		// Video pixel formats

 		{ EUidPixelFormatYUV_422Interleaved, KNumFrameSizes, 2 },

 		// View finder pixel formats

 		{ EUidPixelFormatYUV_422Interleaved, KNumFrameSizes, 2 }

 	};

 // These constants must be updated if the number of pixel formats listed above changes

 static const TInt KNumImagePixelFormats = 1;

 static const TInt KNumVideoPixelFormats = 1;

 static const TInt KNumViewFinderPixelFormats = 1;

 // Alternate logo images after this many frames

 static const TInt KAlternateLogoFrameInterval = 5;

 static void ImageTimerCallback(TAny* aSensorIf)

 	{

 	DTemplateSensorIf* sensor = (DTemplateSensorIf*) aSensorIf;

 	// XXX - Call the buffer done function in the sensor class.  In this case we are just emulating the

 	// interrupt and DFC callback that would happen when an image is captured, so we always pass in KErrNone.

 	// In a real driver, we would read the hardware here to check that the capture happened successfully and

 	// would pass in the appropriate error code

 	sensor->BufferDoneCallback(KErrNone);

 	}

 /**

 Saves a configuration specifying such details as dimensions and pixel format in which the sensor should

 capture images.

 @param	aConfig	A TCameraConfigV02 structure containing the settings to be used.

 @return	KErrNone if successful, otherwise one of the other system wide error codes.

 */

 TInt DSensorIf::SetConfig(const TCameraConfigV02& aConfig)

 	{

 	// Manual settings for flash mode, focus, white balance etc. are not supported by the sensor,

 	// so check for these and return KErrNotSupported if they have been requested

 	if ((aConfig.iFlashMode != ECamFlashNone) ||

 		(aConfig.iExposureMode != ECamExposureAuto) ||

 		(aConfig.iZoom != 0) /*||

         (aConfig.iWhiteBalanceMode != ECamWBAuto) ||

 		(aConfig.iContrast != ECamContrastAuto) ||

 		(aConfig.iBrightness != ECamBrightnessAuto)*/)

 		{

 		// XXX: Remove this once support is addded for these modes

 		return KErrNotSupported;

 		}

 	// As well as saving the configuration, also save copies of the width and height for easy access,

 	// as they are accessed frequently, as well as the offset in bytes between lines

 	iConfig = aConfig;

 	iWidth = aConfig.iFrameSize.iWidth;

 	iHeight = aConfig.iFrameSize.iHeight;

 	iLineOffset = (iWidth * iConfig.iPixelFormat.iPixelWidthInBytes);

 	return KErrNone;

 	}

 /**

 Constructor for the Template sensor class.

 */

 DTemplateSensorIf::DTemplateSensorIf(MSensorObserver& aObserver, TDfcQue* aDFCQueue)

 	: iDFCQueue(aDFCQueue)

 	{

 	iObserver = &aObserver;

 	iXDirection = iYDirection = 1;

 	iCounter = 0;

 	iFlipSwitch = EFalse;

 	}

 /**

 Second stage constructor for the Template sensor class.

 @return KErrNone if successful, otherwise one of the other system wide error codes.

 */

 TInt DTemplateSensorIf::DoCreate()

 	{

 	__KTRACE_CAM(Kern::Printf("> DTemplateSensorIf::DoCreate()"));

 	TInt r = KErrNone;

 	for (TInt index = 0; index < KTotalCameraRequests; ++index)

 		{

 		if ((iImageTimerDFCs[index] = new TDfc(ImageTimerCallback, this, iDFCQueue, 0)) == NULL)

 			{

 			r = KErrNoMemory;

 			break;

 			}

 		}

 	__KTRACE_CAM(Kern::Printf("< DTemplateSensorIf::DoCreate() => Returning %d", r));

 	return r;

 	}

 /**

 Destructor for the Template sensor class.

 */

 DTemplateSensorIf::~DTemplateSensorIf()

 	{

 	for (TInt index = 0; index < KTotalCameraRequests; ++index)

 		{

 		iImageTimers[index].Cancel();

 		delete iImageTimerDFCs[index];

 		}

 	}

 /**

 Called by the underlying sensor class when an image has been captured.

 @param aResult	KErrNone if the image was captured successfully, otherwise one of

 				the other system wide error codes.

 @return KErrNone if successful, otherwise one of the other system wide error codes.

 */

 TInt DTemplateSensorIf::BufferDoneCallback(TInt aResult)

 	{

 	TInt r = KErrNone;

 	NKern::LockedDec(iPendingRequests);

 	TLinAddr linAddr;

 	TPhysAddr physAddr;

 	// Call the LDD to let it know that an image capture has completed.  If the LDD needs more images

 	// to be captured, then it will return KErrNone and the virtual and physical addresses of the

 	// next buffer to be filled will be returned in linAddr and physAddr respectively.  Note that as

 	// will as starting a capture of an image in here, the LDD may also call CaptureNextImage() to start

 	// capture as well

 	r = iObserver->NotifyImageCaptureEvent(aResult, linAddr, physAddr);

 	if (r == KErrNone)

 		{

 		iNextRequest = ((iNextRequest + 1) % KTotalCameraRequests);

 		NKern::LockedInc(iPendingRequests);

 		// XXX: Temporary code to be removed in a real driver.  Fill the buffer for testing

 		//      with user side code

 		FillBuffer(linAddr);

 		// XXX: Send buffer to sensor.  Normally the address of the buffer passed in in aLinAddr and

 		//      aPhysAddr would be programmed into the sensor and/or bus hardware here and an interrupt

 		//      would be generated when the iamge had been captured into the buffer.  In this simulated

 		//      driver we will use a nanokernel timer to simulate this process

 		iImageTimers[iNextRequest].OneShot(iImageTimerTicks, *iImageTimerDFCs[iNextRequest]);

 		}

 	return r;

 	}

 /**

 Fills a buffer with a white background with a moving logo on top.

 @param aBuffer	Pointer to the buffer to be filled.

 */

 void DTemplateSensorIf::FillBuffer(TLinAddr aBuffer)

 	{

 	const TUint8* LogoData = Logo.iPixelData;

 	const TUint8* LogoData2 = Logo.iPixelData2;

 	TInt index = 0;

 	TInt numPixels = (iConfig.iFrameSize.iWidth * iConfig.iFrameSize.iHeight);

 	TUint yC, uC, vC;

 	TUint16* buffer = (TUint16*) aBuffer;

     // Alternate between the two logos for cheesy animation effect

     if( ++iCounter == KAlternateLogoFrameInterval )

          {

          iFlipSwitch ^= 1;

          iCounter = 0;

          }

 	// Set the "photo" background to be all white

 	memset(buffer, 0xff, (numPixels * 2));

 	// Point to the correct location in the buffer at which to render the logo

 	buffer += ((iY * iConfig.iFrameSize.iWidth) + iX);

 	// Iterate through the data for the logo and copy it into the "photo"

 	for (TUint y = 0; y < Logo.iHeight; ++y)

 		{

 		for (TUint x = 0; x < Logo.iWidth; ++x)

 			{

 			// The logo is in 24 bit BGR format so read each pixel and convert it to 16 bit BGR565

 			// before writing it into the "photo" buffer

 			if( iFlipSwitch )

 			    {

                 yC = LogoData[index];

                 uC = LogoData[index + 1];

                 vC = LogoData[index + 2];

 			    }

 			else

                 {

                 yC = LogoData2[index];

                 uC = LogoData2[index + 1];

                 vC = LogoData2[index + 2];

                 }

 			*buffer++ = YUVtoYUV565(yC, uC, vC);

 			// Point to the next source pixel

 			index += 3;

 			}

 			// Point to the start of the next line in the buffer, taking into account that the logo

 			// is narrower than the buffer

 			buffer += (iConfig.iFrameSize.iWidth - Logo.iWidth);

 		}

 	// Bounce the logo around in the X direction.  This will take effect the next time this is called

 	iX += iXDirection;

 	if (iX <= 0)

 		{

 		iX = 0;

 		iXDirection = -iXDirection;

 		}

 	else if (iX >= (TInt) (iConfig.iFrameSize.iWidth - Logo.iWidth))

 		{

 		iX = (iConfig.iFrameSize.iWidth - Logo.iWidth);

 		iXDirection = -iXDirection;

 		}

 	// Bounce the logo around in the Y direction.  This will take effect the next time this is called

 	iY += iYDirection;

 	if (iY <= 0)

 		{

 		iY = 0;

 		iYDirection = -iYDirection;

 		}

 	else if (iY >= (TInt) (iConfig.iFrameSize.iHeight - Logo.iHeight))

 		{

 		iY = (iConfig.iFrameSize.iHeight - Logo.iHeight);

 		iYDirection = -iYDirection;

 		}

 	// Now flush the cache to memory, taking into account the size of each pixel.  This is not normally

 	// necessary but given that we are emulating a camera driver in software we must ensure that the

 	// cache is flushed to memory.  This is because in a real driver the buffer will have been filled

 	// by DMA so upon return to the LDD, the LDD will discard the contents of the cache to ensure the

 	// DMA-written data is ok.  In the case of filling the buffer using the CPU in this virtual camera

 	// driver, that would result in the data being discarded!

 	Cache::SyncMemoryBeforeDmaWrite((TLinAddr) aBuffer, (numPixels * iConfig.iPixelFormat.iPixelWidthInBytes));

 	}

 /**

 Based on the capture mode and pixel format passed in, copies an array of supported SFrameSize

 structures into a buffer supplied by the LDD.  These frame sizes and their associated frame rates

 will reflect the capabilities of the given capture mode and pixel format.

 @param aCaptureMode			The capture mode for which to obtain the supported frame sizes.

 @param aUidPixelFormat		The UID of the pixel format (as defined in \epoc32\include\pixelformats.h)

 							for which to obtain the supported frame sizes.

 @param aFrameSizeCapsBuf	A reference to a descriptor that contains a buffer into which to place

 							the frame size structures.  It is up to the LDD to ensure that this is

 							large enough to hold all of the frame sizes.

 @return Always KErrNone.

 */

 TInt DTemplateSensorIf::FrameSizeCaps(TDevCamCaptureMode /*aCaptureMode*/, TUidPixelFormat /*aUidPixelFormat*/, TDes8& aFrameSizeCapsBuf)

 	{

 	TPtrC8 sourceFrameSizes((const TUint8*) FrameSizes, sizeof(FrameSizes));

 	// Ensure the buffer passed in from the LDD is large enough and copy the requested frame sizes

 	if (aFrameSizeCapsBuf.Size() < sourceFrameSizes.Size())

 		{

 		Kern::Printf("*** ECapsBufferTooSmall: %d vs %d",

 				aFrameSizeCapsBuf.Size(),

 				sourceFrameSizes.Size());

 		Kern::Fault("camerasc", ECapsBufferTooSmall);

 		}

 	//__ASSERT_DEBUG((aFrameSizeCapsBuf.Size() >= sourceFrameSizes.Size()), Kern::Fault("camerasc", ECapsBufferTooSmall));

 	aFrameSizeCapsBuf = sourceFrameSizes;

 	return KErrNone;

 	}

 /**

 Allocates a buffer large enough to hold the TCameraCapsV02 structure and its succeeding array of

 pixel formats, and populates the structure and array with information about the capabilities of

 the sensor.

 @param aCameraCaps	Reference to a pointer into which to place the pointer to allocated buffer

 @return	Size of the capabilities structure if successful, otherwise one of the other system wide

 		error codes.

 */

 TInt DTemplateSensorIf::GetCaps(TCameraCapsV02*& aCameraCaps)

 	{

 	// Allocate a buffer large enough to hold the TCameraCapsV02 structure and the array of pixel formats

 	// that will follow it

 	TInt r = (sizeof(TCameraCapsV02) + sizeof(PixelFormats));

 	TUint8* capsBuffer = new TUint8[r];

 	if (capsBuffer)

 		{

 		aCameraCaps = (TCameraCapsV02*) capsBuffer;

 		// No special modes are supported at the moment

 		aCameraCaps->iFlashModes = ECamFlashNone;

 		aCameraCaps->iExposureModes = ECamExposureAuto; // or None?

 		// do we still need whitebalance mode filed?

 		aCameraCaps->iWhiteBalanceModes = ECamWBAuto | ECamWBDaylight | ECamWBCloudy | ECamWBTungsten | ECamWBFluorescent | ECamWBFlash | ECamWBSnow | ECamWBBeach;

 		aCameraCaps->iMinZoom = 0;

 		aCameraCaps->iMaxZoom = 0;

 		aCameraCaps->iCapsMisc = KCamMiscContrast | KCamMiscBrightness | KCamMiscColorEffect;

 		// There isn't really such thing as inwards or outwards orientation on an SDP, but we'll pretend it's

 		// an outwards facing camera

 		aCameraCaps->iOrientation = ECamOrientationOutwards;

 		// Initialise the number of different pixel formats supported

 		aCameraCaps->iNumImagePixelFormats = KNumImagePixelFormats;

 		aCameraCaps->iNumVideoPixelFormats = KNumVideoPixelFormats;

 		aCameraCaps->iNumViewFinderPixelFormats = KNumViewFinderPixelFormats;

 		for (TInt i = 0; i < ECamAttributeMax; i++)

 		    {

 		    if (ECamAttributeColorEffect == (TDevCamDynamicAttribute)(i))

 		        {

 		        // WhiteBalance

 		        // In case of white balance, we shouldn't use MIN and MAX values as some of them in between MIN and MAX can be missed out.

 		        // As this is fake driver, There doesn't seem to be any major issue though.

 		        aCameraCaps->iDynamicRange[i].iMin = ECamWBAuto;

 		        aCameraCaps->iDynamicRange[i].iMax = ECamWBBeach;

 		        aCameraCaps->iDynamicRange[i].iDefault = ECamWBAuto;

 		        }

 		    else

 		        {    

 		        // TBC :: Contrast, Brightness

 		        aCameraCaps->iDynamicRange[i].iMin = 0;

 		        aCameraCaps->iDynamicRange[i].iMax = 6;

 		        aCameraCaps->iDynamicRange[i].iDefault = 3;

 		        }

 		    }

 		// Setup some descriptors pointing to the pixel format array and the array passed in by the LDD

 		// (located at the end of the TCameraCapsV02 structure) and copy the pixel format array

 		TPtrC8 sourcePixelFormats((const TUint8*) PixelFormats, sizeof(PixelFormats));

 		TPtr8 destPixelFormats((capsBuffer + sizeof(TCameraCapsV02)), sizeof(PixelFormats), sizeof(PixelFormats));

 		destPixelFormats = sourcePixelFormats;

 		}

 	else

 		{

 		r = KErrNoMemory;

 		}

 	return r;

 	}

 /**

 Powers up the sensor hardware.

 @return KErrNone if successful, otherwise one of the other system wide error codes.

 */

 TInt DTemplateSensorIf::RequestPower()

 	{

 	__KTRACE_CAM(Kern::Printf("> DTemplateSensorIf::RequestPower()"));

 	TInt r = KErrNone;

 	__KTRACE_CAM(Kern::Printf("< DTemplateSensorIf::RequestPower() => Returning %d", r));

 	return r;

 	}

 /**

 Powers down the sensor hardware.

 @return KErrNone if successful, otherwise one of the other system wide error codes.

 */

 TInt DTemplateSensorIf::RelinquishPower()

 	{

 	__KTRACE_CAM(Kern::Printf("> DTemplateSensorIf::RelinquishPower()"));

 	TInt r = KErrNone;

 	__KTRACE_CAM(Kern::Printf("< DTemplateSensorIf::RelinquishPower() => Returning %d", r));

 	return r;

 	}

 /**

 Begins capture of the next image into the buffer provided.  This function assumes that

 Start() has already been called to start capture.  However, Stop() may also have been

 subsequently called (for example to pause capture) and in this case, this function will

 handle restarting the sensor.

 @param aLinAddr		A virtual pointer to the buffer into which to capture the image.

 @param aPhysAddr	A physical pointer to the buffer into which to capture the image.

 					This points to the same memory as aLinAddr.

 @return KErrNone if successful.

 		KErrNotReady if there are no free requests to capture the image.

 		Otherwise one of the other system wide error codes.

 */

 TInt DTemplateSensorIf::CaptureNextImage(TLinAddr aLinAddr, TPhysAddr /*aPhysAddr*/)

 	{

 	TInt r = KErrNone;

 	// Only start capturing the next image if there are any pending request slots available

 	if (iPendingRequests < KTotalCameraRequests)

 		{

 		// Queue a transfer on the next available channel and indicate that the channel is

 		// in use

 		iNextRequest = ((iNextRequest + 1) % KTotalCameraRequests);

 		NKern::LockedInc(iPendingRequests);

 		// XXX: Temporary code to be removed in a real driver.  Fill the buffer for testing

 		//      with user side code.  This is to simulate an image being captured into the buffer that

 		//      has been passed in in aLinAddr.  As well as aLinAddr, which points to the virtual

 		//      address of the buffer, the LDD will pass in the physical address as well, in aPhysAddr.

 		//      Depending on the underlying sensor hardware and/or bus in use, you will have to choose

 		//      which of these to use

 		FillBuffer(aLinAddr);

 		// XXX: Send buffer to sensor.  Normally the address of the buffer passed in in aLinAddr and

 		//      aPhysAddr would be programmed into the sensor and/or bus hardware here and an interrupt

 		//      would be generated when the iamge had been captured into the buffer.  In this simulated

 		//      driver we will use a nanokernel timer to simulate this process

 		iImageTimers[iNextRequest].OneShot(iImageTimerTicks, *iImageTimerDFCs[iNextRequest]);

 		// If capturing has not yet started or has been paused by Stop(), start it

 		if (!(iEnabled))

 			{

 			iEnabled = ETrue;

 			}

 		}

 	else

 		{

 		r = KErrNotReady;

 		}

 	return r;

 	}

 /**

 Begins capture of the first image into the buffer provided.  This function is similar to

 CaptureNextImage(), except that it will perform any extra sensor intitialisation required

 to start capture.

 @param aCaptureMode	The capture mode for which to start capturing.

 @param aLinAddr		A virtual pointer to the buffer into which to capture the image.

 @param aPhysAddr	A physical pointer to the buffer into which to capture the image.

 					This points to the same memory as aLinAddr.

 @return KErrNone if successful

 		KErrInUse if capture is already under way.

 		KErrNotSupported if the frame size and/or frame rate are out of range.

 		Otherwise one of the other system wide error codes.

 */

 TInt DTemplateSensorIf::Start(TDevCamCaptureMode /*aCaptureMode*/, TLinAddr aLinAddr, TPhysAddr aPhysAddr)

 	{

 	__KTRACE_CAM(Kern::Printf("> DTemplateSensorIf::Start()"));

 	TInt r = KErrNone;

 	// XXX - In a real camera driver, in here we would initialise start the capturing process in here.

 	//       When an image is captured, the sensor hardware (or maybe the CSI bus) will generate an

 	//       which will then be enqueued into the DFC queue that was passed into the constructor of

 	//       the sensor class.  It is important to do the DFC processing in this DFC queue rather than

 	//       a separate one because it ensures that fucntions in the PDD and LDD are called in a serialised

 	//       manner, without the need for mutexts.  In this example camera driver we will convert the

 	//       framerate into a nanokernel tick count and will use an NTimer.OneShot() call to simulate

 	//       the sensor interrupt and DFC callback.  Divides are slow so we'll calculate the tick count

 	//       here and will save it for later use

 	iImageTimerTicks = ((1000000 / NKern::TickPeriod()) / iConfig.iFrameRate);

 	// XXX - Once the one off hardware initialisation has been done for starting a new capture, then

 	//       subsequent captures can usually reuse the same code in CaptureNextImage() for starting

 	//       the next capture

 	r = CaptureNextImage(aLinAddr, aPhysAddr);

 	__KTRACE_CAM(Kern::Printf("< DTemplateSensorIf::Start() => Returning %d", r));

 	return r;

 	}

 /**

 Stops capturing any image capture that is currently in progress.  This function will act

 more like a Pause() than a Stop() capturing can be restarted from where it was stopped.

 */

 TInt DTemplateSensorIf::Stop()

 	{

 	__KTRACE_CAM(Kern::Printf("> DTemplateSensorIf::Stop()"));

 	iEnabled = EFalse;

 	iPendingRequests = iNextRequest = 0;

 	// XXX - Cancel all of our pending image timer callbacks.  In a real driver we would write to the

 	//       sensor and/or bus hardware here to cause them to cancel any pending image captures

 	for (TInt index = 0; index < KTotalCameraRequests; ++index)

 		{

 		iImageTimers[index].Cancel();

 		}

 	__KTRACE_CAM(Kern::Printf("< DTemplateSensorIf::Stop()"));

 	return KErrNone;

 	}