ppclass.cpp

freescale i.mx31 BSP CE5.0全部源码

    return FALSE;
}

//-----------------------------------------------------------------------------
//
// Function: PpDeinit
//
// This function deinitializes the Image Converter (Postprocessor).
//
// Parameters:
//      None.
//
// Returns:
//      None.
//
//-----------------------------------------------------------------------------
void PpClass::PpDeinit(void)
{

    PP_FUNCTION_ENTRY();

    // Disable Postprocessor
    PpDisable();

    CloseHandle(m_hPpIntrEvent);
    m_hPpIntrEvent = NULL;

    CloseHandle(m_hEOFEvent);
    m_hEOFEvent = NULL;

    CloseHandle(m_hReadDisplayBufferQueue);
    m_hReadDisplayBufferQueue = NULL;

    CloseHandle(m_hWriteDisplayBufferQueue);
    m_hWriteDisplayBufferQueue = NULL;

    if (m_hDisplay != NULL)
    {
        DeleteDC(m_hDisplay);
        m_hDisplay = NULL;
    }

    if (m_hPpISRThread)
    {
        TerminateThread(m_hPpISRThread, 0);
        CloseHandle(m_hPpISRThread);
        m_hPpISRThread = NULL;
    }

    if (m_hPpBufThread)
    {
        TerminateThread(m_hPpBufThread, 0);
        CloseHandle(m_hPpBufThread);
        m_hPpBufThread = NULL;
    }
}


//-----------------------------------------------------------------------------
//
// Function:  PpEnqueueBuffers
//
// This function adds buffers for the PP channel.
// Input and output buffers are provided and added to the buffer queue.
// It is assumed that the caller has allocated physically contiguous 
// buffers for use in the IPU's IDMAC.
//
// Parameters:
//      pBufs
//          [in] Pointer to structure containing a pointer
//          to an input and output buffer.
//
// Returns:
//      TRUE if successful; FALSE if failed
//
//-----------------------------------------------------------------------------
BOOL PpClass::PpEnqueueBuffers(pPpBuffers pBufs)
{

    // Map pointers for input and output buffers;
//    pInputBuf = (UINT32 *) MapCallerPtr(pBufs->inputBuf, pBufs->inBufLen);
//    pOutputBuf = (UINT32 *) MapCallerPtr(pBufs->outputBuf, pBufs->outBufLen);

    // Enqueue input buffer
    if (!WriteMsgQueue(m_hWriteInputBufferQueue, pBufs, sizeof(ppBuffers), 0, 0))
    {
        DEBUGMSG(ZONE_ERROR, 
            (TEXT("%s : Could not write to input buffer queue.  Error!\r\n"), __WFUNCTION__));
        return FALSE;
    }

    // Enqueue output buffer
    if (!WriteMsgQueue(m_hWriteOutputBufferQueue, pBufs, sizeof(ppBuffers), 0, 0))
    {
        DEBUGMSG(ZONE_ERROR, 
            (TEXT("%s : Could not write to output buffer queue.  Error!\r\n"), __WFUNCTION__));
        return FALSE;
    }

    return TRUE;
}


//-----------------------------------------------------------------------------
//
// Function:  PpClearBuffers
//
// This function clears out the input and output buffer queues
// for the Post-processor.
//
// Parameters:
//      None.
//
// Returns:
//      None.
//
//-----------------------------------------------------------------------------
void PpClass::PpClearBuffers()
{
    ppBuffers bufs;
    DWORD dwFlags, bytesRead;

    // Read all buffers from Input queue.
    while (ReadMsgQueue(m_hReadInputBufferQueue, &bufs, sizeof(ppBuffers), &bytesRead, 0, &dwFlags)){}

    // Read all buffers from Output queue.
    while (ReadMsgQueue(m_hReadOutputBufferQueue, &bufs, sizeof(ppBuffers), &bytesRead, 0, &dwFlags)){}
}

//-----------------------------------------------------------------------------
//
// Function:  PpGetMaxBuffers
//
// This function returns the maximum number of buffers supported
// by the postprocessor.
// with the IPU hardware.
//
// Parameters:
//      None.
//
// Returns:
//      Returns the Max buffer number.
//
//-----------------------------------------------------------------------------
UINT32 PpClass::PpGetMaxBuffers(void)
{
    return PP_MAX_NUM_BUFFERS;
}


