cameradevice.cpp.svn-base

PXA270 平台 Windows Mobile 5 摄像头驱动

    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;

    m_DevProps[ENUM_EXPOSURE].ulCurrentValue       = ExposureDefault;
    m_DevProps[ENUM_EXPOSURE].ulDefaultValue       = ExposureDefault;
    m_DevProps[ENUM_EXPOSURE].pRangeNStep          = &ExposureRangeAndStep[0];
    m_DevProps[ENUM_EXPOSURE].ulFlags              = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_EXPOSURE].ulCapabilities       = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
    m_DevProps[ENUM_EXPOSURE].fSetSupported        = VideoProcAmpProperties[ENUM_EXPOSURE-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
    m_DevProps[ENUM_EXPOSURE].fGetSupported        = VideoProcAmpProperties[ENUM_EXPOSURE-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
    m_DevProps[ENUM_EXPOSURE].pCsPropValues        = &ExposureValues;

    m_DevProps[ENUM_FOCUS].ulCurrentValue          = FocusDefault;
    m_DevProps[ENUM_FOCUS].ulDefaultValue          = FocusDefault;
    m_DevProps[ENUM_FOCUS].pRangeNStep             = &FocusRangeAndStep[0];
    m_DevProps[ENUM_FOCUS].ulFlags                 = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
    m_DevProps[ENUM_FOCUS].ulCapabilities          = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
    m_DevProps[ENUM_FOCUS].fSetSupported           = VideoProcAmpProperties[ENUM_FOCUS-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
    m_DevProps[ENUM_FOCUS].fGetSupported           = VideoProcAmpProperties[ENUM_FOCUS-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
    m_DevProps[ENUM_FOCUS].pCsPropValues           = &FocusValues;

    m_DevProps[ENUM_FLASH].ulCurrentValue          = FlashDefault;
    m_DevProps[ENUM_FLASH].ulDefaultValue          = FlashDefault;
    m_DevProps[ENUM_FLASH].pRangeNStep             = &FlashRangeAndStep[0];
    m_DevProps[ENUM_FLASH].ulFlags                 = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
    m_DevProps[ENUM_FLASH].ulCapabilities          = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
    m_DevProps[ENUM_FLASH].fSetSupported           = VideoProcAmpProperties[ENUM_FLASH-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
    m_DevProps[ENUM_FLASH].fGetSupported           = VideoProcAmpProperties[ENUM_FLASH-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
    m_DevProps[ENUM_FLASH].pCsPropValues           = &FlashValues;


    // Video Format initialization
    m_PinVideoFormat[CAPTURE].categoryGUID         = PINNAME_VIDEO_CAPTURE;
    m_PinVideoFormat[CAPTURE].ulAvailFormats       = 1;
    m_PinVideoFormat[CAPTURE].pCsDataRangeVideo[0] = &DCAM_StreamMode_0;

    m_PinVideoFormat[STILL].categoryGUID           = PINNAME_VIDEO_STILL;
    m_PinVideoFormat[STILL].ulAvailFormats         = 1;
    m_PinVideoFormat[STILL].pCsDataRangeVideo[0]   = &DCAM_StreamMode_1;

    m_PinVideoFormat[PREVIEW].categoryGUID         = PINNAME_VIDEO_PREVIEW;
    m_PinVideoFormat[PREVIEW].ulAvailFormats       = 1;
    m_PinVideoFormat[PREVIEW].pCsDataRangeVideo[0] = &DCAM_StreamMode_0;

    // Video Control Caps
    m_PinVideoCaps[CAPTURE].ulVideoControlCaps     = DefaultVideoControlCaps[CAPTURE];
    m_PinVideoCaps[STILL].ulVideoControlCaps       = DefaultVideoControlCaps[STILL];
    // Note PREVIEW and VIDEOPORT control caps are the same, so we don't differentiate
    m_PinVideoCaps[PREVIEW].ulVideoControlCaps     = DefaultVideoControlCaps[PREVIEW];

    return true;
}


bool
CCameraDevice::BindApplicationProc(
    HANDLE hCurrentProc
    )
{
    if ( NULL != m_hCallerProcess )
    {
        return false;
    }

    m_ulCTypes = 3;

    // Check the registry to see what format and number of pins we support.
    HKEY hKey = NULL;

    if ( ERROR_SUCCESS == RegOpenKeyEx( HKEY_LOCAL_MACHINE, L"Drivers\\Capture\\Mainstone_ii", 0, 0, &hKey ) )
    {
        DWORD dwType  = 0;
        DWORD dwSize  = sizeof ( DWORD );
        DWORD dwValue = 0;

        // Find out if we should be using some other number of pins. The only
        // valid options are 2 or 3. Default to 3.
        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, L"PinCount", 0, &dwType, (BYTE *)&dwValue, &dwSize ) )
        {
            if ( REG_DWORD == dwType
                 && sizeof ( DWORD ) == dwSize
                 && 2 == dwValue )
            {
                m_ulCTypes = 2;
            }
        }

        RegCloseKey( hKey );
    }

    m_hCallerProcess = hCurrentProc;

    return true;
}


bool
CCameraDevice::UnBindApplicationProc( )
{
    DEBUGMSG( ZONE_FUNCTION, ( _T("CAM_Close: Unbind application from camera device\r\n") ) );

    m_hCallerProcess = NULL;

    return true;
}

bool
CCameraDevice::IsValidPin(
    ULONG ulPinId
    )
{
    if ( ulPinId >= m_ulCTypes )
    {
        return false;
    }

    return true;
}

bool
CCameraDevice::IncrCInstances(
    ULONG        ulPinId,
    CPinDevice * pPinDev
    )
{
    if ( false == IsValidPin( ulPinId ) || 1 == m_StrmInstances[ulPinId].ulCInstances )
    {
        return false;
    }
    else
    {
        m_StrmInstances[ulPinId].ulCInstances++;
        m_StrmInstances[ulPinId].pPinDev = pPinDev;
    }

    return true;
}

bool
CCameraDevice::DecrCInstances(
    ULONG ulPinId
    )
{
    if ( false == IsValidPin( ulPinId ) || 0 == m_StrmInstances[ulPinId].ulCInstances )
    {
        return false;
    }
    else
    {
        m_StrmInstances[ulPinId].ulCInstances--;
        m_StrmInstances[ulPinId].pPinDev = NULL;
    }

    return true;
}

bool
CCameraDevice::PauseCaptureAndPreview( void )
{
    if ( PREVIEW < m_ulCTypes )
    {
        if ( NULL != m_StrmInstances[PREVIEW].pPinDev )
        {
            m_StrmInstances[PREVIEW].pPinDev->SetState( CSSTATE_PAUSE, &m_StrmInstances[PREVIEW].CsPrevState );
        }
    }

    if ( NULL != m_StrmInstances[CAPTURE].pPinDev )
    {
        m_StrmInstances[CAPTURE].pPinDev->SetState( CSSTATE_PAUSE, &m_StrmInstances[CAPTURE].CsPrevState );
    }

    return true;
}

bool
CCameraDevice::RevertCaptureAndPreviewState( void )
{
    if ( PREVIEW < m_ulCTypes )
    {
        m_StrmInstances[PREVIEW].pPinDev->SetState( m_StrmInstances[PREVIEW].CsPrevState, NULL );
    }

    m_StrmInstances[CAPTURE].pPinDev->SetState( m_StrmInstances[CAPTURE].CsPrevState, NULL );

    return true;
}


bool
CCameraDevice::GetPinFormat(
    ULONG                 ulPinId,
    ULONG                 ulIndex,
    PCS_DATARANGE_VIDEO * ppCsDataRangeVid
    )
{
    if ( 0 >= ulIndex || ulIndex > m_PinVideoFormat[ulPinId].ulAvailFormats )
    {
        return false;
    }

    *ppCsDataRangeVid = m_PinVideoFormat[ulPinId].pCsDataRangeVideo[ulIndex-1];

    return true;
}


bool
CCameraDevice::AdapterCompareFormat(
    ULONG                       ulPinId,
    const PCS_DATARANGE_VIDEO   pCsDataRangeVideoToCompare,
    PCS_DATARANGE_VIDEO       * ppCsDataRangeVideoMatched,
    bool                        fDetailedComparison
    )
{
    for ( ULONG ulCount = 0 ; ulCount < m_PinVideoFormat[ulPinId].ulAvailFormats ; ulCount++ )
    {
        PCS_DATARANGE_VIDEO pCsDataRangeVideo = m_PinVideoFormat[ulPinId].pCsDataRangeVideo[ulCount];

        if ( false == AdapterCompareGUIDsAndFormatSize( reinterpret_cast<PCSDATARANGE>( pCsDataRangeVideo ),
                                                        reinterpret_cast<PCSDATARANGE>( pCsDataRangeVideoToCompare ) ) )
        {
            continue;
        }

        if ( true == fDetailedComparison )
        {
            if ( ( pCsDataRangeVideoToCompare->bFixedSizeSamples != pCsDataRangeVideo->bFixedSizeSamples )
                  || ( pCsDataRangeVideoToCompare->bTemporalCompression   != pCsDataRangeVideo->bTemporalCompression )
                  || ( pCsDataRangeVideoToCompare->StreamDescriptionFlags != pCsDataRangeVideo->StreamDescriptionFlags )
                  || ( pCsDataRangeVideoToCompare->MemoryAllocationFlags  != pCsDataRangeVideo->MemoryAllocationFlags ) )
            {
                continue;
            }
            // Real Camera drivers can now do ConfigCaps related intersection. Null driver doesn't do such comparison
            if ( 0 != memcmp(&pCsDataRangeVideoToCompare->VideoInfoHeader.bmiHeader, &pCsDataRangeVideo->VideoInfoHeader.bmiHeader, sizeof (pCsDataRangeVideo->VideoInfoHeader.bmiHeader) ) )
            {
                continue;
            }

        }

        // You can now perform more granular comparison involving ConfigCaps and VIDOINFOHEADER etc.

        /////////////////////////////////////////
        if ( NULL != ppCsDataRangeVideoMatched )
        {
            *ppCsDataRangeVideoMatched = pCsDataRangeVideo;
        }

        return true;
    }

    return false;
}


bool
CCameraDevice::AdapterCompareFormat(
    ULONG                                  ulPinId,
    const PCS_DATAFORMAT_VIDEOINFOHEADER   pCsDataVIHToCompare,
    PCS_DATARANGE_VIDEO                  * ppCsDataRangeVideoMatched,
    bool                                   fDetailedComparison
    )
{
    for ( ULONG ulCount = 0 ; ulCount < m_PinVideoFormat[ulPinId].ulAvailFormats ; ulCount++ )
    {
        PCS_DATARANGE_VIDEO pCsDataRangeVideo = m_PinVideoFormat[ulPinId].pCsDataRangeVideo[ulCount];

        if ( false == AdapterCompareGUIDsAndFormatSize( reinterpret_cast<PCSDATARANGE>( pCsDataRangeVideo ),
                                                        reinterpret_cast<PCSDATARANGE>( pCsDataVIHToCompare ) ) )
        {
            continue;
        }

        if ( true == fDetailedComparison )
        {
            if ( 0 != memcmp(&pCsDataVIHToCompare->VideoInfoHeader.bmiHeader, &pCsDataRangeVideo->VideoInfoHeader.bmiHeader, sizeof (pCsDataRangeVideo->VideoInfoHeader.bmiHeader) ) )
            {
                continue;
            }
        }

        // You can now perform more granular comparison involving ConfigCaps and VIDOINFOHEADER etc.

        /////////////////////////////////////////
        if ( NULL != ppCsDataRangeVideoMatched )
        {
            *ppCsDataRangeVideoMatched = pCsDataRangeVideo;
        }

        return true;
    }

    return false;
}


bool
CCameraDevice::AdapterCompareGUIDsAndFormatSize(
    const PCSDATARANGE DataRange1,
    const PCSDATARANGE DataRange2
    )
{
    return ( IsEqualGUID( DataRange1->MajorFormat, DataRange2->MajorFormat )
             && IsEqualGUID( DataRange1->SubFormat, DataRange2->SubFormat )
             && IsEqualGUID( DataRange1->Specifier, DataRange2->Specifier ) );
}


LPVOID
CCameraDevice::ValidateBuffer(
    LPVOID   lpBuff,
    ULONG    ulActualBufLen,
    ULONG    ulExpectedBuffLen,
    DWORD  * dwError
    )
{
    LPVOID lpMapped = NULL;

    if ( NULL == lpBuff )
    {
        DEBUGMSG( ZONE_IOCTL | ZONE_ERROR, (_T("IOControl(%08x): buffer is NULL\r\n"), this ) );
        *dwError = ERROR_INSUFFICIENT_BUFFER;

        return NULL;
    }

    if ( ulActualBufLen < ulExpectedBuffLen )
    {
        DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, (_T("IOControl(%08x): buffer is not large enough\r\n"), this ) );
        *dwError = ERROR_INSUFFICIENT_BUFFER;

        return NULL;
    }

    if ( NULL == (lpMapped = MapCallerPtr( lpBuff, ulActualBufLen ) ) )
    {
        DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, (_T("IOControl(%08x): MapCallerPtr failed for buffer.\r\n"), this ) );
        *dwError = ERROR_INVALID_USER_BUFFER;

        return NULL;