umc_avi_splitter_base.cpp

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

    delete[] m_pAudioStreams;
    m_pAudioStreams = NULL;

    delete[] m_info.m_audio_info_aux;
    m_info.m_audio_info_aux = NULL;

    delete[] m_info.m_video_info_aux;
    m_info.m_video_info_aux = NULL;

    m_uiVideoStreamCount = 0;
    m_uiAudioStreamCount = 0;

    return UMC_OK;
}

UMC::Status
UMC::BaseAVISplitter::ReadFormat(DataReader* pDataReader,
                             Mutex&      rMutex,
                             UMC::MainAVIHeader& rAviHdr,
                             AVISplitStrmStruct*& rpStrmArray,
                             AVIIndex& rAviIndex,
                             vm_var32& ruiFlags,
                             tFOURCC& rVideoChunkCode)
{
    Status umcRes = UMC_OK;

    if (NULL == pDataReader)
    {   umcRes = UMC_NULL_PTR;  }

    AVIChunk CfgChunkRdr;
    if (UMC_OK == umcRes)
    {
        pDataReader->Reset();
        umcRes = CfgChunkRdr.Init(LockableDataReaderRef(pDataReader, &rMutex));
    }

    if (UMC_OK == umcRes)
    {   umcRes = CfgChunkRdr.DescendRIFF(AVI_FOURCC_AVI_);  }

    if (UMC_OK == umcRes)
    {   umcRes = CfgChunkRdr.DescendLIST(AVI_FOURCC_HDRL);  }

    if (UMC_OK == umcRes)
    {   umcRes = CfgChunkRdr.DescendChunk(AVI_FOURCC_AVIH); }

    if (UMC_OK == umcRes)
    {
        umcRes = CfgChunkRdr.GetData((vm_byte*)&rAviHdr,
                                     sizeof(UMC::MainAVIHeader));
        rAviHdr.SwapBigEndian();
    }

    if (UMC_OK == umcRes)
    {   umcRes = CfgChunkRdr.Ascend();  }

    if (UMC_OK == umcRes)
    {
        delete[] rpStrmArray;
        rpStrmArray = new AVISplitStrmStruct[rAviHdr.uiStreams];
        if (NULL == rpStrmArray) {  umcRes = UMC_ALLOC; }
    }

    for (vm_var32 i = 0; UMC_OK == umcRes && i < rAviHdr.uiStreams; i++)
    {   umcRes = ReadStreamsInfo(CfgChunkRdr, rpStrmArray + i); }

    //  Ascend from hdrl
    if (UMC_OK == umcRes)
    {   umcRes = CfgChunkRdr.Ascend();  }

    if (UMC_OK == umcRes)
    {   umcRes = CheckForREC_(CfgChunkRdr, ruiFlags, rVideoChunkCode);  }

    if (UMC_OK == umcRes)
    {
        umcRes = rAviIndex.Init(CfgChunkRdr);
        if (UMC_END_OF_STREAM == umcRes)  //  index chunk wasn't found
        {   umcRes = UMC_OK;    }
    }

    if (UMC_OK != umcRes)
    {   vm_debug_trace(4, VM_STRING("BaseAVISplitter ReadFormat failed\n"));   }

    return umcRes;
}

