cameradriver.h

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

//-----------------------------------------------------------------------------
//
// Copyright (C) 2003-2004, MOTOROLA, INC. All Rights Reserved
// THIS SOURCE CODE IS CONFIDENTIAL AND PROPRIETARY AND MAY NOT
// BE USED OR DISTRIBUTED WITHOUT THE WRITTEN PERMISSION OF
// MOTOROLA, INC.
//
//------------------------------------------------------------------------------
//
//  Copyright (C) 2004-2006, Freescale Semiconductor, Inc. All Rights Reserved.
//  THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
//  AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT
//
//------------------------------------------------------------------------------
//
//  File:  CameraDriver.h
//
//  Header file for CameraDevice class
//
//------------------------------------------------------------------------------

#include <windows.h>
#include "cs.h"
#include "Csmedia.h"
#include "CsiClass.h"
#include "PrpClass.h"

#ifndef __CAMERADRIVER_H__
#define __CAMERADRIVER_H__

//------------------------------------------------------------------------------
// Defines

/*
#ifndef DEBUG
#define DEBUG                // always turn on debug output
#endif // DEBUG

#ifdef DEBUG

#define DEBUGMASK(bit)       (1 << (bit))

#define MASK_ERROR           DEBUGMASK(0)
#define MASK_WARN            DEBUGMASK(1)
#define MASK_INIT            DEBUGMASK(2)
#define MASK_FUNCTION        DEBUGMASK(3)
#define MASK_IOCTL           DEBUGMASK(4)
#define MASK_DEVICE          DEBUGMASK(5)

#ifdef CAMINTERFACE
DBGPARAM dpCurSettings = {
    _T("CAM"), 
    {
        _T("Errors"), _T("Warnings"), _T("Init"), _T("Function"), 
        _T("Ioctl"), _T("Device"), _T("Activity"), _T(""),
        _T(""),_T(""),_T(""),_T(""),
        _T(""),_T(""),_T(""),_T("") 
    },
    ZONEMASK_ERROR | ZONEMASK_WARN | ZONEMASK_INIT | ZONEMASK_IOCTL | ZONEMASK_FUNCTION | ZONEMASK_DEVICE
}; 
#else
extern DBGPARAM dpCurSettings;
#endif // CAMINTERFACE

#define ZONE_ERROR           DEBUGZONE(0)
#define ZONE_WARN            DEBUGZONE(1)
#define ZONE_INIT            DEBUGZONE(2)
#define ZONE_FUNCTION        DEBUGZONE(3)
#define ZONE_IOCTL           DEBUGZONE(4)
#define ZONE_DEVICE          DEBUGZONE(5)

#endif // DEBUG
*/
#define CAM_FUNCTION_ENTRY() \
    DEBUGMSG(ZONE_FUNCTION, (TEXT("++%s\r\n"), __WFUNCTION__))
#define CAM_FUNCTION_EXIT() \
    DEBUGMSG(ZONE_FUNCTION, (TEXT("--%s\r\n"), __WFUNCTION__))

#define PIN_REG_PATH         L"Software\\Microsoft\\DirectX\\DirectShow\\Capture"

#define dim(x)               (sizeof(x) / sizeof(x[0]))

#define SAFEDELETE( pointer ) \
    if ( NULL != pointer )    \
    {                         \
        delete pointer;       \
        pointer = NULL;       \
    }

#define MAX_SUPPORTED_PINS        3
#define MAX_PINNAME_LENGTH        10
#define MAX_VIDEO_FORMAT          10
#define NUM_VIDEOPROCAMP_ITEMS    10
#define NUM_CAMERACONTROL_ITEMS   8
#define NUM_PROPERTY_ITEMS        NUM_VIDEOPROCAMP_ITEMS + NUM_CAMERACONTROL_ITEMS
#define NUM_FRAMERATE_ITEMS       21


//------------------------------------------------------------------------------
// Types

// zero based index of stream
enum
{
    CAPTURE = 0,
    STILL,
    PREVIEW
};

//zero based index of range
enum
{
    FRAMERATE_1000000 = 0,
    FRAMERATE_909000,
    FRAMERATE_833000,
    FRAMERATE_769000,
    FRAMERATE_714000,
    FRAMERATE_666000,
    FRAMERATE_625000,
    FRAMERATE_588000,
    FRAMERATE_556000,
    FRAMERATE_526000,
    FRAMERATE_500000,
    FRAMERATE_476000,
    FRAMERATE_455000,
    FRAMERATE_435000,
    FRAMERATE_417000,
    FRAMERATE_400000,
    FRAMERATE_385000,
    FRAMERATE_370000,
    FRAMERATE_357000,
    FRAMERATE_345000,
    FRAMERATE_333000
};

static const WCHAR g_wszPinNames[MAX_SUPPORTED_PINS][MAX_PINNAME_LENGTH] = { L"Capture"
                                                                            ,L"Still"
                                                                            ,L"Preview"
                                                                            };

static const WCHAR g_wszPinDeviceNames[MAX_SUPPORTED_PINS][MAX_PINNAME_LENGTH] = {L"PIN1:", L"PIN1:", L"PIN1:"};

typedef struct _Supported_Video_Formats
{
    GUID                categoryGUID;
    ULONG               ulAvailFormats;
    PCS_DATARANGE_VIDEO pCsDataRangeVideo[ MAX_VIDEO_FORMAT ];
} PINVIDEOFORMAT, * PPINVIDEOFORMAT;

typedef struct _Dev_Property 
{
    ULONG                     ulDefaultValue;
    ULONG                     ulCurrentValue;
    ULONG                     ulFlags;
    ULONG                     ulCapabilities;
    PCSPROPERTY_VALUES        pCsPropValues;
    PCSPROPERTY_STEPPING_LONG pRangeNStep;
    BOOL                      fGetSupported;
    BOOL                      fSetSupported;
} DEV_PROPERTY, * PDEV_PROPERTY;

typedef struct _Video_Control_Caps
{
    ULONG ulVideoControlCaps;
} VIDCONTROLCAPS, *PVIDCONTROLCAPS;

class CPinDevice;

typedef struct _StreamInstances
{
    ULONG        ulCInstances;
    CSSTATE      CsPrevState;
    CPinDevice * pPinDev;
} STREAM_INSTANCES, * PSTREAM_INSTANCES;

