pts_buf.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 "pts_buf.h"

void
UMC::BufPTSArrayM::Normalize()
{
    vm_var32 uiPos = 0;
    unsigned int uiSize = m_PtsArray.GetSize();
    sPtsEntry* pts_entry = m_PtsArray.GetArray();
    sPtsEntry* pts_entry_next = pts_entry + 1;

    if (1.0 != m_dfNorm)
    {
        while (uiPos + 1 < uiSize)
        {
            if (pts_entry->uiStart + pts_entry->uiLen >
                                                pts_entry_next->uiStart)
            {
                if (pts_entry->uiStart + pts_entry->uiLen <
                    pts_entry_next->uiStart + pts_entry_next->uiLen)
                {
                    vm_var32 uiDiff = pts_entry->uiStart +
                        pts_entry->uiLen - pts_entry_next->uiStart;

                    pts_entry_next->dfPts += uiDiff * m_dfNorm;
                    pts_entry_next->uiStart += uiDiff;
                    pts_entry_next->uiLen -= uiDiff;

                    pts_entry = pts_entry_next;
                    pts_entry_next++;
                    uiPos++;

                }
                else
                {
                    m_PtsArray.DeleteAt(uiPos + 1);
                    uiSize--;
                }
            }
            else
            {
                uiPos++;
                pts_entry = pts_entry_next;
                pts_entry_next++;
            }
        }
    }
}

UMC::Status
UMC::BufPTSArrayM::Init(const vm_var32 /*uiArraySize*/,
                       const double fdNorm,
                       bool doNormalize)
{
    m_doNormalize = doNormalize;
    m_PtsArray.DeleteAll();
    m_dfNorm = fdNorm;
    return m_Mutex.Init();
}

UMC::Status
UMC::BufPTSArrayM::SetFramePTS(const vm_var32 uiBufPos,
                              const vm_var32 uiLen,
                              const double dfPTS)
{
    UMC::Status umcRes = UMC_OK;

    m_Mutex.Lock();
    unsigned int uiPos = 0;
    unsigned int size = m_PtsArray.GetSize();
    sPtsEntry* pts_entry = m_PtsArray.GetArray();

//      vm_debug_trace(-1,"SetFramePTS: pos=%d len=%d time=%f\n",uiBufPos,uiLen,dfPTS);
    if (uiBufPos == 0)
        uiPos = 0;

    while (uiPos < size)
    {
      if (pts_entry->uiStart > uiBufPos)
          break;

//        vm_debug_trace(-1,"SetFramePTS: skipped[%d] %f %d %d\n", uiPos, pts_entry->dfPts,pts_entry->uiStart,pts_entry->uiLen);


      pts_entry++;
      uiPos++;
    }

    if (size == uiPos ||
        pts_entry->uiStart > uiBufPos ||
        pts_entry->dfPts != dfPTS)
    {
        if (!m_PtsArray.Insert(uiPos, sPtsEntry()))
        {   umcRes = UMC_ALLOC; }

        pts_entry = m_PtsArray.GetArray();
        pts_entry += uiPos;

//          vm_debug_trace(-1,"SetFramePTS: inserted[%d] %f %d %d\n", uiPos,dfPTS,uiBufPos,uiLen);


    }

    if (UMC_OK == umcRes) {

//          vm_debug_trace(-1,"SetFramePTS: updated[%d] %f %d %d\n", uiPos, dfPTS,uiBufPos,uiLen);


        pts_entry->dfPts = dfPTS;
        pts_entry->uiStart = uiBufPos;
        pts_entry->uiLen = uiLen;

        if (m_doNormalize)
            Normalize();
    }

    m_Mutex.Unlock();
    return umcRes;
}

