cameradevice.cpp

Samsung公司S3C6400芯片的BSP源码包

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

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

            break;
        }

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

    return dwError;
}

DWORD 
CCameraDevice::AdapterHandlePowerRequests(
    DWORD  dwCode,
    PUCHAR pInBuf,
    DWORD  InBufLen,
    PUCHAR pOutBuf,
    DWORD  OutBufLen,
    PDWORD pdwBytesTransferred
    )
{
    DWORD dwErr = ERROR_INVALID_PARAMETER;

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

    switch (dwCode)
    {
    //
    // Power Management Support.
    //
    case IOCTL_POWER_CAPABILITIES:

        DEBUGMSG(ZONE_IOCTL, (TEXT("CAM: IOCTL_POWER_CAPABILITIES\r\n")));
        if ( pOutBuf && OutBufLen >= sizeof(POWER_CAPABILITIES) )
        {
             memcpy(pOutBuf, &m_AdapterInfo.PowerCaps, sizeof(POWER_CAPABILITIES));
             if(pdwBytesTransferred)
             {
                 *pdwBytesTransferred = sizeof(POWER_CAPABILITIES);
             }
             dwErr = ERROR_SUCCESS;
        }
        break;

    case IOCTL_POWER_SET:

        DEBUGMSG(ZONE_IOCTL, (TEXT("CAM: IOCTL_POWER_SET\r\n")));
        if ( pOutBuf && OutBufLen >= sizeof(CEDEVICE_POWER_STATE) )
        {
            PCEDEVICE_POWER_STATE pState = (PCEDEVICE_POWER_STATE) pOutBuf;

            switch (*pState)
            {
            case D0:
                RETAILMSG(ZONE_IOCTL, (TEXT("CAM: D0\r\n")));

                m_PowerState = D0;
                PowerUp();

                dwErr = ERROR_SUCCESS;
                break;
            
            case D1:
                RETAILMSG(ZONE_IOCTL, (TEXT("CAM: D0\r\n")));

                m_PowerState = D1;
                PowerUp();                

                dwErr = ERROR_SUCCESS;
                break;


            case D2:
                RETAILMSG(ZONE_IOCTL, (TEXT("CAM: D2\r\n")));

                m_PowerState = D2;
                PowerUp();                

                dwErr = ERROR_SUCCESS;
                break;
        
            case D3:
                RETAILMSG(ZONE_IOCTL, (TEXT("CAM: D3\r\n")));

                m_PowerState = D3;
                PowerDown();

                dwErr = ERROR_SUCCESS;
                break;
                
            case D4:
                RETAILMSG(ZONE_IOCTL, (TEXT("CAM: D4\r\n")));

                m_PowerState = D4;
                PowerDown();

                dwErr = ERROR_SUCCESS;
                break;

            default:
                RETAILMSG(ZONE_IOCTL|ZONE_WARN, (TEXT("CAM: Unrecognized Valid Power state. Powering Up\r\n")));
                
                m_PowerState = *pState;
                PowerUp();                
                
                dwErr = ERROR_SUCCESS;
                break;
            }

            if ( dwErr == ERROR_SUCCESS )
            {
                *pState = m_PowerState;
                if(pdwBytesTransferred)
                {
                    *pdwBytesTransferred = sizeof(CEDEVICE_POWER_STATE);
                }
            }
        }
        break;

    case IOCTL_POWER_GET:

        DEBUGMSG(ZONE_IOCTL, (TEXT("CAM: IOCTL_POWER_GET\r\n")));
        if ( pOutBuf && OutBufLen >= sizeof(CEDEVICE_POWER_STATE) )
        {
            *((PCEDEVICE_POWER_STATE) pOutBuf) = m_PowerState;
            if(pdwBytesTransferred)
            {
                *pdwBytesTransferred = sizeof(CEDEVICE_POWER_STATE);
            }
            dwErr = ERROR_SUCCESS;
        }
        break;

    default:
        break;
    }

    return dwErr;
}

DWORD
CCameraDevice::AdapterHandleCustomRequests(
    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): AdapterHandleCustomRequests\r\n"), this ) );
    return m_PDDFuncTbl.PDD_HandleAdapterCustomProperties( m_PDDContext, pInBuf, InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred );
}

void 
CCameraDevice::PowerDown()
{
    if ( m_hCallerProcess )
    {
        for( UINT i = 0; i < m_AdapterInfo.ulCTypes; i++ )
        {
            if ( NULL != m_pStrmInstances[i].pPinDev ) 
            {
                m_pStrmInstances[i].pPinDev->SetState( CSSTATE_STOP, &m_pStrmInstances[i].CsPrevState );
            }
        }
        m_PDDFuncTbl.PDD_SetPowerState( m_PDDContext, m_PowerState);
    }
}

void 
CCameraDevice::PowerUp()
{
    if ( m_hCallerProcess )
    {
    	m_PDDFuncTbl.PDD_SetPowerState( m_PDDContext, m_PowerState );
        for( UINT i = 0; i < m_AdapterInfo.ulCTypes; i++ )
        {
            if ( NULL != m_pStrmInstances[i].pPinDev ) 
            {
                m_pStrmInstances[i].pPinDev->SetState( m_pStrmInstances[i].CsPrevState, NULL );
            }
        }
    }
}