typedef class CCameraDevice 
{
    public:
        CCameraDevice( );

        ~CCameraDevice( );

        BOOL Initialize( PVOID context);

        BOOL BindApplicationProc(HANDLE);

        BOOL UnBindApplicationProc( );

        DWORD AdapterHandleVersion(
            PUCHAR pOutBuf,
            DWORD  OutBufLen,
            PDWORD pdwBytesTransferred
            );   

        DWORD AdapterHandlePinRequests(
            PUCHAR pInBuf,
            DWORD  InBufLen,
            PUCHAR pOutBuf,
            DWORD  OutBufLen,
            PDWORD pdwBytesTransferred
            );
     
        DWORD AdapterHandleVidProcAmpRequests(
            PUCHAR pInBuf,
            DWORD  InBufLen,
            PUCHAR pOutBuf,
            DWORD  OutBufLen,
            PDWORD pdwBytesTransferred 
            );

        DWORD AdapterHandleCamControlRequests(
            PUCHAR pInBuf,
            DWORD  InBufLen,
            PUCHAR pOutBuf,
            DWORD  OutBufLen,
            PDWORD pdwBytesTransferred
            );

        DWORD AdapterHandleCompressionRequests(
            PUCHAR pInBuf,
            DWORD  InBufLen,
            PUCHAR pOutBuf,
            DWORD  OutBufLen,
            PDWORD pdwBytesTransferred
            );

        DWORD AdapterHandleVideoControlRequests( 
            PUCHAR pInBuf , 
            DWORD InBufLen, 
            PUCHAR pOutBuf, 
            DWORD OutBufLen, 
            PDWORD pdwBytesTransferred 
            ) ;

        LONGLONG AdapterHandleVideoCtrlActFrameRateSubRequests(ULONG ulPinId);

        DWORD AdapterHandleDroppedFramesRequests(
            PUCHAR pInBuf,              // Warning: This is an unsafe buffer, access with care
            DWORD  InBufLen,
            PUCHAR pOutBuf,             // Warning: This is an unsafe buffer, access with care
            DWORD  OutBufLen,
            PDWORD pdwBytesTransferred  // Warning: This is an unsafe buffer, access with care
            );

        LPVOID ValidateBuffer(
            LPVOID  lpBuff,
            ULONG   ulActualBufLen,
            ULONG   ulExpectedBuffLen,
            DWORD * dwError
            );

        BOOL AdapterCompareFormat(
            const ULONG                 ulPinId,
            const PCS_DATARANGE_VIDEO   pCsDataRangeVideoToCompare,
            PCS_DATARANGE_VIDEO       * ppCsDataRangeVideoMatched,
            BOOL                        fDetailedComparison
            );

        BOOL AdapterCompareFormat(
            const ULONG                            ulPinId,
            const PCS_DATAFORMAT_VIDEOINFOHEADER   pCsDataRangeVideoToCompare,
            PCS_DATARANGE_VIDEO                  * ppCsDataRangeVideoMatched,
            BOOL                                   fDetailedComparison
            );

        BOOL IsValidPin(ULONG ulPinId);

        BOOL GetPinFormat(
            ULONG                 ulPinId,
            ULONG                 ulIndex,
            PCS_DATARANGE_VIDEO * ppCsDataRangeVid
            );

        BOOL IncrCInstances(ULONG ulPinId, CPinDevice * pPinDev);

        BOOL DecrCInstances(ULONG ulPinId);

        BOOL PauseCaptureAndPreview( );

        BOOL RevertCaptureAndPreviewState( );

        BOOL GetZoom(PULONG pulZoom);

        BOOL GetBrightness(PULONG pulBrightness);

        BOOL CameraConfig(UINT32 iEncPin, UINT32 iBufNum);

        BOOL CameraClosePin(UINT32 iPin);

        BOOL CameraStartEncodingChannel();

        BOOL CameraStopEncodingChannel();

        BOOL CameraStartViewfindingChannel();

        BOOL CameraStopViewfindingChannel();

        void CameraSensorZoom(DWORD);
        void CameraChangeFrameRate(DWORD);

        void CameraSetDirectDisplay(BOOL);
        void CameraSetDirectCapture(BOOL);

        void CameraMarkAsModified(ULONG);

        void SetCameraPower(CEDEVICE_POWER_STATE);
        BOOL  CameraPowerUp(BOOL);
        void  CameraPowerDown(BOOL);

        LPVOID CameraRemoteLocalAlloc(UINT uFlags, ULONG ulBytes);
        VOID CameraRemoteLocalFree(LPVOID lpData);

        PrpClass *m_pPrp;
        CsiClass *m_pCsi;

        CEDEVICE_POWER_STATE m_Dx;

        STREAM_INSTANCES m_StrmInstances[MAX_SUPPORTED_PINS];

        ULONG            m_StillPinInherited;

    private:
        void GetBasicSupportInfo(
            PUCHAR        pOutBuf,
            DWORD         OutBufLen,
            PDWORD        pdwBytesTransferred,
            PDEV_PROPERTY pDevProp,
            PDWORD        pdwError
            );

        void GetDefaultValues(
            PUCHAR pOutBuf,
            DWORD         OutBufLen,
            PDWORD        pdwBytesTransferred,
            PDEV_PROPERTY pDevProp,
            PDWORD        pdwError
            );

        BOOL AdapterCompareGUIDsAndFormatSize(
            const PCSDATARANGE DataRange1,
            const PCSDATARANGE DataRange2
            );

        BOOL CameraInit();

        void CameraDeinit();

        BOOL CameraSensorConfig();
        BOOL CameraPrpConfig(UINT32 iBufNum);

		// TODO: uncomment when structure is created
        // DisplayCharacteristics m_displayCharacteristics;

        CRITICAL_SECTION m_csDevice;        
        HANDLE           m_hStream;                        // Handle to the corresponding stream sub-device
        HANDLE           m_hCallerProcess;

        PINVIDEOFORMAT   m_PinVideoFormat[MAX_SUPPORTED_PINS];
        VIDCONTROLCAPS   m_PinVideoCaps[MAX_SUPPORTED_PINS];
        ULONG            m_ulCTypes;

        ULONG            m_ulPropSetSupported;             // Number of property item supported.
        CSPROPERTY_SET   m_VideoProcAmpSet;                // This is also the beginning of the property set table.
        CSPROPERTY_SET   m_CameraControlSet;

        BOOL             m_SensorConfigured;
        prpInputFormat   m_inFormat;                         // Input parameters, dependent on the camera sensor
        prpFrameSize     m_inFrameSize;                      // and configured one time.

        BOOL             m_bFlipVertical;
        BOOL             m_bFlipHorizontal;
        BOOL             m_bRotate;

        DWORD         m_dFrameRate;
        
        // Property items of what device supports 
        CSPROPERTY_ITEM  m_CameraControlItems[NUM_CAMERACONTROL_ITEMS];
        DEV_PROPERTY     m_DevProps[NUM_PROPERTY_ITEMS];

        // If TRUE, camera has been configured for encoding
        // or viewfinding task and may be started
        // without requiring reconfiguration.  If FALSE, camera
        // must be configured before starting.
        BOOL             m_bCameraConfig;

        // If TRUE, use hardware support to send data on PREVIEW
        // pin directly to display.  Ignored for any other pins.
        BOOL             m_bDirectDisplay;

        // If TRUE, use hardware support to send sensor data directly
        // to memory without any preprocessing.  Ignored for PREVIEW pin.
        BOOL             m_bDirectCapture;

} CAMERADEVICE, * PCAMERADEVICE;

typedef struct CCameraOpenHandle
{
    PCAMERADEVICE pCamDevice;
} CAMERAOPENHANDLE, * PCAMERAOPENHANDLE;

//------------------------------------------------------------------------------
// Functions

#endif // __CAMERADRIVER_H__