cameradevice.cpp

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:  CameraDevice.cpp
//
//  CameraDevice Class Implementation 
//
//------------------------------------------------------------------------------

#include <windows.h>
#include <ceddk.h>

#include "csp.h"
#include "CsiClass.h"
#include "Prp.h"
#include "PrpClass.h"
#include "camera.h"
#include "cameradbg.h"
#include "CameraDriver.h"
#include "PinDriver.h"

#include "CameraProps.h"


//------------------------------------------------------------------------------
// External Functions
extern void BSPGetSensorFormat(DWORD *);
extern void BSPGetSensorResolution(DWORD *);
extern BOOL BSPCameraMemCpy(LPVOID pDst, LPCVOID pSrc, DWORD cbSize);
extern BOOL BSPCameraIsTVin(void);

//------------------------------------------------------------------------------
// External Variables


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


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


//------------------------------------------------------------------------------
// Global Variables


//------------------------------------------------------------------------------
// Local Variables


//------------------------------------------------------------------------------
// Local Functions


BOOL
ConvertStringToGuid(
    LPCTSTR   GuidString,
    GUID    * Guid
    )
{
    // ConvertStringToGuid
    // this routine converts a string into a GUID and returns TRUE if the
    // conversion was successful.

    // Local variables.
    UINT Data4[8];
    int  Count;
    BOOL Ok = FALSE;
    LPWSTR GuidFormat = L"{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}";

    DEBUGCHK(Guid != NULL && GuidString != NULL);

    __try
    {
        if (_stscanf(GuidString, GuidFormat, &Guid->Data1,
             &Guid->Data2, &Guid->Data3, &Data4[0], &Data4[1], &Data4[2], &Data4[3],
             &Data4[4], &Data4[5], &Data4[6], &Data4[7]) == 11)
        {
            for (Count = 0; Count < (sizeof(Data4) / sizeof(Data4[0])); Count++)
            {
                Guid->Data4[Count] = (UCHAR) Data4[Count];
            }
        }

        Ok = TRUE;
    }
    __except(EXCEPTION_EXECUTE_HANDLER)
    {
    }

    return Ok;
}


//------------------------------------------------------------------------------
//
// Function: CCameraDevice
//
// CCameraDevice constructor.
//
// Parameters:
//      None.
//
// Returns:
//      None.
//
//------------------------------------------------------------------------------
CCameraDevice::CCameraDevice()
{
    m_hStream = NULL;
    m_hCallerProcess = NULL;
    
    InitializeCriticalSection(&m_csDevice);
    
    m_ulCTypes = 0;
    memset(m_StrmInstances, 0x0, sizeof(STREAM_INSTANCES)*MAX_SUPPORTED_PINS);
    memset(m_DevProps, 0x0, sizeof(DEV_PROPERTY)* NUM_PROPERTY_ITEMS);

    m_pCsi = NULL;
    m_pPrp = NULL;
    m_bCameraConfig = FALSE;

    m_bDirectDisplay = FALSE;
    m_bDirectCapture = FALSE;

    m_SensorConfigured = FALSE;
    m_inFormat = prpInputFormat_RGB16;
    m_inFrameSize.height = 0;
    m_inFrameSize.width = 0;

    m_bFlipVertical = FALSE;
    m_bFlipHorizontal = FALSE;
    m_bRotate = FALSE;

    m_dFrameRate = FRAMERATE_666000;

    m_StillPinInherited = STILL;

    m_Dx = D4;     // intialize camera power management

}


//------------------------------------------------------------------------------
//
// Function: ~CCameraDevice
//
// CCameraDevice destructor.
//
// Parameters:
//      None.
//
// Returns:
//      None.
//
//------------------------------------------------------------------------------
CCameraDevice::~CCameraDevice()
{
    if ( NULL != m_hStream )
    {
        DeactivateDevice( m_hStream );
    }
    DeleteCriticalSection(&m_csDevice);

    CameraDeinit();

    if (NULL != m_hStream)
    {
        DeactivateDevice(m_hStream);
    }

    if (m_pPrp != NULL)
    {
        if (!VirtualFree((void*)m_pPrp, 0, MEM_RELEASE))
        {
            DEBUGMSG(ZONE_ERROR, (TEXT("%s : m_pPrp Deallocation failed\r\n"), __WFUNCTION__));
        }
        m_pPrp = NULL;
    }

    if (m_pCsi != NULL)
    {
        if (!VirtualFree((void*)m_pCsi, 0, MEM_RELEASE))
        {
            DEBUGMSG(ZONE_ERROR, (TEXT("$s : m_pCsi Deallocation failed\r\n"), __WFUNCTION__));
        }
        m_pCsi = NULL;
    }
}

