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

// e32test\multimedia\t_camera_api.cpp

// 

//

#include <e32test.h>

#include <d32camerasc.h>

#include <e32def.h>

#include <e32def_private.h>

#include "t_camera_display.h"

#include "t_camera_bitmap.h"

#include "d_mmcsc.h"

_LIT(KTstLddFileName,"D_MMCSC.LDD");

_LIT(KCamLddFileName,"ECAMERASC.LDD");

#ifdef __WINSCW__

_LIT(KCamPddFileName,"_TEMPLATE_CAMERASC.PDD");

#else

_LIT(KCamPddFileName,"CAMERASC.PDD");

#endif

_LIT(KCamFreePddExtension,".*");

_LIT(KFrameSize, "%dx%d");

_LIT(KSensor, "d:\\Sensor_");

_LIT(KUnderscore, "_");

_LIT(KBmp, ".bmp");

_LIT(KJpeg, ".jpg");

_LIT(KSpeedTaggedJpeg, ".stj");

LOCAL_D TCameraCapsV02* CameraCaps;

LOCAL_D TInt CapsSize;

LOCAL_D TAny* CapsBufPtr;

RTest Test(_L("T_CAMERA_API"));

const TInt KNumVideoFramesToAllocate=6;

const TInt KNumVideoFramesToCapture=(KNumVideoFramesToAllocate-2);

const TInt KHeapSize=0x4000;

const TInt KUnit0=0;

enum TSecThreadTestId

	{

	ESecThreadTestOpen,

	ESecThreadTestDuplicateHandle,

	ESecThreadReuseHandle

	};

struct SSecondaryThreadInfo

	{

	TSecThreadTestId iTestId;

	TInt iExpectedRetVal;

	TThreadId iThreadId;

	TInt iDrvHandle;

	TInt iCameraModuleIndex;

	};

LOCAL_C TInt secondaryThread(TAny* aTestInfo)

	{

	RTest stest(_L("Secondary test camera thread"));

	stest.Title();

	stest.Start(_L("Check which test to perform"));

	SSecondaryThreadInfo sti =*((SSecondaryThreadInfo*)aTestInfo);

	TInt r;

	switch(sti.iTestId)

		{

		case ESecThreadTestOpen:

			{

			stest.Next(_L("Open channel test"));

			RDevCameraSc cam;

			r=cam.Open(sti.iCameraModuleIndex);

			stest(r==sti.iExpectedRetVal);

			cam.Close();

			break;

			}

		case ESecThreadTestDuplicateHandle:

			{

			stest.Next(_L("Duplicate channel handle test"));

			// Get a reference to the main thread - which created the handle

			RThread thread;

			r=thread.Open(sti.iThreadId);

			stest(r==KErrNone);

			// Duplicate the driver handle passed from the other thread - for this thread

			RDevCameraSc cam;

			cam.SetHandle(sti.iDrvHandle);

			r=cam.Duplicate(thread);

			stest(r==sti.iExpectedRetVal);

			cam.Close();

			thread.Close();

			break;

			}

		case ESecThreadReuseHandle:

			{

			stest.Next(_L("Re-use channel test"));

			RDevCameraSc* camPtr=(RDevCameraSc*)sti.iDrvHandle;

			TCameraConfigV02Buf camConfBuf;

			camPtr->GetCamConfig(ECamCaptureModeImage, camConfBuf);	// This should cause a panic.

			break;

			}

		default:

			break;

		}

	stest.End();

	return(KErrNone);

	}

/** Test for defect DEF135950. */

