cameradevice.cpp

三星2440原版bsp

    // TODO : Set the following caps to 0 for this null DD.
    m_PinVideoCaps[CAPTURE].ulVideoControlCaps     = DefaultVideoControlCaps[CAPTURE];
    m_PinVideoCaps[STILL].ulVideoControlCaps       = DefaultVideoControlCaps[STILL];
    // Note PREVIEW 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\\BuiltIn\\Camera", 0, 0, &hKey ) )
    {
        DWORD dwType  = 0;
        DWORD dwSize  = sizeof ( DWORD );
        DWORD dwValue = 0;

        WCHAR szGuid[MAX_PATH];
        GUID  guid;

        // 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;
            }
        }

        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, L"StreamGuid0", 0, &dwType, (BYTE *)szGuid, &dwSize ) )
        {
            if ( REG_SZ == dwType
                 && ConvertStringToGuid( szGuid, &guid ) )
            {
                DCAM_StreamMode_0.DataRange.SubFormat = guid;
            }
        }

        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, L"StreamGuid1", 0, &dwType, (BYTE *)szGuid, &dwSize ) )
        {
            if ( REG_SZ == dwType
                 && ConvertStringToGuid( szGuid, &guid ) )
            {
                DCAM_StreamMode_1.DataRange.SubFormat = guid;
            }
        }

        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, L"StreamGuid2", 0, &dwType, (BYTE *)szGuid, &dwSize ) )
        {
            if ( REG_SZ == dwType
                 && ConvertStringToGuid( szGuid, &guid ) )
            {
                DCAM_StreamMode_2.DataRange.SubFormat = guid;
            }
        }

        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, L"StreamGuid3", 0, &dwType, (BYTE *)szGuid, &dwSize ) )
        {
            if ( REG_SZ == dwType
                 && ConvertStringToGuid( szGuid, &guid ) )
            {
                DCAM_StreamMode_3.DataRange.SubFormat = guid;
            }
        }

        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, L"StreamGuid4", 0, &dwType, (BYTE *)szGuid, &dwSize ) )
        {
            if ( REG_SZ == dwType
                 && ConvertStringToGuid( szGuid, &guid ) )
            {
                DCAM_StreamMode_4.DataRange.SubFormat = guid;
            }
        }

        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, L"StreamGuid6", 0, &dwType, (BYTE *)szGuid, &dwSize ) )
        {
            if ( REG_SZ == dwType
                 && ConvertStringToGuid( szGuid, &guid ) )
            {
                DCAM_StreamMode_6.DataRange.SubFormat = guid;
            }
        }

        RegCloseKey( hKey );
    }

    m_hCallerProcess = hCurrentProc;

    return true;
}


