cameradevice.cpp

三星2440原版bsp

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

        /////////////////////////////////////////
        if ( NULL != ppCsDataRangeVideoMatched )
        {
 			RETAILMSG( RETAIL_ON, ( _T("------------->5\r\n") ) );
            *ppCsDataRangeVideoMatched = pCsDataRangeVideo;
        }

		RETAILMSG( RETAIL_ON, ( _T("--CCameraDevice::AdapterCompareFormat: true\r\n") ) );
        return true;
    }

	RETAILMSG( RETAIL_ON, ( _T("--CCameraDevice::AdapterCompareFormat: false\r\n") ) );
    return false;
}


bool
CCameraDevice::AdapterCompareFormat(
    ULONG                                  ulPinId,
    const PCS_DATAFORMAT_VIDEOINFOHEADER   pCsDataVIHToCompare,
    PCS_DATARANGE_VIDEO                  * ppCsDataRangeVideoMatched,
    bool                                   fDetailedComparison
    )
{
	RETAILMSG( RETAIL_ON, ( _T("++CCameraDevice::AdapterCompareFormat drvh\r\n") ) );
    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( pCsDataVIHToCompare->VideoInfoHeader.AvgTimePerFrame < pCsDataRangeVideo->ConfigCaps.MinFrameInterval  ||
                pCsDataVIHToCompare->VideoInfoHeader.AvgTimePerFrame > pCsDataRangeVideo->ConfigCaps.MaxFrameInterval  )
            {
                continue;
            }

            // Real Camera drivers can now do ConfigCaps related intersection. Null driver doesn't do such comparison
            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;
        }
		RETAILMSG( RETAIL_ON, ( _T("--CCameraDevice::AdapterCompareFormat: true\r\n") ) );
        return true;
    }
	RETAILMSG( RETAIL_ON, ( _T("--CCameraDevice::AdapterCompareFormat: false\r\n") ) );
    return false;
}


bool
CCameraDevice::AdapterCompareGUIDsAndFormatSize(
    const PCSDATARANGE DataRange1,
    const PCSDATARANGE DataRange2
    )
{
	RETAILMSG( RETAIL_ON, ( _T("+-CCameraDevice::AdapterCompareGUIDsAndFormatSize\r\n") ) );
    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;
	RETAILMSG( 0/*RETAIL_ON*/, ( _T("++CCameraDevice::ValidateBuffer\r\n") ) );

    if ( NULL == lpBuff )
    {
        RETAILMSG( 0/*RETAIL_ON*/, (_T("IOControl(%08x): buffer is NULL\r\n"), this ) );
        *dwError = ERROR_INSUFFICIENT_BUFFER;

        return NULL;
    }

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

        return NULL;
    }

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

        return NULL;
    }
	RETAILMSG( 0/*RETAIL_ON*/, ( _T("--CCameraDevice::ValidateBuffer\r\n") ) );

    return lpMapped;
}


DWORD
CCameraDevice::AdapterHandleVersion( 
    PUCHAR pOutBuf,
    DWORD  OutBufLen,
    PDWORD pdwBytesTransferred
    )
{
	RETAILMSG( RETAIL_ON, ( _T("+-CCameraDevice::AdapterHandleVersion\r\n") ) );
    DWORD dwVersion = DRIVER_VERSION;

    if( OutBufLen < sizeof( DWORD ))
    {
        return ERROR_INSUFFICIENT_BUFFER;
    }

    *pdwBytesTransferred = sizeof( DWORD );

    if( !CeSafeCopyMemory( pOutBuf, &dwVersion, sizeof( DWORD )))
    {
        return ERROR_INVALID_USER_BUFFER;
    }

    return ERROR_SUCCESS;
}


DWORD
CCameraDevice::AdapterHandlePinRequests(
    PUCHAR pInBuf,
    DWORD  InBufLen,
    PUCHAR pOutBuf,
    DWORD  OutBufLen,
    PDWORD pdwBytesTransferred
    )
{
    RETAILMSG( RETAIL_ON, ( _T("CAM_IOControl(%08x): HandlePinRequests\r\n"), this ) );

    DWORD                          dwError           = ERROR_INVALID_PARAMETER;
    PCSP_PIN                       pCsPin            = NULL;
    PCS_DATARANGE_VIDEO            pCsDataRangeVideo = NULL;
    PCSMULTIPLE_ITEM               pCsMultipleItem   = NULL;
    PCS_DATAFORMAT_VIDEOINFOHEADER pCsDataFormatVih  = NULL;
    PCSPIN_CINSTANCES              pCsPinCinstances  = NULL;

    CSPROPERTY                      csProp = {0};
    LONG                            lPinId = 0;

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

    *pdwBytesTransferred = 0;

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

    // we are here so the request is not SETSUPPORT and after this only GET requests will be entertained since
    // PROPSETID_Pin contains READ-ONLY properties
    if ( CSPROPERTY_TYPE_GET != csProp.Flags )
    {
        return dwError;
    }

    switch( csProp.Id )
    {
        case CSPROPERTY_PIN_CTYPES:
        {
            RETAILMSG( RETAIL_ON, (_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:
        {
            RETAILMSG( RETAIL_ON, (_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 ))
            {
                RETAILMSG( RETAIL_ON, (_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:
        {
            RETAILMSG( RETAIL_ON, (_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 ) )
            {
                RETAILMSG(RETAIL_ON, (_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:
        {
            RETAILMSG( RETAIL_ON, (_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 ) )
            {
                RETAILMSG( RETAIL_ON, (_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 ;
                    }