LOCAL_C void DoCamDynamicSettingsTests(RDevCameraSc& aCam, RTest& aTest)

	{

	aTest.Next(_L("DYNAMIC SETTINGS TESTS"));

	aTest.Next(_L("Get the Caps size. Should be non-zero"));

	TInt capsSize = aCam.CapsSize();

	aTest(capsSize>0);

	aTest.Next(_L("Get the Capabilities (driver owned copy)."));

	TPtrC8 driverCopy = aCam.Caps();

	aTest(driverCopy.Ptr() != NULL);

	aTest(driverCopy.Length()>0);

	aTest.Next(_L("Test failure (buffer too small)."));

	TAny* capsBufPtr = User::Alloc(capsSize-1);

	aTest(capsBufPtr != NULL);

	TPtr8 smallBuf((TUint8*) capsBufPtr, capsSize-1, capsSize-1);

	aTest(KErrArgument==aCam.Caps(smallBuf));

	User::Free(capsBufPtr);

	aTest.Next(_L("Get the Capabilities (client owned copy)."));

	capsBufPtr = User::Alloc(capsSize);

	aTest(capsBufPtr != NULL);

	TPtr8 clientCopy((TUint8*) capsBufPtr, capsSize, capsSize);

	aTest(KErrNone==aCam.Caps(clientCopy));

	aTest(clientCopy.Ptr() != NULL);

	aTest(clientCopy.Length()>0);

	aTest.Next(_L("Obtain the range for Dynamic Settings from both copies (should be the same)."));

	TDynamicRange &driverRangeBrightness = ((TCameraCapsV02*)(driverCopy.Ptr()))->iDynamicRange[ECamAttributeBrightness];

	TDynamicRange &clientRangeBrightness = ((TCameraCapsV02*)(clientCopy.Ptr()))->iDynamicRange[ECamAttributeBrightness];

	aTest(driverRangeBrightness.iMin == 0);

	aTest(driverRangeBrightness.iMax == 6);

	aTest(driverRangeBrightness.iMin == clientRangeBrightness.iMin);

	aTest(driverRangeBrightness.iMax == clientRangeBrightness.iMax);

	TDynamicRange &driverRangeContrast = ((TCameraCapsV02*)(driverCopy.Ptr()))->iDynamicRange[ECamAttributeContrast];

	TDynamicRange &clientRangeContrast = ((TCameraCapsV02*)(clientCopy.Ptr()))->iDynamicRange[ECamAttributeContrast];

	aTest(driverRangeContrast.iMin == 0);

	aTest(driverRangeContrast.iMax == 6);

	aTest(driverRangeContrast.iMin == clientRangeContrast.iMin);

	aTest(driverRangeContrast.iMax == clientRangeContrast.iMax);

	TDynamicRange &driverRangeColorEffect = ((TCameraCapsV02*)(driverCopy.Ptr()))->iDynamicRange[ECamAttributeColorEffect];

	TDynamicRange &clientRangeColorEffect = ((TCameraCapsV02*)(clientCopy.Ptr()))->iDynamicRange[ECamAttributeColorEffect];

	aTest(driverRangeColorEffect.iMin == 0);

	aTest(driverRangeColorEffect.iMax == 7); // TBC::OV3640 set to 7, template driver set to 0x0040 (enum)

	aTest(driverRangeColorEffect.iMin == clientRangeColorEffect.iMin);

	aTest(driverRangeColorEffect.iMax == clientRangeColorEffect.iMax);

	aTest.Next(_L("Test for invalid Min range."));

	aTest(aCam.SetDynamicAttribute(ECamAttributeBrightness, driverRangeBrightness.iMin-1)==KErrArgument);

	aTest(aCam.SetDynamicAttribute(ECamAttributeContrast, driverRangeContrast.iMin-1)==KErrArgument);

	aTest(aCam.SetDynamicAttribute(ECamAttributeColorEffect, driverRangeColorEffect.iMin-1)==KErrArgument);

	aTest.Next(_L("Test for invalid Max range."));

	aTest(aCam.SetDynamicAttribute(ECamAttributeBrightness, driverRangeBrightness.iMax+1)==KErrArgument);

	aTest(aCam.SetDynamicAttribute(ECamAttributeContrast, driverRangeContrast.iMax+1)==KErrArgument);

	aTest(aCam.SetDynamicAttribute(ECamAttributeColorEffect, driverRangeColorEffect.iMax+1)==KErrArgument);

	aTest.Next(_L("Test all valid settings as reported by range - Brightness"));

	for (TUint i=driverRangeBrightness.iMin; i <= driverRangeBrightness.iMax; ++i)

		{

		aTest(aCam.SetDynamicAttribute(ECamAttributeBrightness, i)==KErrNone);

		}

	aTest.Next(_L("Test all valid settings as reported by range - Contrast"));

	for (TUint j=driverRangeContrast.iMin; j <= driverRangeContrast.iMax; ++j)

		{

		aTest(aCam.SetDynamicAttribute(ECamAttributeContrast, j)==KErrNone);

		}

	aTest.Next(_L("Test all valid settings as reported by range - ColorEffect"));

	for (TUint k=driverRangeColorEffect.iMin; k <= driverRangeColorEffect.iMax; ++k)

		{

		aTest(aCam.SetDynamicAttribute(ECamAttributeColorEffect, k)==KErrNone);

		}

	User::Free(capsBufPtr);

	}

/** Test for defect DEF135949. */

