pindevice.cpp

三星2440原版bsp

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
#define PININTERFACE
#include <windows.h>
#include <Msgqueue.h>
#include <pwinbase.h>
#include <camera.h>
#include "CameraDriver.h"
#include "adapterprops.h"
#include "PinDriver.h"
#include "wchar.h"

//#define RETAILMSG		RETAILMSG
#define RETAIL_ON		1

CPinDevice :: CPinDevice( )
{
	RETAILMSG(RETAIL_ON,(TEXT("+-CPinDevice :: CPinDevice\r\n")));
    m_dwMemoryModel             = CSPROPERTY_BUFFER_CLIENT_LIMITED;
    m_fClientInitialized        = false;
    m_fDiscontinuity            = true;
    m_ulPinId                   = -1; // Invalid Pin Id
    m_ulMaxNumOfBuffers         = BUFFER_COUNT;
    m_ulFrameSize               = 0;
    m_RtAveTimePerFrame         = 0;
    m_ulFramesDropped           = 0;
    m_ulPictureNumber           = 0;
    m_hMsgQ                     = NULL;
    m_hTimerDll                 = NULL;
    m_TimerIdentifier           = NULL;
    m_CsState                   = CSSTATE_STOP;
    m_pfnTimeSetEvent           = NULL;
    m_pfnTimeKillEvent          = NULL;
    m_msStart                   = 0xFFFFFFFF;
    m_msLastPT                  = 0;
    m_pfnBufferFill             = NULL;
    m_pStreamDescriptorList     = NULL;
    m_dwBufferCount             = 0;

    InitializeCriticalSection( &m_csStreamBuffer );
}

CPinDevice :: ~CPinDevice( )
{
	RETAILMSG(RETAIL_ON,(TEXT("+-CPinDevice :: ~CPinDevice\r\n")));
    ResetBufferList( );
    
    if ( NULL != m_TimerIdentifier && NULL != m_pfnTimeKillEvent )
    {
        m_pfnTimeKillEvent( m_TimerIdentifier );
        m_TimerIdentifier = NULL;
    }

    if ( NULL != m_hMsgQ )
    {
        CloseMsgQueue( m_hMsgQ );
    }

    if ( NULL != m_hTimerDll )
    {
        FreeLibrary( m_hTimerDll );
    }

    if ( NULL != m_pStreamDescriptorList )
    {
        LocalFree( m_pStreamDescriptorList );
        m_pStreamDescriptorList = NULL;
    }

    m_CsState = CSSTATE_STOP;
    DeleteCriticalSection( &m_csStreamBuffer );
}

bool CPinDevice :: InitializeSubDevice( PCAMERADEVICE pCamDevice )
{
    TCHAR *tszLibraryName = NULL;
    TCHAR *tszFunctionName = NULL;
    DWORD dwDataSize = 0;
    DWORD dwDataType = 0;
    HKEY hkeyFillLibrary = NULL;

	RETAILMSG(RETAIL_ON,(TEXT("+-CPinDevice :: InitializeSubDevice\r\n")));


    // if a user specified function doesn't exist, then use the default.
    //if(!m_pfnBufferFill)
    //    m_pfnBufferFill = &BufferFill;

    m_pCamAdapter = pCamDevice ;
    if (NULL == m_pCamAdapter)
        return false ;

    // Let's retrieve the pin model from the registry. If none is provided, 
    // the default model will be APPLICATION_LIMITED
    ReadMemoryModelFromRegistry();    
    return true ;
}

bool CPinDevice :: CloseSubDevice()
{
	RETAILMSG(RETAIL_ON,(TEXT("+-CPinDevice :: CloseSubDevice\r\n")));
    m_pCamAdapter->DecrCInstances( m_ulPinId ) ;

    // free the library if it was loaded.
    if(m_hInstBuffer)
    {
        FreeLibrary(m_hInstBuffer);
        m_hInstBuffer = 0;
    }

    // and if we were using the filler function from the library, invalidate it.
    //if(m_pfnBufferFill != &BufferFill)
    //    m_pfnBufferFill = NULL;
    
    return true ;
}

