umc_dv_decoder.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 <math.h>
#include <ippi.h>
#include <ipps.h>
#include <ippvc.h>
#include "vm_event.h"
#include "vm_thread.h"
#include "vm_sys_info.h"
#include "umc_dv_decoder.h"
#include "umc_dv_internal.h"
#include "umc_video_data.h"
#include "umc_color_space_converter.h"

#ifdef _OPENMP
#include "omp.h"
#endif

namespace UMC
{

DVVideoDecoder::DVVideoDecoder()
{
    m_pHuffTable        = NULL;
    m_pShortBlocksNA    = NULL;
    m_ppShortBlocks     = NULL;

    StoreDVSegment = NULL;

    m_lpADequantizeTable= NULL;
    m_lpBuffer2         = NULL;

    m_lpADequantizeLineTable            = NULL;
    m_lpvInternalFrameBuffer            = NULL;
    m_lpvInternalFrameBufferNotAligned  = NULL;

    m_nSystem           = SYSTEM_UNK;
    m_nStream           = NONE_STREAM;
    m_nPitch            = 0;
    m_bDCOnly           = false;

    m_bSecondPicture    = false;

    m_nNumberOfThreads = 0;
    vm_event_set_invalid(&m_Quit);
    m_lpThreads = NULL;
    m_lpStartEvent = NULL;
    m_lpStopEvent = NULL;
    m_lpThreadsID = NULL;

} // DVVideoDecoder::DVVideoDecoder()

DVVideoDecoder::~DVVideoDecoder()
{
    Close();

} // DVVideoDecoder::~DVVideoDecoder()

Status DVVideoDecoder::Close()
{
    vm_var32 i;

    // let all threads to exit
    if (m_lpThreads)
    {
        vm_event_signal(&m_Quit);

        for (i = 1;i < m_nNumberOfThreads;i += 1)
            vm_event_signal(m_lpStartEvent + i);

        for (i = 1;i < m_nNumberOfThreads;i += 1)
        {
            if (vm_thread_is_valid(m_lpThreads + i))
                vm_thread_wait(m_lpThreads + i);
        };
    };

    // delete all threading tools
    if (vm_event_is_valid(&m_Quit))
    {
        vm_event_destroy(&m_Quit);
        vm_event_set_invalid(&m_Quit);
    }

    if (m_lpThreads)
    {
        for (i = 1;i < m_nNumberOfThreads;i += 1)
            vm_thread_set_invalid(m_lpThreads + i);

        delete [] m_lpThreads;
    };

    if (m_lpStartEvent)
    {
        for (i = 1;i < m_nNumberOfThreads;i += 1)
        {
            if (vm_event_is_valid(m_lpStartEvent + i))
            {
                vm_event_destroy(m_lpStartEvent + i);
                vm_event_set_invalid(m_lpStartEvent + i);
            };
        }

        delete [] m_lpStartEvent;
    };

    if (m_lpStopEvent)
    {
        for (i = 1;i < m_nNumberOfThreads;i += 1)
        {
            if (vm_event_is_valid(m_lpStopEvent + i))
            {
                vm_event_destroy(m_lpStopEvent + i);
                vm_event_set_invalid(m_lpStopEvent + i);
            };
        }

        delete [] m_lpStopEvent;
    };

    if (m_lpThreadsID)
        delete [] m_lpThreadsID;

    if (m_pHuffTable)
        ippiFreeHuffmanTable_DV_32u((Ipp32u *)m_pHuffTable);

    if (m_lpBuffer2)
        ippsFree(m_lpBuffer2);

    if (m_lpADequantizeLineTable)
        ippsFree(m_lpADequantizeLineTable);

    if (m_lpvInternalFrameBufferNotAligned)
        delete [] m_lpvInternalFrameBufferNotAligned;

    if(m_ppShortBlocks)
        delete [] m_ppShortBlocks;

    if(m_pShortBlocksNA)
        delete [] m_pShortBlocksNA;

    m_pHuffTable = 0;
    m_lpBuffer2 = 0;
    m_lpADequantizeLineTable = 0;

    m_ppShortBlocks = NULL;
    m_pShortBlocksNA = NULL;

    m_nSystem = SYSTEM_UNK;
    m_nStream = NONE_STREAM;

    m_ConversionParam.Reset();
    m_ConversionParamPreview.Reset();

    m_bSecondPicture = false;
    m_bDCOnly = false;

    m_lpvInternalFrameBuffer =
    m_lpvInternalFrameBufferNotAligned = NULL;
    m_nPitch = 0;

    StoreDVSegment = NULL;

    m_pConverter = NULL;

    return UMC_OK;

} // Status DVVideoDecoder::Close()


Status DVVideoDecoder::Init(BaseCodecParams *lpInit)
{
    VideoDecoderParams *init_param = DynamicCast<VideoDecoderParams> (lpInit);
    vm_var32 i;
    vm_var32 nWidth, nHeight;

    if (NULL == init_param)
        return UMC_NULL_PTR;

    Close();

    if(init_param->uiLimitThreads == 0)
    {
#ifdef _OPENMP
        m_nNumberOfThreads = omp_get_max_threads();
#else //_OPENMP
        m_nNumberOfThreads = vm_sys_info_get_cpu_num();
#endif //_OPENMP
    }
    else
        m_nNumberOfThreads = init_param->uiLimitThreads;


    if (0 >= m_nNumberOfThreads)
        m_nNumberOfThreads = 1;
    else if (8 < m_nNumberOfThreads)
        m_nNumberOfThreads = 8;

    // allocate working buffer(s)
    m_pShortBlocksNA = new vm_byte[(SIZE_OF_VIDEO_SEGMENT + MEMORY_ALIGN) * m_nNumberOfThreads];
    if (NULL == m_pShortBlocksNA)
        return UMC_FAILED_TO_ALLOCATE_BUFFER;
    m_ppShortBlocks = new vm_var16 *[m_nNumberOfThreads];
    if (NULL == m_ppShortBlocks)
        return UMC_FAILED_TO_ALLOCATE_BUFFER;
    for (i = 0;i < m_nNumberOfThreads;i += 1)
        m_ppShortBlocks[i] = align_pointer<vm_var16 *> (m_pShortBlocksNA + SIZE_OF_VIDEO_SEGMENT * i, MEMORY_ALIGN);

    // create threading tools
    if (1 < m_nNumberOfThreads)
    {
        // create stop event
        if (VM_OK != vm_event_init(&m_Quit, 1, 0))
            return UMC_FAILED_TO_INITIALIZE;

        // create start event(s)
        m_lpStartEvent = new vm_event[m_nNumberOfThreads];
        if (NULL == m_lpStartEvent)
            return UMC_FAILED_TO_ALLOCATE_BUFFER;
        for (i = 1;i < m_nNumberOfThreads;i += 1)
        {
            vm_event_set_invalid(m_lpStartEvent + i);
            if (VM_OK != vm_event_init(m_lpStartEvent + i, 0, 0))
                return UMC_FAILED_TO_INITIALIZE;
        };

        // create stop event(s)
        m_lpStopEvent = new vm_event[m_nNumberOfThreads];
        if (NULL == m_lpStopEvent)
            return UMC_FAILED_TO_ALLOCATE_BUFFER;
        for (i = 1;i < m_nNumberOfThreads;i += 1)
        {
            vm_event_set_invalid(m_lpStopEvent + i);
            if (VM_OK != vm_event_init(m_lpStopEvent + i, 0, 0))
                return UMC_FAILED_TO_INITIALIZE;
        };

        // allocate thread ID(s)
        m_lpThreadsID = new THREAD_ID[m_nNumberOfThreads];
        if (NULL == m_lpThreadsID)
            return UMC_FAILED_TO_ALLOCATE_BUFFER;

        // starting thread(s)
        m_lpThreads = new vm_thread[m_nNumberOfThreads];
        if (NULL == m_lpThreads)
            return UMC_FAILED_TO_ALLOCATE_BUFFER;
        for (i = 1;i < m_nNumberOfThreads;i += 1)
        {
            vm_thread_set_invalid(m_lpThreads + i);
            m_lpThreadsID[i].m_nNumber = i;
            m_lpThreadsID[i].m_lpOwner = this;
            if (0 == vm_thread_create(m_lpThreads + i, ThreadWorkingRoutine, m_lpThreadsID + i))
                return UMC_FAILED_TO_INITIALIZE;
        };
    };

    // init color convertsion
    if (NULL == init_param->lpConvertInit)
        return UMC_NULL_PTR;

    // check parameters
    if ((WIDTH_DV != init_param->lpConvertInit->SizeSource.width) ||
        ((HEIGHT_625 != init_param->lpConvertInit->SizeSource.height) && (HEIGHT_525 != init_param->lpConvertInit->SizeSource.height)))
        return UMC_BAD_FORMAT;

    // set working system
    m_nSystem = ((HEIGHT_625 == init_param->lpConvertInit->SizeSource.height) ? (SYSTEM_625) : (SYSTEM_525));
    m_nMaxNumberOfDIFSequences = ((HEIGHT_625 == init_param->lpConvertInit->SizeSource.height) ? (12) : (10));

    m_pConverter = init_param->lpConverter;

    m_ConversionParam.ConversionInit = *(init_param->lpConvertInit);
    // check output size
    m_ConversionParam.ConversionInit.FormatSource = YUY2;
    switch (m_ConversionParam.ConversionInit.lFlags)
    {
    case FLAG_CCNV_NONE:
    case FLAG_CCNV_CONVERT:
    case FLAG_CCNV_RESIZE_CUSTOM:
        nHeight = m_ConversionParam.ConversionInit.SizeSource.height;
        nWidth = m_ConversionParam.ConversionInit.SizeSource.width;
        break;

    case FLAG_CCNV_RESIZE_2S:
        nHeight = m_ConversionParam.ConversionInit.SizeSource.height / 2;
        nWidth = m_ConversionParam.ConversionInit.SizeSource.width / 2;
        break;

    case FLAG_CCNV_RESIZE_4S:
        nHeight = m_ConversionParam.ConversionInit.SizeSource.height / 4;
        nWidth = m_ConversionParam.ConversionInit.SizeSource.width / 4;
        break;

    case FLAG_CCNV_RESIZE_8S:
        nHeight = m_ConversionParam.ConversionInit.SizeSource.height / 8;
        nWidth = m_ConversionParam.ConversionInit.SizeSource.width / 8;
        m_bDCOnly = true;
        break;

    default:
        return UMC_FLAGS_ERROR;
    };

    // when no custom resize
    if (FLAG_CCNV_RESIZE_CUSTOM != m_ConversionParam.ConversionInit.lFlags)
    {
        if (FLAG_CCNV_NONE != m_ConversionParam.ConversionInit.lFlags)
            m_ConversionParam.ConversionInit.lFlags = FLAG_CCNV_CONVERT;
        m_ConversionParam.ConversionInit.SizeDest.width =
        m_ConversionParam.ConversionInit.SizeSource.width = nWidth;
        m_ConversionParam.ConversionInit.SizeDest.height =
        m_ConversionParam.ConversionInit.SizeSource.height = nHeight;
    }
    // when custom resize is used
    else
    {
        m_ConversionParam.ConversionInit.SizeDest = init_param->lpConvertInit->SizeDest;
        m_ConversionParam.ConversionInit.SizeSource = init_param->lpConvertInit->SizeSource;
    };

    if (NULL != m_pConverter &&
        UMC_OK != m_pConverter->Init(m_ConversionParam.ConversionInit))
        return UMC_BAD_FORMAT;

    m_ClipInfo = init_param->info;
    m_ClipInfo.clip_info.width = m_ConversionParam.ConversionInit.SizeDest.width;
    m_ClipInfo.clip_info.height = m_ConversionParam.ConversionInit.SizeDest.height;

    // allocate internal frame buffer
    if ((0 == (init_param->lFlags & FLAG_VDEC_NO_PREVIEW)) ||
        (YUY2 != m_ConversionParam.ConversionInit.FormatDest))
    {
        m_nPitch = align_value<vm_var32> (2 * nWidth, WIDTH_ALIGN);
        m_lpvInternalFrameBufferNotAligned = new vm_byte[m_nPitch * nHeight + MEMORY_ALIGN];
        if (NULL == m_lpvInternalFrameBufferNotAligned)
            return UMC_FAILED_TO_ALLOCATE_BUFFER;
        m_lpvInternalFrameBuffer = align_pointer<vm_byte *> (m_lpvInternalFrameBufferNotAligned, MEMORY_ALIGN);