UMC::Status
UMC::BaseAVISplitter::CheckForREC_(AVIChunk& rCfgChunkRdr,
                               vm_var32& ruiFlags,
                               tFOURCC& rVideoChunkCode)
{
    Status umcRes = UMC_OK;

    if (UMC_OK == umcRes)
    {   umcRes = rCfgChunkRdr.DescendLIST(AVI_FOURCC_MOVI); }

    while (UMC_OK == umcRes)
    {
        umcRes = rCfgChunkRdr.DescendChunk(AVI_FOURCC_ANY_);
        if (UMC_NOT_FIND_SYNCWORD == umcRes)
        {
            // No more chunks
            umcRes = UMC_OK;
            break;
        }

        if (rCfgChunkRdr.GetChunkFOURCC() == AVI_FOURCC_REC_)
        {
            //  'REC ' chunk was found!
            ruiFlags |= FLAGS_AVISPL_RECPRESENT;
            umcRes = rCfgChunkRdr.Ascend();
            if (UMC_OK != umcRes)
            {   umcRes = rCfgChunkRdr.DescendLIST(AVI_FOURCC_REC_); }
        }
        else if (rCfgChunkRdr.GetChunkFOURCC() == AVI_FOURCC_00DB ||
                    rCfgChunkRdr.GetChunkFOURCC() == AVI_FOURCC_00DC)
        {
            //  Video chunk was found - now we know its' FOURCC code!
            rVideoChunkCode = rCfgChunkRdr.GetChunkFOURCC();
            umcRes = rCfgChunkRdr.Ascend();
            break;
        }
        else
        //  Unknown chunk - ascend and continue.
        {    umcRes = rCfgChunkRdr.Ascend();    }
    }

    if (UMC_OK == umcRes && FLAGS_AVISPL_RECPRESENT & ruiFlags)
    //  Ascend from 'rec ' chunk
    {   umcRes = rCfgChunkRdr.Ascend(); }

    if (UMC_OK == umcRes)
    //  Ascend from 'movi' chunk
    {   umcRes = rCfgChunkRdr.Ascend(); }

    if (UMC_OK == umcRes)
    { rCfgChunkRdr.GoChunkHead(); }

    if (UMC_OK != umcRes)
    {   vm_debug_trace(4, VM_STRING("BaseAVISplitter CheckForREC_ failed\n")); }

    return umcRes;
}

UMC::Status
UMC::BaseAVISplitter::ReadStreamsInfo(AVIChunk& rCfgChunkRdr,
                                  AVISplitStrmStruct* pStream)
{
    Status umcRes = rCfgChunkRdr.DescendLIST(AVI_FOURCC_STRL);

    if (UMC_OK == umcRes)
    {   umcRes = rCfgChunkRdr.DescendChunk(AVI_FOURCC_STRH);    }

    if (UMC_OK == umcRes)
    {
        umcRes = rCfgChunkRdr.GetData((vm_byte*)&pStream->sStrmHdr,
                                       sizeof(UMC::AVIStreamHeader));
        pStream->sStrmHdr.SwapBigEndian();
    }

    if (UMC_OK == umcRes)
    {   umcRes = rCfgChunkRdr.Ascend(); }

    if (UMC_OK == umcRes)
    {   umcRes = rCfgChunkRdr.DescendChunk(AVI_FOURCC_STRF);    }

    if (UMC_OK == umcRes)
    {
        vm_var32 uiSize = rCfgChunkRdr.GetChunkSize();
        pStream->pbStrmFmt = new vm_byte[uiSize];
        if (NULL == pStream->pbStrmFmt)
        {   umcRes = UMC_ALLOC; }
        else
        {   pStream->uiStrmFmtSize = rCfgChunkRdr.GetChunkSize();   }
    }

    if (UMC_OK == umcRes)
    {
        umcRes = rCfgChunkRdr.GetData((vm_byte*)pStream->pbStrmFmt,
                                        rCfgChunkRdr.GetChunkSize());
        if (AVI_FOURCC_VIDEOSTRM == pStream->sStrmHdr.fccType)
        {
            UMC::BITMAPINFOHEADER* pBmpHdr =(UMC::BITMAPINFOHEADER*)(pStream->pbStrmFmt);
            pBmpHdr->SwapBigEndian();
        }
        else if (AVI_FOURCC_AUDIOSTRM == pStream->sStrmHdr.fccType)
        {    ((WAVEFORMATEX*)(pStream->pbStrmFmt))->SwapBigEndian();   }
    }

    //  Ascend from 'strf'
    if (UMC_OK == umcRes)
    {   umcRes = rCfgChunkRdr.Ascend(); }

    //  Ascend from LIST
    if (UMC_OK == umcRes)
    {   umcRes = rCfgChunkRdr.Ascend(); }

    if (UMC_OK != umcRes)
    {   vm_debug_trace(4, VM_STRING("BaseAVISplitter ReadStreamsInfo failed\n"));  }

    return umcRes;
}