ULONG CPinDevice :: PictureNumber( ) const
{
	RETAILMSG(RETAIL_ON,(TEXT("+-CPinDevice :: PictureNumber\r\n")));
    return m_ulPictureNumber;
}

ULONG CPinDevice :: FramesDropped( ) const
{
    return m_ulFramesDropped;
}

ULONG CPinDevice :: FrameSize( ) const
{
    return m_ulFrameSize;
}

DWORD CPinDevice :: StreamInstantiate( PCSPROPERTY_STREAMEX_S pCsPropStreamEx, PUCHAR pOutBuf, DWORD  OutBufLen, PDWORD pdwBytesTransferred )
{
    PCS_DATARANGE_VIDEO pCsDataRangeVid = NULL;
    DWORD               dwError         = ERROR_INVALID_PARAMETER;

	RETAILMSG(RETAIL_ON,(TEXT("+-CPinDevice :: StreamInstantiate\r\n")));
    
    if ( -1 != m_ulPinId )
    {
        RETAILMSG(RETAIL_ON, (_T("PIN_IOControl(%08x): Pin %d is already instantiated.\r\n"), this, m_ulPinId )) ;
        return dwError ;
    }

    if ( false == m_pCamAdapter->IsValidPin( pCsPropStreamEx->CsPin.PinId ) )
    {
        RETAILMSG(RETAIL_ON, (_T("PIN_IOControl(%08x): Invalid Pin Id\r\n"), this)) ;
        return dwError ;
    }
    
    m_ulPinId = pCsPropStreamEx->CsPin.PinId ;
	RETAILMSG(RETAIL_ON, (TEXT("---------------->>>> PIN ID is: %d"), m_ulPinId));
    
    // Let us set a default format for this pin

    if ( false == m_pCamAdapter->GetPinFormat( m_ulPinId, 1, &pCsDataRangeVid ) )
    {
        RETAILMSG(RETAIL_ON, (_T("PIN_IOControl(%08x): No Pin Format provided for pin\r\n"), this)) ;
        return dwError ;
    }
    
    memcpy(&m_CsDataRangeVideo,pCsDataRangeVid, sizeof(CS_DATARANGE_VIDEO) ) ;

    if ( NULL == pCsPropStreamEx->hMsgQueue )
    {
        RETAILMSG(RETAIL_ON, (_T("PIN_IOControl(%08x): NULL Handle provided for msgqueue\r\n"), this)) ;
        return dwError ;
    }    

    if ( false == m_pCamAdapter->IncrCInstances( m_ulPinId, this ) )
    {
        RETAILMSG(RETAIL_ON, (_T("PIN_IOControl(%08x): Pin %d is already instantiated.\r\n"), this, m_ulPinId)) ;
        return dwError ;
    }

    //TODO : Check whether the client created msgqueue with enough buffersize and number of buffers.

    MSGQUEUEOPTIONS msgQueueOptions;
    msgQueueOptions.bReadAccess = FALSE; // we need write-access to msgqueue
    msgQueueOptions.dwSize      = sizeof(MSGQUEUEOPTIONS);

    if ( NULL == (m_hMsgQ = OpenMsgQueue( GetCallerProcess(),pCsPropStreamEx->hMsgQueue, &msgQueueOptions ) ) )
    {
        RETAILMSG(RETAIL_ON, (_T("PIN_IOControl(%08x): Failed to open MsgQueue\r\n"), this)) ;
        m_pCamAdapter->DecrCInstances( m_ulPinId ) ;
        return dwError ;
    }

    return ERROR_SUCCESS ;
}

void CPinDevice :: SetState( CSSTATE CsState, CSSTATE *CsPrevState )
{
	RETAILMSG(RETAIL_ON,(TEXT("+-CPinDevice :: SetState\r\n")));
    if ( NULL != CsPrevState )
        *CsPrevState = m_CsState ;
    
    m_CsState = CsState ;
    return ;
}


