camerawindow.cpp

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

 *
 *  PARAMETERS:     None
 *
 *  RETURNS:        None
 *
 ********************************************************************/
void CCameraWindow::UpdateButtons()
{
    UINT ii;

    for(ii=0; ii<SKIN_SIZE; ii++)
    {
        switch(m_binfo[BUTTON_CAPTURE].eState)
        {
            case ENABLED:
                SetWindowText(m_binfo[ii].hWnd, m_binfo[ii].pCaptNormal);
                EnableWindow(m_binfo[ii].hWnd, TRUE);
                break;

            case DISABLED:
                EnableWindow(m_binfo[BUTTON_CAPTURE].hWnd, FALSE);
                break;

            case ONCAPTURE:
                SetWindowText(m_binfo[ii].hWnd, m_binfo[ii].pCaptCapture);
                EnableWindow(m_binfo[ii].hWnd, TRUE);
                break;

            default:
                RETAILMSG(CAMAPP_ERROR_MSG,(TEXT("UpdateButtons: Invalid button state!\r\n")));
                break;
        }
    }
}

/********************************************************************
 *
 *  FUNCTION:    ReadPinDataRanges
 *
 *  DESCRIPTION:    
 *
 *  PARAMETERS:    None
 *
 *  RETURNS:        TRUE if successfully, otherwise return FALSE
 *
 ********************************************************************/

void CCameraWindow::ReadPinDataRanges(UINT32 pinId)
{
    PCSMULTIPLE_ITEM pDataRanges;
    DWORD dwDataRangesSize;
    UINT32 iNumDataRanges;
    DWORD dwBytesTransferred;

    // Get data format for preview pin
    CSP_PIN pin =
    {
        { // CSPROPERTY
            CSPROPSETID_Pin,           // GUID Set
            CSPROPERTY_PIN_DATARANGES, // ULONG Id
            CSPROPERTY_TYPE_GET        // ULONG Flags
        },
        pinId,                         // ULONG PinID
        0                              // ULONG Reserved
    };

    // First, call with NULL output buffer...this will not succeed, but
    // we will be returned the size of out datarange structure
    if (!DeviceIoControl(m_hCameraDll,     // file handle to the driver
             IOCTL_CS_PROPERTY,            // I/O control code
             &pin,                         // in buffer
             sizeof(CSP_PIN),              // in buffer size
             NULL,                         // out buffer
             0,                            // out buffer size
             &dwBytesTransferred,          // number of bytes returned
             NULL))                        // ignored (=NULL)
    {
        RETAILMSG(CAMAPP_ERROR_MSG,(TEXT("ReadPinDataRanges: Get size of dataranges failed!\r\n")));
    }
    
    dwDataRangesSize = dwBytesTransferred;
    pDataRanges = (PCSMULTIPLE_ITEM) malloc(dwDataRangesSize);
    if (NULL == pDataRanges )
    {
        RETAILMSG(CAMAPP_ERROR_MSG,(TEXT("ReadPinDataRanges: Malloc memory Failed.\r\n")));
        return;
    }
   
    iNumDataRanges = dwDataRangesSize / sizeof(CS_DATARANGE_VIDEO);

    // Now, we have a structure that has been allocated with the correct size,
    // that can hold the dataranges we need to read.
    if (!DeviceIoControl(m_hCameraDll,     // file handle to the driver
             IOCTL_CS_PROPERTY,            // I/O control code
             &pin,                         // in buffer
             sizeof(CSP_PIN),              // in buffer size
             pDataRanges,                  // out buffer
             dwDataRangesSize,             // out buffer size
             &dwBytesTransferred,          // number of bytes returned
             NULL))                        // ignored (=NULL)
    {
        RETAILMSG(CAMAPP_ERROR_MSG,(TEXT("ReadPinDataRanges: Get size of dataranges failed!\r\n")));
    }

    switch (pinId)
    {
        case CAPTURE:
            m_pCaptureDataRanges = pDataRanges;
            m_iNumCaptureDataRanges = iNumDataRanges;
            break;
        case STILL:
            m_pStillDataRanges = pDataRanges;
            m_iNumStillDataRanges = iNumDataRanges;
            break;
        case PREVIEW:
            m_pPreviewDataRanges = pDataRanges;
            m_iNumPreviewDataRanges = iNumDataRanges;
            break;
        default:
            RETAILMSG(CAMAPP_ERROR_MSG,(TEXT("ReadPinDataRangs: Bad pin parameter!\r\n")));
            break;
    }
}