//------------------------------------------------------------------------------
//
// Function: Initialize
//
// CCameraDevice initializer.
//
// Parameters:
//      context
//          [in] Device context.
//
// Returns:
//      TRUE if initialization is successful, otherwise return FALSE.
//
//------------------------------------------------------------------------------
BOOL CCameraDevice::Initialize(PVOID context)
{
    CAM_FUNCTION_ENTRY();
    
    m_hStream = ActivateDeviceEx( PIN_REG_PATH, 0, 0, reinterpret_cast<LPVOID>( this ) );
    DEBUGMSG( ZONE_INIT, ( _T("Initialize: getlasterror is %d.\r\n"), GetLastError()));

    if ( NULL == m_hStream )
    {
        DEBUGMSG(ZONE_INIT|ZONE_ERROR, (_T("%s: ActivateDevice on Pin failed\r\n"), __WFUNCTION__));

        return FALSE;
    }

    DEBUGMSG(ZONE_INIT, (_T("%s: ActivateDevice on Pin OK\r\n"), __WFUNCTION__));

    m_ulCTypes = 3;

    //VideoProcAmp
    m_DevProps[ENUM_BRIGHTNESS].ulCurrentValue     = BrightnessDefault;
    m_DevProps[ENUM_BRIGHTNESS].ulDefaultValue     = BrightnessDefault;
    m_DevProps[ENUM_BRIGHTNESS].pRangeNStep        = &BrightnessRangeAndStep[0];
    m_DevProps[ENUM_BRIGHTNESS].ulFlags            = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;
    m_DevProps[ENUM_BRIGHTNESS].ulCapabilities     = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL|CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_BRIGHTNESS].fSetSupported      = VideoProcAmpProperties[ENUM_BRIGHTNESS].SetSupported;
    m_DevProps[ENUM_BRIGHTNESS].fGetSupported      = VideoProcAmpProperties[ENUM_BRIGHTNESS].GetSupported;
    m_DevProps[ENUM_BRIGHTNESS].pCsPropValues      = &BrightnessValues;

    m_DevProps[ENUM_CONTRAST].ulCurrentValue       = ContrastDefault;
    m_DevProps[ENUM_CONTRAST].ulDefaultValue       = ContrastDefault;
    m_DevProps[ENUM_CONTRAST].pRangeNStep          = &ContrastRangeAndStep[0];
    m_DevProps[ENUM_CONTRAST].ulFlags              = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;
    m_DevProps[ENUM_CONTRAST].ulCapabilities       = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL|CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_CONTRAST].fSetSupported        = VideoProcAmpProperties[ENUM_CONTRAST].SetSupported;
    m_DevProps[ENUM_CONTRAST].fGetSupported        = VideoProcAmpProperties[ENUM_CONTRAST].GetSupported;
    m_DevProps[ENUM_CONTRAST].pCsPropValues        = &ContrastValues;

    m_DevProps[ENUM_HUE].ulCurrentValue            = HueDefault;
    m_DevProps[ENUM_HUE].ulDefaultValue            = HueDefault;
    m_DevProps[ENUM_HUE].pRangeNStep               = &HueRangeAndStep[0];
    m_DevProps[ENUM_HUE].ulFlags                   = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_HUE].ulCapabilities            = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_HUE].fSetSupported             = VideoProcAmpProperties[ENUM_HUE].SetSupported;
    m_DevProps[ENUM_HUE].fGetSupported             = VideoProcAmpProperties[ENUM_HUE].GetSupported;
    m_DevProps[ENUM_HUE].pCsPropValues             = &HueValues;

    m_DevProps[ENUM_SATURATION].ulCurrentValue     = SaturationDefault;
    m_DevProps[ENUM_SATURATION].ulDefaultValue     = SaturationDefault;
    m_DevProps[ENUM_SATURATION].pRangeNStep        = &SaturationRangeAndStep[0];
    m_DevProps[ENUM_SATURATION].ulFlags            = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_SATURATION].ulCapabilities     = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL|CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_SATURATION].fSetSupported      = VideoProcAmpProperties[ENUM_SATURATION].SetSupported;
    m_DevProps[ENUM_SATURATION].fGetSupported      = VideoProcAmpProperties[ENUM_SATURATION].GetSupported;
    m_DevProps[ENUM_SATURATION].pCsPropValues      = &SaturationValues;

    m_DevProps[ENUM_SHARPNESS].ulCurrentValue      = SharpnessDefault;
    m_DevProps[ENUM_SHARPNESS].ulDefaultValue      = SharpnessDefault;
    m_DevProps[ENUM_SHARPNESS].pRangeNStep         = &SharpnessRangeAndStep[0];
    m_DevProps[ENUM_SHARPNESS].ulFlags             = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_SHARPNESS].ulCapabilities      = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_SHARPNESS].fSetSupported       = VideoProcAmpProperties[ENUM_SHARPNESS].SetSupported;
    m_DevProps[ENUM_SHARPNESS].fGetSupported       = VideoProcAmpProperties[ENUM_SHARPNESS].GetSupported;
    m_DevProps[ENUM_SHARPNESS].pCsPropValues       = &SharpnessValues;

    m_DevProps[ENUM_GAMMA].ulCurrentValue          = GammaDefault;
    m_DevProps[ENUM_GAMMA].ulDefaultValue          = GammaDefault;
    m_DevProps[ENUM_GAMMA].pRangeNStep             = &GammaRangeAndStep[0];
    m_DevProps[ENUM_GAMMA].ulFlags                 = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_GAMMA].ulCapabilities          = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_GAMMA].fSetSupported           = VideoProcAmpProperties[ENUM_GAMMA].SetSupported;
    m_DevProps[ENUM_GAMMA].fGetSupported           = VideoProcAmpProperties[ENUM_GAMMA].GetSupported;
    m_DevProps[ENUM_GAMMA].pCsPropValues           = &GammaValues;

    m_DevProps[ENUM_COLORENABLE].ulCurrentValue    = ColorEnableDefault;
    m_DevProps[ENUM_COLORENABLE].ulDefaultValue    = ColorEnableDefault;
    m_DevProps[ENUM_COLORENABLE].pRangeNStep       = &ColorEnableRangeAndStep[0];
    m_DevProps[ENUM_COLORENABLE].ulFlags           = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_COLORENABLE].ulCapabilities    = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL|CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_COLORENABLE].fSetSupported     = VideoProcAmpProperties[ENUM_COLORENABLE].SetSupported;
    m_DevProps[ENUM_COLORENABLE].fGetSupported     = VideoProcAmpProperties[ENUM_COLORENABLE].GetSupported;
    m_DevProps[ENUM_COLORENABLE].pCsPropValues     = &ColorEnableValues;

    m_DevProps[ENUM_WHITEBALANCE].ulCurrentValue   = WhiteBalanceDefault;
    m_DevProps[ENUM_WHITEBALANCE].ulDefaultValue   = WhiteBalanceDefault;
    m_DevProps[ENUM_WHITEBALANCE].pRangeNStep      = &WhiteBalanceRangeAndStep[0];
    m_DevProps[ENUM_WHITEBALANCE].ulFlags          = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_WHITEBALANCE].ulCapabilities   = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_WHITEBALANCE].fSetSupported    = VideoProcAmpProperties[ENUM_WHITEBALANCE].SetSupported;
    m_DevProps[ENUM_WHITEBALANCE].fGetSupported    = VideoProcAmpProperties[ENUM_WHITEBALANCE].GetSupported;
    m_DevProps[ENUM_WHITEBALANCE].pCsPropValues    = &WhiteBalanceValues;

    m_DevProps[ENUM_BACKLIGHT_COMPENSATION].ulCurrentValue = BackLightCompensationDefault;
    m_DevProps[ENUM_BACKLIGHT_COMPENSATION].ulDefaultValue = BackLightCompensationDefault;
    m_DevProps[ENUM_BACKLIGHT_COMPENSATION].pRangeNStep    = &BackLightCompensationRangeAndStep[0];
    m_DevProps[ENUM_BACKLIGHT_COMPENSATION].ulFlags        = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_BACKLIGHT_COMPENSATION].ulCapabilities = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_BACKLIGHT_COMPENSATION].fSetSupported  = VideoProcAmpProperties[ENUM_BACKLIGHT_COMPENSATION].SetSupported;
    m_DevProps[ENUM_BACKLIGHT_COMPENSATION].fGetSupported  = VideoProcAmpProperties[ENUM_BACKLIGHT_COMPENSATION].GetSupported;
    m_DevProps[ENUM_BACKLIGHT_COMPENSATION].pCsPropValues  = &BackLightCompensationValues;

    m_DevProps[ENUM_GAIN].ulCurrentValue           = GainDefault;
    m_DevProps[ENUM_GAIN].ulDefaultValue           = GainDefault;
    m_DevProps[ENUM_GAIN].pRangeNStep              = &GainRangeAndStep[0];
    m_DevProps[ENUM_GAIN].ulFlags                  = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_GAIN].ulCapabilities           = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
    m_DevProps[ENUM_GAIN].fSetSupported            = VideoProcAmpProperties[ENUM_GAIN].SetSupported;
    m_DevProps[ENUM_GAIN].fGetSupported            = VideoProcAmpProperties[ENUM_GAIN].GetSupported;
    m_DevProps[ENUM_GAIN].pCsPropValues            = &GainValues;

    //CameraControl
    m_DevProps[ENUM_PAN].ulCurrentValue            = PanDefault;
    m_DevProps[ENUM_PAN].ulDefaultValue            = PanDefault;
    m_DevProps[ENUM_PAN].pRangeNStep               = &PanRangeAndStep[0];
    m_DevProps[ENUM_PAN].ulFlags                   = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_PAN].ulCapabilities            = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_PAN].fSetSupported             = VideoProcAmpProperties[ENUM_PAN-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
    m_DevProps[ENUM_PAN].fGetSupported             = VideoProcAmpProperties[ENUM_PAN-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
    m_DevProps[ENUM_PAN].pCsPropValues             = &PanValues;

    m_DevProps[ENUM_TILT].ulCurrentValue           = TiltDefault;
    m_DevProps[ENUM_TILT].ulDefaultValue           = TiltDefault;
    m_DevProps[ENUM_TILT].pRangeNStep              = &TiltRangeAndStep[0];
    m_DevProps[ENUM_TILT].ulFlags                  = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_TILT].ulCapabilities           = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_TILT].fSetSupported            = VideoProcAmpProperties[ENUM_TILT-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
    m_DevProps[ENUM_TILT].fGetSupported            = VideoProcAmpProperties[ENUM_TILT-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
    m_DevProps[ENUM_TILT].pCsPropValues            = &TiltValues;

    m_DevProps[ENUM_ROLL].ulCurrentValue           = RollDefault;
    m_DevProps[ENUM_ROLL].ulDefaultValue           = RollDefault;
    m_DevProps[ENUM_ROLL].pRangeNStep              = &RollRangeAndStep[0];
    m_DevProps[ENUM_ROLL].ulFlags                  = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_ROLL].ulCapabilities           = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_ROLL].fSetSupported            = VideoProcAmpProperties[ENUM_ROLL-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
    m_DevProps[ENUM_ROLL].fGetSupported            = VideoProcAmpProperties[ENUM_ROLL-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
    m_DevProps[ENUM_ROLL].pCsPropValues            = &RollValues;

    m_DevProps[ENUM_ZOOM].ulCurrentValue           = ZoomDefault;
    m_DevProps[ENUM_ZOOM].ulDefaultValue           = ZoomDefault;
    m_DevProps[ENUM_ZOOM].pRangeNStep              = &ZoomRangeAndStep[0];
    m_DevProps[ENUM_ZOOM].ulFlags                  = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_ZOOM].ulCapabilities           = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_ZOOM].fSetSupported            = VideoProcAmpProperties[ENUM_ZOOM-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
    m_DevProps[ENUM_ZOOM].fGetSupported            = VideoProcAmpProperties[ENUM_ZOOM-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
    m_DevProps[ENUM_ZOOM].pCsPropValues            = &ZoomValues;
        
    m_DevProps[ENUM_IRIS].ulCurrentValue           = IrisDefault;
    m_DevProps[ENUM_IRIS].ulDefaultValue           = IrisDefault;
    m_DevProps[ENUM_IRIS].pRangeNStep              = &IrisRangeAndStep[0];
    m_DevProps[ENUM_IRIS].ulFlags                  = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_IRIS].ulCapabilities           = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_IRIS].fSetSupported            = VideoProcAmpProperties[ENUM_IRIS-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
    m_DevProps[ENUM_IRIS].fGetSupported            = VideoProcAmpProperties[ENUM_IRIS-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
    m_DevProps[ENUM_IRIS].pCsPropValues            = &IrisValues;