void CPinDevice::EnableCamera()
{
	m_pCamAdapter->CameraEnable();		
}



void CPinDevice::DisableCamera()
{
	m_pCamAdapter->CameraDisable();
}
bool CPinDevice :: CreateTimer()
{
	RETAILMSG(RETAIL_ON,(TEXT("+-CPinDevice :: CreateTimer\r\n")));
    if ( NULL == m_hTimerDll )
    {
        m_hTimerDll        = LoadLibrary( L"MMTimer.dll" );
        m_pfnTimeSetEvent  = (FNTIMESETEVENT)GetProcAddress( m_hTimerDll, L"timeSetEvent" );
        m_pfnTimeKillEvent = (FNTIMEKILLEVENT)GetProcAddress( m_hTimerDll, L"timeKillEvent" );

        if ( NULL == m_pfnTimeSetEvent || NULL == m_pfnTimeKillEvent )
        {
            RETAILMSG(RETAIL_ON, (_T("PIN_IOControl(%08x): GetProcAddress Returned Null.\r\n"), this));
            return false;
        }
    }
    

    if ( NULL == m_hTimerDll )
    {
            RETAILMSG(RETAIL_ON, (_T("PIN_IOControl(%08x): LoadLibrary failedr.\r\n"), this));
            return false;
    }

	EnableCamera();
    ASSERT( m_pfnTimeSetEvent );

    if ( NULL == m_TimerIdentifier )
    {
        RETAILMSG(RETAIL_ON, (_T("PIN_IOControl(%08x): Creating new timer.\r\n"), this));
        m_TimerIdentifier = m_pfnTimeSetEvent( (ULONG)m_RtAveTimePerFrame/10000, 10, CPinDevice::TimerCallBack, reinterpret_cast<DWORD>(this), TIME_PERIODIC|TIME_CALLBACK_FUNCTION);

        if ( NULL == m_TimerIdentifier )
        {
            RETAILMSG(RETAIL_ON, (_T("PIN_IOControl(%08x): Timer could not be created.\r\n"), this));
            return false;
        }
    }
    else
    {
        RETAILMSG(RETAIL_ON, (_T("PIN_IOControl(%08x): Timer already created.\r\n"), this));
    }

    return true;
}

void CPinDevice :: TimerCallBack( UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2 )
{
    UNREFERENCED_PARAMETER(uTimerID) ;
    UNREFERENCED_PARAMETER(uMsg);
    UNREFERENCED_PARAMETER(dw1);
    UNREFERENCED_PARAMETER(dw2);

    PPINDEVICE pPinDevice = reinterpret_cast<PPINDEVICE>(dwUser) ;
    if( NULL == pPinDevice )
    {
        RETAILMSG(RETAIL_ON, (_T("PIN_IOControl: TimerCallBack PinDevice is NULL.\r\n"))) ;
    }
    else
    {
        pPinDevice->HandlePinIO() ;
    }
}

