umc_color_space_converter.cpp

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

        lpConvertParam->lpDest0 = lpConvertParam->lpSource0;
        lpConvertParam->lpDest1 = lpConvertParam->lpSource1;
        lpConvertParam->lpDest2 = lpConvertParam->lpSource2;
        lpConvertParam->PitchDest0 = lpConvertParam->PitchSource0;
        lpConvertParam->PitchDest1 = lpConvertParam->PitchSource1;
        lpConvertParam->PitchDest2 = lpConvertParam->PitchSource2;
        return UMC_OK;
    }

    Param = *lpConvertParam;

    // copy data
    if (NONE == Param.ConversionInit.FormatDest)
        Param.ConversionInit.FormatDest = Param.ConversionInit.FormatSource;

    // if Init was not called
    if (NULL == lpConvertParam->ConversionInit.iInternal)
        return UMC_NOT_INITIALIZED;

    // check formats & fix it
    if (UMC_OK != (Error = CheckParameters(Param)))
        return Error;

    UMC::RECT SliceRect;
    { // Prepare RECT description of converted slice
        SliceRect.left = 0;
        SliceRect.right = static_cast<signed short> (Param.ConversionInit.SizeSource.width);
        SliceRect.top = static_cast<signed short> (SLICE_WIDTH * (short)lSliceNum);
        SliceRect.bottom = static_cast<signed short> (SliceRect.top + SLICE_WIDTH);

        // intersept crop region and slice region
        SliceRect.left = max(SliceRect.left,
                             Param.ConversionInit.SrcCropRect.left);

        SliceRect.right = max(SliceRect.left,
                min(SliceRect.right, Param.ConversionInit.SrcCropRect.right));

        SliceRect.top = max(SliceRect.top,
                            Param.ConversionInit.SrcCropRect.top);

        SliceRect.bottom = max(SliceRect.top,
               min(SliceRect.bottom, Param.ConversionInit.SrcCropRect.bottom));
    }

//  if ((Param.ConversionInit.SizeDest.width != Param.ConversionInit.SizeSource.width) ||
//      (Param.ConversionInit.SizeDest.height != Param.ConversionInit.SizeSource.height))
    if (Param.ConversionInit.SrcCropRect.right -
            Param.ConversionInit.SrcCropRect.left !=
            Param.ConversionInit.SizeDest.width ||
        Param.ConversionInit.SrcCropRect.bottom -
            Param.ConversionInit.SrcCropRect.top !=
            Param.ConversionInit.SizeDest.height)
    {   return UMC_OK;  }

    ColorFormatConsts& rSrcConsts = Param.ConversionInit.SrcFmtConsts;
    // increment source pointer(s)
    switch (Param.ConversionInit.FormatSource)
    {
    case YUV411:
    case YV12:
    case YUV420:
//      Param.lpSource2 += (SLICE_WIDTH / 2) * lSliceNum * Param.PitchSource2;
        if (3 == rSrcConsts.uiPlanNum)
        {
            Param.lpSource2 += SliceRect.top * Param.PitchSource2 /
                rSrcConsts.uiColPerLinePl12 +
                SliceRect.left / rSrcConsts.uiPixPerBytePl12;
        }

    case NV12:
    case YUV420M:
//      Param.lpSource1 += (SLICE_WIDTH / 2) * lSliceNum * Param.PitchSource1;
        if (2 <= rSrcConsts.uiPlanNum)
        {
            Param.lpSource1 += SliceRect.top * Param.PitchSource1 /
                rSrcConsts.uiColPerLinePl12 +
                SliceRect.left / rSrcConsts.uiPixPerBytePl12;
        }

    case YUY2:
    case UYVY:
//      Param.lpSource0 += SLICE_WIDTH * lSliceNum * Param.PitchSource0;
        Param.lpSource0 += SliceRect.top * Param.PitchSource0;
        break;

    // other RGB formats
    default:
        Param.lpSource0 +=
//           (Param.ConversionInit.SizeSource.height - SLICE_WIDTH * lSliceNum) *
           (Param.ConversionInit.SizeSource.height - SliceRect.top) *
           Param.PitchSource0;
        break;
    };

    // increment dest pointer(s)
    switch (Param.ConversionInit.FormatDest)
    {
    case YUV411:
    case YV12:
    case YUV420:
        Param.lpDest2 += (SLICE_WIDTH / 2) * lSliceNum * Param.PitchDest2;

    case NV12:
    case YUV420M:
        Param.lpDest1 += (SLICE_WIDTH / 2) * lSliceNum * Param.PitchDest1;

    case YUY2:
    case UYVY:
        Param.lpDest0 += SLICE_WIDTH * lSliceNum * Param.PitchDest0;
        break;

    case RGB565:
#if defined (LINUX32) && (defined(ARM) || defined(_ARM_))
        Param.lpDest0 += (Param.ConversionInit.SizeDest.height - SLICE_WIDTH * lSliceNum) * 2;
#else
        Param.lpDest0 += SLICE_WIDTH * lSliceNum * Param.PitchDest0;
#endif
        break;
    // other RGB formats
    default:
        Param.lpDest0 += (Param.ConversionInit.SizeDest.height - SLICE_WIDTH * lSliceNum) * Param.PitchDest0;
        break;
    };

