cameradevice.cpp.svn-base

PXA270 平台 Windows Mobile 5 摄像头驱动

    LONG                       lValue                  = 0;
    PDEV_PROPERTY              pDevProp                = NULL;
    PCSPROPERTY_VIDEOPROCAMP_S pCsPropVidProcAmpOutput = NULL;
    PCSPROPERTY_VIDEOPROCAMP_S pCsPropVidProcAmpInput  = NULL;
    PCSPROPERTY_DESCRIPTION    pCsPropDesc             = NULL;
    PCSPROPERTY_VALUES         pCsPropValues           = NULL;

    CSPROPERTY                 csProp = {0};

    if( !CeSafeCopyMemory( &csProp, pInBuf, sizeof( CSPROPERTY )))
    {
        return dwError;
    }

    *pdwBytesTransferred = 0;

    // we support PROPSETID_Pin, so just return success
    if ( CSPROPERTY_TYPE_SETSUPPORT == csProp.Flags )
    {
        return ERROR_SUCCESS;
    }

    // TODO: This check would only make sense once we have all the PROCAMP properties defined.
    //       The initial checkin supports property values for brightness, sharpness, hue, saturation
    //       and whitebalance. Value structures for the rest of the properties are initialized to 0 in constructor.

    if ( csProp.Id < CSPROPERTY_VIDEOPROCAMP_BRIGHTNESS || csProp.Id > ENUM_GAIN )
    {
        DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): Invalid Property\r\n"), this ) );

        return dwError;
    }

    pDevProp = m_DevProps + csProp.Id;

    switch( csProp.Flags )
    {
    case CSPROPERTY_TYPE_GET:


        if ( FALSE == pDevProp->fGetSupported )
        {
            SetLastError(ERROR_INVALID_OPERATION);
            break;
        }

        *pdwBytesTransferred = sizeof(CSPROPERTY_VIDEOPROCAMP_S);
        if ( NULL == ( pCsPropVidProcAmpInput = reinterpret_cast<PCSPROPERTY_VIDEOPROCAMP_S>( ValidateBuffer( pInBuf, InBufLen, sizeof (CSPROPERTY_VIDEOPROCAMP_S), &dwError ) ) ) )
        {
            return dwError;
        }

        if( NULL == ( pCsPropVidProcAmpOutput = reinterpret_cast<PCSPROPERTY_VIDEOPROCAMP_S>( ValidateBuffer( pOutBuf, OutBufLen, *pdwBytesTransferred, &dwError ) ) ) )
        {
            dwError = ERROR_MORE_DATA;
            break;
        }

        //Copy the CSPROPERTY structure to the output buffer just in case!
        memcpy( pCsPropVidProcAmpOutput, pCsPropVidProcAmpInput, sizeof(CSPROPERTY) );

        pCsPropVidProcAmpOutput->Value        = pDevProp->ulCurrentValue;
        pCsPropVidProcAmpOutput->Flags        = pDevProp->ulFlags;
        pCsPropVidProcAmpOutput->Capabilities = pDevProp->ulCapabilities;

        dwError = ERROR_SUCCESS;
        break;

    case CSPROPERTY_TYPE_SET:

        if ( NULL == ( pCsPropVidProcAmpInput = reinterpret_cast<PCSPROPERTY_VIDEOPROCAMP_S>( ValidateBuffer( pInBuf, InBufLen, sizeof (CSPROPERTY_VIDEOPROCAMP_S), &dwError ) ) ) )
        {
            return dwError;
        }

        if ( FALSE == pDevProp->fSetSupported )
        {
            SetLastError(ERROR_INVALID_OPERATION);
            break;
        }

        // CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL and CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO are mutually exclusive
        if( pCsPropVidProcAmpInput->Flags != CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL && 
            pCsPropVidProcAmpInput->Flags != CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO )
        {
            SetLastError(ERROR_INVALID_OPERATION);
            break;
        }

        lValue = pCsPropVidProcAmpInput->Value;

        if( pCsPropVidProcAmpInput->Flags & ~pDevProp->ulCapabilities )
        {
            break;
        }

        if( CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL == pCsPropVidProcAmpInput->Flags )
        {
            if ( lValue < pDevProp->pRangeNStep->Bounds.SignedMinimum ||
                lValue > pDevProp->pRangeNStep->Bounds.SignedMaximum ||
                0 != ((lValue - pDevProp->pRangeNStep->Bounds.SignedMinimum) % pDevProp->pRangeNStep->SteppingDelta) )
            {
                break;
            }
            pDevProp->ulCurrentValue = lValue;
        }

        pDevProp->ulFlags        = pCsPropVidProcAmpInput->Flags;

        dwError = ERROR_SUCCESS;
        break;

    case CSPROPERTY_TYPE_DEFAULTVALUES:

        GetDefaultValues( pOutBuf, OutBufLen, pdwBytesTransferred, pDevProp, &dwError );
        break;

    case CSPROPERTY_TYPE_BASICSUPPORT:

        GetBasicSupportInfo( pOutBuf, OutBufLen, pdwBytesTransferred, pDevProp, &dwError );
        break;

    default :
        DEBUGMSG(ZONE_IOCTL, (_T("CAM_IOControl(%08x): Invalid Request\r\n"), this));
        return dwError;
    }

    return dwError;
}