BOOL CPinDevice::InitMsgQueueDescriptor (PCCS_MSGQUEUE_BUFFER pCsMsgQBuff, PCS_STREAM_DESCRIPTOR pCsStreamDesc, PVOID pMappedData, PVOID pUnmappedData, BOOL bBufferFill, DWORD dwBuffNumber)
{
    PCSSTREAM_HEADER pCsStreamHeader = reinterpret_cast<PCSSTREAM_HEADER>(pCsStreamDesc);
    PCS_FRAME_INFO   pCsFrameInfo    = reinterpret_cast<PCS_FRAME_INFO>(pCsStreamHeader + 1);

	RETAILMSG(RETAIL_ON,(TEXT("+-CPinDevice :: InitMsgQueueDescriptor\r\n")));
    if(( pCsStreamHeader == NULL ) || ( pCsFrameInfo == NULL ))
    {
        RETAILMSG(RETAIL_ON, (_T("InitMsgQueueDescriptor(%08x): Invalid Stream Descriptor\r\n"), this));
        return false;
    }

	RETAILMSG(RETAIL_ON,(TEXT("MQ1 pMappedData = 0x%x, pUnmappedData = 0x%x\r\n"), pMappedData, pUnmappedData));
    if (bBufferFill)
    {
        // The buffer fill function must use the pointer that's been mapped into this process.
        pCsStreamHeader->Data = pMappedData;
		RETAILMSG(RETAIL_ON,(TEXT("MQ2\r\n")));

        BUFFERFILLPARAMS buffFillParams;
        m_pCamAdapter->GetBrightness( &(buffFillParams.ulBrightness) );
        m_pCamAdapter->GetZoom( &(buffFillParams.ulZoom) );
		RETAILMSG(RETAIL_ON,(TEXT("MQ3\r\n")));

        EnterCriticalSection(&m_csStreamBuffer) ;
        //pCsStreamHeader->DataUsed = m_pfnBufferFill( (PUCHAR) pMappedData, reinterpret_cast<PCS_VIDEOINFOHEADER>(&m_CsDataRangeVideo.VideoInfoHeader),  IMAGE_GRAY_INCREASING, false, (LPVOID)&buffFillParams ) ;
        pCsStreamHeader->DataUsed = BufferFill( (PUCHAR) pMappedData, reinterpret_cast<PCS_VIDEOINFOHEADER>(&m_CsDataRangeVideo.VideoInfoHeader),  IMAGE_GRAY_INCREASING, false, (LPVOID)&buffFillParams ) ;
        LeaveCriticalSection(&m_csStreamBuffer) ;
		RETAILMSG(RETAIL_ON,(TEXT("MQ4\r\n")));

        pCsFrameInfo->PictureNumber = (LONGLONG)++m_ulPictureNumber;
        pCsFrameInfo->DropCount     = (LONGLONG)m_ulFramesDropped;
    }
	RETAILMSG(RETAIL_ON,(TEXT("MQ5\r\n")));
    // The message queue requires the original pointer value.
    pCsStreamHeader->Data = pUnmappedData;
	RETAILMSG(RETAIL_ON,(TEXT("MQ6\r\n")));

    // Init the flags to zero
    pCsStreamHeader->OptionsFlags = 0;

    // Set the discontinuity flag if frames have been previously
    // dropped, and then reset our internal flag

    if ( true == m_fDiscontinuity ) 
    {
        pCsStreamHeader->OptionsFlags |= CSSTREAM_HEADER_OPTIONSF_DATADISCONTINUITY;
        m_fDiscontinuity = false;
    }
	RETAILMSG(RETAIL_ON,(TEXT("MQ7\r\n")));
    DWORD msNow = GetTickCount();

    if (m_msStart == 0xFFFFFFFF)
    {
        m_msStart = msNow;
    }

    //
    // Return the timestamp for the frame
    //
    pCsStreamHeader->PresentationTime.Numerator   = 1;
    pCsStreamHeader->PresentationTime.Denominator = 1;
    pCsStreamHeader->Duration                     = m_RtAveTimePerFrame;
    DWORD prevPT = m_msLastPT;
    if (bBufferFill)
    {
        m_msLastPT = msNow - m_msStart;

        pCsStreamHeader->PresentationTime.Time        = (LONGLONG) m_msLastPT * 10000;  // presentation time stamp in 100s of ns

    }
    else
    {
        pCsStreamHeader->PresentationTime.Time        = 0;
    }

    RETAILMSG(RETAIL_ON, (_T("InitMsgQueueDescriptor: LastPT = %d, elapsed = %d\n"), m_msLastPT, m_msLastPT - prevPT));

    // clear the timestamp valid flags
    pCsStreamHeader->OptionsFlags &= ~( CSSTREAM_HEADER_OPTIONSF_TIMEVALID | CSSTREAM_HEADER_OPTIONSF_DURATIONVALID );

    // Every frame we generate is a key frame (aka SplicePoint)
    // Delta frames (B or P) should not set this flag

    pCsStreamHeader->OptionsFlags |= CSSTREAM_HEADER_OPTIONSF_SPLICEPOINT;

    pCsMsgQBuff->CsMsgQueueHeader.Size    = sizeof(CS_MSGQUEUE_HEADER);
    pCsMsgQBuff->CsMsgQueueHeader.Flags   = FLAG_MSGQ_FRAME_BUFFER;
    pCsMsgQBuff->CsMsgQueueHeader.Context = NULL;
    pCsMsgQBuff->pStreamDescriptor        = pCsStreamDesc;
	pCsMsgQBuff->dwInfo						= dwBuffNumber;

    RETAILMSG(RETAIL_ON, (_T("InitMsgQueueDescriptor(%08x): Frame buf queued: %d (dropped %d), start %d, time %d\n"), 
        this,
        (LONG)pCsFrameInfo->PictureNumber, 
        (LONG)pCsFrameInfo->DropCount, 
        (LONG)m_msStart,
        (LONG)(pCsStreamHeader->PresentationTime.Time / 10000)));

    return TRUE;
   
}

