umc_dv_decoder.cpp

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

        m_ConversionParam.lpSource0 = reinterpret_cast<Ipp8u *> (m_lpvInternalFrameBuffer);
        m_ConversionParam.PitchSource0 = (vm_var32) m_nPitch;
    }

    // second picture
    if (init_param->lpConvertInitPreview)
    {
        m_ConversionParamPreview = m_ConversionParam;
        m_ConversionParamPreview.ConversionInit = *(init_param->lpConvertInitPreview);
        if (NULL != m_pConverter &&
            UMC_OK != m_pConverter->Init(m_ConversionParamPreview.ConversionInit))
            return UMC_BAD_FORMAT;
        m_bSecondPicture = true;
    };

    // allocate buffer(s)
    if (ippStsOk != ippiInitAllocHuffmanTable_DV_32u((Ipp32s *) dvTable1,
                                                     (Ipp32s *) dvTable2,
                                                     reinterpret_cast<Ipp32u **> (&m_pHuffTable)))
        return UMC_ALLOC;

    if (DVCreateADequantizeTable())
        return UMC_ALLOC;

    return UMC_OK;

} // Status DVVideoDecoder::Init(BaseCodecParams *init_param)

void SetOutputPointersDV(ColorConversionParams &ConversionParam, VideoData *output)
{
    // we have picture details
    ConversionParam.lpDest0 = (Ipp8u *) output->m_lpDest[0];
    ConversionParam.lpDest1 = (Ipp8u *) output->m_lpDest[1];
    ConversionParam.lpDest2 = (Ipp8u *) output->m_lpDest[2];

    ConversionParam.PitchDest0 = (vm_var32) output->m_lPitch[0];
    ConversionParam.PitchDest1 = (vm_var32) output->m_lPitch[1];
    ConversionParam.PitchDest2 = (vm_var32) output->m_lPitch[2];

    output->SetColorFormat(ConversionParam.ConversionInit.FormatDest);

} // void SetOutputPointersDV(ColorConversionParams &ConversionParam, MediaData *output)

vm_var32 DVVideoDecoder::GetStreamType(void *lpv)
{
    DIFSequence *lp = reinterpret_cast<DIFSequence *> (lpv);
    HeaderData *lpHD = lp->H0.GetHeaderData();
    vm_var32 nStreamType = DVSD_STREAM;

    // check error(s)
    if ((lpHD->APT != lpHD->AP1) ||
        (lpHD->AP2 != lpHD->AP3) ||
        (lpHD->APT != lpHD->AP3))
        return DVSD_STREAM;

    // check real stream type
    switch (lpHD->APT)
    {
        // Consumer digital VCR
    case 0:
        nStreamType = DVSD_STREAM;
        break;

        // DVCPRO VCR
    case 1:
        nStreamType = DV25_STREAM;
        break;

    };

    return nStreamType;

} // vm_var32 DVVideoDecoder::GetStreamType(void *lpv)