/********************************************************************
 *
 *  FUNCTION:    GetDataFormat
 *
 *  DESCRIPTION:    
 *
 *  PARAMETERS:    None
 *
 *  RETURNS:        TRUE if successfully, otherwise return FALSE
 *
 ********************************************************************/
BOOL CCameraWindow::GetDataFormat(UINT32 pinId, ECamResolution res, PCS_DATARANGE_VIDEO pDataRangeMatched)
{
    UINT32 i;
    LONG iTargetWidth, iTargetHeight;
    PCSMULTIPLE_ITEM pDataRanges;
    PCS_DATARANGE_VIDEO pCurrentDataRange;
    UINT32 *pNumDataRanges;
    BOOL retVal = FALSE;

    switch (pinId)
    {
        case CAPTURE:
            pDataRanges = m_pCaptureDataRanges;
            pNumDataRanges = &m_iNumCaptureDataRanges;
            break;
        case STILL:
            pDataRanges = m_pStillDataRanges;
            pNumDataRanges = &m_iNumStillDataRanges;
            break;
        case PREVIEW:
            pDataRanges = m_pPreviewDataRanges;
            pNumDataRanges = &m_iNumPreviewDataRanges;
            break;
        default:
            RETAILMSG(CAMAPP_ERROR_MSG, (TEXT("GetDataFormat: Bad pin parameter!\r\n")));
            return FALSE;
    }

    switch(res)
    {
        case VGA:
            iTargetWidth = 640;
            iTargetHeight = 480;
            break;
        case QVGA:
            iTargetWidth = 320;
            iTargetHeight = 240;
            break;
        case CIF:
            iTargetWidth = 352;
            iTargetHeight = 288;
            break;
        case QCIF:
            iTargetWidth = 176;
            iTargetHeight = 144;
            break;
        case QQVGA:
            iTargetWidth = 160;
            iTargetHeight = 120;
            break;
        default:
            RETAILMSG(CAMAPP_ERROR_MSG, (TEXT("GetDataFormat: Bad pin parameter!\r\n")));
            return FALSE;
    }

    pCurrentDataRange = (PCS_DATARANGE_VIDEO) (pDataRanges + 1);
    for (i = 0; i < *pNumDataRanges; i++)
    {
        if ((abs(pCurrentDataRange->VideoInfoHeader.bmiHeader.biWidth) == iTargetWidth)
            && (abs(pCurrentDataRange->VideoInfoHeader.bmiHeader.biHeight) == iTargetHeight))
        {
            memcpy(pDataRangeMatched, pCurrentDataRange, sizeof(CS_DATARANGE_VIDEO));
            retVal = TRUE;
            break;
        }
        pCurrentDataRange = pCurrentDataRange + 1;
    }

    return retVal;
}


/********************************************************************
 *
 *  FUNCTION:       LoadCamDriver
 *
 *  DESCRIPTION:    Register camera driver and do some initializtion
 *
 *  PARAMETERS:     None
 *
 *  RETURNS:        TRUE if successfully, otherwise return FALSE
 *
 ********************************************************************/
