camtest.cpp

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

            if (!CaptureSetState(CAMERA_STATE_PAUSE))
                return FALSE;

            if (!CaptureSetState(CAMERA_STATE_RUN))
                return FALSE;

            task++;

            g_pKato->Log(CAM_ZONE_ERROR,
                (TEXT("CaptureISR: Image flipped vertically and horizontally.\r\n")));
        }

        if ((elapsedTicks > 26000) && (task == 6)) // 36 seconds
        {
            // Stop capture
            if (!CaptureSetState(CAMERA_STATE_STOP))
                return FALSE;

            if (!ChangeRotation(0))
            {
                goto enc_error;
            }

            // Restart capture
            if (!CaptureSetState(CAMERA_STATE_PAUSE))
                return FALSE;

            if (!CaptureSetState(CAMERA_STATE_RUN))
                return FALSE;

            task++;

            g_pKato->Log(CAM_ZONE_ERROR,
                (TEXT("CaptureISR: Rotation turned off.\r\n")));
        }

        if ((elapsedTicks > 30000) && (task == 7)) // 30 seconds
        {
            // Stop capture
            if (!CaptureSetState(CAMERA_STATE_STOP))
            {
                return FALSE;
            }

            g_pKato->Log(CAM_ZONE_ERROR,
                (TEXT("CaptureISR: 40 seconds up.  Ending capture.\r\n")));

            return TRUE;
        }
#else
        if ((elapsedTicks > 15000) && (task == 3)) // 30 seconds
        {
            // Stop capture
            if (!CaptureSetState(CAMERA_STATE_STOP))
            {
                return FALSE;
            }

            g_pKato->Log(CAM_ZONE_ERROR,
                (TEXT("CaptureISR: 40 seconds up.  Ending capture.\r\n")));

            return TRUE;
        }

#endif
    }

enc_error:
    // Stop capture
    if (!CaptureSetState(CAMERA_STATE_STOP))
    {
        return FALSE;
    }

    CAM_TEST_FUNCTION_EXIT();
    return FALSE;
}



//------------------------------------------------------------------------------
//
// Function: CameraTestPreview
//
// This function test the functionality of camera preview.  It sets
// the DirectDisplay mode so that the preview images are drawn
// directly to the display.  It then allocates buffers for the pin.  
// Finally, it kicks off an ISR to capture images and display them.
//
// Parameters:
//      uiMsg
//           [in] Ignored.
//
//      tpParam
//           [in] Ignored.
//
//      lpFTE
//           [in] Ignored.
//
// Returns:
//      Specifies if the test passed (TPR_PASS), failed (TPR_FAIL), or was
//      skipped (TPR_SKIP).
//
//------------------------------------------------------------------------------
TESTPROCAPI CameraTestPreview(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE)
{
    CAM_TEST_FUNCTION_ENTRY();
    //DWORD dwBufferCommand;
    CSBUFFER_INFO csBufferInfo;

    // Validate that the shell wants the test to run
    if (uMsg != TPM_EXECUTE)
    {
        return TPR_NOT_HANDLED;
    }

    // reset the interrupt count each time this test is run
    int_count = 0;

    gCurrentIndex = 2;
    
#ifndef BSP_MX27
    if (!DeviceIoControl(hPreviewPin,         // file handle to the driver
            IOCTL_SET_DIRECT_DISPLAY_MODE,    // I/O control code
            NULL,                             // in buffer
            TRUE,                             // in buffer size
            NULL,                             // out buffer
            0,                                // out buffer size
            &gBytesTransferred,               // number of bytes returned
            NULL))                            // ignored (=NULL)
    {
        g_pKato->Log(CAM_ZONE_ERROR,(TEXT("Could not set direct display. Dang.\r\n")));
    }
#endif

    // Pause Preview Stream
    if (!PreviewSetState(CAMERA_STATE_PAUSE))
    {
        return TPR_FAIL;
    }
    
    // allocate buffer for preview pin
    csBufferInfo.dwCommand = CS_ALLOCATE;
    csBufferInfo.pStreamDescriptor = &previewStreamDesc;

    DeviceIoControl(hPreviewPin,                  // file handle to the driver
                    IOCTL_CS_BUFFERS,             // I/O control code
                    &csBufferInfo,                // in buffer
                    sizeof(csBufferInfo),         // in buffer size
                    &previewStreamDesc,           // out buffer
                    sizeof(CS_STREAM_DESCRIPTOR), // out buffer size
                    &gBytesTransferred,           // number of bytes returned
                    NULL);                        // ignored (=NULL)

    // Start Preview Stream
    if (!PreviewSetState(CAMERA_STATE_RUN))
    {
        return TPR_FAIL;
    }

    // Enter ISR loop
    if (!PreviewISR(INFINITE))
    {
        CAM_TEST_FUNCTION_EXIT();
        return TPR_FAIL;
    }
    else
    {
        CAM_TEST_FUNCTION_EXIT();
        return TPR_PASS;
    }
}

//------------------------------------------------------------------------------
//
// Function: PreviewISR
//
// This function performs image capture for the PREVIEW Pin.
// It contains a loop in which a PREVIEW pin image is read from
// its message queue, and then a new buffer
// in enqueued.  Intermittently, the PREVIEW pin or the camera driver 
// is modified.  These modifications include changing the
// camera zoom, modifying the flipping orientation, and changing
// the display offset in the display panel.  Additionally,
// the STILL pin is tested, capturing a still image and displaying
// it to the display panel.
//
// Parameters:
//      timeout
//           [in] Timeout period while waiting for an interrupt
//
// Returns:
//      TRUE if success, FALSE if failure.
//
//------------------------------------------------------------------------------
static BOOL PreviewISR(DWORD timeout)
{
    CS_MSGQUEUE_BUFFER CsMsgQBuff;
    DWORD size, flags;
    DWORD startTicks, elapsedTicks;
    int task;
    CSPROPERTY_CAMERACONTROL_S tiltIOCTL;
    //DWORD dwBufferCommand;
    PCS_DATARANGE_VIDEO pPreviewDataRange = NULL;
    PCS_DATAFORMAT_VIDEOINFOHEADER pPreviewDataFormat = NULL;
    PCSP_PIN pCsPin = NULL;
    PCSMULTIPLE_ITEM pCSDataRangeItems = NULL;
    PCS_DATARANGE_VIDEO pCSDataRangeVideo = NULL;
    DWORD dwStructSize;
    BOOL  bResult;
    CSBUFFER_INFO csBufferInfo;

    CAM_TEST_FUNCTION_ENTRY();

    tiltIOCTL.Property.Set = PROPSETID_VIDCAP_CAMERACONTROL;
    tiltIOCTL.Property.Id = CSPROPERTY_CAMERACONTROL_TILT;
    tiltIOCTL.Property.Flags = CSPROPERTY_TYPE_SET;
    tiltIOCTL.Flags = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;

    startTicks = GetTickCount();
    task = 1;


    // loop here
    while(TRUE)
    {
        // Add buffer to the message queue
        csBufferInfo.dwCommand = CS_ENQUEUE;
        csBufferInfo.pStreamDescriptor = &previewStreamDesc;

        bResult = DeviceIoControl(hPreviewPin,           // file handle to the driver
                 IOCTL_CS_BUFFERS,             // I/O control code
                 &csBufferInfo,                // in buffer
                 sizeof(csBufferInfo),         // in buffer size
                 &previewStreamDesc,           // out buffer
                 sizeof(CS_STREAM_DESCRIPTOR), // out buffer size
                 &gBytesTransferred,           // number of bytes returned
                 NULL);                        // ignored (=NULL)

        if (TRUE == bResult)
        {
           g_pKato->Log(CAM_ZONE_ERROR, (TEXT("PreviewISR: WaitForSingleObject\r\n")));

           // Wait for message queue to be signaled
           if (WaitForSingleObject(hPreviewMsgQ, timeout) != WAIT_OBJECT_0)
           {
               g_pKato->Log(CAM_ZONE_ERROR, (TEXT("PreviewISR: WaitForSingleObject Timeout!\r\n")));
               return FALSE;
           }

           // Our message queue handle has been signaled.
           // Now try to read a captured image from the buffer queue.
           if (!ReadMsgQueue(hPreviewMsgQ, &CsMsgQBuff, sizeof(CS_MSGQUEUE_BUFFER), &size, 10, &flags))
           {
               g_pKato->Log(CAM_ZONE_ERROR, (TEXT("PreviewISR: Could not read from buffer queue!\r\n")));
               return FALSE;
           }
        }
        else
        {
           g_pKato->Log(CAM_ZONE_ERROR, (TEXT("PreviewISR: Enqueue the buffer error!\r\n")));
           g_pKato->Log(CAM_ZONE_ERROR, (TEXT("PreviewISR: Don't suspend the system during running this test case!\r\n")));
           Sleep(500);
        }

        // Increment count of interrupts that have occurred
        int_count++;

        // After a certain period has elapsed, stop viewfinder
        elapsedTicks = GetTickCount() - startTicks;

        if ((elapsedTicks > 5000) && (task == 1)) // 15 seconds
        {
            if (!Zoom(2))
            {
                goto vf_error;
            }

            task++;

            g_pKato->Log(CAM_ZONE_ERROR,
                (TEXT("PreviewISR: Completed camera zoom update (2X).\r\n")));
        }

        else if ((elapsedTicks > 10000) && (task == 2)) // 15 seconds
        {
            if (!Zoom(1))
            {
                goto vf_error;
            }

            task++;

            g_pKato->Log(CAM_ZONE_ERROR,
                (TEXT("PreviewISR: Completed camera zoom update (1X).\r\n")));
        }

        else if ((elapsedTicks > 12000) && (task == 3)) // 15 seconds
        {
            // Pause viewfinder
            if (!PreviewSetState(CAMERA_STATE_PAUSE))
                return FALSE;
#ifndef BSP_MX27
            StillCaptureAndDisplay();
#else
            StillPreviewAndDisplay();
#endif

            pPreviewDataRange = (PCS_DATARANGE_VIDEO) malloc(sizeof(CS_DATARANGE_VIDEO));

            if (NULL == pPreviewDataRange)
                return TPR_FAIL;

#ifndef BSP_MX27
            if (!GetDataFormat(1, QQVGA, pPreviewDataRange))
#else
            if (!GetDataFormat(2, QQVGA, pPreviewDataRange))
#endif
            {
                g_pKato->Log(CAM_ZONE_ERROR,(TEXT("Could not find QQVGA datarange for STILL pin...bummer.\r\n")));
            }

            inputIOCTL.Set = CSPROPSETID_Pin;
            inputIOCTL.Id = CSPROPERTY_PIN_DATAINTERSECTION;
            inputIOCTL.Flags = CSPROPERTY_TYPE_GET;

            // Get Dataformat using PININTERSECTION
            dwStructSize = sizeof(CSP_PIN) + sizeof(CSMULTIPLE_ITEM) + sizeof(CS_DATARANGE_VIDEO);
            pCsPin = (PCSP_PIN) malloc(dwStructSize);
            
            if (NULL == pCsPin)
               return TPR_FAIL;
         
            pCsPin->Property = inputIOCTL;

#ifndef BSP_MX27
            pCsPin->PinId = 1;
#else
            pCsPin->PinId = 2;
#endif
            pCSDataRangeItems = (PCSMULTIPLE_ITEM) (pCsPin + 1);
            pCSDataRangeItems->Count = 1;
            pCSDataRangeItems->Size = sizeof(CSMULTIPLE_ITEM) + sizeof(CS_DATARANGE_VIDEO);
            pCSDataRangeVideo = (PCS_DATARANGE_VIDEO) (pCSDataRangeItems + 1);
            memcpy(pCSDataRangeVideo, pPreviewDataRange, sizeof(CS_DATARANGE_VIDEO));

            pPreviewDataFormat = (PCS_DATAFORMAT_VIDEOINFOHEADER) malloc(sizeof(CS_DATAFORMAT_VIDEOINFOHEADER));

            if (NULL == pPreviewDataFormat)
               return TPR_FAIL;

            // Get Preview format
            if (!DeviceIoControl(hCamera,                   // file handle to the driver
                     IOCTL_CS_PROPERTY,                     // I/O control code
                     pCsPin,                                // in buffer
                     dwStructSize,                          // in buffer size
                     pPreviewDataFormat,                    // out buffer
                     sizeof(CS_DATAFORMAT_VIDEOINFOHEADER), // out buffer size
                     &gBytesTransferred,                    // number of bytes returned
                     NULL))                                 // ignored (=NULL)
            {
                g_pKato->Log(CAM_ZONE_ERROR,(TEXT("Could not perform DATAINTERSECTION GET. Dang.\r\n")));
                return TPR_FAIL;
            }