UMC::Status
UMC::BaseAVISplitter::SelectAudioStream(vm_var32 uiInd, AudioStreamType& raType)
{
    Status umcRes = UMC_OK;

//    vm_var32 fccHandler = m_pStreams[uiInd].sStrmHdr.fccHandler;
    if (AVI_FOURCC_AUDIOSTRM == m_pStreams[uiInd].sStrmHdr.fccType)
    {
        umcRes = UMC_OK;
        assert(NULL != m_pStreams[uiInd].pbStrmFmt);
        AVISplitStrmStruct& rCurStream = m_pStreams[uiInd];
        UMC::WAVEFORMATEX* pWavFmt = (UMC::WAVEFORMATEX*)rCurStream.pbStrmFmt;

        if (WAVE_FORMAT_PCM == pWavFmt->wFormatTag)
        {   raType = PCM_AUDIO; }
        else if (WAVE_FORMAT_MPEGLAYER3 == pWavFmt->wFormatTag)
        {
            if (pWavFmt->nSamplesPerSec >= 32000)
            {   raType = MP1L3_AUDIO;   }
            else
            {   raType = MP2L3_AUDIO;   }

        }
        else if (WAVE_FORMAT_AAC == pWavFmt->wFormatTag)
        {   raType = AAC_AUDIO; }
    }
    else
    {   umcRes = UMC_BAD_STREAM;  }

    if (UMC_OK != umcRes)
    {   vm_debug_trace(4, VM_STRING("BaseAVISplitter SelectAudioStream failed\n"));    }

    return umcRes;
}

UMC::Status
UMC::BaseAVISplitter::ExtractVideoInfo(const vm_var32 cuiStreamInd,
                                   FifoBuffer* pFifo)
{
    Status umcRes = UMC_OK;

    VideoStreamType     vtype    = UNDEF_VIDEO;
    VideoStreamSubType  vsubtype = UNDEF_VIDEO_SUBTYPE; // just as default placeholder

    if (NULL == pFifo)
    {   umcRes = UMC_NULL_PTR;  }

    if (UMC_OK == umcRes)
    {   umcRes = SelectVideoStream(cuiStreamInd, vtype, vsubtype);   }

    assert(NULL != m_pStreams[cuiStreamInd].pbStrmFmt);
    AVISplitStrmStruct& rCurStream = m_pStreams[cuiStreamInd];
    UMC::BITMAPINFOHEADER* pBmpHdr =
                                (UMC::BITMAPINFOHEADER*)rCurStream.pbStrmFmt;

    if (UNDEF_VIDEO != vtype)
    {
        if (0 == rCurStream.sStrmHdr.uiSuggestedBufferSize)
        {
            umcRes = m_AviIndex.GetMaxChunkSize(m_VideoChunkCode,
                                    rCurStream.sStrmHdr.uiSuggestedBufferSize);
        }

        if (0 == rCurStream.sStrmHdr.uiSuggestedBufferSize)
        {
            rCurStream.sStrmHdr.uiSuggestedBufferSize =
                        pBmpHdr->biWidth * pBmpHdr->biHeight * 4;
        }
        assert(0 != rCurStream.sStrmHdr.uiSuggestedBufferSize);
        umcRes = pFifo->Init(rCurStream.sStrmHdr.uiSuggestedBufferSize,
                                                    UMC_DVSPL_VIDEOFIFO_LEN);
    }

    if (UMC_OK != umcRes)
    {   vm_debug_trace(4, VM_STRING("BaseAVISplitter ExtractVideoInfo failed\n")); }

    return umcRes;
}

UMC::Status
UMC::BaseAVISplitter::FillVideoInfo(const vm_var32 uiIndex,
                                sVideoStreamInfo* pVSInfo)
{
    Status umcRes = UMC_OK;

    if (NULL == pVSInfo)
    {   umcRes = UMC_NULL_PTR;  }

    if (UMC_OK == umcRes)
    {
        assert(NULL != m_pStreams[m_pVideoStreams[uiIndex].m_iStreamInd].pbStrmFmt);
        AVISplitStrmStruct& rCurStream =
                            m_pStreams[m_pVideoStreams[uiIndex].m_iStreamInd];
        UMC::BITMAPINFOHEADER* pBmpHdr =
                                  (UMC::BITMAPINFOHEADER*)rCurStream.pbStrmFmt;

        pVSInfo->clip_info.width = pBmpHdr->biWidth;
        pVSInfo->clip_info.height = pBmpHdr->biHeight;
        pVSInfo->bitrate = m_sAviHdr.uiMaxBytesPerSec * 8;
        pVSInfo->framerate =
              (double)rCurStream.sStrmHdr.uiRate / rCurStream.sStrmHdr.uiScale;

        umcRes = SelectVideoStream(m_pVideoStreams[uiIndex].m_iStreamInd,
                                   pVSInfo->stream_type,
                                   pVSInfo->stream_subtype);
    }

    if (UMC_OK != umcRes)
    {   vm_debug_trace(4, VM_STRING("BaseAVISplitter FillVideoInfo failed\n"));    }

    return umcRes;
}