DWORD
CCameraDevice::AdapterHandleCamControlRequests(
    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
    )
{
    // Note: This whole function is wrapped in a __try/__except block

    DEBUGMSG( ZONE_IOCTL, ( _T("CAM_IOControl(%08x): HandleCamControlRequests\r\n"), this ) );
    DWORD dwError = ERROR_INVALID_PARAMETER;
    long  lValue  = 0;
    long  lFlags  = 0;
    PDEV_PROPERTY pDevProp = NULL;
    PCSPROPERTY_CAMERACONTROL_S pCsPropCamControlOutput = NULL;
    PCSPROPERTY_CAMERACONTROL_S pCsPropCamControlInput  = NULL;

    CSPROPERTY   csProp = {0};
    if( !CeSafeCopyMemory( &csProp, pInBuf, sizeof( CSPROPERTY )))
    {
        return dwError;
    }

    *pdwBytesTransferred = 0;

    // we support PROPSETID_Pin, so just return success
    if ( CSPROPERTY_TYPE_SETSUPPORT == csProp.Flags )
    {
        return ERROR_SUCCESS;
    }

    // TODO :    This check would only make sense once we have all the CAMERACONTROL properties defined.
    //            The initial checkin supports property values for Zoom and Flash.
    //            Value structures for the rest of the properties are initialized to 0 in constructor.

    if ( csProp.Id < CSPROPERTY_CAMERACONTROL_PAN || csProp.Id > CSPROPERTY_CAMERACONTROL_FLASH )
    {
        DEBUGMSG(ZONE_IOCTL, (_T("CAM_IOControl(%08x): Invalid Property\r\n"), this));
        return dwError;
    }

    pDevProp = m_DevProps + (csProp.Id + NUM_VIDEOPROCAMP_ITEMS);

    switch( csProp.Flags )
    {
    case CSPROPERTY_TYPE_GET:

        if ( NULL == ( pCsPropCamControlInput = reinterpret_cast<PCSPROPERTY_CAMERACONTROL_S>( ValidateBuffer( pInBuf, InBufLen, sizeof(CSPROPERTY_CAMERACONTROL_S), &dwError ) ) ) )
        {
            return dwError;
        }

        if ( FALSE == pDevProp->fGetSupported )
        {
            SetLastError(ERROR_INVALID_OPERATION);
            break;
        }

        *pdwBytesTransferred = sizeof(CSPROPERTY_CAMERACONTROL_S);
        if( NULL == ( pCsPropCamControlOutput = reinterpret_cast<PCSPROPERTY_CAMERACONTROL_S>(ValidateBuffer( pOutBuf, OutBufLen, *pdwBytesTransferred, &dwError ) ) ) )
        {
            dwError = ERROR_MORE_DATA;
            break;
        }

        //Copy the CSPROPERTY structure to the output buffer just in case!
        memcpy( pCsPropCamControlOutput, pCsPropCamControlInput, sizeof(CSPROPERTY) );

        pCsPropCamControlOutput->Value         = pDevProp->ulCurrentValue;
        pCsPropCamControlOutput->Flags         = pDevProp->ulFlags;
        pCsPropCamControlOutput->Capabilities  = pDevProp->ulCapabilities;

        dwError = ERROR_SUCCESS;
        break;

    case CSPROPERTY_TYPE_SET:

        if ( NULL == ( pCsPropCamControlInput = reinterpret_cast<PCSPROPERTY_CAMERACONTROL_S>( ValidateBuffer( pInBuf, InBufLen, sizeof(CSPROPERTY_CAMERACONTROL_S), &dwError ) ) ) )
        {
            return dwError;
        }

        if ( FALSE == pDevProp->fSetSupported )
        {
            SetLastError(ERROR_INVALID_OPERATION);
            break;
        }

        // CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL and CSPROPERTY_CAMERACONTROL_FLAGS_AUTO are mutually exclusive
        if( pCsPropCamControlInput->Flags != CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL && 
            pCsPropCamControlInput->Flags != CSPROPERTY_CAMERACONTROL_FLAGS_AUTO )
        {
            SetLastError(ERROR_INVALID_OPERATION);
            break;
        }

        lValue = pCsPropCamControlInput->Value;
        lFlags = pCsPropCamControlInput->Flags;

        if( lFlags & ~pDevProp->ulCapabilities )
        {
            break;
        }
        
        if( CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL == lFlags )
        {
            if ( lValue < pDevProp->pRangeNStep->Bounds.SignedMinimum ||
                lValue > pDevProp->pRangeNStep->Bounds.SignedMaximum ||
                0 != ((lValue - pDevProp->pRangeNStep->Bounds.SignedMinimum) % pDevProp->pRangeNStep->SteppingDelta) )
            {
                break;
            }

            pDevProp->ulCurrentValue = lValue;
        }

        pDevProp->ulFlags        = lFlags;

        dwError = ERROR_SUCCESS;
        break;

    case CSPROPERTY_TYPE_DEFAULTVALUES:

        GetDefaultValues( pOutBuf, OutBufLen, pdwBytesTransferred, pDevProp, &dwError );
        break;

    case CSPROPERTY_TYPE_BASICSUPPORT:

        GetBasicSupportInfo( pOutBuf, OutBufLen, pdwBytesTransferred, pDevProp, &dwError );
        break;

    default :
        DEBUGMSG(ZONE_IOCTL, (_T("CAM_IOControl(%08x): Invalid Request\r\n"), this));
        return dwError;
    }

    return dwError;
}