void
CCameraDevice::GetBasicSupportInfo(
    PUCHAR pOutBuf,
    DWORD  OutBufLen,
    PDWORD pdwBytesTransferred,
    PSENSOR_PROPERTY pSensorProp,
    PDWORD pdwError
    )
{
    PCSPROPERTY_DESCRIPTION   pCsPropDesc          = NULL;
    PCSPROPERTY_MEMBERSHEADER pCsPropMembersHeader = NULL;

    if ( OutBufLen >= sizeof(CSPROPERTY_DESCRIPTION) )
    {
        if( OutBufLen >= StandardSizeOfBasicValues )
        {
            *pdwBytesTransferred = StandardSizeOfBasicValues;
        }
        else
        {
            *pdwBytesTransferred = sizeof(CSPROPERTY_DESCRIPTION);
        }

        pCsPropDesc = reinterpret_cast<PCSPROPERTY_DESCRIPTION>( ValidateBuffer( pOutBuf, OutBufLen, sizeof (CSPROPERTY_DESCRIPTION), pdwError ) );

        if ( NULL == pCsPropDesc )
        {
            *pdwError = ERROR_MORE_DATA;

            return;
        }

        pCsPropDesc->AccessFlags      = (CSPROPERTY_TYPE_GET | CSPROPERTY_TYPE_SET | CSPROPERTY_TYPE_DEFAULTVALUES);
        pCsPropDesc->MembersListCount = 1;
        pCsPropDesc->Reserved         = 0;
        pCsPropDesc->DescriptionSize  = StandardSizeOfBasicValues;

        memcpy( &pCsPropDesc->PropTypeSet, &pSensorProp->pCsPropValues->PropTypeSet, sizeof (CSIDENTIFIER) );

        if( OutBufLen >= StandardSizeOfBasicValues )
        {
            pCsPropMembersHeader = reinterpret_cast<PCSPROPERTY_MEMBERSHEADER>( pCsPropDesc + 1 );

            // Copy the CSPROPERTY_MEMBERSHEADER
            memcpy( pCsPropMembersHeader, pSensorProp->pCsPropValues->MembersList, sizeof (CSPROPERTY_MEMBERSHEADER) );

            // Copy the CSPROPERTY_STEPPING_LONG
            memcpy( pCsPropMembersHeader + 1, pSensorProp->pCsPropValues->MembersList->Members, sizeof (CSPROPERTY_STEPPING_LONG) );

            *pdwError = ERROR_SUCCESS;
        }
        else
        {
            DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, (_T("CAM_IOControl(%08x): Not all available data could be written\r\n"), this ) );
            *pdwError = ERROR_MORE_DATA;
        }
    }
    else if ( OutBufLen >= sizeof(ULONG) )
    {
        // We just need to return AccessFlags.
        DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): Returning AccessFlags\r\n"), this ) );

        *pdwBytesTransferred = sizeof(ULONG);

        if ( NULL == ValidateBuffer( pOutBuf, OutBufLen, sizeof (ULONG), pdwError ) )
        {
            *pdwError = ERROR_MORE_DATA;
            return;
        }

        *((PULONG)pOutBuf) = static_cast<ULONG>( CSPROPERTY_TYPE_GET | CSPROPERTY_TYPE_SET | CSPROPERTY_TYPE_DEFAULTVALUES );
        *pdwError = ERROR_SUCCESS;
    }
    else
    {
        DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): Output buffer is not large enough\r\n"), this ) );
        *pdwError = ERROR_INSUFFICIENT_BUFFER;
    }

    return;
}