UMC::Status
UMC::BaseAVISplitter::FillAudioInfo(const vm_var32 uiIndex,
                                sAudioStreamInfo* pASInfo)
{
    Status umcRes = UMC_OK;

    if (NULL == pASInfo)
    {   return UMC_NULL_PTR;    }

    UMC::WAVEFORMATEX* pWavFmt = NULL;
    if (UMC_OK == umcRes)
    {
        assert(NULL != m_pStreams[m_pAudioStreams[uiIndex].m_iStreamInd].pbStrmFmt);
        AVISplitStrmStruct& rCurStream =
            m_pStreams[m_pAudioStreams[uiIndex].m_iStreamInd];
        pWavFmt = (UMC::WAVEFORMATEX*)rCurStream.pbStrmFmt;

        // number of audio channels
        pASInfo->channels = pWavFmt->nChannels;
        // sample rate in Hz
        pASInfo->sample_frequency = pWavFmt->nSamplesPerSec;
        // sample rate in Hz// bitstream in bps
        pASInfo->bitrate = pWavFmt->nAvgBytesPerSec * 8;
        // 0 if compressed
        pASInfo->bitPerSample = pWavFmt->wBitsPerSample ?
            pWavFmt->wBitsPerSample: 16;
        //    ((m_pStreams[m_pAudioStreams[uiIndex].m_iStreamInd]).sStrmHdr).uiSampleSize /
        //                                              (*pWavFmt).nChannels * 8;

        umcRes = SelectAudioStream(m_pAudioStreams[uiIndex].m_iStreamInd,
                                   pASInfo->stream_type);
    }

    if (UMC_OK == umcRes)
    {
        switch(pWavFmt->nChannels)
        {
        case 1:
            pASInfo->channel_mask = CHANNEL_FRONT_CENTER;
            break;
        case 2:
            pASInfo->channel_mask = CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT;
            break;
        case 3:
            pASInfo->channel_mask = CHANNEL_FRONT_LEFT |
                                               CHANNEL_FRONT_RIGHT |
                                               CHANNEL_FRONT_CENTER;
            break;
        case 4:
            pASInfo->channel_mask = CHANNEL_FRONT_LEFT |
                                               CHANNEL_FRONT_RIGHT |
                                               CHANNEL_FRONT_CENTER |
                                               CHANNEL_TOP_CENTER;
            break;
        case 5:
            pASInfo->channel_mask = CHANNEL_FRONT_LEFT |
                                               CHANNEL_FRONT_RIGHT |
                                               CHANNEL_FRONT_CENTER |
                                               CHANNEL_BACK_LEFT |
                                               CHANNEL_BACK_RIGHT;
            break;

        case 6:
            pASInfo->channel_mask = CHANNEL_FRONT_LEFT |
                                               CHANNEL_FRONT_RIGHT |
                                               CHANNEL_FRONT_CENTER |
                                               CHANNEL_BACK_LEFT |
                                               CHANNEL_BACK_RIGHT |
                                               CHANNEL_LOW_FREQUENCY;
            break;
        case 7:
            pASInfo->channel_mask = CHANNEL_FRONT_LEFT |
                                               CHANNEL_FRONT_RIGHT |
                                               CHANNEL_FRONT_CENTER |
                                               CHANNEL_BACK_LEFT |
                                               CHANNEL_BACK_RIGHT |
                                               CHANNEL_LOW_FREQUENCY |
                                               CHANNEL_FRONT_LEFT_OF_CENTER |
                                               CHANNEL_FRONT_RIGHT_OF_CENTER;