/*  if((lSliceNum+1)*16 >= ((Param).ConversionInit).SizeSource.height)
    {
        Param.ConversionInit.SizeSource.height =
        Param.ConversionInit.SizeDest.height = ((Param).ConversionInit).SizeSource.height - lSliceNum*16;
    }
    else*/
    {
        Param.ConversionInit.SizeSource.height =
        Param.ConversionInit.SizeDest.height =
//                                                16; // ??? = SLICE_WIDTH;
                                        (SliceRect.bottom - SliceRect.top);

        Param.ConversionInit.SizeSource.width =
        Param.ConversionInit.SizeDest.width =
                                        (SliceRect.right - SliceRect.left);
    }

#ifdef _WIN32_WCE
#if (_WIN32_WCE > 0x0300)
    try
    {
#endif // (_WIN32_WCE > 0x0300)
#endif // _WIN32_WCE

        // convert & deinterlace
        ConvertFrameAndDeinterlace(Param);

#ifdef _WIN32_WCE
#if (_WIN32_WCE > 0x0300)
    }
    catch(...)
    {
    };
#endif // (_WIN32_WCE > 0x0300)
#endif // _WIN32_WCE

    return UMC_OK;

} // Status ColorSpaceConverter::ConvertSlice(ColorConversionParams *lpConvertParam, vm_var32 lSliceNum)