LOCAL_C void DoCamBufferOffsetTests(RDevCameraSc& aCam, RTest& aTest, const SDevCamPixelFormat& aPixelFormat, const SDevCamFrameSize& aFrameSize, TUint aFrameRate)

	{

	TInt r;

	aTest.Next(_L("BUFFER ID OFFSET TESTS"));

	aTest.Printf(_L("PixelFormat = %d, FrameSize = %d x %d\n"),aPixelFormat.iPixelFormat,aFrameSize.iWidth,aFrameSize.iHeight);

	// Configure Image Capture

	aTest.Next(_L("Get the camera config of Image mode"));

	TCameraConfigV02Buf camConfBuf;

	aCam.GetCamConfig(ECamCaptureModeImage, camConfBuf);

	TCameraConfigV02 &camConf=camConfBuf();

	camConf.iFrameSize=aFrameSize;

	camConf.iPixelFormat=aPixelFormat;

	camConf.iFrameRate=aFrameRate;

	// Set the Image configuration.

	aTest.Next(_L("Set the Get the camera config of Image mode"));

	r=aCam.SetCamConfig(ECamCaptureModeImage,camConfBuf);

	aTest(r==KErrNone);

	aCam.GetCamConfig(ECamCaptureModeImage, camConfBuf);

	PrintCamConf(camConf,aTest);

	// Create an Image chunk handle.

	aTest.Next(_L("Create the Image chunk"));

	RChunk imgChunkImage;

	TInt numBuffers=KNumVideoFramesToAllocate;

	r=aCam.SetBufConfigChunkCreate(ECamCaptureModeImage,numBuffers,imgChunkImage);

	aTest(r==KErrNone);

	aTest.Next(_L("Read and display the Image buffer config"));

	TMmSharedChunkBufConfig bufferConfig;

	TPckg<TMmSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

	aCam.GetBufferConfig(ECamCaptureModeImage, bufferConfigBuf);

	PrintBufferConf(bufferConfig,aTest);

	// Configure Video Capture

	aTest.Next(_L("Get the camera config of Video mode"));

	aCam.GetCamConfig(ECamCaptureModeVideo, camConfBuf);

	camConf=camConfBuf();

	camConf.iFrameSize=aFrameSize;

	camConf.iPixelFormat=aPixelFormat;

	camConf.iFrameRate=aFrameRate;

	// Set the video configuration.

	aTest.Next(_L("Set the Get the camera config of Video mode"));

	r=aCam.SetCamConfig(ECamCaptureModeVideo,camConfBuf);

	aTest(r==KErrNone);

	aCam.GetCamConfig(ECamCaptureModeVideo, camConfBuf);

	PrintCamConf(camConf,aTest);

	// Create an Video chunk handle.

	aTest.Next(_L("Create the Video chunk"));

	RChunk chunkVideo;

	numBuffers=KNumVideoFramesToAllocate;

	r=aCam.SetBufConfigChunkCreate(ECamCaptureModeVideo,numBuffers,chunkVideo);

	aTest(r==KErrNone);

	aTest.Next(_L("Read and display the Video buffer config"));

	aCam.GetBufferConfig(ECamCaptureModeVideo, bufferConfigBuf);

	PrintBufferConf(bufferConfig,aTest);

	// Test that stop still returns an error.

	r=aCam.Stop();

	aTest(r==KErrGeneral);

	// Set the current capture mode to image

	aTest.Next(_L("Set the camera in Image mode and capture a buffer, then requesting the buffer offset."));

	r=aCam.SetCaptureMode(ECamCaptureModeImage);

	aTest(r==KErrNone);

	// Start the camera

	r=aCam.Start();

	aTest(r==KErrNone);

	aTest.Next(_L("Issue a capture request"));

	TRequestStatus rs1;

	aCam.NotifyNewImage(rs1);

	User::WaitForRequest(rs1);

	TInt retId=rs1.Int();

	TInt retOffset=-1;

	aTest(retId>=0);

	aCam.BufferIdToOffset(ECamCaptureModeImage,retId,retOffset);

	aTest.Printf(_L("Buffer offset: %d(%xH)\r\n"),retId,retOffset);

	aTest(retOffset>=0);

	// Change capture mode

	aTest.Next(_L("Set the capture mode to Video."));

	r=aCam.SetCaptureMode(ECamCaptureModeVideo);

	aTest(r==KErrNone);

	aTest.Next(_L("Request again the offset for the buffer in Image mode."));

	aCam.BufferIdToOffset(ECamCaptureModeImage,retId,retOffset);

	aTest.Printf(_L("Buffer offset: %d(%xH)\r\n"),retId,retOffset);

	aTest(retOffset>=0);

	// Stop the camera.

	r=aCam.Stop();

	aTest(r==KErrNone);

	aTest.Next(_L("Close the chunk"));

	r=aCam.ChunkClose(ECamCaptureModeImage);

	aTest(r==KErrNone);

	r=aCam.ChunkClose(ECamCaptureModeVideo);

	aTest(r==KErrNone);

	}

