prptest.cpp

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

//
//
// 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.
//
//-----------------------------------------------------------------------------
//
// File: PRPTest.cpp
//
// This file contains test code for the PrP driver.
//
//-----------------------------------------------------------------------------
//
// Copyright (C) 2006, Freescale Semiconductor, Inc. All Rights Reserved.
// THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
// AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT 
//
//-----------------------------------------------------------------------------
#include <windows.h>
#include <Devload.h>
#include <strsafe.h>
#include "prp.h"
#include "main.h"
#include "globals.h"
#include "bsp.h"

//-----------------------------------------------------------------------------
// External Functions

//-----------------------------------------------------------------------------
// External Variables

//-----------------------------------------------------------------------------
// Defines
#define PRP_ZONE_INFO                    0
#define PRP_ZONE_ERROR                   1
#define PRP_ZONE_FUNCTION                0

#define PRP_TEST_FUNCTION_ENTRY() \
    g_pKato->Log(PRP_ZONE_FUNCTION, (TEXT("++%s\r\n"), __WFUNCTION__))
#define PP_TEST_FUNCTION_EXIT() \
    g_pKato->Log(PRP_ZONE_FUNCTION, (TEXT("--%s\r\n"), __WFUNCTION__))

#ifdef DEBUG
// Debug zone bit positions
#define ZONEID_INFO                     12
#define ZONEID_FUNCTION                 13
#define ZONEID_WARN                     14
#define ZONEID_ERROR                    15

// Debug zone masks
#define ZONEMASK_INFO                   (1<<ZONEID_INFO)
#define ZONEMASK_FUNCTION               (1<<ZONEID_FUNCTION)
#define ZONEMASK_WARN                   (1<<ZONEID_WARN)
#define ZONEMASK_ERROR                  (1<<ZONEID_ERROR)

// Debug zone args to DEBUGMSG
#define ZONE_INFO                       DEBUGZONE(ZONEID_INFO)
#define ZONE_FUNCTION                   DEBUGZONE(ZONEID_FUNCTION)
#define ZONE_WARN                       DEBUGZONE(ZONEID_WARN)
#define ZONE_ERROR                      DEBUGZONE(ZONEID_ERROR)
#endif

// Screen size
#define PRP_TEST_SCREEN_WIDTH           240
#define PRP_TEST_SCREEN_HEIGHT          320
#define PRP_TEST_SCREEN_SIZE            (PRP_TEST_SCREEN_HEIGHT * PRP_TEST_SCREEN_WIDTH * 2)

#define YUV420_U_OFFSET(x)              (x * 2 / 3)
#define YUV420_V_OFFSET(x)              (x * 5 / 6)

// Ouput parameters
#define PRP_TEST_OUTPUT_FILENAME        TEXT("\\release\\PrpOut_YUV420.yuv")
#define PRP_TEST_OUTPUT_WIDTH           240
#define PRP_TEST_OUTPUT_HEIGHT          320

#define PRP_TEST_FRAME_NUM              15

//-----------------------------------------------------------------------------
// Types

//-----------------------------------------------------------------------------
// Global Variables

//-----------------------------------------------------------------------------
// Local Variables
static HANDLE hPrP;
static HANDLE g_hPrPEncEOFEvent;
static UINT8 *FrameBufferVirtualAddr;

//-----------------------------------------------------------------------------
// Local Functions
static BOOL PRPTestInit();
static void PRPTestDeinit();