bool
CCameraDevice::UnBindApplicationProc( )
{
    RETAILMSG( RETAIL_ON, ( _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 )
{
	RETAILMSG( RETAIL_ON, ( _T("+-CCameraDevice::PauseCaptureAndPreview\r\n") ) );
    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 )
{
	RETAILMSG( RETAIL_ON, ( _T("+-CCameraDevice::RevertCaptureAndPreviewState\r\n") ) );
    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;
}

void CCameraDevice::GetCurrentCBufferAddress(DWORD *pdwYAddress,
						DWORD *pdwCBAddress, DWORD *pdwCRAddress)
{

	RETAILMSG( 0/*RETAIL_ON*/, ( _T("+-CCameraDevice::GetCurrentCBufferAddress\r\n") ) );
	//return the latest codec buffer addresses
	Lock(m_csIST);
	*pdwYAddress 	= m_nYAddress;
	*pdwCBAddress	= m_nCBAddress;
	*pdwCRAddress	= m_nCRAddress;
	Unlock(m_csIST);
	RETAILMSG( 0/*RETAIL_ON*/, ( _T("-YAddress 0x%x\n"), m_nYAddress ) );
	RETAILMSG( 0/*RETAIL_ON*/, ( _T("-CBAddress 0x%x\n"), m_nCBAddress) );
	RETAILMSG( 0/*RETAIL_ON*/, ( _T("-CRAddress 0x%x\n"), m_nCRAddress) );
	RETAILMSG( 0/*RETAIL_ON*/, ( _T("--CCameraDevice::GetCurrentCBufferAddress\r\n") ) );
}



void CCameraDevice::GetCurrentPBufferAddress(DWORD *pdwPAddress)
{
	RETAILMSG( 0/*RETAIL_ON*/, ( _T("+-CCameraDevice::GetCurrentPBufferAddress\r\n") ) );
	//return the latest preview buffer address
	Lock(m_csIST);
	*pdwPAddress 	= m_nRGBAddress;
	Unlock(m_csIST);
	RETAILMSG( 0/*RETAIL_ON*/, ( _T("-RGBAddress 0x%x\n"), m_nRGBAddress) );
	RETAILMSG( 0/*RETAIL_ON*/, ( _T("--CCameraDevice::GetCurrentPBufferAddress\r\n") ) );
}

bool
CCameraDevice::GetPinFormat(
    ULONG                 ulPinId,
    ULONG                 ulIndex,
    PCS_DATARANGE_VIDEO * ppCsDataRangeVid
    )
{
	RETAILMSG( RETAIL_ON, ( _T("+CCameraDevice::GetPinFormat: ulPinId=%d, ulIndex=%d\r\n"),ulPinId, ulIndex) );
    if ( 0 >= ulIndex || ulIndex > m_PinVideoFormat[ulPinId].ulAvailFormats )
    {
 		RETAILMSG( RETAIL_ON, ( _T("------------------->CCameraDevice::GetPinFormat: ERROR\r\n")) );
        return false;
    }

    *ppCsDataRangeVid = m_PinVideoFormat[ulPinId].pCsDataRangeVideo[ulIndex-1];
	RETAILMSG( RETAIL_ON, ( _T("-CCameraDevice::GetPinFormat\r\n")) );

    return true;
}

void CCameraDevice::CameraEnable()
{
	m_rS2440INT->INTMSK &= ~( 1 << IRQ_CAM );
	m_rS2440INT->INTSUBMSK &= ~(( 1 << IRQ_SUB_CAM_P )|( 1 << IRQ_SUB_CAM_C ));
	Camif_Capture(CAPTURE_ON, CAPTURE_ON);
	RETAILMSG( RETAIL_ON, ( _T("-CCameraDevice::CameraEnable\r\n")) );

}



void CCameraDevice::CameraDisable()
{
	m_rS2440INT->INTMSK |= ( 1 << IRQ_CAM );
	m_rS2440INT->INTSUBMSK |= (( 1 << IRQ_SUB_CAM_P )|( 1 << IRQ_SUB_CAM_C ));

	//clear the pending interrupts
	if (m_rS2440INT->INTPND & ( 1 << IRQ_CAM ))
		m_rS2440INT->INTPND |= ( 1 << IRQ_CAM );
	m_rS2440INT->SRCPND |= ( 1 << IRQ_CAM );
	m_rS2440INT->SUBSRCPND |= (( 1 << IRQ_SUB_CAM_P )|( 1 << IRQ_SUB_CAM_C ));

	Camif_Capture(CAPTURE_OFF, CAPTURE_OFF);
	RETAILMSG( RETAIL_ON, ( _T("-CCameraDevice::CameraDisable\r\n")) );

	//DisplayEnable = 0;

	DRIVER_PREVIEW_ENABLE = 2;
}

bool
CCameraDevice::AdapterCompareFormat(
    ULONG                       ulPinId,
    const PCS_DATARANGE_VIDEO   pCsDataRangeVideoToCompare,
    PCS_DATARANGE_VIDEO       * ppCsDataRangeVideoMatched,
    bool                        fDetailedComparison
    )
{
	RETAILMSG( RETAIL_ON, ( _T("++CCameraDevice::AdapterCompareFormat drv: ulPinId=%d\r\n"),ulPinId ) );
    for ( ULONG ulCount = 0 ; ulCount < m_PinVideoFormat[ulPinId].ulAvailFormats ; ulCount++ )
    {
        PCS_DATARANGE_VIDEO pCsDataRangeVideo = m_PinVideoFormat[ulPinId].pCsDataRangeVideo[ulCount];
		RETAILMSG( RETAIL_ON, ( _T("++CCameraDevice::AdapterCompareFormat: ulCount=%d\r\n"),ulCount ) );

        if ( false == AdapterCompareGUIDsAndFormatSize( reinterpret_cast<PCSDATARANGE>( pCsDataRangeVideo ),
                                                        reinterpret_cast<PCSDATARANGE>( pCsDataRangeVideoToCompare ) ) )
        {
 		   RETAILMSG( RETAIL_ON, ( _T("------------->1\r\n") ) );
           continue;
        }

        if ( true == fDetailedComparison )
        {
            if ( ( pCsDataRangeVideoToCompare->bFixedSizeSamples != pCsDataRangeVideo->bFixedSizeSamples )
                  || ( pCsDataRangeVideoToCompare->bTemporalCompression   != pCsDataRangeVideo->bTemporalCompression )
                  || ( pCsDataRangeVideoToCompare->StreamDescriptionFlags != pCsDataRangeVideo->StreamDescriptionFlags )
                  || ( pCsDataRangeVideoToCompare->MemoryAllocationFlags  != pCsDataRangeVideo->MemoryAllocationFlags ) )
            {
 				RETAILMSG( RETAIL_ON, ( _T("++++++++++++++++++++++++++++>2\r\n") ) );
				RETAILMSG( RETAIL_ON, ( _T("bFixedSizeSamples: %d, %d\r\n"), pCsDataRangeVideoToCompare->bFixedSizeSamples,pCsDataRangeVideo->bFixedSizeSamples) );
				RETAILMSG( RETAIL_ON, ( _T("bTemporalCompression: %d, %d\r\n"), pCsDataRangeVideoToCompare->bTemporalCompression,pCsDataRangeVideo->bTemporalCompression) );
				RETAILMSG( RETAIL_ON, ( _T("StreamDescriptionFlags: %d, %d\r\n"), pCsDataRangeVideoToCompare->StreamDescriptionFlags,pCsDataRangeVideo->StreamDescriptionFlags) );
				RETAILMSG( RETAIL_ON, ( _T("MemoryAllocationFlags: %d, %d\r\n"), pCsDataRangeVideoToCompare->MemoryAllocationFlags,pCsDataRangeVideo->MemoryAllocationFlags) );

 				RETAILMSG( RETAIL_ON, ( _T("---------------------------->2\r\n") ) );
                continue;
            }

            if( pCsDataRangeVideoToCompare->VideoInfoHeader.AvgTimePerFrame < pCsDataRangeVideo->ConfigCaps.MinFrameInterval  ||
                pCsDataRangeVideoToCompare->VideoInfoHeader.AvgTimePerFrame > pCsDataRangeVideo->ConfigCaps.MaxFrameInterval  )
            {
 				RETAILMSG( RETAIL_ON, ( _T("------------->3\r\n") ) );
                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) ) )
            {
 				RETAILMSG( RETAIL_ON, ( _T("------------->4\r\n") ) );
                continue;
            }

        }