// 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"));