//------------------------------------------------------------------------------
//
// Function: PRPTest
//
// This function tests the Pre-processor, reading RGB565 frames from 
// framebuffer, converting them to YUV420, and writing them into file.
//
// 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 PRPTest(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE)
{
    prpConfigData prpConfig;
    prpBuffers bufs;
    HANDLE hPrpResultFile;
    DWORD bytesWritten;
    UINT32 iOutputBytesPerFrame;
    UINT8 *pOutputFrameVirtAddr;
    UINT8 *pOutputFramePhysAddr;
    DWORD iFrameCount = 0;
    
    PRP_TEST_FUNCTION_ENTRY();
    
    // Validate that the shell wants the test to run
    if (uMsg != TPM_EXECUTE)
        return TPR_NOT_HANDLED;

    // Initialization
    if (!PRPTestInit()) {
        g_pKato->Log(PRP_ZONE_ERROR, (TEXT("PRPTestInit failed! \r\n")));
        return TPR_FAIL;
    }


    // Allocate output buffer
    iOutputBytesPerFrame = PRP_TEST_OUTPUT_WIDTH * PRP_TEST_OUTPUT_HEIGHT * 3 / 2;
    pOutputFrameVirtAddr = (UINT8 *)AllocPhysMem(
        iOutputBytesPerFrame, 
        PAGE_EXECUTE_READWRITE, 
        0, 
        0, 
        (ULONG *)&pOutputFramePhysAddr);

    //
    // Configure PrP
    //
    // Input configuration
    prpConfig.bWindowing = FALSE;
    prpConfig.inputFormat = prpInputFormat_RGB16;
    prpConfig.inputSize.height = PRP_TEST_SCREEN_HEIGHT;
    prpConfig.inputSize.width = PRP_TEST_SCREEN_WIDTH;
    prpConfig.inputStride = 0;
    // Output configuration
    prpConfig.outputVfFormat = prpVfOutputFormat_Disabled;
    prpConfig.outputEncFormat = prpEncOutputFormat_YUV420;
    prpConfig.outputEncSize.height = PRP_TEST_OUTPUT_HEIGHT;
    prpConfig.outputEncSize.width = PRP_TEST_OUTPUT_WIDTH;
    // CSC equation
    prpConfig.CSCEquation = prpCSCR2Y_A0;
    
    if (!PRPConfigure(hPrP, &prpConfig)) {
        g_pKato->Log(PRP_ZONE_ERROR, (TEXT("PRPConfigure failed! \r\n")));
        return TPR_FAIL;
    }

    // Open file to write YUV420 results
    hPrpResultFile = CreateFile(
        PRP_TEST_OUTPUT_FILENAME,       // "special" file name
        GENERIC_WRITE | GENERIC_READ,   // desired access
        0,                              // sharing mode
        NULL,                           // security attributes (=NULL)
        CREATE_ALWAYS,                  // creation disposition
        FILE_ATTRIBUTE_NORMAL,          // flags and attributes
        NULL);                          // template file (ignored)
    if (hPrpResultFile == INVALID_HANDLE_VALUE) {
        g_pKato->Log(PRP_ZONE_ERROR, 
            (TEXT("Could not open file to write pre-processing results.\r\n")));
        return TPR_FAIL;
    }

    // Start PrP encoding channel
    if (!PRPStart(hPrP, prpChannel_Encoding)) {
        g_pKato->Log(PRP_ZONE_ERROR, (TEXT("PRPStart failed! \r\n")));
        return TPR_FAIL;

    }

    // Set up buffers
    bufs.InBuf = (PVOID)IMAGE_SHARE_FRAMEBUFFER_RAM_PA_START;
    bufs.OutVfBuf = NULL;
    bufs.OutEncBuf = pOutputFramePhysAddr;

    while (iFrameCount < PRP_TEST_FRAME_NUM) {
        // If buffer setting change is need, set up here
        
        // Add buffers
        if (!PRPAddBuffers(hPrP, &bufs)) {
            g_pKato->Log(PRP_ZONE_ERROR, 
                (TEXT("PRPAddBuffers failed! \r\n")));
            return TPR_FAIL;
        }

        // Wait for End of Frame from encoding channel
        WaitForSingleObject(g_hPrPEncEOFEvent, INFINITE);

        if (!WriteFile(hPrpResultFile, (LPVOID)pOutputFrameVirtAddr, 
            iOutputBytesPerFrame, (LPDWORD) &bytesWritten, NULL)) {
            g_pKato->Log(PRP_ZONE_ERROR, 
                (TEXT("Could not write pre-processing results.\r\n")));
        }

        iFrameCount++;
    }

    // Stop PrP encoding channel
    if (!PRPStop(hPrP, prpChannel_Encoding)) {
        g_pKato->Log(PRP_ZONE_ERROR, (TEXT("PRPStop failed! \r\n")));
        return TPR_FAIL;
    }

    // Close file
    CloseHandle(hPrpResultFile);

    // Deinitialization
    PRPTestDeinit();

    return TPR_PASS;
}

//------------------------------------------------------------------------------
//
// Function: PRPTestInit
//
// This function does initialization for pre-processor test.
//
// Parameters:
//      None.
//
// Returns:
//      TRUE if successful; FALSE if failed.
//
//------------------------------------------------------------------------------
static BOOL PRPTestInit()
{
    PHYSICAL_ADDRESS phyAddr;

    // Open handle to the post-processor
    hPrP = PRPOpenHandle();
    if (hPrP == INVALID_HANDLE_VALUE) {
        g_pKato->Log(PRP_ZONE_ERROR, (TEXT("PRPOpenHandle failed!\r\n")));
        goto _error;
    }

    // Map peripheral physical address to virtual address
    phyAddr.QuadPart = IMAGE_SHARE_FRAMEBUFFER_RAM_PA_START;
    FrameBufferVirtualAddr = (UINT8 *)MmMapIoSpace(phyAddr, 
        PRP_TEST_SCREEN_HEIGHT * PRP_TEST_SCREEN_WIDTH * 2, FALSE);
    if (FrameBufferVirtualAddr == NULL) {
        g_pKato->Log(PRP_ZONE_ERROR, 
            (TEXT("Framebuffer MmMapIoSpace failed! \r\n")));
        goto _error;
    }

    // Events to signal pin that frame is ready
    g_hPrPEncEOFEvent = CreateEvent(NULL, FALSE, FALSE, PRP_ENC_EOF_EVENT_NAME);
    if (g_hPrPEncEOFEvent == NULL) {
        g_pKato->Log(PRP_ZONE_ERROR, 
            (TEXT("CreateEvent failed for PrP EOF\r\n")));
        goto _error;
    }

    return TRUE;
    
_error:
    
    PRPTestDeinit();
    
    return FALSE;
    
}

//------------------------------------------------------------------------------
//
// Function: PRPTestDeinit
//
// This function does deinitialization for pre-processor test.
//
// Parameters:
//      None.
//
// Returns:
//      None.
//
//------------------------------------------------------------------------------
static void PRPTestDeinit()
{
    if (hPrP != NULL) {
        PRPCloseHandle(hPrP);
        hPrP = NULL;
    }

    if (FrameBufferVirtualAddr != NULL) {
        MmUnmapIoSpace(FrameBufferVirtualAddr, 
            PRP_TEST_SCREEN_HEIGHT * PRP_TEST_SCREEN_WIDTH * 2);
        FrameBufferVirtualAddr = NULL;
    }

    if (g_hPrPEncEOFEvent != NULL) {
        CloseHandle(g_hPrPEncEOFEvent);
        g_hPrPEncEOFEvent = NULL;
    }
}