umc_color_space_converter.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*
//
//              INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license  agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in  accordance  with the terms of that agreement.
//    Copyright (c) 2003-2005 Intel Corporation. All Rights Reserved.
//
//
*/

#include <stdlib.h>
#include <memory.h>
#include <vm_debug.h>
#include "umc_structures.h"
#include "umc_color_space_converter.h"

namespace UMC
{

static
Status SetFormatConsts(ColorFormat Format, ColorFormatConsts& rConsts)
{
    Status umcRes = UMC_OK;
    switch (Format)
    {
    case YUV411: // Planar Y, U, V, 8 bit per component
        rConsts.uiWidthAlign = (unsigned) ~3;
        rConsts.uiHeightAlign = (unsigned) ~0;
        rConsts.uiPlanNum = 3;
        rConsts.uiBytesPerPixPl0 = 1;
        rConsts.uiPixPerBytePl12 = 4;
        rConsts.uiColPerLinePl12 = 1;
        break;

    case YUV420: // Planar Y, U, V, 8 bit per component (trained peolpe use only)
        rConsts.uiWidthAlign = (unsigned) ~1;
        rConsts.uiHeightAlign = (unsigned) ~1;
        rConsts.uiPlanNum = 3;
        rConsts.uiBytesPerPixPl0 = 1;
        rConsts.uiPixPerBytePl12 = 2;
        rConsts.uiColPerLinePl12 = 2;
        break;

    case YUV420M:// Planar merged Y, U->V, 8 bit per component (trained peolpe use only)
        rConsts.uiWidthAlign = (unsigned) ~1;
        rConsts.uiHeightAlign = (unsigned) ~1;
        rConsts.uiPlanNum = 2;
        rConsts.uiBytesPerPixPl0 = 1;
        rConsts.uiPixPerBytePl12 = 1;
        rConsts.uiColPerLinePl12 = 2;
        break;

    case RGB444: // Composite B->G->R->A, 4 bit per component
    case RGB555: // Composite B->G->R->A, 5 bit per component, 1 bit per A
    case RGB565: // Composite B->G->R 5 bit per B & R, 6 bit per G
        rConsts.uiWidthAlign = (unsigned) ~0;
        rConsts.uiHeightAlign = (unsigned) ~0;
        rConsts.uiPlanNum = 1;
        rConsts.uiBytesPerPixPl0 = 2;
        rConsts.uiPixPerBytePl12 = 0;
        rConsts.uiColPerLinePl12 = 0;
        break;

    case YUY2: // Composite Y->U->Y->V 8 bit per component
    case UYVY: // Composite U->Y->V->Y 8 bit per component
        rConsts.uiWidthAlign = (unsigned) ~1;
        rConsts.uiHeightAlign = (unsigned) ~0;
        rConsts.uiPlanNum = 1;
        rConsts.uiBytesPerPixPl0 = 2;
        rConsts.uiPixPerBytePl12 = 0;
        rConsts.uiColPerLinePl12 = 0;
        break;

    case RGB24: // Composite B->G->R 8 bit per component
        rConsts.uiWidthAlign = (unsigned) ~0;
        rConsts.uiHeightAlign = (unsigned) ~0;
        rConsts.uiPlanNum = 1;
        rConsts.uiBytesPerPixPl0 = 3;
        rConsts.uiPixPerBytePl12 = 0;
        rConsts.uiColPerLinePl12 = 0;
        break;

    case RGB32: // Composite B->G->R->A 8 bit per component
        rConsts.uiWidthAlign = (unsigned) ~0;
        rConsts.uiHeightAlign = (unsigned) ~0;
        rConsts.uiPlanNum = 1;
        rConsts.uiBytesPerPixPl0 = 4;
        rConsts.uiPixPerBytePl12 = 0;
        rConsts.uiColPerLinePl12 = 0;
        break;

    case YV12: // Planar Y, U, V, 8 bit per component
        rConsts.uiWidthAlign = (unsigned) ~1;
        rConsts.uiHeightAlign = (unsigned) ~1;
        rConsts.uiPlanNum = 3;
        rConsts.uiBytesPerPixPl0 = 1;
        rConsts.uiPixPerBytePl12 = 2;
        rConsts.uiColPerLinePl12 = 2;
        break;

    case NV12: // Planar merged Y, U->V, 8 bit per component
        rConsts.uiWidthAlign = (unsigned) ~1;
        rConsts.uiHeightAlign = (unsigned) ~1;
        rConsts.uiPlanNum = 2;
        rConsts.uiBytesPerPixPl0 = 1;
        rConsts.uiPixPerBytePl12 = 1;
        rConsts.uiColPerLinePl12 = 2;
        break;

    case NONE:
    default:
        umcRes = UMC_BAD_FORMAT;
    }

    return umcRes;
}

enum
{
    ALIGN                       = 16,
    SLICE_WIDTH                 = 16
};

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

ColorSpaceConverter::ColorSpaceConverter()
{
    m_lBufferSize = 0;
    m_lpvBuffer = NULL;

    m_lAdditionalSize = 0;
    m_lpvAdditional = NULL;

    m_lDeinterlaceSize = 0;
    m_lpvDeinterlace = NULL;

} // ColorSpaceConverter::ColorSpaceConverter()

ColorSpaceConverter::~ColorSpaceConverter()
{
    // close all tools
    Close();

} // ColorSpaceConverter::~ColorSpaceConverter()

Status ColorSpaceConverter::Close(void)
{
    // delete internal buffer
    if (m_lpvBuffer)
    {
        vm_byte **lpv;

        // get real pointer
        lpv = reinterpret_cast<vm_byte **> (m_lpvBuffer);
        delete lpv[-1];

        m_lBufferSize = 0;
        m_lpvBuffer = NULL;
    };

    // delete additional internal buffer
    if (m_lpvAdditional)
    {
        vm_byte **lpv;

        // get real pointer
        lpv = reinterpret_cast<vm_byte **> (m_lpvAdditional);
        delete(lpv[-1]);

        m_lAdditionalSize = 0;
        m_lpvAdditional = NULL;
    };

    // delete deinterlace internal buffer
    if (m_lpvDeinterlace)
    {
        vm_byte **lpv;

        // get real pointer
        lpv = reinterpret_cast<vm_byte **> (m_lpvDeinterlace);
        delete(lpv[-1]);

        m_lDeinterlaceSize = 0;
        m_lpvDeinterlace = NULL;
    };

    return UMC_OK;

} // Status ColorSpaceConverter::Close(void)

bool ColorSpaceConverter::AllocateInternalBuffer(size_t lSize, size_t &lBufferSize, void * &lpvBuffer)
{
    vm_byte *lp;
    void **lpv;

    // delete internal buffer
    if (lpvBuffer)
    {
        vm_byte **lpv;

        // get real pointer
        lpv = reinterpret_cast<vm_byte **> (lpvBuffer);
        delete(lpv[-1]);

        lBufferSize = 0;
        lpvBuffer = NULL;
    };

    // alloc little bit more memory
    lp = new vm_byte[ALIGN + sizeof(void **) + lSize];
    if (NULL == lp)
        return false;

    // align memory
    lpvBuffer = align_pointer<void *> (lp + sizeof(void **), ALIGN);
    lBufferSize = lSize;

    // save real pointer
    lpv = reinterpret_cast<void **> (lpvBuffer);
    lpv[-1] = lp;

    return true;

} // bool ColorSpaceConverter::AllocateInternalBuffer(size_t lSize, size_t &lOldSize, void * &lpvBuffer)

#undef INITIALIZE_MEMBER
#define INITIALIZE_MEMBER(current_func, type_in, type_out)      \
    switch (type_out)                                           \
    {                                                           \
    case YV12:                                                  \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_YV12;           \
        break;                                                  \
    case NV12:                                                  \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_NV12;           \
        break;                                                  \
    case YUY2:                                                  \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_YCbCr;      \
        break;                                                  \
    case UYVY:                                                  \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_CbYCr;      \
        break;                                                  \
    case YUV411:                                                \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_YUV411;     \
        break;                                                  \
    case YUV420:                                                \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_YUV420;     \
        break;                                                  \
    case YUV420M:                                               \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_YUV420M;        \
        break;                                                  \
    case RGB32:                                                 \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_RGB32;      \
        break;                                                  \
    case RGB24:                                                 \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_RGB24;      \
        break;                                                  \
    case RGB565:                                                \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_RGB565;     \
        break;                                                  \
    case RGB555:                                                \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_RGB555;     \
        break;                                                  \
    case RGB444:                                                \
        current_func = &ColorSpaceConverter::ConvertFrom_##type_in##_To_RGB444;     \
        break;                                                  \
    default:                                                    \
        return UMC_FAILED_TO_INITIALIZE;                        \
    };

Status ColorSpaceConverter::Init(ColorConversionInfo &InitParam)
{
    void (ColorSpaceConverter::*lpFunc)(ColorConversionParams &ConvertParam);

    // set convertion function to correct state
    switch (InitParam.FormatSource)
    {
    case YV12:
        INITIALIZE_MEMBER(lpFunc, YV12, InitParam.FormatDest);
        break;

    case NV12:
        INITIALIZE_MEMBER(lpFunc, NV12, InitParam.FormatDest);
        break;

    case YUY2:
        INITIALIZE_MEMBER(lpFunc, YCbCr, InitParam.FormatDest);
        break;

    case UYVY:
        INITIALIZE_MEMBER(lpFunc, CbYCr, InitParam.FormatDest);
        break;

    case YUV411:
        INITIALIZE_MEMBER(lpFunc, YUV411, InitParam.FormatDest);
        break;

    case YUV420:
        INITIALIZE_MEMBER(lpFunc, YUV420, InitParam.FormatDest);
        break;

    case YUV420M:
        INITIALIZE_MEMBER(lpFunc, YUV420M, InitParam.FormatDest);
        break;

    case RGB32:
        INITIALIZE_MEMBER(lpFunc, RGB32, InitParam.FormatDest);
        break;

    case RGB24:
        INITIALIZE_MEMBER(lpFunc, RGB24, InitParam.FormatDest);
        break;

    case RGB565:
        INITIALIZE_MEMBER(lpFunc, RGB565, InitParam.FormatDest);
        break;

    case RGB555:
        INITIALIZE_MEMBER(lpFunc, RGB555, InitParam.FormatDest);
        break;

    case RGB444:
        INITIALIZE_MEMBER(lpFunc, RGB444, InitParam.FormatDest);
        break;

    default:
        return UMC_FAILED_TO_INITIALIZE;
    };

    // save current pointer
    InitParam.iInternal = static_cast<FuncIndex> (lpFunc);

    if (0 == InitParam.SrcCropRect.right ||
        0 == InitParam.SrcCropRect.bottom)
    {
        // Suppose SrcCropRect parameter just wasn't initialized
        assert(0 == InitParam.SrcCropRect.left);
        assert(0 == InitParam.SrcCropRect.top);

        InitParam.SrcCropRect.right = static_cast<signed short> (InitParam.SizeSource.width);
        InitParam.SrcCropRect.bottom = static_cast<signed short> (InitParam.SizeSource.height);
    }

    if (FLAG_CCNV_NONE == InitParam.lFlags) { // no convert
        InitParam.SizeDest = InitParam.SizeSource;
    } else if (FLAG_CCNV_CONVERT == InitParam.lFlags) { // color convert, no resize
        if(InitParam.SizeDest.width == 0) {
            InitParam.SizeDest.width = InitParam.SrcCropRect.right - InitParam.SrcCropRect.left;