--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/examples/camera1/camera1.h Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,304 @@
+// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// in its implementation.
+//
+//
+
+/**
+ @file The interface to an example camera device driver which uses Shared Chunks
+ @publishedPartner
+ @prototype 9.1
+*/
+
+#ifndef __CAMERA1_H__
+#define __CAMERA1_H__
+
+#include <e32cmn.h>
+#include <e32ver.h>
+#ifndef __KERNEL_MODE__
+#include <e32std.h>
+#endif
+
+/**
+User interface for 'Camera1'
+*/
+class RCamera1 : public RBusLogicalChannel
+ {
+public:
+ /**
+ Structure for holding driver capabilities information
+ (Just a version number in this example.)
+ */
+ class TCaps
+ {
+ public:
+ TVersion iVersion;
+ };
+
+ /**
+ Structure for holding driver configuration data
+ */
+ class TConfig
+ {
+ public:
+ TSize iImageSize; /**< Size of image in pixels */
+ TInt iImageBytesPerPixel; /**< Number of bytes used to represent a single pixel */
+ TInt iFrameRate; /**< Speed to capture images at in frames per second*/
+ TInt iNumImageBuffers; /**< Number of simultanious images the client wishes to process */
+ };
+ typedef TPckgBuf<TConfig> TConfigBuf;
+
+#ifndef __KERNEL_MODE__
+public:
+ TInt Open();
+ void Close();
+ TInt GetConfig(TConfigBuf& aConfig);
+ TInt SetConfig(const TConfigBuf& aConfig);
+ TInt StartCapture();
+ TInt EndCapture();
+ void CaptureImage(TRequestStatus& aStatus, TInt aReleaseImage=-1);
+ void CaptureImageCancel();
+ TInt ReleaseImage(TInt aReleaseImage);
+ TInt Duplicate(const RThread& aSrc,TOwnerType aType=EOwnerProcess);
+ inline RChunk ImageChunk() const;
+private:
+ RChunk iChunk; /**< The chunk into which captured images will be placed */
+#endif
+
+public:
+ inline static const TDesC& Name();
+ inline static TVersion VersionRequired();
+
+private:
+ /**
+ Enumeration of Control messages.
+ */
+ enum TControl
+ {
+ EGetConfig,
+ ESetConfig,
+ EStartCapture,
+ EEndCapture,
+ ECaptureImage,
+ EReleaseImage
+ };
+
+ /**
+ Enumeration of Request messages.
+ (None used in this example)
+ */
+ enum TRequest
+ {
+ ENumRequests,
+ EAllRequests = (1<<ENumRequests)-1
+ };
+
+ // Kernel side LDD channel is a friend
+ friend class DCamera1Channel;
+ };
+
+/**
+ The driver's name
+
+ @return The name of the driver
+
+ @internalComponent
+*/
+inline const TDesC& RCamera1::Name()
+ {
+ _LIT(KCamera1Name,"CAMERA1");
+ return KCamera1Name;
+ }
+
+/**
+ The driver's version
+
+ @return The version number of the driver
+
+ @internalComponent
+*/
+inline TVersion RCamera1::VersionRequired()
+ {
+ const TInt KMajorVersionNumber=1;
+ const TInt KMinorVersionNumber=0;
+ const TInt KBuildVersionNumber=KE32BuildVersionNumber;
+ return TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
+ }
+
+/*
+ NOTE: The following methods would normally be exported from a seperate client DLL
+ but are included inline in this header file for convenience.
+*/
+
+#ifndef __KERNEL_MODE__
+
+/**
+ Open a logical channel to the driver
+
+ @return One of the system wide error codes.
+*/
+TInt RCamera1::Open()
+ {
+ return DoCreate(Name(),VersionRequired(),KNullUnit,NULL,NULL,EOwnerProcess);
+ }
+
+/**
+ Close a logical channel to the driver
+*/
+void RCamera1::Close()
+ {
+ iChunk.Close();
+ RBusLogicalChannel::Close();
+ }
+
+/**
+ Get the current configuration settings.
+
+ @param aConfig A structure which will be filled with the configuration settings.
+
+ @return KErrNone
+*/
+TInt RCamera1::GetConfig(TConfigBuf& aConfig)
+ {
+ return DoControl(EGetConfig,(TAny*)&aConfig);
+ }
+
+/**
+ Set the current configuration settings.
+
+ @param aConfig The new configuration settings to be used.
+
+ @return KErrInUse if image capturing is already in progress
+ KErrArgument if any configuration values are invalid.
+ KErrNone otherwise
+
+ @post On success, iChunk will contain the handle of the chunk used to
+ contain captured images.
+*/
+TInt RCamera1::SetConfig(const TConfigBuf& aConfig)
+ {
+ iChunk.Close(); // The following call will give us a new handle
+ return iChunk.SetReturnedHandle(DoControl(ESetConfig,(TAny*)&aConfig));
+ }
+
+/**
+ Start the image capture process.
+
+ @return KErrNotReady if SetConfig() has not been previously called.
+ KErrNone otherwise.
+
+ @pre The driver must have been previousely initialised by a call to SetConfig()
+*/
+TInt RCamera1::StartCapture()
+ {
+ return DoControl(EStartCapture);
+ }
+
+/**
+ End the image capturing process.
+ Also performs CaptureImageCancel()
+*/
+TInt RCamera1::EndCapture()
+ {
+ return DoControl(EEndCapture);
+ }
+
+/**
+ Get the next available image and optionally release an already captured image.
+ Only one request may be pending at any time.
+
+ @param aStatus The request status signaled when an image is available (or on error).
+ The result value is the offset within iChunk where the capture image resides;
+ or set to one of the system wide error codes when an error occurs:
+ KErrNotReady if StartCapture() hasn't been previousely called,
+ KErrInUse if there is already a pending CaptureImage() request,
+ KErrOverflow if the client already has all the images buffers.
+
+ @param aReleaseImage The chunk offset of an image which the client has finished processing.
+ Set to -1 to indicate 'no image'
+
+ @pre Image capturing must have been started with StartCapture()
+*/
+void RCamera1::CaptureImage(TRequestStatus& aStatus,TInt aReleaseImage)
+ {
+ aStatus=KRequestPending;
+ DoControl(ECaptureImage,(TAny*)&aStatus,(TAny*)aReleaseImage);
+ }
+
+/**
+ Cancel a previous CaptureImage() request
+*/
+void RCamera1::CaptureImageCancel()
+ {
+ DoCancel(1<<ECaptureImage);
+ }
+
+/**
+ Release an already captured image.
+
+ This makes the images buffer available again for the driver to capture images into.
+
+ @param aReleaseImage The chunk offset of the image to be released.
+ This is a value returned by a CaptureImage() request.
+*/
+TInt RCamera1::ReleaseImage(TInt aReleaseImage)
+ {
+ return DoControl(EReleaseImage,(TAny*)aReleaseImage);
+ }
+
+/**
+ Override of RHandleBase::Duplicate.
+ This takes care of also duplicating other resources owned by this object.
+ @param aSrc A reference to the thread containing the handle which is to be
+ duplicated for this thread.
+ @param aType An enumeration whose enumerators define the ownership of this
+ handle. If not explicitly specified, EOwnerProcess is taken
+ as default.
+ @return KErrNone, if successful; otherwise, one of the other system wide error
+ codes.
+ @see RHandleBase::Duplicate
+*/
+TInt RCamera1::Duplicate(const RThread& aSrc,TOwnerType aType)
+ {
+ // Duplicate handle to channel
+ TInt r=RHandleBase::Duplicate(aSrc,aType);
+ if(r==KErrNone && iChunk.Handle()!=KNullHandle)
+ {
+ // Duplicate handle to chunk
+ r = iChunk.Duplicate(aSrc,aType);
+ if(r!=KErrNone)
+ RHandleBase::Close(); // Undo channel open
+ }
+ if(r!=KErrNone)
+ iChunk.SetHandle(KNullHandle); // On error, clear chunk handle
+ return r;
+ }
+
+/**
+ Obtain the chunk into which captured images will be placed.
+ This chunk may change after calls to SetConfig().
+
+ @return The chunk
+
+ @pre The driver must have been configured using SetConfig()
+*/
+inline RChunk RCamera1::ImageChunk() const
+ {
+ return iChunk;
+ }
+
+#endif // !__KERNEL_MODE__
+
+#endif
+