DWORD
CCameraDevice::AdapterHandleCompressionRequests(
    PUCHAR pInBuf,
    DWORD  InBufLen,
    PUCHAR pOutBuf,
    DWORD  OutBufLen,
    PDWORD pdwBytesTransferred
    )
{
    DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): HandleCompressionRequests\r\n"), this ) );

    return ERROR_INVALID_PARAMETER;
}

DWORD
CCameraDevice::AdapterHandleVideoControlRequests(
    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
    )
{
    // Note: This whole function is wrapped in a __try/__except block
    DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): HandleVideoControlRequests\r\n"), this ) );

    DWORD dwError = ERROR_INVALID_PARAMETER;
    LONG  lValue  = 0;
    ULONG ulCaps  = 0;
    LONG lIndex = 0;

    PCSPROPERTY_VIDEOCONTROL_CAPS_S pCsPropVideoControlCapsOutput = NULL;
    PCSPROPERTY_VIDEOCONTROL_CAPS_S pCsPropVideoControlCapsInput  = NULL;
    PCSPROPERTY_VIDEOCONTROL_MODE_S pCsPropVideoControlModeInput  = NULL;

    CSPROPERTY csProp = {0};

    if( !CeSafeCopyMemory( &csProp, pInBuf, sizeof( CSPROPERTY )))
    {
        return dwError;
    }

    *pdwBytesTransferred = 0;

    // we support PROPSETID_Pin, so just return success
    if ( CSPROPERTY_TYPE_SETSUPPORT == csProp.Flags )
    {
        return ERROR_SUCCESS;
    }

    switch( csProp.Id )
    {
    case CSPROPERTY_VIDEOCONTROL_CAPS:
        if( NULL == ( pCsPropVideoControlCapsInput = reinterpret_cast<PCSPROPERTY_VIDEOCONTROL_CAPS_S>(ValidateBuffer( pInBuf, InBufLen, sizeof(CSPROPERTY_VIDEOCONTROL_CAPS_S), &dwError ) ) ) )
        {
            break;
        }

        lIndex = pCsPropVideoControlCapsInput->StreamIndex;
        if ( false == IsValidPin( lIndex ) )
        {
            DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): Invalid PinId\r\n"), this ) );
            break;
        }

        switch ( csProp.Flags )
        {
        case CSPROPERTY_TYPE_GET:
            *pdwBytesTransferred = sizeof(CSPROPERTY_VIDEOCONTROL_CAPS_S);
            if ( NULL == ( pCsPropVideoControlCapsOutput = reinterpret_cast<PCSPROPERTY_VIDEOCONTROL_CAPS_S>( ValidateBuffer( pOutBuf, OutBufLen, *pdwBytesTransferred, &dwError ) ) ) )
            {
                dwError = ERROR_MORE_DATA;