Status  DVVideoDecoder::GetFrame(MediaData *pInData, MediaData *pOutData)
{
    VideoData *lpVData = DynamicCast<VideoData> (pOutData);
    vm_var32 i;

    if ((NULL == pInData) || (NULL == lpVData))
        return UMC_NULL_PTR;

    pOutData->SetTime(pInData->GetTime());

    // select frame type and set right function
    m_nStream = GetStreamType(pInData->GetDataPointer());
    switch (m_nStream)
    {
    case DVSD_STREAM:
        switch (m_ConversionParam.ConversionInit.SizeDest.width)
        {
        case WIDTH_DV / 2:
            StoreDVSegment = &DVVideoDecoder::StoreDVSDSegment_2s;
            break;

        case WIDTH_DV / 4:
            StoreDVSegment = &DVVideoDecoder::StoreDVSDSegment_4s;
            break;

        case WIDTH_DV / 8:
            StoreDVSegment = &DVVideoDecoder::StoreDVSDSegment_8s;
            break;

        default:
            StoreDVSegment = &DVVideoDecoder::StoreDVSDSegment;
            break;
        };
        break;

    case DV25_STREAM:
        switch (m_ConversionParam.ConversionInit.SizeDest.width)
        {
        case WIDTH_DV / 2:
            StoreDVSegment = &DVVideoDecoder::StoreDV25Segment_2s;
            break;

        case WIDTH_DV / 4:
            StoreDVSegment = &DVVideoDecoder::StoreDV25Segment_4s;
            break;

        case WIDTH_DV / 8:
            StoreDVSegment = &DVVideoDecoder::StoreDV25Segment_8s;
            break;

        default:
            StoreDVSegment = &DVVideoDecoder::StoreDV25Segment;
            break;
        };
        break;

    default:
        return UMC_NOT_FIND_SYNCWORD;
    };

    // save dest pointer (when decoding to internal buffer)
    if (m_lpvInternalFrameBuffer)
    {
        m_lpDestination = m_lpvInternalFrameBuffer;
        // set dest pointer(s) for slice conversion
        SetOutputPointersDV(m_ConversionParam, lpVData);
    }
    else
    {
        m_lpDestination = reinterpret_cast<vm_byte *> (lpVData->GetDataPointer());
        m_nPitch = lpVData->m_lPitch[0];
    };
    m_lpSource = reinterpret_cast<vm_byte *> (pInData->GetDataPointer());

    // start additional thread(s)
    for (i = 1;i < m_nNumberOfThreads;i += 1)
        vm_event_signal(m_lpStartEvent + i);

    DecompressSegment(0);

    // wait additional thread(s)
    for (i = 1;i < m_nNumberOfThreads;i += 1)
        vm_event_wait(m_lpStopEvent + i);

    lpVData->SetFrameType(I_PICTURE);

    // copy output frame
    if (m_lpvInternalFrameBuffer)
    {
        if (NULL != m_pConverter)
        {   m_pConverter->ConvertFrame(&m_ConversionParam);    }
    };

    if (SYSTEM_525 == m_nSystem) {
        pInData->MoveDataPointer(120000);
        pInData->SetTime(pInData->GetTime() + 0.0333666);
    } else  {
        pInData->MoveDataPointer(144000);
        pInData->SetTime(pInData->GetTime() + 1.0/25);
    }
    lpVData->SetVideoParameters(m_ConversionParam.ConversionInit.SizeDest.width,
                                m_ConversionParam.ConversionInit.SizeDest.height,
                                m_ConversionParam.ConversionInit.FormatDest);

    return UMC_OK;

} // Status  DVVideoDecoder::GetFrame(MediaData *pInData, MediaData *pOutData)