//-----------------------------------------------------------------------------
//
// Function: PpConfigure
//
// This function configures the IC registers and IDMAC
// channels for the postprocessor channel.
//
// Parameters:
//      pPpConfigureData
//          [in] Pointer to configuration data structure
//
// Returns:
//      TRUE if success
//      FALSE if failure
//
//-----------------------------------------------------------------------------
BOOL PpClass::PpConfigure(pPpConfigData pConfigData)
{
    BOOL result = TRUE;
    ppFormat iFormat = pConfigData->outputFormat;
    ppCSCCoeffs CSCCoeffs;
    ppResizeCoeffs resizeCoeffs;
    UINT16 iResizeOutputHeight, iResizeOutputWidth;

    PP_FUNCTION_ENTRY();

    // Get display characteristics for PpClass.
    // Only perform once.
    if (!m_bDisplayInitialized)
    {
        PpInitDisplayCharacteristics();
        m_bDisplayInitialized = TRUE;
    }

    // If Post-processing enabled, configure
    if (iFormat != ppFormat_Disabled)
    {
        //-----------------------------------------------------------------
        // Setup input source
        //-----------------------------------------------------------------
        PpConfigureInput(pConfigData);

        //-----------------------------------------------------------------
        // Setup input source
        //-----------------------------------------------------------------
        PpConfigureOutput(pConfigData);

        //-----------------------------------------------------------------
        // Setup color space conversion
        //-----------------------------------------------------------------

        // Set up CSC for post-processing
        if (pConfigData->CSCEquation != ppCSCNoOp)
        {
            switch (pConfigData->CSCEquation)
            {
                case ppCSCR2Y_A1:
                case ppCSCR2Y_A0:
                case ppCSCR2Y_B0:
                case ppCSCR2Y_B1:
                    CSCCoeffs.C00 = rgb2yuv_tbl[pConfigData->CSCEquation][0];
                    CSCCoeffs.C01 = rgb2yuv_tbl[pConfigData->CSCEquation][1];
                    CSCCoeffs.C02 = rgb2yuv_tbl[pConfigData->CSCEquation][2];
                    CSCCoeffs.C10 = rgb2yuv_tbl[pConfigData->CSCEquation][3];
                    CSCCoeffs.C11 = rgb2yuv_tbl[pConfigData->CSCEquation][4];
                    CSCCoeffs.C12 = rgb2yuv_tbl[pConfigData->CSCEquation][5];
                    CSCCoeffs.C20 = rgb2yuv_tbl[pConfigData->CSCEquation][6];
                    CSCCoeffs.C21 = rgb2yuv_tbl[pConfigData->CSCEquation][7];
                    CSCCoeffs.C22 = rgb2yuv_tbl[pConfigData->CSCEquation][8];
                    CSCCoeffs.A0 = rgb2yuv_tbl[pConfigData->CSCEquation][9];
                    CSCCoeffs.A1 = rgb2yuv_tbl[pConfigData->CSCEquation][10];
                    CSCCoeffs.A2 = rgb2yuv_tbl[pConfigData->CSCEquation][11];
                    CSCCoeffs.Scale = rgb2yuv_tbl[pConfigData->CSCEquation][12];
                    break;

                case ppCSCY2R_A1:
                case ppCSCY2R_A0:
                case ppCSCY2R_B0:
                case ppCSCY2R_B1:
                    CSCCoeffs.C00 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][0];
                    CSCCoeffs.C01 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][1];
                    CSCCoeffs.C02 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][2];
                    CSCCoeffs.C10 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][3];
                    CSCCoeffs.C11 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][4];
                    CSCCoeffs.C12 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][5];
                    CSCCoeffs.C20 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][6];
                    CSCCoeffs.C21 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][7];
                    CSCCoeffs.C22 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][8];
                    CSCCoeffs.A0 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][9];
                    CSCCoeffs.A1 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][10];
                    CSCCoeffs.A2 = yuv2rgb_tbl[pConfigData->CSCEquation - 4][11];
                    CSCCoeffs.Scale = yuv2rgb_tbl[pConfigData->CSCEquation - 4][12];
                    break;

                case ppCSCCustom:
                    CSCCoeffs.C00 = pConfigData->CSCCoeffs.C00;
                    CSCCoeffs.C01 = pConfigData->CSCCoeffs.C01;
                    CSCCoeffs.C02 = pConfigData->CSCCoeffs.C02;
                    CSCCoeffs.C10 = pConfigData->CSCCoeffs.C10;
                    CSCCoeffs.C11 = pConfigData->CSCCoeffs.C11;
                    CSCCoeffs.C12 = pConfigData->CSCCoeffs.C12;
                    CSCCoeffs.C20 = pConfigData->CSCCoeffs.C20;
                    CSCCoeffs.C21 = pConfigData->CSCCoeffs.C21;
                    CSCCoeffs.C22 = pConfigData->CSCCoeffs.C22;
                    CSCCoeffs.A0 = pConfigData->CSCCoeffs.A0;
                    CSCCoeffs.A1 = pConfigData->CSCCoeffs.A1;
                    CSCCoeffs.A2 = pConfigData->CSCCoeffs.A2;
                    CSCCoeffs.Scale = pConfigData->CSCCoeffs.Scale;
                    break;

                default:
                    DEBUGMSG(ZONE_ERROR,
                        (TEXT("%s: Invalid PP CSC equation. \r\n"), __WFUNCTION__));
            }

            // Set up the task parameter memory
            PpTaskParamConfig(&CSCCoeffs);

            // Now enable CSC in IC configuration register
            INSREG32BF(&P_IPU_REGS->IC_CONF, IPU_IC_CONF_PP_CSC1,
                IPU_IC_CONF_PP_CSC1_ENABLE);
        }
        else
        {
            // Disable CSC in IC configuration register
            INSREG32BF(&P_IPU_REGS->IC_CONF, IPU_IC_CONF_PP_CSC1,
                IPU_IC_CONF_PP_CSC1_DISABLE);
        }

        //-----------------------------------------------------------------
        // Set up resizing.
        //-----------------------------------------------------------------

        // Viewfinding path
        if (pConfigData->outputFormat != ppFormat_Disabled)
        {
            // If we are rotating, we want to resize the input
            // so that it matches the dimensions of the output
            // before rotation. (i.e., width in = height out
            // and height in = width out)
            if (pConfigData->flipRot.rotate90)
            {
                iResizeOutputWidth = pConfigData->outputSize.height;
                iResizeOutputHeight = pConfigData->outputSize.width;
            }
            else
            {
                iResizeOutputWidth = pConfigData->outputSize.width;
                iResizeOutputHeight = pConfigData->outputSize.height;
            }

            // Vertical resizing
            // Get coefficients and then set registers
            if (!PpGetResizeCoeffs(pConfigData->inputSize.height,
                iResizeOutputHeight, &resizeCoeffs))
            {
                DEBUGMSG(ZONE_ERROR,
                    (TEXT("%s: Post-processing vertical resizing failed. \r\n"), __WFUNCTION__));
                result = FALSE;
                goto _done;
            }

            // Set downsizing field
            INSREG32BF(&P_IPU_REGS->IC_PP_RSC, IPU_IC_PP_RSC_PP_DS_R_V,
                resizeCoeffs.downsizeCoeff);

            // Set resizing field
            INSREG32BF(&P_IPU_REGS->IC_PP_RSC, IPU_IC_PP_RSC_PP_RS_R_V,
                resizeCoeffs.resizeCoeff);

            // Horizontal resizing
            // Get coefficients and then set registers
            if (!PpGetResizeCoeffs(pConfigData->inputSize.width,
                iResizeOutputWidth, &resizeCoeffs))
            {
                DEBUGMSG(ZONE_ERROR,
                    (TEXT("%s: Viewfinding horizontal resizing failed. \r\n"), __WFUNCTION__));
                result = FALSE;
                goto _done;
            }

            // Set downsizing field
            INSREG32BF(&P_IPU_REGS->IC_PP_RSC, IPU_IC_PP_RSC_PP_DS_R_H,
                resizeCoeffs.downsizeCoeff);

            // Set resizing field
            INSREG32BF(&P_IPU_REGS->IC_PP_RSC, IPU_IC_PP_RSC_PP_RS_R_H,
                resizeCoeffs.resizeCoeff);
        }

        m_bConfigured = TRUE;
    }

_done:
    PP_FUNCTION_EXIT();
    return result;
}