cameradevice.cpp

来自「该BSP是基于PXA270+WINCE的BSP」· C++ 代码 · 共 1,760 行 · 第 1/5 页

    if ( CSPROPERTY_TYPE_GET != csProp.Flags )
    {
        return dwError;
    }

    switch( csProp.Id )
    {
        case CSPROPERTY_PIN_CTYPES:
        {
            DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): CSPROPERTY_PIN_CTYPES\r\n"), this ) );

            *pdwBytesTransferred = sizeof(ULONG);

            EnterCriticalSection( &m_csDevice );

            if( OutBufLen < sizeof( ULONG ))
            {
                dwError = ERROR_MORE_DATA;
                break;
            }

            if( !CeSafeCopyMemory( pOutBuf, &m_ulCTypes, sizeof (ULONG) ))
            {
                dwError = ERROR_INVALID_PARAMETER;
                break;
            }

            LeaveCriticalSection( &m_csDevice );

            dwError = ERROR_SUCCESS;
            break;
        }

        case CSPROPERTY_PIN_CINSTANCES:
        {
            DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): CSPROPERTY_PIN_CINSTANCES\r\n"), this ) );

            if ( NULL == ( pCsPin = reinterpret_cast<PCSP_PIN>( ValidateBuffer( pInBuf, InBufLen, sizeof (CSP_PIN), &dwError ) ) ) )
            {
                break;
            }

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

            *pdwBytesTransferred = sizeof (CSPIN_CINSTANCES);

            if ( NULL == ( pCsPinCinstances = reinterpret_cast<PCSPIN_CINSTANCES>( ValidateBuffer( pOutBuf, OutBufLen, sizeof (CSPIN_CINSTANCES), &dwError ) ) ) )
            {
                dwError = ERROR_MORE_DATA;
                break;
            }

            pCsPinCinstances->PossibleCount = 1;
            pCsPinCinstances->CurrentCount  = m_StrmInstances[lPinId].ulCInstances;

            dwError = ERROR_SUCCESS;
            break;
        }

        case CSPROPERTY_PIN_DATARANGES:
        {
            DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): CSPROPERTY_PIN_DATARANGES\r\n"), this ) );

            if( NULL == ( pCsPin = reinterpret_cast<PCSP_PIN>( ValidateBuffer( pInBuf, InBufLen, sizeof (CSP_PIN), &dwError ) ) ) )
            {
                break;
            }

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

            *pdwBytesTransferred = sizeof(CSMULTIPLE_ITEM) + ( m_PinVideoFormat[lPinId].ulAvailFormats * sizeof (CS_DATARANGE_VIDEO) );

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

            pCsMultipleItem->Count = m_PinVideoFormat[lPinId].ulAvailFormats;
            pCsMultipleItem->Size  = *pdwBytesTransferred;

            pCsDataRangeVideo = NULL;
            pCsDataRangeVideo = reinterpret_cast<PCS_DATARANGE_VIDEO>( pCsMultipleItem + 1 );

            for ( int iCount = 0 ; iCount < static_cast<int>( m_PinVideoFormat[lPinId].ulAvailFormats ); iCount++ )
            {
                memcpy( pCsDataRangeVideo, m_PinVideoFormat[lPinId].pCsDataRangeVideo[iCount], sizeof (CS_DATARANGE_VIDEO) );
                pCsDataRangeVideo = reinterpret_cast<PCS_DATARANGE_VIDEO>( pCsDataRangeVideo + 1 );
            }

            dwError = ERROR_SUCCESS;

            break;
        }

        case CSPROPERTY_PIN_DATAINTERSECTION:
        {
            DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): CSPROPERTY_PIN_DATAINTERSECTION\r\n"), this ) );
            if ( NULL == ( pCsPin = reinterpret_cast<PCSP_PIN>( ValidateBuffer( pInBuf, InBufLen, sizeof (CSP_PIN), &dwError ) ) ) )
            {
                break;
            }

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

            pCsMultipleItem = NULL;
            pCsMultipleItem = reinterpret_cast<PCSMULTIPLE_ITEM>( pCsPin + 1 );

            if ( NULL == ValidateBuffer( pInBuf, InBufLen, ( sizeof (CSP_PIN) + (pCsMultipleItem->Count * pCsMultipleItem->Size ) ), &dwError ) )
            {
                break;
            }

            *pdwBytesTransferred = sizeof(CS_DATAFORMAT_VIDEOINFOHEADER);

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

            pCsDataRangeVideo = NULL;
            pCsDataRangeVideo = reinterpret_cast<PCS_DATARANGE_VIDEO>( pCsMultipleItem + 1 );

            for ( int iCount = 0 ; iCount < (int)pCsMultipleItem->Count ; iCount++ )
            {
                // First check whether the GUIDs match or not. This driver also tests other high level attributes of KS_DATARANGE_VIDEO
                if ( true == AdapterCompareFormat( lPinId, pCsDataRangeVideo, NULL, true) )
                {
                    // We found our format
                    memcpy(&pCsDataFormatVih->DataFormat,&pCsDataRangeVideo->DataRange, sizeof(CSDATAFORMAT) ) ;
                    memcpy(&pCsDataFormatVih->VideoInfoHeader,&pCsDataRangeVideo->VideoInfoHeader, sizeof(CS_VIDEOINFOHEADER) ) ;
                    dwError = ERROR_SUCCESS ;
                    break ;
                }
                pCsDataRangeVideo = reinterpret_cast<PCS_DATARANGE_VIDEO>(pCsDataRangeVideo + 1) ;
            }

            if(iCount == (int)pCsMultipleItem->Count)
            {
                // no match found
                dwError = ERROR_MORE_DATA;
            }
            break;
        }

        case CSPROPERTY_PIN_CATEGORY:
        {
            DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): CSPROPERTY_PIN_CATEGORY\r\n"), this ) );

            if ( NULL == ( pCsPin = reinterpret_cast<PCSP_PIN>( ValidateBuffer( pInBuf, InBufLen, sizeof (CSP_PIN), &dwError ) ) ) )
            {
                break;
            }

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

            *pdwBytesTransferred = sizeof( GUID );

            if( OutBufLen < *pdwBytesTransferred )
            {
                dwError = ERROR_MORE_DATA;
                break;
            }

            if ( CeSafeCopyMemory( pOutBuf, &m_PinVideoFormat[lPinId].categoryGUID, sizeof( GUID ) ))
            {
                dwError = ERROR_SUCCESS;
            }

            break;
        }

        case CSPROPERTY_PIN_NAME:
        {
            DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): Property CSPROPERTY_PIN_NAME\r\n"), this ) );

            if ( NULL == ( pCsPin = reinterpret_cast<PCSP_PIN>( ValidateBuffer( pInBuf, InBufLen, sizeof(CSP_PIN), &dwError ) ) ) )
            {
                break;
            }

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

            *pdwBytesTransferred = ( wcslen(g_wszPinNames[lPinId] ) + 1 ) * sizeof( g_wszPinNames[0][0] );

            if( OutBufLen < *pdwBytesTransferred )
            {
                dwError = ERROR_MORE_DATA;
                break;
            }

            if( CeSafeCopyMemory( pOutBuf, g_wszPinNames[lPinId], *pdwBytesTransferred ))
            {
                dwError = ERROR_SUCCESS;
            }

            break;
        }

        case CSPROPERTY_PIN_DEVICENAME:
        {
            DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): Property CSPROPERTY_PIN_NAME\r\n"), this ) );

            if ( NULL == ( pCsPin = reinterpret_cast<PCSP_PIN>( ValidateBuffer( pInBuf, InBufLen, sizeof(CSP_PIN), &dwError ) ) ) )
            {
                break;
            }

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

            *pdwBytesTransferred = ( wcslen( g_wszPinDeviceNames[lPinId] ) + 1 ) * sizeof( g_wszPinDeviceNames[0][0] ) ;

            if( OutBufLen < *pdwBytesTransferred )
            {
                dwError = ERROR_MORE_DATA;
                break;
            }

            if( CeSafeCopyMemory( pOutBuf, g_wszPinDeviceNames[lPinId], *pdwBytesTransferred ))
            {
                dwError = ERROR_SUCCESS;
            }

            break;
        }

        default:
        {
            DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): Invalid Property\r\n"), this ) );

            break;
        }
    }

    return dwError;
}

DWORD
CCameraDevice::AdapterHandleVidProcAmpRequests(
    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): HandleVidProcAmpRequests\r\n"), this ) );

    DWORD                      dwError                 = ERROR_INVALID_PARAMETER;
    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: