camerafunc.cpp

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

		    bResult = FALSE;

    DeleteCriticalSection( &gcsPreview);
    DeleteCriticalSection( &gcsCapture);
    
    if(g_pCaptureDataRanges != NULL)
    {
        free(g_pCaptureDataRanges);
        g_pCaptureDataRanges = NULL;
    }
    
    if(g_pPreviewDataRanges != NULL)
    {
        free(g_pPreviewDataRanges);    
        g_pPreviewDataRanges = NULL;
    }
    
    if(g_pCapDataFormat != NULL)
    {
        free(g_pCapDataFormat);    
        g_pCapDataFormat = NULL;
    }
    
    return bResult;
}


void ReadPinDataRanges(UINT32 pinId)
{
    PCSMULTIPLE_ITEM pDataRanges;
    DWORD dwDataRangesSize;
    UINT32 iNumDataRanges;
	DWORD dBytesTransferred;
    
    // Get data format for preview pin
    // change size for preview
    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(ghCameraDll,          // 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
             &dBytesTransferred,           // number of bytes returned
             NULL))                        // ignored (=NULL)
    {
        RETAILMSG(TRUE,
            (TEXT("ReadPinDataRanges: Get size of dataranges failed! Expected!\r\n")));
    }

    dwDataRangesSize = dBytesTransferred;
    pDataRanges = (PCSMULTIPLE_ITEM) malloc(dwDataRangesSize);

    if ( NULL == pDataRanges )
         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(ghCameraDll,          // 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
             &dBytesTransferred,           // number of bytes returned
             NULL))                        // ignored (=NULL)
    {
        RETAILMSG(TRUE,
            (TEXT("ReadPinDataRanges: Get size of dataranges failed!\r\n")));
    }

    switch (pinId)
    {
        case 0:
            g_pCaptureDataRanges = pDataRanges;
            g_iNumCaptureDataRanges = iNumDataRanges;
            break;
        case 2:
            g_pPreviewDataRanges = pDataRanges;
            g_iNumPreviewDataRanges = iNumDataRanges;
            break;
        default:
            RETAILMSG(TRUE,
                (TEXT("ReadPinDataRangs: Bad pin parameter!\r\n")));
            break;
    }
}

//------------------------------------------------------------------------------
//
// Function: CaptureSetState
//
// This function sets a new state for the CAPTURE pin.
//
// Parameters:
//      csNewState
//          [in] The new state for the CAPTURE pin.
//
// Returns:
//      TRUE if success, FALSE if failure.
//
//------------------------------------------------------------------------------
static BOOL CaptureSetState(CSSTATE csNewState)
{
    char *stateString;
    DWORD dBytesTransferred;

    inputIOCTL.Set = CSPROPSETID_Connection;
    inputIOCTL.Id = CSPROPERTY_CONNECTION_STATE;
    inputIOCTL.Flags = CSPROPERTY_TYPE_SET;
    switch (csNewState)
    {
        case CSSTATE_PAUSE:
            state = CSSTATE_PAUSE;
            stateString = "PAUSE";
            break;
        case CSSTATE_RUN:
            state = CSSTATE_RUN;
            stateString = "RUN";
            break;
        case CSSTATE_STOP:
            state = CSSTATE_STOP;
            stateString = "STOP";
            break;
        default:
            RETAILMSG(TRUE,(TEXT("You broke it!!!!!!\r\n")));
            return FALSE;
    }

    if (!DeviceIoControl(ghCapturePinDll,        // file handle to the driver
                IOCTL_CS_PROPERTY,           // I/O control code
                &inputIOCTL,                 // in buffer
                sizeof(CSPROPERTY),          // in buffer size
                &state,                      // out buffer
                sizeof(CSSTATE),             // out buffer size
                &dBytesTransferred,          // number of bytes returned
                NULL))                       // ignored (=NULL)
    {
        RETAILMSG(TRUE,(TEXT("Failed setting state to %s.\r\n"), stateString));
        return FALSE;
    }

    return TRUE;
}


BOOL GetDataFormat(UINT32 pinId, CAMERA_RESOLUTION 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 0:
            pDataRanges = g_pCaptureDataRanges;
            pNumDataRanges = &g_iNumCaptureDataRanges;
            break;
        case 1:
            pDataRanges = g_pStillDataRanges;
            pNumDataRanges = &g_iNumStillDataRanges;
            break;
        case 2:
            pDataRanges = g_pPreviewDataRanges;
            pNumDataRanges = &g_iNumPreviewDataRanges;
            break;
        default:
            RETAILMSG(TRUE,
                (TEXT("ReadPinDataRangs: Bad pin parameter!\r\n")));
            break;
    }

    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(TRUE,
                (TEXT("ReadPinDataRangs: Bad resolution parameter!\r\n")));
            break;
    }

    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;
}

bool CameraTestCapture(void)
{
    CSPROPERTY_VIDEOCONTROL_MODE_S rotateIOCTL;
    //DWORD dwBufferCommand;
    PCS_DATARANGE_VIDEO pCaptureDataRange;
    PCSMULTIPLE_ITEM pCSDataRangeItems;
    PCSP_PIN pCsPin;
    PCS_DATARANGE_VIDEO pCSDataRangeVideo;
    DWORD dwStructSize;
	DWORD dwBytesTransferred;
    CSBUFFER_INFO csBufferInfo;


    // reset the interrupt count each time this test is run

    rotateIOCTL.Property.Set = PROPSETID_VIDCAP_VIDEOCONTROL;
    rotateIOCTL.Property.Id = CSPROPERTY_VIDEOCONTROL_MODE;
    rotateIOCTL.Property.Flags = CSPROPERTY_TYPE_SET;
    rotateIOCTL.StreamIndex = 1;

    // Stop Capture Stream
    // First we must stop, in case stream was running before, and
    // to change the format.
    if (!CaptureSetState(CSSTATE_STOP))
    {
        return FALSE;
    }

    // modify Capture data format to RGB, so we can draw it to the
    // framebuffer and view it on the LCD.  Try QCIF.

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

    if (NULL == pCaptureDataRange)
     return FALSE;

    if (!GetDataFormat(0, QVGA, pCaptureDataRange))        
    {
        RETAILMSG(TRUE,(TEXT("Could not find QCIF datarange for CAPTURE 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 FALSE;
    
    pCsPin->Property = inputIOCTL;

    pCsPin->PinId = 0;

    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, pCaptureDataRange, sizeof(CS_DATARANGE_VIDEO));

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

    if (NULL == g_pCapDataFormat)
     return FALSE;

    // Get Capture format
    if (!DeviceIoControl(ghCameraDll,                    // file handle to the driver
             IOCTL_CS_PROPERTY,                      // I/O control code
             pCsPin,                                 // in buffer
             dwStructSize,                           // in buffer size
             g_pCapDataFormat,                       // out buffer
             sizeof(CS_DATAFORMAT_VIDEOINFOHEADER),  // out buffer size
             &dwBytesTransferred,                     // number of bytes returned
             NULL))                                  // ignored (=NULL)
    {
        RETAILMSG(TRUE,(TEXT("Could not perform DATAINTERSECTION GET. Dang.\r\n")));
        return FALSE;
    }

    // Set Capture format to QCIF
    inputIOCTL.Set = CSPROPSETID_Connection;
    inputIOCTL.Id = CSPROPERTY_CONNECTION_DATAFORMAT;
    inputIOCTL.Flags = CSPROPERTY_TYPE_SET;
    if (!DeviceIoControl(ghCapturePinDll,                // file handle to the driver
             IOCTL_CS_PROPERTY,                      // I/O control code
             &inputIOCTL,                            // in buffer
             sizeof(CSPROPERTY),                     // in buffer size
             g_pCapDataFormat,                       // out buffer
             sizeof(CS_DATAFORMAT_VIDEOINFOHEADER),  // out buffer size
             &dwBytesTransferred,                     // number of bytes returned
             NULL))                                  // ignored (=NULL)
    {
        RETAILMSG(TRUE,(TEXT("Could not perform DATAFORMAT SET. Dang.\r\n")));
        return FALSE;
    }

    // Start Capture Stream
    // First we must pause, and then transition to run state
    if (!CaptureSetState(CSSTATE_PAUSE))
    {
        return FALSE;
    }

    // allocate buffer for capture pin
    csBufferInfo.dwCommand = CS_ALLOCATE;
    csBufferInfo.pStreamDescriptor = gpCaptureStreamDesc;

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

    if (!CaptureSetState(CSSTATE_RUN))
    {
        return FALSE;
    }
    
    free(pCaptureDataRange);
    free(pCsPin);
    return TRUE;

}