LOCAL_C void DoCamOpenCapTests(RTest& aTest,TInt aCameraSensorIndex)

	{

	TInt r;

	// Open the camera driver to obtain the basic capabilities for use throughout the tests and

	// then close it again so that it may be confirmed that opening multiple times is ok

	aTest.Next(_L("CHANNEL OPEN AND CAPABILITIES TESTS"));

	RDevCameraSc cam;

	aTest.Next(_L("Open a channel on the camera driver"));

	r=cam.Open(aCameraSensorIndex);

	aTest(r==KErrNone);

	// Make sure that the driver can handle attempts to start it before it has been configured

	aTest.Next(_L("Try to start/stop camera before its configured"));

	r=cam.Start();

	aTest(r==KErrNotReady);

	r=cam.Stop();

	aTest(r==KErrGeneral);

	aTest.Next(_L("Read the capabilities structure size of this device"));

	CapsSize=cam.CapsSize();

	aTest.Next(_L("Read and display the capabilities of this device"));

	CapsBufPtr = User::Alloc(CapsSize);

	TPtr8 capsPtr( (TUint8*)CapsBufPtr, CapsSize, CapsSize );

	r=cam.Caps(capsPtr);

	aTest(r==KErrNone);

	CameraCaps = (TCameraCapsV02*) capsPtr.Ptr();

	PrintCamModes(CameraCaps,aTest);

	TAny* frameSizeCapsBuf;

	SDevCamPixelFormat* pixelFormat;

	TBuf<80> buf;

	SDevCamFrameSize* frameSize;

	TPtr8 frameSizeCapsPtr(0,0,0);

	TUint fsCount, pfCount, theCount = 0;

	/* IMAGE */

	/* Use pixel formats from 0 to CapsBuf->iNumImagePixelFormats */

	buf.Zero();

	buf.Append(KCaptureModeImage);

	buf.Append(_L("\r\n"));

	aTest.Printf(buf);

	pixelFormat = (SDevCamPixelFormat*) (CameraCaps + 1);

	for (pfCount = theCount; pfCount < CameraCaps->iNumImagePixelFormats; pfCount++)

		{

		buf.Zero();

		AppendPixelFormat(buf, pixelFormat->iPixelFormat);

		aTest.Printf(buf);

		frameSizeCapsBuf = User::Alloc(pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize));

		new (&frameSizeCapsPtr) TPtr8((TUint8*)frameSizeCapsBuf, pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize), pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize));

		r=cam.FrameSizeCaps(ECamCaptureModeImage, pixelFormat->iPixelFormat, frameSizeCapsPtr);

		aTest(r==KErrNone);

		frameSize = (SDevCamFrameSize*) frameSizeCapsPtr.Ptr();

		for (fsCount = 0; fsCount < pixelFormat->iNumFrameSizes; fsCount++)

			{

			aTest.Printf(_L("%dx%d "),frameSize->iWidth,frameSize->iHeight);

			frameSize++;

			}

		aTest.Printf(_L("\n"));

		User::Free(frameSizeCapsBuf);

		pixelFormat++;

		}

	/* VIDEO */

	buf.Zero();

	buf.Append(KCaptureModeVideo);

	buf.Append(_L("\r\n"));

	aTest.Printf(buf);

	pixelFormat = (SDevCamPixelFormat*) (CameraCaps + 1);

	pixelFormat += CameraCaps->iNumImagePixelFormats;

	theCount = CameraCaps->iNumImagePixelFormats + CameraCaps->iNumVideoPixelFormats;

	for (pfCount = CameraCaps->iNumImagePixelFormats; pfCount < theCount; pfCount++)

		{

		buf.Zero();

		AppendPixelFormat(buf, pixelFormat->iPixelFormat);

		aTest.Printf(buf);

		frameSizeCapsBuf = User::Alloc(pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize));

		new (&frameSizeCapsPtr) TPtr8((TUint8*)frameSizeCapsBuf, pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize), pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize));

		r=cam.FrameSizeCaps(ECamCaptureModeVideo, pixelFormat->iPixelFormat, frameSizeCapsPtr);

		aTest(r==KErrNone);

		frameSize = (SDevCamFrameSize*) frameSizeCapsPtr.Ptr();

		for (fsCount = 0; fsCount < pixelFormat->iNumFrameSizes; fsCount++)

			{

			aTest.Printf(_L("%dx%d "),frameSize->iWidth,frameSize->iHeight);

			frameSize++;

			}

		aTest.Printf(_L("\n"));

		User::Free(frameSizeCapsBuf);

		pixelFormat++;

		}

	/* VIEW FINDER */

	buf.Zero();

	buf.Append(KCaptureModeViewFinder);

	buf.Append(_L("\r\n"));

	aTest.Printf(buf);

	pixelFormat = (SDevCamPixelFormat*) (CameraCaps + 1);

	pixelFormat += (CameraCaps->iNumImagePixelFormats + CameraCaps->iNumVideoPixelFormats);

	theCount = CameraCaps->iNumImagePixelFormats + CameraCaps->iNumVideoPixelFormats + CameraCaps->iNumViewFinderPixelFormats;

	for (pfCount = CameraCaps->iNumImagePixelFormats + CameraCaps->iNumVideoPixelFormats; pfCount < theCount; pfCount++)

		{

		buf.Zero();

		AppendPixelFormat(buf, pixelFormat->iPixelFormat);

		aTest.Printf(buf);

		frameSizeCapsBuf = User::Alloc(pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize));

		new (&frameSizeCapsPtr) TPtr8((TUint8*)frameSizeCapsBuf, pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize), pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize));

		r=cam.FrameSizeCaps(ECamCaptureModeViewFinder, pixelFormat->iPixelFormat, frameSizeCapsPtr);

		aTest(r==KErrNone);

		frameSize = (SDevCamFrameSize*) frameSizeCapsPtr.Ptr();

		for (fsCount = 0; fsCount < pixelFormat->iNumFrameSizes; fsCount++)

			{

			aTest.Printf(_L("%dx%d "),frameSize->iWidth,frameSize->iHeight);

			frameSize++;

			}

		aTest.Printf(_L("\n"));

		User::Free(frameSizeCapsBuf);

		pixelFormat++;

		}

	aTest.Next(_L("Try opening the same unit a second time."));

	RDevCameraSc cam2;

	r=cam2.Open(aCameraSensorIndex);

	aTest(r==KErrInUse);

	aTest.Next(_L("Open a channel from the 2nd thread without closing the 1st"));

	RThread thread;

	TRequestStatus stat;

	SSecondaryThreadInfo sti;

	// Setup the 2nd thread to open a channel on the same unit

	sti.iTestId=ESecThreadTestOpen;

	sti.iExpectedRetVal=KErrInUse;

	sti.iCameraModuleIndex=aCameraSensorIndex;

	r=thread.Create(_L("Thread"),secondaryThread,KDefaultStackSize,KHeapSize,KHeapSize,&sti);

	Test(r==KErrNone);

	thread.Logon(stat);

	thread.Resume();

	User::WaitForRequest(stat);

	Test(stat.Int()==KErrNone);

	Test(thread.ExitType()==EExitKill);

	thread.Close();

	User::After(10000);	// Wait 10ms

	aTest.Next(_L("Open a channel from the 2nd thread having closed the 1st"));

	cam.Close();		// Close the 1st channel

	sti.iTestId=ESecThreadTestOpen;

	sti.iExpectedRetVal=KErrNone;

	r=thread.Create(_L("Thread02"),secondaryThread,KDefaultStackSize,KHeapSize,KHeapSize,&sti);

	Test(r==KErrNone);

	thread.Logon(stat);

	thread.Resume();

	User::WaitForRequest(stat);

	Test(stat.Int()==KErrNone);

	Test(thread.ExitType()==EExitKill);

	thread.Close();

	User::After(10000);	// Wait 10ms

	aTest.Next(_L("Re-open channel and duplicate it from 2nd thread"));

	r=cam.Open(aCameraSensorIndex);		// Re-open the channel

	aTest(r==KErrNone);

	sti.iTestId=ESecThreadTestDuplicateHandle;

	sti.iExpectedRetVal=KErrAccessDenied;

	sti.iThreadId=RThread().Id();	// Get the ID of this thread

	sti.iDrvHandle=cam.Handle();	// Pass the channel handle

	r=thread.Create(_L("Thread03"),secondaryThread,KDefaultStackSize,KHeapSize,KHeapSize,&sti); // Create secondary thread

	Test(r==KErrNone);

	thread.Logon(stat);

	thread.Resume();

	User::WaitForRequest(stat);

	Test(stat.Int()==KErrNone);

	Test(thread.ExitType()==EExitKill);

	thread.Close();

	User::After(10000);	// Wait 10ms

	aTest.Next(_L("Re-use the same channel from 2nd thread"));

	sti.iTestId=ESecThreadReuseHandle;

	sti.iDrvHandle=(TInt)&cam;	// Pass a pointer to the channel

	r=thread.Create(_L("Thread04"),secondaryThread,KDefaultStackSize,KHeapSize,KHeapSize,&sti); // Create secondary thread

	Test(r==KErrNone);

	thread.Logon(stat);

	thread.Resume();

	User::WaitForRequest(stat);

	TExitCategoryName exitCategoryName = thread.ExitCategory();

	Test.Printf(_L("Thread exit info: Cat:%S, Reason:%x, Type:%d\r\n"),&exitCategoryName,thread.ExitReason(),thread.ExitType());

	Test(thread.ExitType()==EExitPanic);	// Secondary thread is expected to panic

	Test(stat.Int()==KErrNone);

	thread.Close();

	User::After(10000);	// Wait 10ms

	cam.Close();

	}

