camera_pdd.cpp

6410BSP3

    m_SensorProps[ENUM_FOCUS].pRangeNStep             = &FocusRangeAndStep[0];
    m_SensorProps[ENUM_FOCUS].ulFlags                 = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
    m_SensorProps[ENUM_FOCUS].ulCapabilities          = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
    m_SensorProps[ENUM_FOCUS].fSetSupported           = VideoProcAmpProperties[ENUM_FOCUS-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
    m_SensorProps[ENUM_FOCUS].fGetSupported           = VideoProcAmpProperties[ENUM_FOCUS-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
    m_SensorProps[ENUM_FOCUS].pCsPropValues           = &FocusValues;

    m_SensorProps[ENUM_FLASH].ulCurrentValue          = FlashDefault;
    m_SensorProps[ENUM_FLASH].ulDefaultValue          = FlashDefault;
    m_SensorProps[ENUM_FLASH].pRangeNStep             = &FlashRangeAndStep[0];
    m_SensorProps[ENUM_FLASH].ulFlags                 = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
    m_SensorProps[ENUM_FLASH].ulCapabilities          = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
    m_SensorProps[ENUM_FLASH].fSetSupported           = VideoProcAmpProperties[ENUM_FLASH-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
    m_SensorProps[ENUM_FLASH].fGetSupported           = VideoProcAmpProperties[ENUM_FLASH-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
    m_SensorProps[ENUM_FLASH].pCsPropValues           = &FlashValues;
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    m_pModeVideoFormat = NULL;
    // Allocate Video Format specific array.
    m_pModeVideoFormat = new PINVIDEOFORMAT[m_ulCTypes];
    if( NULL == m_pModeVideoFormat )
    {
        return ERROR_INSUFFICIENT_BUFFER;
    }

    // Video Format initialization
    m_pModeVideoFormat[CAPTURE].categoryGUID         = PINNAME_VIDEO_CAPTURE;
    //mio
    m_pModeVideoFormat[CAPTURE].ulAvailFormats       = CAPTURE_FORMATS_COUNT;
    m_pModeVideoFormat[CAPTURE].pCsDataRangeVideo = new PCS_DATARANGE_VIDEO[m_pModeVideoFormat[CAPTURE].ulAvailFormats];

    if( NULL == m_pModeVideoFormat[CAPTURE].pCsDataRangeVideo )
    {
        return ERROR_INSUFFICIENT_BUFFER;
    }

    m_pModeVideoFormat[CAPTURE].pCsDataRangeVideo[0] = &DCAM_StreamMode_5;
    m_pModeVideoFormat[CAPTURE].pCsDataRangeVideo[1] = &DCAM_StreamMode_6;
    m_pModeVideoFormat[CAPTURE].pCsDataRangeVideo[2] = &DCAM_StreamMode_7;
    m_pModeVideoFormat[CAPTURE].pCsDataRangeVideo[3] = &DCAM_StreamMode_8;
    m_pModeVideoFormat[CAPTURE].pCsDataRangeVideo[4] = &DCAM_StreamMode_9;

    m_pModeVideoFormat[STILL].categoryGUID           = PINNAME_VIDEO_STILL;
    //mio
    m_pModeVideoFormat[STILL].ulAvailFormats         = STILLSHOT_FORMATS_COUNT;
    m_pModeVideoFormat[STILL].pCsDataRangeVideo = new PCS_DATARANGE_VIDEO[m_pModeVideoFormat[STILL].ulAvailFormats];

    if( NULL == m_pModeVideoFormat[STILL].pCsDataRangeVideo )
    {
        return ERROR_INSUFFICIENT_BUFFER;
    }

    m_pModeVideoFormat[STILL].pCsDataRangeVideo[0]   = &DCAM_StreamMode_6;
    m_pModeVideoFormat[STILL].pCsDataRangeVideo[1]   = &DCAM_StreamMode_8;

    if( 3 == m_ulCTypes )
    {
        m_pModeVideoFormat[PREVIEW].categoryGUID         = PINNAME_VIDEO_PREVIEW;
        //mio
        m_pModeVideoFormat[PREVIEW].ulAvailFormats       = PREVIEW_FORMATS_COUNT;
        m_pModeVideoFormat[PREVIEW].pCsDataRangeVideo = new PCS_DATARANGE_VIDEO[m_pModeVideoFormat[PREVIEW].ulAvailFormats];

        if( NULL == m_pModeVideoFormat[PREVIEW].pCsDataRangeVideo )
        {
            return ERROR_INSUFFICIENT_BUFFER;
        }
        m_pModeVideoFormat[PREVIEW].pCsDataRangeVideo[0] = &DCAM_StreamMode_0;
        m_pModeVideoFormat[PREVIEW].pCsDataRangeVideo[1] = &DCAM_StreamMode_1;
        m_pModeVideoFormat[PREVIEW].pCsDataRangeVideo[2] = &DCAM_StreamMode_2;
        m_pModeVideoFormat[PREVIEW].pCsDataRangeVideo[3] = &DCAM_StreamMode_3;
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    m_pModeVideoCaps = NULL;
    // Allocate Video Control Caps specific array.
    m_pModeVideoCaps = new VIDCONTROLCAPS[m_ulCTypes];
    if( NULL == m_pModeVideoCaps )
    {
        return ERROR_INSUFFICIENT_BUFFER;
    }
    // Video Control Caps

    m_pModeVideoCaps[CAPTURE].DefaultVideoControlCaps     = DefaultVideoControlCaps[CAPTURE];
    m_pModeVideoCaps[CAPTURE].CurrentVideoControlCaps     = DefaultVideoControlCaps[CAPTURE];;
    m_pModeVideoCaps[STILL].DefaultVideoControlCaps       = DefaultVideoControlCaps[STILL];
    m_pModeVideoCaps[STILL].CurrentVideoControlCaps       = DefaultVideoControlCaps[STILL];;
    if( 3 == m_ulCTypes )
    {
        // Note PREVIEW control caps are the same, so we don't differentiate
        m_pModeVideoCaps[PREVIEW].DefaultVideoControlCaps     = DefaultVideoControlCaps[PREVIEW];
        m_pModeVideoCaps[PREVIEW].CurrentVideoControlCaps     = DefaultVideoControlCaps[PREVIEW];;
    }

   // m_SensorModeInfo[CAPTURE].MemoryModel = CSPROPERTY_BUFFER_CLIENT_UNLIMITED;
    m_SensorModeInfo[CAPTURE].MaxNumOfBuffers = 1;
    m_SensorModeInfo[CAPTURE].PossibleCount = 1;
  //  m_SensorModeInfo[STILL].MemoryModel = CSPROPERTY_BUFFER_CLIENT_UNLIMITED;
    m_SensorModeInfo[STILL].MaxNumOfBuffers = 1;
    m_SensorModeInfo[STILL].PossibleCount = 1;
    if( 3 == m_ulCTypes )
    {
   //     m_SensorModeInfo[PREVIEW].MemoryModel = CSPROPERTY_BUFFER_CLIENT_UNLIMITED;
        m_SensorModeInfo[PREVIEW].MaxNumOfBuffers = 1;
        m_SensorModeInfo[PREVIEW].PossibleCount = 1;
    }

    m_ppModeContext = new LPVOID[m_ulCTypes];
    if ( NULL == m_ppModeContext )
    {
        return ERROR_INSUFFICIENT_BUFFER;
    }

    m_pCurrentFormat = new CS_DATARANGE_VIDEO[m_ulCTypes];
    if( NULL == m_pCurrentFormat )
    {
        return ERROR_INSUFFICIENT_BUFFER;
    }

    return ERROR_SUCCESS;
}


void CCameraPdd::PDD_DeInit()
{
    RETAILMSG(MSG_INOUT,(TEXT("++++++++++++++++++++PDD_DeInit\n")));
    CameraDeinit();

    if( NULL != m_ppModeContext )
    {
        delete [] m_ppModeContext;
        m_ppModeContext = NULL;
    }

    if( NULL != m_pModeVideoCaps )
    {
        delete [] m_pModeVideoCaps;
        m_pModeVideoCaps = NULL;
    }

    if( NULL != m_pModeVideoFormat )
    {
        if (NULL != m_pModeVideoFormat[CAPTURE].pCsDataRangeVideo)
        {
            delete [] m_pModeVideoFormat[CAPTURE].pCsDataRangeVideo;
            m_pModeVideoFormat[CAPTURE].pCsDataRangeVideo = NULL;
        }

        if (NULL != m_pModeVideoFormat[STILL].pCsDataRangeVideo)
        {
            delete [] m_pModeVideoFormat[STILL].pCsDataRangeVideo;
            m_pModeVideoFormat[STILL].pCsDataRangeVideo = NULL;
        }

        if (NULL != m_pModeVideoFormat[PREVIEW].pCsDataRangeVideo)
        {
            delete [] m_pModeVideoFormat[PREVIEW].pCsDataRangeVideo;
            m_pModeVideoFormat[PREVIEW].pCsDataRangeVideo = NULL;
        }

        delete [] m_pModeVideoFormat;
        m_pModeVideoFormat = NULL;
    }
    RETAILMSG(MSG_INOUT,(TEXT("---------------------PDD_DeInit\n")));
}


DWORD CCameraPdd::GetAdapterInfo( PADAPTERINFO pAdapterInfo )
{
        RETAILMSG(MSG_INOUT,(TEXT("++++++++++++++++++++GetAdapterInfo\n")));
    pAdapterInfo->ulCTypes = m_ulCTypes;
    pAdapterInfo->PowerCaps = PowerCaps;
    pAdapterInfo->ulVersionID = DRIVER_VERSION_2; //Camera MDD and DShow support DRIVER_VERSION and DRIVER_VERSION_2. Defined in camera.h
    memcpy( &pAdapterInfo->SensorProps, &m_SensorProps, sizeof(m_SensorProps));

    return ERROR_SUCCESS;

}

DWORD CCameraPdd::HandleVidProcAmpChanges( DWORD dwPropId, LONG lFlags, LONG lValue )
{
        RETAILMSG(MSG_INOUT,(TEXT("++++++++++++++++++++HandleVidProcAmpChanges\n")));
    PSENSOR_PROPERTY pDevProp = NULL;

    pDevProp = m_SensorProps + dwPropId;

    if( CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL == lFlags )
    {
        pDevProp->ulCurrentValue = lValue;
    }

    pDevProp->ulFlags = lFlags;
    return ERROR_SUCCESS;
}

DWORD CCameraPdd::HandleCamControlChanges( DWORD dwPropId, LONG lFlags, LONG lValue )
{
    RETAILMSG(MSG_INOUT,(TEXT("++++++++++++++++++++HandleCamControlChanges\n")));
    PSENSOR_PROPERTY pDevProp = NULL;
    int    value;
    pDevProp = m_SensorProps + dwPropId;
    
    if( CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL == lFlags )
    {
        pDevProp->ulCurrentValue = lValue;
        switch(dwPropId)
        {
        case ENUM_ZOOM:
            RETAILMSG(MSG_INFO,(TEXT("[CAM] Set Zoom value = %d!!!\n"), pDevProp->ulCurrentValue));
            value = (int)((pDevProp->ulCurrentValue-ZoomRangeAndStep[0].Bounds.UnsignedMinimum)/ZoomRangeAndStep[0].SteppingDelta);
            RETAILMSG(MSG_INFO,(TEXT("[CAM] Zoom value=%ld\n"),value));
            if(!CameraZoom(value))
            {
                RETAILMSG(MSG_ERROR,(TEXT("[CAM_ERROR] Zoom value %ld is not supported\n"),value));
            }
            break;
        default:
            break;
        }        
    }

    pDevProp->ulFlags = lFlags;
    
    return ERROR_SUCCESS;
}

DWORD CCameraPdd::HandleVideoControlCapsChanges( LONG lModeType ,ULONG ulCaps )
{
        RETAILMSG(MSG_INOUT,(TEXT("++++++++++++++++++++HandleVideoControlCapsChanges\n")));
    m_pModeVideoCaps[lModeType].CurrentVideoControlCaps = ulCaps;
    return ERROR_SUCCESS;
}

DWORD CCameraPdd :: SetPowerState( CEDEVICE_POWER_STATE PowerState )
{
    DWORD dwErr = ERROR_SUCCESS;    
    RETAILMSG(MSG_INOUT,(TEXT("++++++++++++++++++++SetPowerState\n")));
    switch (PowerState)
    {
    case D0:  
        RETAILMSG(MSG_ON, (TEXT("[CAM]: D0\r\n")));

        if (m_PowerState != D0) 
            ResumeCamera();

        m_PowerState = D0;

        dwErr = ERROR_SUCCESS;
        break;

    case D4:
        RETAILMSG(MSG_ON, (TEXT("[CAM]: D4\r\n")));
        if (m_PowerState != D4) 
            SuspendCamera();
           m_PowerState = D4;
        dwErr = ERROR_SUCCESS;
        break;

    default:
        break;
    }
    return dwErr;
}

DWORD CCameraPdd::HandleAdapterCustomProperties( PUCHAR pInBuf, DWORD  InBufLen, PUCHAR pOutBuf, DWORD  OutBufLen, PDWORD pdwBytesTransferred )
{
        RETAILMSG(MSG_INOUT,(TEXT("++++++++++++++++++++HandleAdapterCustomProperties\n")));
     DEBUGMSG( ZONE_IOCTL, ( _T("IOControl Adapter PDD: Unsupported PropertySet Request\r\n")) );
    return ERROR_NOT_SUPPORTED;
}

DWORD CCameraPdd::InitSensorMode( ULONG ulModeType, LPVOID ModeContext )
{
    DWORD hr = ERROR_SUCCESS;
    RETAILMSG(MSG_INOUT,(TEXT("++++++++++++++++++++InitSensorMode\n")));
    ASSERT( ModeContext );

    EnterCriticalSection( &m_csPddDevice );
    m_iPinUseCount += 1;
    if(m_iPinUseCount > MAX_SUPPORTED_PINS)
        m_iPinUseCount = MAX_SUPPORTED_PINS;
    //RETAILMSG(1,(TEXT("m_iPinUseCount=%d\r\n"),m_iPinUseCount));
    if(m_iPinUseCount == 1)
    {
        CameraClockOn(TRUE);
        CameraResume();
    }
    LeaveCriticalSection( &m_csPddDevice );
    m_ppModeContext[ulModeType] = ModeContext;

    return hr;
}

DWORD CCameraPdd::DeInitSensorMode( ULONG ulModeType )
{
    RETAILMSG(MSG_INOUT,(TEXT("++++++++++++++++++++DeInitSensorMode\n")));
    EnterCriticalSection( &m_csPddDevice );
    m_iPinUseCount -= 1;
    if(m_iPinUseCount < 0)
        m_iPinUseCount = 0;
    //RETAILMSG(1,(TEXT("m_iPinUseCount=%d\r\n"),m_iPinUseCount));
    if(m_iPinUseCount == 0)
    {
        CameraSleep();
        CameraClockOn(FALSE);
    }
    LeaveCriticalSection( &m_csPddDevice );
    return ERROR_SUCCESS;
}

DWORD CCameraPdd::SetSensorState( ULONG lModeType, CSSTATE csState )
{
    DWORD dwError = ERROR_SUCCESS;
        RETAILMSG(MSG_INOUT,(TEXT("++++++++++++++++++++SetSensorState\n")));
    int format = (lModeType==CAPTURE)?VIDEO_CAPTURE_BUFFER:((lModeType==STILL)?STILL_CAPTURE_BUFFER:PREVIEW_CAPTURE_BUFFER);

    switch ( csState )
    {
        case CSSTATE_STOP:
            RETAILMSG(MSG_ON,(TEXT("[CAM] %d STOP\n"),format));
            m_CsState[lModeType] = CSSTATE_STOP;

            if( STILL == lModeType )
            {
                m_bStillCapInProgress = false;
            } 
            else if(CAPTURE == lModeType)
            {
                m_bCameraVideoRunning = false;
            } 
            else
            {
                m_bCameraPreviewRunning = false;
            }
            CameraCaptureControl(format, FALSE);
            break;

        case CSSTATE_PAUSE:
            RETAILMSG(MSG_ON,(TEXT("[CAM] %d PAUSE\n"),format));
            if(CAPTURE == lModeType)
            {
                m_bCameraVideoRunning = false;
            } 
            else
            {
                m_bCameraPreviewRunning = false;
            }            
            m_CsState[lModeType] = CSSTATE_PAUSE;
            //mio
            CameraCaptureControl(format, FALSE);
            break;

        case CSSTATE_RUN:
            RETAILMSG(MSG_ON,(TEXT("[CAM] %d RUN\n"),format));
            m_CsState[lModeType] = CSSTATE_RUN;

            if(CAPTURE == lModeType)
            {
                m_bCameraVideoRunning = true;
            } 
            else
            {
                m_bCameraPreviewRunning = true;
            }
            SetSensorFormat(lModeType);
            CameraSetRegisters(format);
                        //mio
            CameraCaptureControl(format,TRUE);
            break;

        default:
            DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, ( _T("IOControl(%08x): Incorrect State\r\n"), this ) );
            dwError = ERROR_INVALID_PARAMETER;
    }

    return dwError;