UMC::Status
UMC::BufPTSArrayM::UpdateFramePTS( const vm_var32 uiOldBufPos,
                            const vm_var32 uiNewBufPos,
                            const vm_var32 /*uiNewLen*/,
                            const double dfNewPTS)
{

    m_Mutex.Lock();

    unsigned int uiPos = 0;
    unsigned int size;
    sPtsEntry* pts_entry = m_PtsArray.GetArray();


    size = m_PtsArray.GetSize();

//      vm_debug_trace(-1,"UpdateFramePTS:   %d %d\n\n",uiOldBufPos,uiNewBufPos);


    while (uiPos < size &&  pts_entry->uiStart != uiOldBufPos)
    {
      //vm_debug_trace(-1,"UpdateFramePTS: skipped[%d] %f %d %d\n", uiPos, pts_entry->dfPts,pts_entry->uiStart,pts_entry->uiLen);

      uiPos++;
      pts_entry++;
    }

    if (uiOldBufPos > uiNewBufPos)
    {
        while (uiPos < size)
        {
            //vm_debug_trace(-1,"UpdateFramePTS: removed[%d] %f %d %d\n", uiPos,pts_entry->dfPts,pts_entry->uiStart,pts_entry->uiLen);

            m_PtsArray.DeleteAt(uiPos);
            size--;
        }

        uiPos = 0;
        pts_entry = m_PtsArray.GetArray();
    }


    while (uiPos < size &&  pts_entry->uiStart + pts_entry->uiLen <= uiNewBufPos)
    {
        //vm_debug_trace(-1,"UpdateFramePTS: removed[%d] %f %d %d\n", uiPos,pts_entry->dfPts,pts_entry->uiStart,pts_entry->uiLen);

        m_PtsArray.DeleteAt(uiPos);
        size--;
    }

    if ((uiPos) < size) {
        //vm_debug_trace(-1,"UpdateFramePTS: tobeupd[%d] %f %d %d\n", uiPos,pts_entry->dfPts,pts_entry->uiStart,pts_entry->uiLen);
        pts_entry->uiLen   = pts_entry->uiLen - (uiNewBufPos - pts_entry->uiStart);
        if (pts_entry->uiStart != uiNewBufPos) {
            pts_entry->uiStart = uiNewBufPos;
            pts_entry->dfPts   = dfNewPTS;
        }

        //vm_debug_trace(-1,"UpdateFramePTS: updated[%d] %f %d %d\n", uiPos,pts_entry->dfPts,pts_entry->uiStart,pts_entry->uiLen);
    }


    pts_entry = m_PtsArray.GetArray();

    //vm_debug_trace(-1,"\n\n");
    uiPos = 0;
    while (uiPos < size)
    {
      //vm_debug_trace(-1,"[%d] %f pos=%d len=%d\n", uiPos, pts_entry->dfPts,pts_entry->uiStart,pts_entry->uiLen);
      pts_entry++;
      uiPos++;
    }
    //vm_debug_trace(-1,"\n\n");

    m_Mutex.Unlock();



    return UMC_OK;
}

double
UMC::BufPTSArrayM::GetTime(const vm_var32 uiCurPos)
{
    vm_var32 uiPos = 0;
    double   dfPts = 0;
    unsigned int size;
    sPtsEntry* pts_entry;

    m_Mutex.Lock();

    pts_entry = m_PtsArray.GetArray();
    size = m_PtsArray.GetSize();


    if (size > 0) {
        while (uiPos + 1 < size &&
                (pts_entry+1)->uiStart <= uiCurPos)
        {
            uiPos++;
            pts_entry++;
        }

        dfPts = pts_entry->dfPts;

        if (1 != m_dfNorm) {
            dfPts += (uiCurPos - pts_entry->uiStart) * m_dfNorm;
        }
    }

    m_Mutex.Unlock();

    return dfPts;
}

void
UMC::BufPTSArrayM::Reset()
{   m_PtsArray.DeleteAll(); }

//------------------------------------------------------------------------//