LOCAL_C void DoCamConfigTests(RDevCameraSc& aCam, RTest& aTest, TDevCamCaptureMode aCaptureMode, const SDevCamPixelFormat& aPixelFormat, const SDevCamFrameSize& aFrameSize)

	{

	TInt r;

	aTest.Next(_L("GETTING & SETTING CONFIG TESTS"));

	aTest.Printf(_L("CaptureMode = %d, PixelFormat = %x, FrameSize = %d x %d\n"),aCaptureMode,aPixelFormat.iPixelFormat,aFrameSize.iWidth,aFrameSize.iHeight);

	aTest.Next(_L("Read and display the default camera config for requested capture mode"));

	TCameraConfigV02Buf camConfBuf;

	aCam.GetCamConfig(aCaptureMode, camConfBuf);

	TCameraConfigV02 &camConf=camConfBuf();

	PrintCamConf(camConf,aTest);

	aTest.Next(_L("Read and display the default buffer config for requested capture mode"));

	TMmSharedChunkBufConfig bufferConfig;

	TPckg<TMmSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

	aCam.GetBufferConfig(aCaptureMode, bufferConfigBuf);

	PrintBufferConf(bufferConfig,aTest);

	aTest.Next(_L("Setup the config - creating a chunk"));

	camConf.iFrameSize=aFrameSize;

	camConf.iPixelFormat=aPixelFormat;

	camConf.iFrameRate=aFrameSize.iMaxFrameRate;

	r=aCam.SetCamConfig(aCaptureMode, camConfBuf);

	aTest(r==KErrNone);

	RChunk chunk;

	r=aCam.SetBufConfigChunkCreate(aCaptureMode, KNumVideoFramesToAllocate, chunk);

	aTest(r==KErrNone);

	aCam.GetCamConfig(aCaptureMode, camConfBuf);

	PrintCamConf(camConf,aTest);

	aTest.Next(_L("Read and display the resulting buffer config"));

	aCam.GetBufferConfig(aCaptureMode, bufferConfigBuf);

	PrintBufferConf(bufferConfig,aTest);

	aTest.Next(_L("Close the chunk created"));

	chunk.Close();

	aTest.Next(_L("Open a channel on the test driver"));

	RMmCreateSc tstDrv;

	r=tstDrv.Open();		// Opening the channel results in the creation of a shared chunk.

	aTest(r==KErrNone);

	aTest.Next(_L("Get a handle on its shared chunk"));

	r=tstDrv.GetChunkHandle(chunk);	// Get a handle on the shared chunk created by the test driver

	aTest(r==KErrNone);

	aTest.Next(_L("Read and display the buffer config"));

	TMmSharedChunkBufConfig bufferConfigTest;

	TPckg<TMmSharedChunkBufConfig> bufferConfigBufTest(bufferConfigTest);

	// Get info on the buffers within the shared chunk

	aTest.Next(_L("Get info. on the shared chunk"));

	r=tstDrv.GetBufInfo(bufferConfigBufTest);

	aTest(r==KErrNone);

	PrintBufferConf(bufferConfigTest,aTest);

	aTest.Next(_L("Setup the config - supplying a chunk"));

	r=aCam.SetBufConfigChunkOpen(aCaptureMode, bufferConfigBufTest, chunk);

	aTest(r==KErrNone);

	aCam.GetCamConfig(aCaptureMode, camConfBuf);

	PrintCamConf(camConf,aTest);

	aCam.GetBufferConfig(aCaptureMode, bufferConfigBufTest);

	PrintBufferConf(bufferConfigTest,aTest);

	aTest.Next(_L("Close the chunk driver and the 2nd chunk"));

	tstDrv.Close();

	chunk.Close();

	}

