cameradevice.cpp

三星2440原版bsp

        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 :
        RETAILMSG(RETAIL_ON, (_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
    )
{
    RETAILMSG( RETAIL_ON, (_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
    RETAILMSG( RETAIL_ON, (_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 ) )
        {
            RETAILMSG( RETAIL_ON, (_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;
                break;
            }

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

            pCsPropVideoControlCapsOutput->StreamIndex      = lIndex;
            pCsPropVideoControlCapsOutput->VideoControlCaps = m_PinVideoCaps[lIndex].ulVideoControlCaps;

            dwError = ERROR_SUCCESS;

            break;

        case CSPROPERTY_TYPE_SET:
            lIndex = pCsPropVideoControlCapsInput->StreamIndex;

            ulCaps = pCsPropVideoControlCapsInput->VideoControlCaps;
            if ( ulCaps & ~( CS_VideoControlFlag_FlipHorizontal        |
                             CS_VideoControlFlag_FlipVertical          |
                             CS_VideoControlFlag_ExternalTriggerEnable |
                             CS_VideoControlFlag_Trigger ) )
            {
                RETAILMSG( RETAIL_ON, ( _T("CAM_IOControl(%08x): Invalid flag specified as Video Control Caps.\r\n"), this ) );
                break;
            }

            if( false == IsValidPin( lIndex ))
            {
                RETAILMSG( RETAIL_ON, ( _T("CAM_IOControl(%08x): Invalid pin index.\r\n"), this ) );
                break;
            }

            m_PinVideoCaps[lIndex].ulVideoControlCaps = ulCaps;
            dwError = ERROR_SUCCESS;
            break;

        case CSPROPERTY_TYPE_DEFAULTVALUES:
            *pdwBytesTransferred = sizeof(CSPROPERTY_VIDEOCONTROL_CAPS_S);

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

            lIndex = pCsPropVideoControlCapsInput->StreamIndex;
            if( false == IsValidPin( lIndex ))
            {
                RETAILMSG( RETAIL_ON, ( _T("CAM_IOControl(%08x): Invalid pin index.\r\n"), this ) );
                break;
            }

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

            pCsPropVideoControlCapsOutput->StreamIndex      = lIndex;
            pCsPropVideoControlCapsOutput->VideoControlCaps = DefaultVideoControlCaps[ lIndex ];

            dwError = ERROR_SUCCESS;

            break;

        default:
            RETAILMSG( RETAIL_ON, ( _T("CAM_IOControl(%08x): Invalid Request\r\n"), this ) );
            break;
        }

        break;

    case CSPROPERTY_VIDEOCONTROL_MODE:
        if( NULL == ( pCsPropVideoControlModeInput = reinterpret_cast<PCSPROPERTY_VIDEOCONTROL_MODE_S>(ValidateBuffer( pInBuf, InBufLen, sizeof(CSPROPERTY_VIDEOCONTROL_MODE_S), &dwError ) ) ) )
        {
            break;
        }

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

        switch( csProp.Flags )
        {
        case CSPROPERTY_TYPE_SET:
            ulCaps = pCsPropVideoControlModeInput->Mode;
            if ( ulCaps != CS_VideoControlFlag_Trigger )
            {
                RETAILMSG( RETAIL_ON, (_T("CAM_IOControl(%08x): Invalid flag specified as Video Control Mode.\r\n"), this ) );
                break;
            }

            if ( m_StrmInstances[lIndex].pPinDev &&
                 ( lIndex == CAPTURE ||
                   lIndex == STILL ) )
            {
                m_StrmInstances[lIndex].pPinDev->SetState( CSSTATE_RUN, NULL );
                dwError = ERROR_SUCCESS;
            }
            else
            {
                RETAILMSG( RETAIL_ON, (_T("CAM_IOControl(%08x): Invalid pin for Trigger.\r\n"), this ) );
            }

            break ;

        default :
            RETAILMSG(RETAIL_ON, (_T("CAM_IOControl(%08x): Invalid Request\r\n"), this)) ;
            break ;
        }

    default:
        RETAILMSG(RETAIL_ON, (_T("CAM_IOControl(%08x): Invalid Property\r\n"), this)) ;
        return dwError ;
    }

    return dwError;
}

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

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

    CSPROPERTY csProp;
    CSPROPERTY_DROPPEDFRAMES_CURRENT_S csPropDroppedFramesOutput = {0};

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

    *pdwBytesTransferred = 0;

    switch( csProp.Id )
    {
    case CSPROPERTY_DROPPEDFRAMES_CURRENT:

        switch ( csProp.Flags )
        {
        case CSPROPERTY_TYPE_GET:
            *pdwBytesTransferred = sizeof(CSPROPERTY_DROPPEDFRAMES_CURRENT_S);
            if( OutBufLen < *pdwBytesTransferred  )
            {
                dwError = ERROR_MORE_DATA;
                break;
            }

            //Copy the CSPROPERTY structure to the output buffer just in case!
            memcpy( &csPropDroppedFramesOutput, &csProp, sizeof( CSPROPERTY ) );

            if ( m_StrmInstances[CAPTURE].pPinDev )
            {
                csPropDroppedFramesOutput.PictureNumber    = m_StrmInstances[CAPTURE].pPinDev->PictureNumber( );
                csPropDroppedFramesOutput.DropCount        = m_StrmInstances[CAPTURE].pPinDev->FramesDropped( );
                csPropDroppedFramesOutput.AverageFrameSize = m_StrmInstances[CAPTURE].pPinDev->FrameSize( );

                if( CeSafeCopyMemory( pOutBuf, &csPropDroppedFramesOutput, sizeof( CSPROPERTY_DROPPEDFRAMES_CURRENT_S )))
                {
                    dwError = ERROR_SUCCESS;
                }
            }

            break;
        }

    default:
        RETAILMSG(RETAIL_ON, (_T("CAM_IOControl(%08x): Invalid Property\r\n"), this)) ;
        return dwError;
    }

    return dwError;
}

void
CCameraDevice::GetBasicSupportInfo(
    PUCHAR pOutBuf,
    DWORD  OutBufLen,
    PDWORD pdwBytesTransferred,
    PDEV_PROPERTY pDevProp,
    PDWORD pdwError
    )
{
    PCSPROPERTY_DESCRIPTION   pCsPropDesc          = NULL;
    PCSPROPERTY_MEMBERSHEADER pCsPropMembersHeader = NULL;
	RETAILMSG( RETAIL_ON, (_T("+-CCameraDevice::GetBasicSupportInfo\r\n")) );

    if ( O