umc_mpeg2_spl_av.cpp

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

                   // m_readVideoStream.SetPointer(((unsigned char*)m_readVideoStream.GetBufferPointer()) + 4,
                   //                                 m_readVideoStream.GetDataSize() - 4);
                   // m_readVideoStream.SetDataSize(m_readVideoStream.GetDataSize() - 4);
                    m_lockedVideoBuffer.SetDataSize(0);
                    uiStartCodeMax   = MAX_CODE_COUNT;
                    m_uiStartCodePos = 0;
                    m_uiStartCodeOff = 0;

                }
                else if(!m_bStop        &&
                        (ret == UMC_OK) &&
                        (m_lockedVideoBuffer.GetDataSize() > 0))
                {
                    /*if(m_lFlagsReq & FLAG_VSPL_VIDEO_FRAME_REQ)
                    {
                        m_lFlagsReq &= ~FLAG_VSPL_VIDEO_FRAME_REQ;
                        m_uiStartCodeOff  = m_lockedVideoBuffer.GetDataSize();
                        m_uiStartCodePos += uiStartCodeMax;
                        uiStartCodeMax    = MAX_CODE_COUNT - m_uiStartCodePos;
                        VM_ASSERT(uiStartCodeMax > 0);
                        VM_ASSERT(m_uiStartCodePos < MAX_CODE_COUNT);
                    }
                    else*/
                    {
                        unsigned char tmp_ptr[10];
                        Ipp32u i;

                        for(i = m_uiStartCodePos; i < m_uiStartCodePos+uiStartCodeMax; i++)
                        {
                            if((m_pStartCodes[i].m_startCode&0x1f) == 7)
                            {
                                //SPS
                                unsigned char sps[2048];
                                unsigned int  *uiSps = reinterpret_cast<unsigned int*>(sps);
                                int size = m_pStartCodes[i+1].m_StartCodePos-m_pStartCodes[i].m_StartCodePos;
                                int bf = 31;
                                uiSps++;
                                memcpy(sps, (unsigned char*)m_lockedVideoBuffer.GetBufferPointer()+
                                        m_pStartCodes[i].m_StartCodePos, size);
#ifndef _BIG_ENDIAN_
                                Swap4BytesH264(sps, size);
#endif
                                m_h264Headers.m_uiValidSPSIndex = GetSequenceParamSet(&uiSps,
                                                                            &bf, &m_h264Headers);

                                //m_h264Headers.m_nPicComplete = 1;//not needed??
                                m_h264Headers.m_uiSPSCount++;
                                vm_debug_trace(0,VM_STRING("H264 SPS found\n"));


                            }
                            else if((m_pStartCodes[i].m_startCode&0x1f) == 8 &&
                                    (m_h264Headers.m_uiSPSCount > 0))
                            {
                                //PPS
                                unsigned char pps[16];
                                unsigned int  *uiPps = reinterpret_cast<unsigned int*>(pps);
                                int size = 16;
                                int bf = 31;
                                uiPps++;
                                memcpy(pps, (unsigned char*)m_lockedVideoBuffer.GetBufferPointer()+
                                        m_pStartCodes[i].m_StartCodePos, 16);
#ifndef _BIG_ENDIAN_
                                Swap4BytesH264(pps, size);
#endif
                                GetPictureParamSet(&uiPps, &bf, &m_h264Headers);

                                //m_h264Headers.m_nPicComplete = 1;  //not needed??

                                m_h264Headers.m_uiPPSCount++;
                                vm_debug_trace(0, VM_STRING("H264 PPS found\n"));
                            }
                            else if(((m_pStartCodes[i].m_startCode&0x1f) == 1 ||
                               (m_pStartCodes[i].m_startCode&0x1f) == 5) &&
                               (i == m_uiStartCodePos+uiStartCodeMax - 1) &&
                               (m_h264Headers.m_uiSPSCount > 0) && (m_h264Headers.m_uiPPSCount > 0))
                            {
                    broken_header:
                                //next SH
                                unsigned char sh[MINIMUM_H_SIZE];
                                unsigned int  *uiSH = reinterpret_cast<unsigned int*>(sh);
                                int size = MINIMUM_H_SIZE;
                                int bf = 31;

                                if(m_readVideoStream.GetDataSize() < MINIMUM_H_SIZE)
                                {
                                    bf = 0;
                                    m_h264Headers.m_bBrokenHeader = true;

                                    memcpy(m_h264Headers.m_pubBrokenHeader,
                                            (unsigned char*)m_readVideoStream.GetDataPointer(),
                                                                m_readVideoStream.GetDataSize());

                                    m_h264Headers.m_puiBrokenHeaderSize = m_readVideoStream.GetDataSize();
                                    m_readVideoStream.SetDataSize(0);
                                    m_h264Headers.m_uiSavedIndex = i;

                                    m_h264Headers.m_uiStartCodeOff  = m_uiStartCodeOff;
                                    m_h264Headers.m_uiStartCodePos  = m_uiStartCodePos;
                                    m_h264Headers.uiStartCodeMax    = uiStartCodeMax;


                                    ret = UMC_NOT_ENOUGH_DATA;

                                    break;
                                }
                                if(m_h264Headers.m_bBrokenHeader)
                                {
                                    m_uiStartCodeOff  = m_h264Headers.m_uiStartCodeOff;
                                    m_uiStartCodePos  = m_h264Headers.m_uiStartCodePos;
                                    uiStartCodeMax    = m_h264Headers.uiStartCodeMax;
                                    i = m_h264Headers.m_uiSavedIndex;
                                }
                                memcpy(sh, (unsigned char*)m_readVideoStream.GetDataPointer(), MINIMUM_H_SIZE);
#ifndef _BIG_ENDIAN_
                                Swap4BytesH264(sh, size);
#endif
                                GetSliceHeader(&uiSH, &bf, &m_h264Headers,(m_pStartCodes[i].m_startCode&0x1f)==5,//idr flag
                                    (Ipp8u) ((m_pStartCodes[i].m_startCode >> 5) & 3));//nal_ref_idc

// THIS CODE NEEDS ADDITIONAL CHECKING!!!
                                if(m_h264Headers.m_uiSHCount==1 || 1 ||//FIRST SLICE IS ALLWAYS SOP
                                   (m_h264Headers.m_uiSHCount>1 &&
                                   IsSOP(&m_h264Headers.m_SH[m_h264Headers.m_uiSHCount-2],
                                   &m_h264Headers.m_SH[m_h264Headers.m_uiSHCount-1],
                                   m_h264Headers.m_SPS[
                                       m_h264Headers.m_PPS[
                                           m_h264Headers.m_SH[
                                               m_h264Headers.m_uiSHCount-1].pic_parameter_set_id].seq_parameter_set_id].pic_order_cnt_type)))
                                {
                                    /*if(m_h264Headers.m_SH[m_h264Headers.m_uiSHCount-1].field_pic_flag)
                                    {
                                        if(m_h264Headers.m_uiFieldIndex == 0) // Both fields are already parsed and now we have next SOP
                                            m_h264Headers.m_nPicComplete = 1;

                                        m_h264Headers.m_uiFieldIndex = !m_h264Headers.m_uiFieldIndex;
                                    }
                                    else*/
                                        m_h264Headers.m_nPicComplete = 1;


                                }
                                /*
                                else
                                {
                                    if(!m_h264Headers.m_SH[m_h264Headers.m_uiSHCount-1].field_pic_flag)
                                    {
                                        if((m_h264Headers.m_SH[m_h264Headers.m_uiSHCount-1].first_mb_in_slice == 0) &&
                                           (m_h264Headers.m_SH[m_h264Headers.m_uiSHCount-2].first_mb_in_slice == 0) &&
                                           (m_dCurrVideoPts >= 0))
                                           {
                                                m_h264Headers.m_nPicComplete = 1;
                                           }
                                    }
                               }*/
                               m_h264Headers.m_SH[m_h264Headers.m_uiSHCount-1].m_dTimeStamp = m_dCurrVideoPts;
                               vm_debug_trace(0, VM_STRING("H264 SH found\n"));
                               if(m_h264Headers.m_bBrokenHeader)
                               {
                                    m_h264Headers.m_bBrokenHeader = false;
                                    break;
                               }


                            }
                            else if(((m_pStartCodes[i].m_startCode&0x1f) == 1 ||
                               (m_pStartCodes[i].m_startCode&0x1f) == 5 ) &&
                               (m_h264Headers.m_uiSPSCount > 0) && (m_h264Headers.m_uiPPSCount > 0))
                            {
                                //SH
                                unsigned char sh[16];
                                unsigned int  *uiSH = reinterpret_cast<unsigned int*>(sh);
                                int size = 16;
                                int bf = 31;
                                uiSH++;
                                memcpy(sh, (unsigned char*)m_lockedVideoBuffer.GetBufferPointer()+
                                        m_pStartCodes[i].m_StartCodePos, 16);
#ifndef _BIG_ENDIAN_
                                Swap4BytesH264(sh, size);
#endif
                                GetSliceHeader(&uiSH, &bf, &m_h264Headers,(m_pStartCodes[i].m_startCode&0x1f)==5,//idr flag
                                    (Ipp8u) ((m_pStartCodes[i].m_startCode >> 5) & 3)//nal_ref_idc
                                    );

                                m_h264Headers.m_SH[m_h264Headers.m_uiSHCount-1].m_dTimeStamp = m_dCurrVideoPts;
                                vm_debug_trace(0,VM_STRING( "H264 SH found\n"));

                            }
                        }
                        if(m_h264Headers.m_bBrokenHeader)
                        {
                            continue;
                        }

                        if(!m_h264Headers.IsCompletePicture())
                        {
                            m_uiStartCodeOff  = m_lockedVideoBuffer.GetDataSize();
                            m_uiStartCodePos += uiStartCodeMax;
                            uiStartCodeMax    = MAX_CODE_COUNT - m_uiStartCodePos;
                            VM_ASSERT(uiStartCodeMax > 0);
                            VM_ASSERT(m_uiStartCodePos < MAX_CODE_COUNT);
                            continue;
                        }
                        vm_debug_trace(0,VM_STRING("H264 picture complete(%d slices), PTS = %lf\n"), m_h264Headers.m_uiSHCount-1,
                                                                                    m_h264Headers.m_SH[0].m_dTimeStamp);

                        m_lockedVideoBuffer.SetTime(m_h264Headers.m_SH[0].m_dTimeStamp);
                        if(0 < m_h264Headers.m_uiSHCount-1)
                            memcpy(&m_h264Headers.m_SH[0],
                                &m_h264Headers.m_SH[m_h264Headers.m_uiSHCount-1],
                                sizeof(H264SH));
                        m_h264Headers.m_nPicComplete--;
                        m_h264Headers.m_uiSHCount = 1;

                        memcpy(tmp_ptr, (unsigned char*)m_lockedVideoBuffer.GetDataPointer()+
                                       m_lockedVideoBuffer.GetDataSize()-10, 10);
                        for(i = 7; i >= 0; i--)
                        {
                            if(tmp_ptr[i] != 0)
                                break;
                        }
                        if(i == -1)
                        {
                            //too much zeroes in prefix
                            i = 5;
                        }

                        int tmp_size = m_lockedVideoBuffer.GetDataSize()+i+1-10;
                        m_lockedVideoBuffer.SetBufferPointer((vm_byte*)m_lockedVideoBuffer.GetBufferPointer(),
                                                                       m_lockedVideoBuffer.GetBufferSize());
                        m_lockedVideoBuffer.SetDataSize(tmp_size);

#ifndef _BIG_ENDIAN_
                        if(swapFlag == 2)
#endif
                        {
                            //if start code was find make buffer size 16 bytes aligned
                            //and swap data if needed
                            int size = m_lockedVideoBuffer.GetDataSize();

                            // swap source data
                            if (NULL == m_pVideoAuxData)
                            {
                                Swap4BytesH264((unsigned char*)m_lockedVideoBuffer.GetBufferPointer(),size);
                            // swap source data & update starting code positions
                            }
                            else
                            {
                                Swap4BytesH264((unsigned char*)m_lockedVideoBuffer.GetBufferPointer(),
                                               size,
                                               m_uiStartCodePos + uiStartCodeMax - 1);
                            }
                            //size = ((size+3)&~3);
                            g_count++;

                            m_lockedVideoBuffer.SetDataSize(size);
                        }
                        if(UMC_OK == retBuff && m_pVideoAuxData)
                        {
                            Ipp32u i;
                            MediaDataEx::_MediaDataEx *stCodes;
                            stCodes = new MediaDataEx::_MediaDataEx;

                            if(!stCodes) return UMC_ALLOC;
                            int num_codes = 0;
                            m_startCodesData.SetDataSize(sizeof(MediaDataEx::_MediaDataEx));

                            stCodes->count     = m_uiStartCodePos + uiStartCodeMax - 1;
                            stCodes->index     = 0;
                            stCodes->bstrm_pos = 0;
                            for(i = 0; i < stCodes->count; i++)
                            {
                                if(m_pStartCodes[i].m_startCode >= 0x00000100 &&
                                   m_pStartCodes[i].m_startCode <= 0x000001AF)
                                {
                                    stCodes->offsets[num_codes] = m_pStartCodes[i].m_StartCodePos;
                                    stCodes->values[num_codes]  = m_pStartCodes[i].m_startCode;
                                    num_codes++;
                                }
                            }
                            stCodes->count = num_codes;
                            VM_ASSERT(0 < stCodes->count);
                            memcpy(m_startCodesData.GetBufferPointer(), &stCodes, sizeof(MediaDataEx::_MediaDataEx*));
                            retBuff = m_pVideoAuxData->UnLockInputBuffer(&m_startCodesData);

                        }
                        retBuff = m_pVideoBuffer->UnLockInputBuffer(&m_lockedVideoBuffer);
                        m_uiVideoFrameCount++;

                        StoreLastPositionAndPTS(m_lockedVideoBuffer.GetTime(),
                                                m_pDataReader->GetPosition() -
                                                m_readVideoStream.GetDataSize());


                        VM_ASSERT(retBuff == UMC_OK);

                        //vm_time_sleep(10);


                        do {
                            retBuff = m_pVideoBuffer->LockInputBuffer(&m_lockedVideoBuffer);

                            vm_time_sleep(5);

                        } while(!m_bStop && retBuff == UMC_NOT_ENOUGH_BUFFER);

                        if(UMC_OK == retBuff &&