Status ColorSpaceConverter::ConvertFrameAndDeinterlace(ColorConversionParams &Param)
{
    size_t lNeededSize, lNewPitch;

    void *lpvRealPointer, *lpvRealPointerU, *lpvRealPointerV;
    size_t lRealPitch, lRealPitchU, lRealPitchV;

    if (FLAG_CCNV_NONE == (Param.ConversionInit.lDeinterlace & FLAG_CCNV_DEINTERLACE))
    {
        void (ColorSpaceConverter::*lpFunc)(ColorConversionParams &ConvertParam);

        lpFunc = static_cast<void (ColorSpaceConverter::*)(ColorConversionParams &ConvertParam)> (Param.ConversionInit.iInternal);
        // call function by pointer
        (this->*(lpFunc))(Param);
        return UMC_OK;
    };

    // calc deinterlace buffer size
    switch (Param.ConversionInit.FormatDest)
    {
    case RGB444:
    case RGB555:
    case RGB565:
    case YUY2:
    case UYVY:
        lNewPitch = Param.ConversionInit.SizeDest.width * 2;
        lNeededSize = lNewPitch * Param.ConversionInit.SizeDest.height;
        break;

    case RGB24:
        lNewPitch = (Param.ConversionInit.SizeDest.width & ~(3)) * 3;
        lNeededSize = lNewPitch * Param.ConversionInit.SizeDest.height;
        break;

    case RGB32:
        lNewPitch = Param.ConversionInit.SizeDest.width * 4;
        lNeededSize = lNewPitch * Param.ConversionInit.SizeDest.height;
        break;

    case YV12:
    case NV12:
        lNewPitch = Param.ConversionInit.SizeDest.width;
        lNeededSize = (lNewPitch * Param.ConversionInit.SizeDest.height * 3) / 2;
        break;

    default:
        lNewPitch = 0;
        lNeededSize = 0;
        break;
    };

    // unknown format for deinterlace
    if (0 == lNeededSize)
    {
        void (ColorSpaceConverter::*lpFunc)(ColorConversionParams &ConvertParam);

        lpFunc = static_cast<void (ColorSpaceConverter::*)(ColorConversionParams &ConvertParam)> (Param.ConversionInit.iInternal);
        // call function by pointer
        (this->*(lpFunc))(Param);
        return UMC_OK;
    };

    // allocate deinterlace buffer
    if (lNeededSize > m_lDeinterlaceSize)
    {
        AllocateInternalBuffer(lNeededSize, m_lDeinterlaceSize, m_lpvDeinterlace);
        if (NULL == m_lpvDeinterlace)
        {
            void (ColorSpaceConverter::*lpFunc)(ColorConversionParams &ConvertParam);

            lpFunc = static_cast<void (ColorSpaceConverter::*)(ColorConversionParams &ConvertParam)> (Param.ConversionInit.iInternal);
            // call function by pointer
            (this->*(lpFunc))(Param);
            return UMC_OK;
        };
    };

    // save real destination
    lpvRealPointer = Param.lpDest0;
    lpvRealPointerU = Param.lpDest1;
    lpvRealPointerV = Param.lpDest2;
    lRealPitch = Param.PitchDest0;
    lRealPitchU = Param.PitchDest1;
    lRealPitchV = Param.PitchDest2;

    // set new (internal) destination pointer
    switch (Param.ConversionInit.FormatDest)
    {
    case UYVY:
    case YUY2:
    case RGB24:
    case RGB32:
    case RGB444:
    case RGB555:
    case RGB565:
        Param.lpDest0 = reinterpret_cast<vm_byte *> (m_lpvDeinterlace);
        Param.PitchDest0 = (vm_var32) lNewPitch;
        break;

    case YV12:
        {
            vm_byte *lpbSource = reinterpret_cast<vm_byte *> (m_lpvDeinterlace);

            Param.lpDest0 = lpbSource;
            Param.PitchDest0 = (vm_var32) lNewPitch;
            Param.lpDest1 = lpbSource +
                            lNewPitch * Param.ConversionInit.SizeDest.height;
            Param.PitchDest1 = ((vm_var32) (lNewPitch / 2));
            Param.lpDest2 = lpbSource +
                            lNewPitch * Param.ConversionInit.SizeDest.height +
                            (lNewPitch / 2) * (Param.ConversionInit.SizeDest.height / 2);
            Param.PitchDest2 = ((vm_var32) (lNewPitch / 2));
        }
        break;

    case NV12:
        {
            vm_byte *lpbSource = reinterpret_cast<vm_byte *> (m_lpvDeinterlace);

            Param.lpDest0 = lpbSource;
            Param.PitchDest0 = (vm_var32) lNewPitch;
            Param.lpDest1 = lpbSource +
                            lNewPitch * Param.ConversionInit.SizeDest.height;
            Param.PitchDest1 = (vm_var32) lNewPitch;
        }
        break;

    default:
        break;
    }

    // call function by pointer
    {
        void (ColorSpaceConverter::*lpFunc)(ColorConversionParams &ConvertParam);

        lpFunc = static_cast<void (ColorSpaceConverter::*)(ColorConversionParams &ConvertParam)> (Param.ConversionInit.iInternal);
        // call function by pointer
        (this->*(lpFunc))(Param);
    };

    // set real pointer(s)
    Param.lpSource0 = Param.lpDest0;
    Param.lpSource1 = Param.lpDest1;
    Param.lpSource2 = Param.lpDest2;
    Param.PitchSource0 = Param.PitchDest0;
    Param.PitchSource1 = Param.PitchDest1;
    Param.PitchSource2 = Param.PitchDest2;

    Param.lpDest0 = reinterpret_cast<vm_byte *> (lpvRealPointer);
    Param.lpDest1 = reinterpret_cast<vm_byte *> (lpvRealPointerU);
    Param.lpDest2 = reinterpret_cast<vm_byte *> (lpvRealPointerV);
    Param.PitchDest0 = (vm_var32) lRealPitch;
    Param.PitchDest1 = (vm_var32) lRealPitchU;
    Param.PitchDest2 = (vm_var32) lRealPitchV;

    // deinterlace frame
    DeinterlaceFrame(Param);

    return UMC_OK;

} // Status ColorSpaceConverter::ConvertFrameAndDeinterlace(ColorConversionParams &Param)

Status ColorSpaceConverter::BeginFrame(ColorConversionParams *lpConvertParam)
{
    // touch unreferenced parameter
    lpConvertParam = lpConvertParam;

    return UMC_OK;

} // Status ColorSpaceConverter::BeginFrame(ColorConversionParams *lpConvertParam)

Status ColorSpaceConverter::CloseFrame(ColorConversionParams *lpParam)
{
    if ((lpParam->ConversionInit.SizeDest.width == lpParam->ConversionInit.SizeSource.width) &&
        (lpParam->ConversionInit.SizeDest.height == lpParam->ConversionInit.SizeSource.height) &&
        (0 == (lpParam->ConversionInit.lDeinterlace & FLAG_CCNV_DEINTERLACE)))
        return UMC_OK;

    return ConvertFrame(lpParam);

} // Status ColorSpaceConverter::CloseFrame(ColorConversionParams *lpConvertParam)

} // end namespace UMC