BOOL CCameraWindow::LoadCamDriver()
{
    MSGQUEUEOPTIONS msgOptions;
    CSPROPERTY_STREAMEX_S CsPropStreamEx; 
    DWORD dwBytesTransferred;
    PCSSTREAM_HEADER hBufferheader = NULL;
    BOOL bResult = FALSE;

    // Open camera device.
    m_hCameraDll = CreateFile(TEXT("CAM1:"),                // "special" file name
                        GENERIC_READ|GENERIC_WRITE,         // desired access
                        FILE_SHARE_READ|FILE_SHARE_WRITE,   // sharing mode
                        NULL,                               // security attributes (=NULL)
                        OPEN_EXISTING,                      // creation disposition
                        FILE_ATTRIBUTE_NORMAL,              // flags and attributes
                        NULL);                              // template file (ignored)

    if (INVALID_HANDLE_VALUE == m_hCameraDll)    
    {
        ERRORMSG(CAMAPP_ERROR_MSG, (TEXT("LoadCamDriver: CreateFile CAM1 failed!Last error code is %d \r\n"),GetLastError()));
        return FALSE;
    }
    RETAILMSG(CAMAPP_DEBUG_MSG, (TEXT("LoadCamDriver: CreateFile CAM1 Done!\r\n")));

    // Open a preview pin
    m_hPreviewPinDll= CreateFile(TEXT("PIN1:"),          // "special" file name
                        GENERIC_READ|GENERIC_WRITE,      // desired access
                        0,                               // sharing mode
                        NULL,                            // security attributes (=NULL)
                        OPEN_ALWAYS,                     // creation disposition
                        FILE_ATTRIBUTE_NORMAL,           // flags and attributes
                        NULL);                           // template file (ignored)
    if (INVALID_HANDLE_VALUE == m_hPreviewPinDll)
    {
        ERRORMSG(CAMAPP_ERROR_MSG, (TEXT("LoadCamDriver: Open a pin for preview failed!Last error code is %d \r\n"),GetLastError()));
        return FALSE;
    }
    RETAILMSG(CAMAPP_DEBUG_MSG, (TEXT("LoadCamDriver: Open a pin for preview Done!\r\n")));

    // Open a still pin
    m_hStillPinDll = CreateFile(TEXT("PIN1:"),          // "special" file name
                    GENERIC_READ|GENERIC_WRITE,         // desired access
                    0,                                  // sharing mode
                    NULL,                               // security attributes (=NULL)
                    OPEN_ALWAYS,                        // creation disposition
                    FILE_ATTRIBUTE_NORMAL,              // flags and attributes
                    NULL);                              // template file (ignored)
    if (INVALID_HANDLE_VALUE == m_hStillPinDll)
    {
        ERRORMSG(CAMAPP_ERROR_MSG, (TEXT("LoadCamDriver: Open a pin for capture still image failed!Last error code is %d \r\n"),GetLastError()));
        return FALSE;
    }
    RETAILMSG(CAMAPP_DEBUG_MSG, (TEXT("LoadCamDriver: Open a pin for capture still image done!\r\n")));

    // Open a capture pin
    m_hCapturePinDll = CreateFile(TEXT("PIN1:"),        // "special" file name
                    GENERIC_READ|GENERIC_WRITE,         // desired access
                    0,                                  // sharing mode
                    NULL,                               // security attributes (=NULL)
                    OPEN_ALWAYS,                        // creation disposition
                    FILE_ATTRIBUTE_NORMAL,              // flags and attributes
                    NULL);                              // template file (ignored)
    if (INVALID_HANDLE_VALUE == m_hCapturePinDll)
    {
        ERRORMSG(CAMAPP_ERROR_MSG, (TEXT("LoadCamDriver: Open a pin for capture still image failed!Last error code is %d \r\n"),GetLastError()));
        return FALSE;
    }
    RETAILMSG(CAMAPP_DEBUG_MSG, (TEXT("LoadCamDriver: Open a pin for capture still image done!\r\n")));

    // Open msg queue for Preview Pin
    msgOptions.dwSize = sizeof(MSGQUEUEOPTIONS);
    msgOptions.dwFlags = MSGQUEUE_ALLOW_BROKEN;
    msgOptions.dwMaxMessages = 0;
    msgOptions.cbMaxMessage  = sizeof(CS_MSGQUEUE_BUFFER);
    msgOptions.bReadAccess = TRUE;

    m_hPreviewMsgQ = CreateMsgQueue(NULL, &msgOptions);

    if(!m_hPreviewMsgQ)
    {
        RETAILMSG(CAMAPP_ERROR_MSG, (TEXT("LoadCamDriver: CreateMsgQueue for Preview pin failed!\r\n")));
        return FALSE;
    }
    RETAILMSG(CAMAPP_DEBUG_MSG, (TEXT("LoadCamDriver: CreateMsgQueue for Preview pin done!\r\n")));

    // Open msg queue for Still Pin
    m_hStillMsgQ = CreateMsgQueue(NULL, &msgOptions);
    if(!m_hStillMsgQ)
    {
        RETAILMSG(CAMAPP_ERROR_MSG, (TEXT("LoadCamDriver: CreateMsgQueue for STILL pin failed!\r\n")));
        return FALSE;
    }
    RETAILMSG(CAMAPP_DEBUG_MSG, (TEXT("LoadCamDriver: CreateMsgQueue for STILL pin done!\r\n")));

    // Open msg queue for Capture Pin
    m_hCaptureMsgQ = CreateMsgQueue(NULL, &msgOptions);
    if(!m_hCaptureMsgQ)
    {
        RETAILMSG(CAMAPP_ERROR_MSG, (TEXT("LoadCamDriver: CreateMsgQueue for Capture pin failed!\r\n")));
        return FALSE;
    }
    RETAILMSG(CAMAPP_DEBUG_MSG, (TEXT("LoadCamDriver: CreateMsgQueue for Capture pin done!\r\n")));

    // create preview pin instance
    CsPropStreamEx.hMsgQueue = m_hPreviewMsgQ; 
    CsPropStreamEx.CsPin.PinId = PREVIEW;    // 2= PREVIEW, 0=CAPTURE ,1=STILL
    CsPropStreamEx.CsPin.Property.Set = CSPROPSETID_StreamEx;
    CsPropStreamEx.CsPin.Property.Id = CSPROPERTY_STREAMEX_INIT;
    CsPropStreamEx.CsPin.Property.Flags = CSPROPERTY_TYPE_SET;

    EnterCriticalSection(&m_csPreview); 

    bResult = DeviceIoControl(m_hPreviewPinDll,            // file handle to the driver
                        IOCTL_STREAM_INSTANTIATE,          // I/O control code
                        &CsPropStreamEx,                   // in buffer
                        sizeof(CSPROPERTY_STREAMEX_S),     // in buffer size
                        NULL,                              // out buffer
                        0,                                 // out buffer size
                        &dwBytesTransferred,               // number of bytes returned
                        NULL);                             // ignored (=NULL)

    LeaveCriticalSection(&m_csPreview); 

    if (!bResult)
    {
        RETAILMSG(CAMAPP_ERROR_MSG, (TEXT("LoadCamDriver: create preview pin instance failed!\r\n")));
        return FALSE;
    }

    // create still pin instance
    CsPropStreamEx.hMsgQueue = m_hStillMsgQ; 
    CsPropStreamEx.CsPin.PinId = STILL;     // 0=CAPTURE,1=STILL,2=PREVIEW
    CsPropStreamEx.CsPin.Property.Set = CSPROPSETID_StreamEx;
    CsPropStreamEx.CsPin.Property.Id = CSPROPERTY_STREAMEX_INIT;
    CsPropStreamEx.CsPin.Property.Flags = CSPROPERTY_TYPE_SET;

    EnterCriticalSection(&m_csStill); 

    bResult = DeviceIoControl(m_hStillPinDll,              // file handle to the driver
                        IOCTL_STREAM_INSTANTIATE,          // I/O control code