void
UMC::BufPTSArray::Normalize()
{
    vm_var32 uiPos = 0;
    while ( uiPos + 1 < m_PtsArray.GetSize())
    {
        if (m_PtsArray[uiPos].uiStart + m_PtsArray[uiPos].uiLen >
                                            m_PtsArray[uiPos+1].uiStart)
        {
            if (m_PtsArray[uiPos].uiStart + m_PtsArray[uiPos].uiLen <
                m_PtsArray[uiPos+1].uiStart + m_PtsArray[uiPos+1].uiLen)
            {
                vm_var32 uiDiff = m_PtsArray[uiPos].uiStart +
                    m_PtsArray[uiPos].uiLen - m_PtsArray[uiPos+1].uiStart;

                m_PtsArray[uiPos+1].dfPts += uiDiff * m_dfNorm;
                m_PtsArray[uiPos+1].uiStart += uiDiff;
                m_PtsArray[uiPos+1].uiLen -= uiDiff;
                uiPos++;
            }
            else
            {   m_PtsArray.DeleteAt(uiPos + 1); }
        }
        else
        {   uiPos++;    }
    }
}

UMC::Status
UMC::BufPTSArray::Init(const vm_var32 /*uiArraySize*/,
                       const double fdNorm)
{
    m_PtsArray.DeleteAll();
    m_dfNorm = fdNorm;
    return m_Mutex.Init();
}

double UMC::BufPTSArray::DynamicSetParams(const double fdNorm)
{
    double ret = m_dfNorm;
    m_Mutex.Lock();
    m_dfNorm = fdNorm;
    m_Mutex.Unlock();

    return ret;
}

UMC::Status
UMC::BufPTSArray::SetFramePTS(const vm_var32 uiBufPos,
                              const vm_var32 uiLen,
                              const double dfPTS)
{
    UMC::Status umcRes = UMC_OK;
    //if (1 == m_dfNorm) {  umcRes = UMC_NOT_INITIALIZED;   }

    m_Mutex.Lock();
    unsigned int uiPos = 0;
    while (UMC_OK == umcRes && uiPos < m_PtsArray.GetSize() &&
            m_PtsArray[uiPos].uiStart < uiBufPos)
    { uiPos++; }

    if (m_PtsArray.GetSize() == uiPos ||
        m_PtsArray[uiPos].uiStart > uiBufPos ||
        m_PtsArray[uiPos].dfPts != dfPTS)
    {
        if (!m_PtsArray.Insert(uiPos, sPtsEntry()))
        {   umcRes = UMC_ALLOC; }
    }

    if (UMC_OK == umcRes)
    {
        m_PtsArray[uiPos].dfPts = dfPTS;
        m_PtsArray[uiPos].uiStart = uiBufPos;
        m_PtsArray[uiPos].uiLen = uiLen;
        Normalize();
    }

    m_Mutex.Unlock();
    return umcRes;
}

double
UMC::BufPTSArray::GetTime(const vm_var32 uiCurPos)
{
    double dfPts = -1.0;

    m_Mutex.Lock();
    if (m_PtsArray.GetSize() > 0)
    {
        vm_var32 uiPos = 0;
        while (uiPos + 1 < m_PtsArray.GetSize() &&
                m_PtsArray[uiPos + 1].uiStart < uiCurPos)
        {   uiPos++; }

        dfPts = m_PtsArray[uiPos].dfPts;

        if (1 != m_dfNorm &&
            m_PtsArray[uiPos].uiStart + m_PtsArray[uiPos].uiLen > uiCurPos)
        {   dfPts += (uiCurPos - m_PtsArray[uiPos].uiStart) * m_dfNorm; }
    }
    m_Mutex.Unlock();
//  vm_debug_trace(-1,"GetTime:%f for pos %d\n", dfPts, uiCurPos);
    return dfPts;
}

void
UMC::BufPTSArray::Reset()
{   m_PtsArray.DeleteAll(); }