void
CCameraDevice::GetDefaultValues(
    PUCHAR pOutBuf,
    DWORD  OutBufLen,
    PDWORD pdwBytesTransferred,
    PSENSOR_PROPERTY pSensorProp,
    PDWORD pdwError
    )
{
    PCSPROPERTY_DESCRIPTION   pCsPropDesc          = NULL;
    PCSPROPERTY_MEMBERSHEADER pCsPropMembersHeader = NULL;

    if ( OutBufLen >= sizeof(CSPROPERTY_DESCRIPTION) )
    {
        if( OutBufLen >= StandardSizeOfDefaultValues )
        {
            *pdwBytesTransferred = StandardSizeOfDefaultValues;
        }
        else
        {
            *pdwBytesTransferred = sizeof(CSPROPERTY_DESCRIPTION);
        }

        pCsPropDesc = reinterpret_cast<PCSPROPERTY_DESCRIPTION>( ValidateBuffer( pOutBuf, OutBufLen, sizeof (CSPROPERTY_DESCRIPTION), pdwError ) );

        if ( NULL == pCsPropDesc )
        {
            *pdwError = ERROR_MORE_DATA;

            return;
        }

        pCsPropDesc->AccessFlags      = (CSPROPERTY_TYPE_GET | CSPROPERTY_TYPE_SET | CSPROPERTY_TYPE_DEFAULTVALUES);
        pCsPropDesc->MembersListCount = 1;
        pCsPropDesc->Reserved         = 0;
        pCsPropDesc->DescriptionSize  = StandardSizeOfDefaultValues;

        memcpy( &pCsPropDesc->PropTypeSet, &pSensorProp->pCsPropValues->PropTypeSet, sizeof (CSIDENTIFIER) );

        if( OutBufLen >= StandardSizeOfDefaultValues )
        {
            pCsPropMembersHeader = reinterpret_cast<PCSPROPERTY_MEMBERSHEADER>( pCsPropDesc + 1 );

            // Copy the CSPROPERTY_MEMBERSHEADER
            memcpy( pCsPropMembersHeader, &(pSensorProp->pCsPropValues->MembersList[1]), sizeof (CSPROPERTY_MEMBERSHEADER) );

            // Copy the LONG (default value)
            memcpy( pCsPropMembersHeader + 1, pSensorProp->pCsPropValues->MembersList[1].Members, sizeof (LONG) );

            *pdwError = ERROR_SUCCESS;
        }
        else
        {
            DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, (_T("CAM_IOControl(%08x): Not all available data could be written\r\n"), this ) );
            *pdwError = ERROR_MORE_DATA;
        }
    }
    else if ( OutBufLen >= sizeof(ULONG) )
    {
        // We just need to return AccessFlags.
        DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): Returning AccessFlags\r\n"), this ) );

        *pdwBytesTransferred = sizeof(ULONG);

        if ( NULL == ValidateBuffer( pOutBuf, OutBufLen, sizeof (ULONG), pdwError ) )
        {
            *pdwError = ERROR_MORE_DATA;
            return;
        }

        *((PULONG)pOutBuf) = static_cast<ULONG>( CSPROPERTY_TYPE_GET | CSPROPERTY_TYPE_SET | CSPROPERTY_TYPE_DEFAULTVALUES );
        *pdwError = ERROR_SUCCESS;
    }
    else
    {
        DEBUGMSG( ZONE_IOCTL, (_T("CAM_IOControl(%08x): Output buffer is not large enough\r\n"), this ) );
        *pdwError = ERROR_INSUFFICIENT_BUFFER;
    }

    return;
}

DWORD CCameraDevice::PDDClosePin( ULONG ulPinId )
{   
    return m_PDDFuncTbl.PDD_DeInitSensorMode( m_PDDContext, ulPinId );
}

DWORD CCameraDevice::PDDGetPinInfo( ULONG ulPinId, PSENSORMODEINFO pSensorModeInfo )
{    
    return m_PDDFuncTbl.PDD_GetSensorModeInfo( m_PDDContext, ulPinId, pSensorModeInfo );
}


DWORD CCameraDevice::PDDSetPinState( ULONG ulPinId, CSSTATE State )
{   
    return m_PDDFuncTbl.PDD_SetSensorState( m_PDDContext, ulPinId, State );
}


DWORD CCameraDevice::PDDFillPinBuffer( ULONG ulPinId, PUCHAR pImage )
{  
    return m_PDDFuncTbl.PDD_FillBuffer( m_PDDContext, ulPinId, pImage );
}


DWORD CCameraDevice::PDDInitPin( ULONG ulPinId, CPinDevice *pPin )
{   
    return m_PDDFuncTbl.PDD_InitSensorMode( m_PDDContext, ulPinId, pPin );
}

DWORD CCameraDevice::PDDSetPinFormat( ULONG ulPinId, PCS_DATARANGE_VIDEO pCsDataRangeVideo )
{
    if( NULL == pCsDataRangeVideo )
    {
        return ERROR_INVALID_PARAMETER;
    }
    
    return m_PDDFuncTbl.PDD_SetSensorModeFormat( m_PDDContext, ulPinId, pCsDataRangeVideo );
}


PVOID CCameraDevice::PDDAllocatePinBuffer( ULONG ulPinId )
{   
    return m_PDDFuncTbl.PDD_AllocateBuffer( m_PDDContext, ulPinId );
}


DWORD CCameraDevice::PDDDeAllocatePinBuffer( ULONG ulPinId, PVOID pBuffer )
{
    return m_PDDFuncTbl.PDD_DeAllocateBuffer( m_PDDContext, ulPinId, pBuffer );
}

DWORD CCameraDevice::PDDRegisterClientBuffer( ULONG ulPinId, PVOID pBuffer )
{
    return m_PDDFuncTbl.PDD_RegisterClientBuffer( m_PDDContext, ulPinId, pBuffer );
}

DWORD CCameraDevice::PDDUnRegisterClientBuffer( ULONG ulPinId, PVOID pBuffer )
{   
    return m_PDDFuncTbl.PDD_UnRegisterClientBuffer( m_PDDContext, ulPinId, pBuffer );
}

DWORD 
CCameraDevice::PDDHandlePinCustomProperties(
    ULONG ulPinId,
    PUCHAR pInBuf,
    DWORD  InBufLen,
    PUCHAR pOutBuf,
    DWORD  OutBufLen,
    PDWORD pdwBytesTransferred
    )
{   
    return m_PDDFuncTbl.PDD_HandleModeCustomProperties( m_PDDContext, ulPinId, pInBuf, InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred );
}