void  CPinDevice::FlushBufferQueue()
{
    PCS_STREAM_DESCRIPTOR pCsStreamDesc = NULL;
    PVOID                 pMappedData   = NULL;
    PVOID                 pUnmappedData = NULL;
	CCS_MSGQUEUE_BUFFER    CsMsgQBuff ;

	RETAILMSG(RETAIL_ON,(TEXT("+-CPinDevice :: FlushBufferQueue\r\n")));
    DWORD dwSavedPermissions = SetProcPermissions( (DWORD)-1 ) ;
	DWORD dwBuffNumber = 0;

	while (( true == RemoveBufferFromList( &pCsStreamDesc, &pMappedData, &pUnmappedData, &dwBuffNumber)) && ( NULL != pCsStreamDesc ) && ( m_hMsgQ != NULL ))
    {
	    if (!InitMsgQueueDescriptor (&CsMsgQBuff, pCsStreamDesc, pMappedData, pUnmappedData, FALSE, dwBuffNumber))
        {
            continue;
        }

        if ( false == WriteMsgQueue( m_hMsgQ, reinterpret_cast<LPVOID>(&CsMsgQBuff),  sizeof(CS_MSGQUEUE_BUFFER), PIN_TIMEOUT, 0 ) )
        {
            RETAILMSG(RETAIL_ON, (_T("PIN_Function(%08x): WriteMsgQueue returned false\r\n"), this));
        }
    }

    SetProcPermissions( dwSavedPermissions );

    return;
}

void CPinDevice :: HandlePinIO()
{
	RETAILMSG(RETAIL_ON,(TEXT("+-CPinDevice :: HandlePinIO\r\n")));
    if ( CSSTATE_RUN != m_CsState ) 
    {
		RETAILMSG(RETAIL_ON,(TEXT("HandlePinIO: CSSTATE_RUN != m_CsState\r\n")));
        return;
    }

    if ( STILL == m_ulPinId )
    {
        m_pCamAdapter->PauseCaptureAndPreview( ) ;
    }

    DWORD dwSavedPermissions = SetProcPermissions( (DWORD)-1 ) ;
    
    PCS_STREAM_DESCRIPTOR pCsStreamDesc = NULL;
    PVOID                 pMappedData   = NULL;
    PVOID                 pUnmappedData = NULL;
	CCS_MSGQUEUE_BUFFER    CsMsgQBuff ;
	DWORD 			dwBuffNumber = 0;

	if ( false == RemoveBufferFromList( &pCsStreamDesc, &pMappedData, &pUnmappedData, &dwBuffNumber) || NULL == pCsStreamDesc )
    {
        // We dropped a frame
        m_ulFramesDropped++;
        m_fDiscontinuity = true;
        SetProcPermissions( dwSavedPermissions  );

        return;
    }

	if (!InitMsgQueueDescriptor (&CsMsgQBuff, pCsStreamDesc, pMappedData, pUnmappedData, TRUE, dwBuffNumber))
    {
        SetProcPermissions( dwSavedPermissions  );
        return;
    }