LOCAL_C void DoCamVideoCaptureTests(RDevCameraSc& aCam, RTest& aTest, TDevCamCaptureMode aCaptureMode, const SDevCamPixelFormat& aPixelFormat, const SDevCamFrameSize& aFrameSize, TUint aFrameRate)

	{

	TInt r;

	aTest.Next(_L("VIDEO CAPTURE TESTS"));

	aTest.Printf(_L("CaptureMode = %d, PixelFormat = %x, FrameSize = %d x %d\n"),aCaptureMode,aPixelFormat.iPixelFormat,aFrameSize.iWidth,aFrameSize.iHeight);

	// Configure Video or Viewfinder Capture

	TCameraConfigV02Buf camConfBuf;

	aCam.GetCamConfig(aCaptureMode, camConfBuf);

	TCameraConfigV02 &camConf=camConfBuf();

	camConf.iFrameSize=aFrameSize;

	camConf.iPixelFormat=aPixelFormat;

	camConf.iFrameRate=aFrameRate;

	// Set the camera configuration.

	r=aCam.SetCamConfig(aCaptureMode,camConfBuf);

	aTest(r==KErrNone);

	aCam.GetCamConfig(aCaptureMode, camConfBuf);

	PrintCamConf(camConf,aTest);

	// Create a chunk handle and trigger the buffer creation.

	aTest.Next(_L("Setup the config - creating a chunk"));

	RChunk chunkVideo;

	TInt numBuffers=KNumVideoFramesToAllocate;

	r=aCam.SetBufConfigChunkCreate(aCaptureMode,numBuffers,chunkVideo);

	aTest(r==KErrNone);

	aTest.Next(_L("Read and display the resulting buffer config"));

	TMmSharedChunkBufConfig bufferConfig;

	TPckg<TMmSharedChunkBufConfig> bufferConfigBufVideo(bufferConfig);

	aCam.GetBufferConfig(aCaptureMode, bufferConfigBufVideo);

	PrintBufferConf(bufferConfig,aTest);

	// Request and print the camera and buffer configurations for all three capture modes

	aTest.Next(_L("Read and display the camera configs"));

	aCam.GetCamConfig(ECamCaptureModeVideo, camConfBuf);

	PrintCamConf(camConf,aTest);

	aCam.GetCamConfig(ECamCaptureModeImage, camConfBuf);

	PrintCamConf(camConf,aTest);

	aCam.GetCamConfig(ECamCaptureModeViewFinder, camConfBuf);

	PrintCamConf(camConf,aTest);

	// Create and configure a display handler

	TCamDisplayHandler dispHand;

	r=dispHand.Init();

	aTest(r==KErrNone);

	if (aPixelFormat.iPixelFormat!=EUidPixelFormatJPEG && aPixelFormat.iPixelFormat!=EUidPixelFormatSpeedTaggedJPEG)

		{

		r=dispHand.SetConfig(aFrameSize,aPixelFormat);

		aTest(r==KErrNone);

		}

	// Test that stop still returns an error.

	r=aCam.Stop();

	aTest(r==KErrGeneral);

	// Set the current capture mode

	r=aCam.SetCaptureMode(aCaptureMode);

	aTest(r==KErrNone);

	aTest.Next(_L("Start the camera in video mode"));

	r=aCam.Start();

	aTest(r==KErrNone);

	aTest.Next(_L("Issue capture requests"));

	aTest.Printf(_L("Request %d frames\r\n"),KNumVideoFramesToCapture);

	// Issue new image requests immediately. We'll have to wait while the

	// camera captures the images.

	TRequestStatus rs[KNumVideoFramesToCapture];

	TInt i;

	for (i=0 ; i<KNumVideoFramesToCapture; i++)

		{

		aTest.Printf(_L("Requesting new image... %d\n"), i);

		aCam.NotifyNewImage(rs[i]);

		aTest.Printf(_L("Requested new image... %d\n"), i);

		}

	TInt retId=-1;

	TInt retOffset=-1;

	for (i=0 ; i<KNumVideoFramesToCapture; i++)

		{

		aTest.Printf(_L("Waiting for... %d\n"), i);

		User::WaitForRequest(rs[i]);

		retId=rs[i].Int();

		aTest(retId>=0);

		aTest.Printf(_L("Getting buffer offset for... %d\n"), i);

		aCam.BufferIdToOffset(aCaptureMode,retId,retOffset);

		aTest.Printf(_L("Buffer%d(id:%d) offset: %d(%xH)\r\n"),i,retId,retOffset,retOffset);

		aTest(retOffset>=0);

		}

	TUint8* imgBase;

	// Display each image received for 333ms

	for (i=0 ; i<KNumVideoFramesToCapture; i++)

		{

		if (aPixelFormat.iPixelFormat!=EUidPixelFormatJPEG && aPixelFormat.iPixelFormat!=EUidPixelFormatSpeedTaggedJPEG)

			{

			retId=rs[i].Int();

			aTest(retId>=0);

			aCam.BufferIdToOffset(aCaptureMode,retId,retOffset);

			aTest(retOffset>=0);

			imgBase=chunkVideo.Base()+retOffset;

			r=dispHand.Process(imgBase);

#ifdef __WINSCW__

			aTest(r==KErrNotSupported);

#else

			aTest(r==KErrNone);

#endif

			User::After(333000);	// 0.33sec

			}

		}

	aTest.Next(_L("Free the buffers"));

	for (i=0 ; i<KNumVideoFramesToCapture; i++)

		{

		aTest.Printf(_L("Releasing %d(i:%d) "),rs[i].Int(), i);

		r=aCam.ReleaseBuffer(rs[i].Int());

		aTest.Printf(_L("buffer(%d), r=%d\n"),rs[i].Int(),r);

		aTest(r==KErrNone);

		}

	aTest.Next(_L("Issue more capture requests"));

	// Wait a bit more so camera has images ready as soon as we issue the requests

	User::After(500000);	// 0.5sec

	aTest.Printf(_L("Request %d frames\r\n"),KNumVideoFramesToCapture);

	for (i=0 ; i<KNumVideoFramesToCapture; i++)

		aCam.NotifyNewImage(rs[i]);

	for (i=0 ; i<KNumVideoFramesToCapture; i++)

		{

		User::WaitForRequest(rs[i]);

		retId=rs[i].Int();

		aTest(retId>=0);

		aCam.BufferIdToOffset(aCaptureMode,retId,retOffset);

		aTest.Printf(_L("Buffer%d(id:%d) offset: %d(%xH)\r\n"),i,retId,retOffset,retOffset);

		aTest(retOffset>=0);

		}

	aTest.Next(_L("Stop the camera."));

	r=aCam.Stop();

	aTest(r==KErrNone);

	aTest.Next(_L("Start it again."));

	r=aCam.Start();

	aTest(r==KErrNone);

	aTest.Next(_L("Continuously display for 10 secs"));

	RTimer tim;

	tim.CreateLocal();

	TRequestStatus timStatus;

	const TUint KTimeOut=10000000;	// 10 seconds

	tim.After(timStatus,KTimeOut);

	aTest(timStatus==KRequestPending);

	aCam.NotifyNewImage(rs[0]);

	aCam.NotifyNewImage(rs[1]);

	FOREVER

		{

		User::WaitForAnyRequest();

		if (timStatus!=KRequestPending)

			{

			aCam.NotifyNewImageCancel();

			User::WaitForRequest(rs[0]);

			User::WaitForRequest(rs[1]);

			break;

			}

		else if (rs[0]!=KRequestPending)

			{

			retId=rs[0].Int();

			aTest(retId>=0);

			aCam.BufferIdToOffset(aCaptureMode,retId,retOffset);

			aTest(retOffset>=0);

			imgBase=chunkVideo.Base()+retOffset;

			if (aPixelFormat.iPixelFormat!=EUidPixelFormatJPEG && aPixelFormat.iPixelFormat!=EUidPixelFormatSpeedTaggedJPEG)

				{

				r=dispHand.Process(imgBase);

#ifdef __WINSCW__

				aTest(r==KErrNotSupported);

#else

				aTest(r==KErrNone);

#endif

				}

			r=aCam.ReleaseBuffer(retId);

			aTest(r==KErrNone);

			aCam.NotifyNewImage(rs[0]);

			}

		else if (rs[1]!=KRequestPending)

			{

			retId=rs[1].Int();

			aTest(retId>=0);

			aCam.BufferIdToOffset(aCaptureMode,retId,retOffset);

			aTest(retOffset>=0);

			imgBase=chunkVideo.Base()+retOffset;

			if (aPixelFormat.iPixelFormat!=EUidPixelFormatJPEG && aPixelFormat.iPixelFormat!=EUidPixelFormatSpeedTaggedJPEG)

				{

				r=dispHand.Process(imgBase);

#ifdef __WINSCW__

				aTest(r==KErrNotSupported);

#else

				aTest(r==KErrNone);

#endif

				}

			r=aCam.ReleaseBuffer(retId);

			aTest(r==KErrNone);

			aCam.NotifyNewImage(rs[1]);

			}

		else

			aTest(0);

		}

	tim.Close();

	aTest.Next(_L("Stop the camera."));

	r=aCam.Stop();

	aTest(r==KErrNone);

	aTest.Next(_L("Close the chunk"));

	r=aCam.ChunkClose(aCaptureMode);

	}

