diff -r c1f20ce4abcf -r 3e88ff8f41d5 kerneltest/e32test/multimedia/t_camera_api.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/multimedia/t_camera_api.cpp Wed Sep 01 12:34:56 2010 +0100 @@ -0,0 +1,1487 @@ +// 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 +#include +#include +#include +#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 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 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 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 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=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=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=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 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 + } + + r=aCam.ReleaseBuffer(retId); + aTest(r==KErrNone); + + aTest.Next(_L("Issue four more separate capture requests")); + for (TInt i=0 ; i<4 ; i++) + { + aCam.NotifyNewImage(rs1); + User::WaitForRequest(rs1); + retId=rs1.Int(); + aTest(retId>=0); + aCam.BufferIdToOffset(ECamCaptureModeImage,retId,retOffset); + aTest.Printf(_L("Buffer%d offset: %d(%xH)\r\n"),i,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); + + aTest.Next(_L("Stop the camera.")); + r=aCam.Stop(); + aTest(r==KErrNone); + + aTest.Next(_L("Close the chunk")); + r=aCam.ChunkClose(ECamCaptureModeImage); + aTest(r==KErrNone); + } + +LOCAL_C void DoCamCancelTests(RTest& aTest, TInt aCameraSensorIndex) + { + TInt bufferSize, r; + SDevCamFrameSize* frameSizes; + TCameraConfigV02Buf camConfBuf; + + aTest.Next(_L("CAPTURE CANCEL TESTS")); + + RDevCameraSc cam; + aTest.Next(_L("Open a channel on the camera driver")); + r=cam.Open(aCameraSensorIndex); + aTest(r==KErrNone); + + TInt numBuffers=KNumVideoFramesToAllocate; + SDevCamPixelFormat* pixelFormat = (SDevCamPixelFormat*) (CameraCaps + 1); + + // Test Image Capture, if supported + if (CameraCaps->iNumImagePixelFormats) + { + // If iNumImagePixelFormats is > 0 then the matching iNumFrameSizes should also be > 0 + Test(pixelFormat->iNumFrameSizes > 0); + frameSizes = new SDevCamFrameSize[pixelFormat->iNumFrameSizes]; + Test(frameSizes != NULL); + bufferSize = (sizeof(SDevCamFrameSize) * pixelFormat->iNumFrameSizes); + TPtr8 frameSizesBuf((TUint8*) frameSizes, bufferSize, bufferSize); + r = cam.FrameSizeCaps(ECamCaptureModeImage, pixelFormat->iPixelFormat, frameSizesBuf); + Test(r == KErrNone); + + cam.GetCamConfig(ECamCaptureModeImage, camConfBuf); + + camConfBuf().iFrameSize=frameSizes[0]; + camConfBuf().iPixelFormat=*pixelFormat; + camConfBuf().iFrameRate=frameSizes[0].iMaxFrameRate; + + // Set the camera configuration. + r=cam.SetCamConfig(ECamCaptureModeImage, camConfBuf); + aTest(r==KErrNone); + cam.GetCamConfig(ECamCaptureModeImage, camConfBuf); + PrintCamConf(camConfBuf(), aTest); + + // Create a chunk handle and trigger the buffer creation. + RChunk chunkImage; + aTest.Next(_L("Setup the config - creating a chunk for image capture")); + r=cam.SetBufConfigChunkCreate(ECamCaptureModeImage,numBuffers,chunkImage); + aTest(r==KErrNone); + + aTest.Next(_L("Read and display the resulting buffer config")); + TMmSharedChunkBufConfig bufferConfig; + TPckg bufferConfigBufImage(bufferConfig); + cam.GetBufferConfig(ECamCaptureModeImage, bufferConfigBufImage); + PrintBufferConf(bufferConfig,aTest); + + // Set the current capture mode + r=cam.SetCaptureMode(ECamCaptureModeImage); + aTest(r==KErrNone); + + aTest.Next(_L("Start the camera in image capture mode.")); + r=cam.Start(); + aTest(r==KErrNone); + + TRequestStatus rs[KNumVideoFramesToCapture]; + TInt retId, retOffset; + + aTest.Next(_L("Issue a request and then cancel it")); + cam.NotifyNewImage(rs[0]); + cam.NotifyNewImageCancel(); + User::WaitForRequest(rs[0]); + retId=rs[0].Int(); + aTest(retId==KErrCancel || retId>=0); + if (retId>=0) + { + cam.BufferIdToOffset(ECamCaptureModeImage,retId,retOffset); + aTest.Printf(_L("Buffer%d : %d\r\n"),retId,retOffset); + aTest(retOffset>=0); + cam.ReleaseBuffer(retId); + } + + aTest.Next(_L("Stop the camera.")); + r=cam.Stop(); + aTest(r==KErrNone); + + aTest.Next(_L("Close the Image chunk")); + chunkImage.Close(); + + delete [] frameSizes; + } + + // Skip past the image pixel formats + pixelFormat += CameraCaps->iNumImagePixelFormats; + + // Test Video Capture, if supported + if (CameraCaps->iNumVideoPixelFormats) + { + // If iNumVideoPixelFormats is > 0 then the matching iNumFrameSizes should also be > 0 + Test(pixelFormat->iNumFrameSizes > 0); + frameSizes = new SDevCamFrameSize[pixelFormat->iNumFrameSizes]; + Test(frameSizes != NULL); + bufferSize = (sizeof(SDevCamFrameSize) * pixelFormat->iNumFrameSizes); + TPtr8 frameSizesBuf((TUint8*) frameSizes, bufferSize, bufferSize); + r = cam.FrameSizeCaps(ECamCaptureModeImage, pixelFormat->iPixelFormat, frameSizesBuf); + Test(r == KErrNone); + + cam.GetCamConfig(ECamCaptureModeVideo, camConfBuf); + + camConfBuf().iFrameSize=frameSizes[0]; + camConfBuf().iPixelFormat=*pixelFormat; + camConfBuf().iFrameRate=frameSizes[0].iMaxFrameRate; + + // Set the camera configuration. + r=cam.SetCamConfig(ECamCaptureModeVideo, camConfBuf); + aTest(r==KErrNone); + cam.GetCamConfig(ECamCaptureModeVideo, camConfBuf); + PrintCamConf(camConfBuf(), aTest); + + // Create a chunk handle and trigger the buffer creation. + RChunk chunkVideo; + aTest.Next(_L("Setup the config - creating a chunk for video capture")); + r=cam.SetBufConfigChunkCreate(ECamCaptureModeVideo,numBuffers,chunkVideo); + aTest(r==KErrNone); + + aTest.Next(_L("Read and display the resulting buffer config")); + TMmSharedChunkBufConfig bufferConfig; + TPckg bufferConfigBufVideo(bufferConfig); + cam.GetBufferConfig(ECamCaptureModeVideo, bufferConfigBufVideo); + PrintBufferConf(bufferConfig,aTest); + + // Set the current capture mode + r=cam.SetCaptureMode(ECamCaptureModeVideo); + aTest(r==KErrNone); + + aTest.Next(_L("Start the camera in video mode")); + r=cam.Start(); + aTest(r==KErrNone); + + aTest.Next(_L("Issue capture requests and globally cancel them all")); + aTest.Printf(_L("Request %d frames\r\n"),KNumVideoFramesToCapture); + TRequestStatus rs[KNumVideoFramesToCapture]; + TInt i; + for (i=0 ; i=0); + if (retId>=0) + { + cam.BufferIdToOffset(ECamCaptureModeVideo,retId,retOffset); + aTest.Printf(_L("Buffer%d : %d\r\n"),retId,retOffset); + aTest(retOffset>=0); + cam.ReleaseBuffer(retId); + } + } + + aTest.Next(_L("Issue capture requests and individually cancel them all")); + aTest.Printf(_L("Request %d frames\r\n"),KNumVideoFramesToCapture); + + for (i=0 ; i=0); + if (retId>=0) + { + cam.BufferIdToOffset(ECamCaptureModeVideo,retId,retOffset); + aTest.Printf(_L("Buffer%d : %d\r\n"),retId,retOffset); + aTest(retOffset>=0); + cam.ReleaseBuffer(retId); + } + } + + aTest.Next(_L("Stop the camera.")); + r=cam.Stop(); + aTest(r==KErrNone); + + aTest.Next(_L("Close the Video chunk")); + chunkVideo.Close(); + + delete [] frameSizes; + } + + // Skip past the video pixel formats + pixelFormat += CameraCaps->iNumVideoPixelFormats; + + // Test Viewfinder Capture, if supported + if (CameraCaps->iNumViewFinderPixelFormats) + { + // If iNumViewFinderPixelFormats is > 0 then the matching iNumFrameSizes should also be > 0 + Test(pixelFormat->iNumFrameSizes > 0); + frameSizes = new SDevCamFrameSize[pixelFormat->iNumFrameSizes]; + Test(frameSizes != NULL); + bufferSize = (sizeof(SDevCamFrameSize) * pixelFormat->iNumFrameSizes); + TPtr8 frameSizesBuf((TUint8*) frameSizes, bufferSize, bufferSize); + r = cam.FrameSizeCaps(ECamCaptureModeViewFinder, pixelFormat->iPixelFormat, frameSizesBuf); + Test(r == KErrNone); + + cam.GetCamConfig(ECamCaptureModeViewFinder, camConfBuf); + + camConfBuf().iFrameSize=frameSizes[0]; + camConfBuf().iPixelFormat=*pixelFormat; + camConfBuf().iFrameRate=frameSizes[0].iMaxFrameRate; + + // Set the camera configuration. + r=cam.SetCamConfig(ECamCaptureModeViewFinder, camConfBuf); + aTest(r==KErrNone); + cam.GetCamConfig(ECamCaptureModeViewFinder, camConfBuf); + PrintCamConf(camConfBuf(), aTest); + + // Create a chunk handle and trigger the buffer creation. + RChunk chunkViewFinder; + aTest.Next(_L("Setup the config - creating a chunk for viewfinder capture")); + r=cam.SetBufConfigChunkCreate(ECamCaptureModeViewFinder,numBuffers,chunkViewFinder); + aTest(r==KErrNone); + + aTest.Next(_L("Read and display the resulting buffer config")); + TMmSharedChunkBufConfig bufferConfig; + TPckg bufferConfigBufViewFinder(bufferConfig); + cam.GetBufferConfig(ECamCaptureModeViewFinder, bufferConfigBufViewFinder); + PrintBufferConf(bufferConfig,aTest); + + aTest.Next(_L("Close the Viewfinder chunk")); + chunkViewFinder.Close(); + + delete [] frameSizes; + } + + aTest.Next(_L("Close the drivers")); + cam.Close(); + } + +void CameraTests(TInt aCameraSensorIndex) + { + TUint index, size; + Test.Printf(_L("Testing unit number: %d\r\n"),aCameraSensorIndex); + + // Perform some basic opening and multithreaded tests. We don't want just in time debugging during + // these tests + TBool justInTime=User::JustInTime(); + User::SetJustInTime(EFalse); + DoCamOpenCapTests(Test,aCameraSensorIndex); + User::SetJustInTime(justInTime); + + // Test request handling + DoCamCancelTests(Test, aCameraSensorIndex); + + // Re-open the camera driver for use below and to ensure that it can deal with being re-opened (it + // has already been opened and closed by DoCamOpenCapTests()) + RDevCameraSc cam; + Test.Next(_L("Open a channel on the camera driver")); + TInt r=cam.Open(aCameraSensorIndex); + Test(r==KErrNone); + + // Test Dynamic Settings, e.g. Brightness, Contrast, etc. + DoCamDynamicSettingsTests(cam, Test); + + // Go through all supported image, video and viewfinder pixel formats and perform configuration + // and capture tests on them all, for all supported frame sizes and frame rates + TInt bufferSize; + SDevCamFrameSize* frameSizes; + TBool imageConfigTestsDone=EFalse, videoConfigTestsDone=EFalse, viewFinderConfigTestsDone=EFalse; + SDevCamPixelFormat* pixelFormat = (SDevCamPixelFormat*) (CameraCaps + 1); + + for (index = 0; index < CameraCaps->iNumImagePixelFormats; ++index) + { + // If iNumImagePixelFormats is > 0 then the matching iNumFrameSizes should also be > 0 + Test(pixelFormat->iNumFrameSizes > 0); + Test.Printf(_L("Image pixel format %x, number of frame sizes = %d\n"), pixelFormat->iPixelFormat, pixelFormat->iNumFrameSizes); + frameSizes=new SDevCamFrameSize[pixelFormat->iNumFrameSizes]; + Test(frameSizes!=NULL); + bufferSize=(sizeof(SDevCamFrameSize) * pixelFormat->iNumFrameSizes); + TPtr8 frameSizesBuf((TUint8*) frameSizes, bufferSize, bufferSize); + r = cam.FrameSizeCaps(ECamCaptureModeImage, pixelFormat->iPixelFormat, frameSizesBuf); + Test(r == KErrNone); + + // Test camera configuration for image capture. This is only done once for the sake of + // test expediency + if (!imageConfigTestsDone) + { + imageConfigTestsDone = ETrue; + DoCamConfigTests(cam, Test, ECamCaptureModeImage, *pixelFormat, frameSizes[0]); + } + + // Test image capture mode + for (size = 0; size < pixelFormat->iNumFrameSizes; ++size) + { + DoCamImageCaptureTests(cam, Test, aCameraSensorIndex, *pixelFormat, frameSizes[size], frameSizes[size].iMaxFrameRate); + } + + // Test buffer offset + for (size = 0; size < pixelFormat->iNumFrameSizes; ++size) + { + DoCamBufferOffsetTests(cam, Test, *pixelFormat, frameSizes[size], frameSizes[size].iMaxFrameRate); + } + + delete [] frameSizes; + ++pixelFormat; + } + + for (index = 0; index < CameraCaps->iNumVideoPixelFormats; ++index) + { + // If iNumVideoPixelFormats is > 0 then the matching iNumFrameSizes should also be > 0 + Test(pixelFormat->iNumFrameSizes > 0); + Test.Printf(_L("Video pixel format %x, number of frame sizes = %d\n"), pixelFormat->iPixelFormat, pixelFormat->iNumFrameSizes); + frameSizes=new SDevCamFrameSize[pixelFormat->iNumFrameSizes]; + Test(frameSizes!=NULL); + bufferSize=(sizeof(SDevCamFrameSize) * pixelFormat->iNumFrameSizes); + TPtr8 frameSizesBuf((TUint8*) frameSizes, bufferSize, bufferSize); + r = cam.FrameSizeCaps(ECamCaptureModeVideo, pixelFormat->iPixelFormat, frameSizesBuf); + Test(r == KErrNone); + + // Test camera configuration for video capture. This is only done once for the sake of + // test expediency + if (!videoConfigTestsDone) + { + videoConfigTestsDone=ETrue; + DoCamConfigTests(cam, Test, ECamCaptureModeVideo, *pixelFormat, frameSizes[0]); + } + + // Test video capture mode + for (size = 0; size < pixelFormat->iNumFrameSizes; ++size) + { + DoCamVideoCaptureTests(cam, Test, ECamCaptureModeVideo, *pixelFormat,frameSizes[size], frameSizes[size].iMaxFrameRate); + } + delete [] frameSizes; + ++pixelFormat; + } + + for (index = 0; index < CameraCaps->iNumViewFinderPixelFormats; ++index) + { + // If iNumViewFinderPixelFormats is > 0 then the matching iNumFrameSizes should also be > 0 + Test(pixelFormat->iNumFrameSizes > 0); + Test.Printf(_L("Viewfinder pixel format %x, number of frame sizes = %d\n"), pixelFormat->iPixelFormat, pixelFormat->iNumFrameSizes); + frameSizes=new SDevCamFrameSize[pixelFormat->iNumFrameSizes]; + Test(frameSizes!=NULL); + bufferSize=(sizeof(SDevCamFrameSize) * pixelFormat->iNumFrameSizes); + TPtr8 frameSizesBuf((TUint8*) frameSizes, bufferSize, bufferSize); + r = cam.FrameSizeCaps(ECamCaptureModeViewFinder, pixelFormat->iPixelFormat, frameSizesBuf); + Test(r == KErrNone); + + // Test camera configuration for view finder capture. This is only done once for the sake of + // test expediency + if (!viewFinderConfigTestsDone) + { + viewFinderConfigTestsDone=ETrue; + DoCamConfigTests(cam, Test, ECamCaptureModeViewFinder, *pixelFormat, frameSizes[0]); + } + + // Test view finder capture mode + for (size = 0; size < pixelFormat->iNumFrameSizes; ++size) + { + DoCamVideoCaptureTests(cam, Test, ECamCaptureModeViewFinder, *pixelFormat, frameSizes[size], frameSizes[size].iMaxFrameRate); + } + delete [] frameSizes; + ++pixelFormat; + } + cam.Close(); + + // And free the global capabilities buffer that was allocated in DoCamOpenCapTests() + User::Free(CapsBufPtr); + } + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + + Test.Title(); + Test.Start(_L("Camera module API test")); + + Test.Next(_L("Loading CAMERA PDD")); + TInt r=User::LoadPhysicalDevice(KCamPddFileName); + Test.Printf(_L("Returned %d\r\n"),r); + + if (r==KErrNotFound) + { + Test.Printf(_L("Shared chunk camera driver not supported - test skipped\r\n")); + Test.End(); + Test.Close(); + __UHEAP_MARKEND; + return(KErrNone); + } + + Test(r==KErrNone || r==KErrAlreadyExists); + + Test.Next(_L("Loading CAMERA LDD")); + r=User::LoadLogicalDevice(KCamLddFileName); + Test.Printf(_L("Returned %d\r\n"),r); + Test(r==KErrNone || r==KErrAlreadyExists); + + Test.Next(_L("Loading D_MMCSC LDD")); + r=User::LoadLogicalDevice(KTstLddFileName); + Test.Printf(_L("Returned %d\r\n"),r); + Test(r==KErrNone||r==KErrAlreadyExists); + + __KHEAP_MARK; + + if (User::CommandLineLength()>0) + { + TBuf<0x100> cmd; + TInt moduleIndex = KUnit0; + User::CommandLine(cmd); + Test(cmd.Length()>0); + if (cmd[0]>='0' && cmd[0]<='9') + moduleIndex=(TInt)(cmd[0]-'0'); + CameraTests(moduleIndex); + } + else // If no command line arguments are passed we perform tests on the module 0 and 1 + { + CameraTests(0); + } + + __KHEAP_MARKEND; + + // Free the PDDs and LDDs + Test.Next(_L("Freeing ECAMERASC LDD")); + r=User::FreeLogicalDevice(KDevCameraScName); + Test(r==KErrNone); + + Test.Next(_L("Freeing CAMERASC PDD")); + TFindPhysicalDevice fDr; + TFullName drivName; + TName searchName; + searchName.Append(KDevCameraScName); + searchName.Append(KCamFreePddExtension); + fDr.Find(searchName); + r=fDr.Next(drivName); + Test(r==KErrNone); + r=User::FreePhysicalDevice(drivName); + Test(r==KErrNone); + + Test.Next(_L("Freeing D_MMCSC LDD")); + r=User::FreeLogicalDevice(KDevMmCScName); + Test(r==KErrNone); + + Test.End(); + Test.Close(); + + __UHEAP_MARKEND; + return(KErrNone); + }