void DVVideoDecoder::DecompressSegment(vm_var32 nThreadNum)
{
    vm_var32 i, k;
    vm_var32 i_start, i_stop;
    vm_var32 nTemp;
    vm_byte *lpSrc;

    // check error(s)
    if (nThreadNum >= m_nNumberOfThreads)
        return;

    // set working i & k
    nTemp = m_nMaxNumberOfDIFSequences;
    i_start = (nTemp * (nThreadNum)) / m_nNumberOfThreads;
    i_stop = (nTemp * (nThreadNum + 1)) / m_nNumberOfThreads;

    vm_var16 *lpsBlocks = m_ppShortBlocks[nThreadNum];

    if (false == m_bDCOnly)
    {
        union
        {
            BlockParam BlParam[30];
            vm_var32 BlParamBuffer[30];
        };
        vm_var32 b_num, mb_num, block_type, block_quant_class, qno;
        vm_var16 *lpsTable;

        for (i = i_start;i < i_stop;i += 1)
        {
            for (k = 0;k < 27;k += 1)
            {
                // get source pointer
                lpSrc = m_lpSource + SIZE_OF_DV_SEGMENT * (i * 150 + 6 + (k / 3 + 1) + k * 5);

                //reset working block
                memset(lpsBlocks, 0, SIZE_OF_VIDEO_SEGMENT);

                // start video decompressing
                ippiHuffmanDecodeSegment_DV_8u16s((unsigned char *) lpSrc,
                                                  (unsigned int *) _INTERNAL_DEZIGZAG_TABLE_0,
                                                  (unsigned int *) m_pHuffTable,
                                                  (short *) lpsBlocks,
                                                  (unsigned int *) BlParamBuffer);

                // do dequantize and iDCT
                for (mb_num = 0;mb_num < 5;mb_num++)
                {
                    // get quantization number
                    qno = BlParam[mb_num * 6].qno;

                    // decompress each block
                    for (b_num = 0;b_num < 6;b_num++)
                    {
                        block_quant_class = BlParam[mb_num * 6 + b_num].cl;
                        block_type = BlParam[mb_num * 6 + b_num].m0;

                                    // get beginning of arrays of dequantize tables
                        lpsTable =  m_lpADequantizeTable +
                                    // get needed array of tables, depending on block class
                                    (block_type * 64 * 14) +
                                    // get offset of needed table, depending on quantization class
                                    // & quantization number
                                    64 * m_lpADequantizeLineTable[qno + block_quant_class * 16];

                        // do inverse and adaptive dequantization
                        ippiQuantInv_DV_16s_C1I((short *) (lpsBlocks + 64 * (b_num + 6 * mb_num)),
                                                (short *) lpsTable);

                        // do iDCT
                        if (0 == block_type)
                            ippiDCT8x8Inv_16s_C1I((short *) (lpsBlocks + 64 * (b_num + 6 * mb_num)));
                        else
                            ippiDCT2x4x8Inv_16s_C1I((short *) (lpsBlocks + 64 * (b_num +6 * mb_num)));
                    };
                };

                // store data to memory
                (this->*(StoreDVSegment))(i, k, nThreadNum);
            };
        };
    }
    else
    {
        for (i = i_start;i < i_stop;i += 1)
        {
            for (k = 0;k < 27;k += 1)
            {
                // get source pointer
                lpSrc = m_lpSource + SIZE_OF_DV_SEGMENT * (i * 150 + 6 + (k / 3 + 1) + k * 5);

                HuffmanDecodeSegment_DV_DC_only(lpSrc, lpsBlocks);

                // store data to memory
                (this->*StoreDVSegment)(i, k, nThreadNum);
            };
        };
    }

} // void DVVideoDecoder::DecompressSegment(vm_var32 ThreadNum)

Status DVVideoDecoder::GetPerformance(double *perf)
{
    if (perf)
        *perf = 1.0;

    return UMC_OK;

} // Status DVVideoDecoder::GetPerformance(double *perf)

Status DVVideoDecoder::Reset(void)
{
    return UMC_OK;

} // Status DVVideoDecoder::Reset(void)

const double MINIMAL_DOUBLE_DIFFERENCE = 1.0/1000000.0;
inline
bool IsEqual(double dOne, double dTwo)
{
    if (fabs(dOne - dTwo) <= MINIMAL_DOUBLE_DIFFERENCE)
        return true;

    return false;

} //bool IsEqual(double dOne, double dTwo)


unsigned int DVVideoDecoder::ThreadWorkingRoutine(void *lpv)
{
    THREAD_ID *lpThreadId;
    DVVideoDecoder *lpOwner;

    // check error(s)
    if (NULL == lpv)
        return 0x0bad;

    lpThreadId = reinterpret_cast<THREAD_ID *> (lpv);
    lpOwner = reinterpret_cast<DVVideoDecoder *> (lpThreadId->m_lpOwner);

    // wait for start
    vm_event_wait(lpOwner->m_lpStartEvent + lpThreadId->m_nNumber);

    while (VM_TIMEOUT == vm_event_timed_wait(&(lpOwner->m_Quit), 0))
    {
        // decompress part of frame
        lpOwner->DecompressSegment(lpThreadId->m_nNumber);

        // set finish
        vm_event_signal(lpOwner->m_lpStopEvent + lpThreadId->m_nNumber);

        // wait for start
        vm_event_wait(lpOwner->m_lpStartEvent + lpThreadId->m_nNumber);
    };

    return lpThreadId->m_nNumber;

} // unsigned int DVVideoDecoder::ThreadWorkingRoutine(void *lpv)

} // end namespace UMC