LOCAL_C void DoCamImageCaptureTests(RDevCameraSc& aCam, RTest& aTest, TInt aCameraSensorIndex, const SDevCamPixelFormat& aPixelFormat, const SDevCamFrameSize& aFrameSize, TUint aFrameRate)

	{

	TInt r;

	aTest.Next(_L("IMAGE CAPTURE TESTS"));

	aTest.Printf(_L("PixelFormat = %d, FrameSize = %d x %d\n"),aPixelFormat.iPixelFormat,aFrameSize.iWidth,aFrameSize.iHeight);

	// Configure Image Capture

	TCameraConfigV02Buf camConfBuf;

	aCam.GetCamConfig(ECamCaptureModeImage, camConfBuf);

	TCameraConfigV02 &camConf=camConfBuf();

	camConf.iFrameSize=aFrameSize;

	camConf.iPixelFormat=aPixelFormat;

	camConf.iFrameRate=aFrameRate;

	// Set the camera configuration.

	r=aCam.SetCamConfig(ECamCaptureModeImage,camConfBuf);

	aTest(r==KErrNone);

	aCam.GetCamConfig(ECamCaptureModeImage, camConfBuf);

	PrintCamConf(camConf,aTest);

	// Create a chunk handle and trigger the buffer creation.

	aTest.Next(_L("Setup the config - creating a chunk"));

	RChunk chunkImage;

	TInt numBuffers=KNumVideoFramesToAllocate;

	r=aCam.SetBufConfigChunkCreate(ECamCaptureModeImage,numBuffers,chunkImage);

	aTest(r==KErrNone);

	aTest.Next(_L("Read and display the resulting buffer config"));

	TMmSharedChunkBufConfig bufferConfig;

	TPckg<TMmSharedChunkBufConfig> bufferConfigBufImage(bufferConfig);

	aCam.GetBufferConfig(ECamCaptureModeImage, bufferConfigBufImage);

	PrintBufferConf(bufferConfig,aTest);

	// Create and configure a display handler

	TCamDisplayHandler dispHand;

	r=dispHand.Init();

	aTest(r==KErrNone);

	if (aPixelFormat.iPixelFormat!=EUidPixelFormatJPEG && aPixelFormat.iPixelFormat!=EUidPixelFormatSpeedTaggedJPEG)

		{

		r=dispHand.SetConfig(aFrameSize,aPixelFormat);

		aTest(r==KErrNone);

		}

	// Test that stop still returns an error.

	r=aCam.Stop();

	aTest(r==KErrGeneral);

	// Set the current capture mode

	r=aCam.SetCaptureMode(ECamCaptureModeImage);

	aTest(r==KErrNone);

	aTest.Next(_L("Start the camera in image capture mode"));

	r=aCam.Start();

	aTest(r==KErrNone);

	aTest.Next(_L("Issue a capture request"));

	TRequestStatus rs1;

	aCam.NotifyNewImage(rs1);

	User::WaitForRequest(rs1);

	TInt retId=rs1.Int();

	TInt retOffset=-1;

	aTest(retId>=0);

	aCam.BufferIdToOffset(ECamCaptureModeImage,retId,retOffset);

	aTest.Printf(_L("Buffer offset: %d(%xH)\r\n"),retId,retOffset);

	aTest(retOffset>=0);

	TUint8* imgBase;

	imgBase=chunkImage.Base()+retOffset;

	if (aPixelFormat.iPixelFormat!=EUidPixelFormatJPEG && aPixelFormat.iPixelFormat!=EUidPixelFormatSpeedTaggedJPEG)

		{

		// Display the image received for 1s

		r=dispHand.Process(imgBase);

#ifdef __WINSCW__

        aTest(r==KErrNotSupported);

#else

        aTest(r==KErrNone);

#endif

		User::After(1000000);	// 1 sec

		}

	// Save the to do MMC card with a filename to indicate its size.  If no MMC card is present

	// then we will just display a warning rather than fail as this is an optional manual step

	TBuf<100> fileName(KSensor);

	fileName.AppendNum(aCameraSensorIndex);

	fileName.Append(KUnderscore);

	fileName.AppendFormat(KFrameSize, aFrameSize.iWidth, aFrameSize.iHeight);

	fileName.Append(KUnderscore);

	AppendPixelFormat(fileName, aPixelFormat.iPixelFormat);

	TBool wrote = ETrue;

	RBitmap bitmap;

	if ((aPixelFormat.iPixelFormat == EUidPixelFormatJPEG) || (aPixelFormat.iPixelFormat == EUidPixelFormatSpeedTaggedJPEG))

		{

		fileName.Append((aPixelFormat.iPixelFormat == EUidPixelFormatJPEG) ? KJpeg : KSpeedTaggedJpeg);

		r=bitmap.WriteBuffer(fileName, imgBase, (aFrameSize.iWidth * aFrameSize.iHeight * aPixelFormat.iPixelWidthInBytes));

		}

	else if ((aPixelFormat.iPixelFormat == EUidPixelFormatYUV_422Interleaved) || (aPixelFormat.iPixelFormat == EUidPixelFormatRGB_565))

		{

		fileName.Append(KBmp);

		r=bitmap.WriteBMP(fileName, imgBase, aPixelFormat, aFrameSize.iWidth, aFrameSize.iHeight);

		}

	else

		{

		wrote = EFalse;

		}

	if (wrote)

		{

		if (r==KErrNone)

			{

			aTest.Printf(_L("Wrote image to %S\n"),&fileName);

			}

		else

			{

			aTest.Printf(_L("Warning: Unable to write %S (error = %d)\r\n"),&fileName,r);

			}

		}

	aTest.Next(_L("Free the buffer"));

	r=aCam.ReleaseBuffer(retId);

	aTest(r==KErrNone);

	aTest.Next(_L("Issue two consecutive capture requests"));

	TRequestStatus rs2;

	aCam.NotifyNewImage(rs1);

	aCam.NotifyNewImage(rs2);

	User::WaitForRequest(rs1);

	retId=rs1.Int();

	aTest(retId>=0);

	aCam.BufferIdToOffset(ECamCaptureModeImage,retId,retOffset);

	aTest.Printf(_L("Buffer0 offset: %d(%xH)\r\n"),retOffset,retOffset);

	aTest(retOffset>=0);

	if (aPixelFormat.iPixelFormat!=EUidPixelFormatJPEG && aPixelFormat.iPixelFormat!=EUidPixelFormatSpeedTaggedJPEG)

		{

		// Display the image received for 1s

		imgBase=chunkImage.Base()+retOffset;

		r=dispHand.Process(imgBase);

#ifdef __WINSCW__

        aTest(r==KErrNotSupported);

#else

        aTest(r==KErrNone);

#endif

		User::After(1000000);	// 1 sec

		}

	r=aCam.ReleaseBuffer(retId);

	aTest(r==KErrNone);

	User::WaitForRequest(rs2);

	retId=rs2.Int();

	aTest(retId>=0);

	aCam.BufferIdToOffset(ECamCaptureModeImage,retId,retOffset);

	aTest.Printf(_L("Buffer1 offset: %d(%xH)\r\n"),retOffset,retOffset);

	aTest(retOffset>=0);

	if (aPixelFormat.iPixelFormat!=EUidPixelFormatJPEG && aPixelFormat.iPixelFormat!=EUidPixelFormatSpeedTaggedJPEG)

		{

		// Display the image received for 1s

		imgBase=chunkImage.Base()+retOffset;

		r=dispHand.Process(imgBase);

#ifdef __WINSCW__

        aTest(r==KErrNotSupported);

#else

        aTest(r==KErrNone);

#endif

		User::After(1000000);	// 1 sec

		}