umc_avi_splitter_base.cpp

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

                (double)pMData->GetDataSize() / (m_info.m_audio_info.channels *
                                m_info.m_audio_info.sample_frequency * usBlockAlign);
        }

        pMData->SetTime(dfTime, m_dfCurAudioTime);
    }

//    m_ObjAccessMut.Unlock();

    //  We can't return any other value
    assert(UMC_OK == umcRes || UMC_END_OF_STREAM == umcRes);

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

    return umcRes;
}

UMC::sInfo_sample
UMC::BaseAVISplitter::GetSamplePositionAudio(vm_var32 uiTrackIdx,
                                         vm_var32 uiSampleIdx)
{
    sInfo_sample Res;
    vm_var32     uiInd  = 0;
    vm_var32     uiTableSize = m_AviIndex.GetIndexTableSize();

    AVIIndex::IndTblEntry entry;

    Res.position = -1;
    Res.size     = -1;

    vm_debug_trace(4, VM_STRING("\nkey frame: %d\n"), uiSampleIdx);

    if (uiTableSize)
    {
        for (unsigned int i = 0; i < uiTableSize; i++)
        {
            m_AviIndex.GetIndexTableEntry(i, entry);

            if (entry.ChunkType == m_pAudioStreams[uiTrackIdx].m_Channel.GetFourCCCode())
            {
                uiInd++;
                vm_debug_trace(0, VM_STRING("Chunck: %d Size: %d\n"),
                               uiInd - 1,
                               entry.uiSize);
                if (uiInd == uiSampleIdx)
                {
                    Res.position = entry.uiPos;
                    Res.size     = entry.uiSize;
                    return Res;
                }
            }
        }
    }

    return Res;
}

UMC::sInfo_sample
UMC::BaseAVISplitter::GetSamplePositionVideo(vm_var32 uiTrackIdx,
                                         vm_var32 uiSampleIdx)
{
    sInfo_sample Res;
    vm_var32     uiInd  = 0;
    vm_var32     uiTableSize = m_AviIndex.GetIndexTableSize();

    AVIIndex::IndTblEntry entry;

    Res.position = -1;
    Res.size     = -1;

    vm_debug_trace(4, VM_STRING("\nkey frame: %d\n"), uiSampleIdx);

    if (uiTableSize)
    {
        for (unsigned int i = 0; i < uiTableSize; i++)
        {
            m_AviIndex.GetIndexTableEntry(i, entry);

            if (entry.ChunkType == m_pVideoStreams[uiTrackIdx].m_Channel.GetFourCCCode())
            {
                uiInd++;
                vm_debug_trace(-1,VM_STRING("Chunck: %d Size: %d\n"),
                               uiInd - 1,
                               entry.uiSize);
                if (uiInd == uiSampleIdx)
                {
                    Res.position = entry.uiPos;
                    Res.size     = entry.uiSize;
                    return Res;
                }
            }
        }
    }

    return Res;
}

UMC::Status
UMC::BaseAVISplitter::GetStreamsInfo(DataReader* pDataReader,
                                 SplitterInfo& rSplInfo)
{
    Status umcRes = UMC_OK;
    MainAVIHeader AviHdr = {0};
    AVISplitStrmStruct* pStrmArray = NULL;
    vm_var32 uiFlags = 0;
    tFOURCC VideoChunkCode;
    AVIIndex AviIndex;
    Mutex    mutex;

    umcRes = mutex.Init();

    if (UMC_OK == umcRes)
    {
        umcRes = ReadFormat(pDataReader, mutex, AviHdr, pStrmArray, AviIndex,
                                uiFlags, VideoChunkCode);
    }

    rSplInfo.m_audio_info.channels          = 0;    // number of audio channels
    rSplInfo.m_audio_info.sample_frequency  = 0;    // sample rate in Hz
    rSplInfo.m_audio_info.bitrate           = 0;    // bitstream in bps
    rSplInfo.m_audio_info.bitPerSample      = 0;    // 0 if compressed
    rSplInfo.m_audio_info.stream_type       = UNDEF_AUDIO;

    //ruiAudioStreamNum = 0;
    rSplInfo.m_video_info.clip_info.width   = 0;
    rSplInfo.m_video_info.clip_info.height  = 0;
    rSplInfo.m_video_info.bitrate           = 0;
    rSplInfo.m_video_info.framerate         = 0;
    rSplInfo.m_video_info.stream_type       = UNDEF_VIDEO;

    rSplInfo.m_system_info.muxrate          = 0;
    rSplInfo.m_system_info.stream_type      = AVI_STREAM;

    for (vm_var32 i = 0; UMC_OK == umcRes && i < AviHdr.uiStreams; i++)
    {
        assert(NULL != pStrmArray);
        if (UNDEF_VIDEO == rSplInfo.m_video_info.stream_type &&
            (AVI_FOURCC_VIDEOSTRM == pStrmArray[i].sStrmHdr.fccType ||
            AVI_FOURCC_IAVS == pStrmArray[i].sStrmHdr.fccType))
        {
            switch (pStrmArray[i].sStrmHdr.fccHandler) {
            case AVI_FOURCC_DVSD:
            case AVI_FOURCC_DSVD:
            case AVI_FOURCC_VIDV:
            case AVI_FOURCC_DVSL:
            case AVI_FOURCC_SLDV:
                rSplInfo.m_video_info.stream_type = DIGITAL_VIDEO_SD;
                break;
            case AVI_FOURCC_ILV4:
            case AVI_FOURCC_vssh:
                rSplInfo.m_video_info.stream_type = H264_VIDEO;
                break;
            case AVI_FOURCC_DIVX:
            case AVI_FOURCC_divx:
                rSplInfo.m_video_info.stream_type    = MPEG4_VIDEO;
                rSplInfo.m_video_info.stream_subtype = UNDEF_VIDEO_SUBTYPE;
                break;
            case AVI_FOURCC_DX50:
                rSplInfo.m_video_info.stream_type = MPEG4_VIDEO;
                rSplInfo.m_video_info.stream_subtype = MPEG4_VIDEO_DIVX5;
                break;
            case AVI_FOURCC_WMV3:
                rSplInfo.m_video_info.stream_type = WMV_VIDEO;
                break;
            case AVI_FOURCC_H263:
            case AVI_FOURCC_h263:
            case AVI_FOURCC_I263:
            case AVI_FOURCC_i263:
            case AVI_FOURCC_M263:
            case AVI_FOURCC_m263:
            case AVI_FOURCC_VIVO:
            case AVI_FOURCC_vivo:
                rSplInfo.m_video_info.stream_type = H263_VIDEO;
                break;
            default:
                break;
            }

            if (0 != pStrmArray[i].sStrmHdr.rcFrame.right)
            {
                rSplInfo.m_video_info.clip_info.width   =
                                    pStrmArray[i].sStrmHdr.rcFrame.right;
                rSplInfo.m_video_info.clip_info.height =
                                    pStrmArray[i].sStrmHdr.rcFrame.bottom;
            }
            else
            {
                assert(pStrmArray[i].pbStrmFmt);
                UMC::BITMAPINFOHEADER* pBMPHdr =
                    (UMC::BITMAPINFOHEADER*)(*pStrmArray).pbStrmFmt;

                rSplInfo.m_video_info.clip_info.width = pBMPHdr->biWidth;
                rSplInfo.m_video_info.clip_info.height = pBMPHdr->biHeight;
            }
        }
        else if (AVI_FOURCC_AUDIOSTRM == pStrmArray[i].sStrmHdr.fccType)
        {
            //ruiAudioStreamNum++;
            if (UNDEF_AUDIO == rSplInfo.m_audio_info.stream_type)
            {
                UMC::WAVEFORMATEX* pWavFmt =
                    (UMC::WAVEFORMATEX*)pStrmArray[i].pbStrmFmt;

                switch (pWavFmt->wFormatTag)
                {
                case WAVE_FORMAT_PCM:
                    rSplInfo.m_audio_info.stream_type = PCM_AUDIO;
                    break;
                case WAVE_FORMAT_MPEGLAYER3:
                    if (pWavFmt->nSamplesPerSec >= 32000)
                        rSplInfo.m_audio_info.stream_type = MP1L3_AUDIO;
                    else
                        rSplInfo.m_audio_info.stream_type = MP2L3_AUDIO;
                    break;
                case WAVE_FORMAT_AAC:
                    rSplInfo.m_audio_info.stream_type = AAC_AUDIO;
                    break;
                default:break;
                }
            }
        }
    }

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

    delete[] pStrmArray;

    return umcRes;
}

UMC::Status
UMC::BaseAVISplitter::GetNextVideoData(MediaData* data)
{   return GetNextVideoData(data, 0);   }

UMC::Status
UMC::BaseAVISplitter::GetNextAudioData(MediaData* data)
{   return GetNextAudioData(data, 0);   }

UMC::Status
UMC::BaseAVISplitter::SelectVideoStream(vm_var32            uiInd,
                                        VideoStreamType&    rvType,
                                        VideoStreamSubType& rvSubType)
{
    Status umcRes = UMC_OK;

    vm_var32 fccHandler = m_pStreams[uiInd].sStrmHdr.fccHandler;

    // MPEG-4
    if (AVI_FOURCC_DIVX == fccHandler  ||
        AVI_FOURCC_divx == fccHandler  ||
        AVI_FOURCC_DX50 == fccHandler  ||
        AVI_FOURCC_DX50 == fccHandler  ||
        AVI_FOURCC_dx50     == fccHandler ||
        AVI_FOURCC_DIV4     == fccHandler ||
        AVI_FOURCC_div4     == fccHandler ||
        AVI_FOURCC_XVID     == fccHandler ||
        AVI_FOURCC_xvid     == fccHandler ||
        AVI_FOURCC_MP4V     == fccHandler ||
        AVI_FOURCC_mp4v     == fccHandler
        )
    {
        if (AVI_FOURCC_VIDEOSTRM == m_pStreams[uiInd].sStrmHdr.fccType)
        {
            rvType    = MPEG4_VIDEO;

            if (AVI_FOURCC_DX50 == fccHandler)
            {
                m_info.m_video_info.stream_subtype = MPEG4_VIDEO_DIVX5;
                rvSubType = MPEG4_VIDEO_DIVX5;
            }
            else
            {
                m_info.m_video_info.stream_subtype = UNDEF_VIDEO_SUBTYPE;
                rvSubType = UNDEF_VIDEO_SUBTYPE;
            }

        }

        return umcRes;
    }

    // DV
    if (AVI_FOURCC_DVSD == fccHandler ||
        AVI_FOURCC_DSVD == fccHandler ||
        AVI_FOURCC_VIDV == fccHandler ||
        AVI_FOURCC_DVSL == fccHandler ||
        AVI_FOURCC_SLDV == fccHandler)
    {
        if (AVI_FOURCC_VIDEOSTRM == m_pStreams[uiInd].sStrmHdr.fccType)
        {
            rvType = DIGITAL_VIDEO_SD;
            umcRes = UMC_OK;
        }
        else if (AVI_FOURCC_IAVS == m_pStreams[uiInd].sStrmHdr.fccType)
        {
            assert(false);
//            m_info.m_video_info.stream_type = DIGITAL_VIDEO_SD;
//            umcRes = ExtractInterleavedInfo(ulStream);
//            if (UMC_OK == umcRes) {
//                ruiInd = ulStream;
//                bVideoStrmFound = true;
//                break;
//            }
        }

        return umcRes;
    }

    // WMV
    if (AVI_FOURCC_WMV3 == fccHandler)
    {
        if (AVI_FOURCC_VIDEOSTRM == m_pStreams[uiInd].sStrmHdr.fccType)
        {
            rvType = WMV_VIDEO;
        }
    }

    // H.263
    if (AVI_FOURCC_H263 == fccHandler  ||
        AVI_FOURCC_h263 == fccHandler  ||
        AVI_FOURCC_I263 == fccHandler  ||
        AVI_FOURCC_i263 == fccHandler  ||
        AVI_FOURCC_M263 == fccHandler  ||
        AVI_FOURCC_m263 == fccHandler  ||
        AVI_FOURCC_VIVO == fccHandler ||
        AVI_FOURCC_vivo == fccHandler
        )
    {
        if (AVI_FOURCC_VIDEOSTRM == m_pStreams[uiInd].sStrmHdr.fccType)
        {
            rvType    = H263_VIDEO;

            m_info.m_video_info.stream_subtype = UNDEF_VIDEO_SUBTYPE;
            rvSubType = UNDEF_VIDEO_SUBTYPE;

        }

        return umcRes;
    }

    // MJPEG
    if (AVI_FOURCC_mjpg == fccHandler  ||
        AVI_FOURCC_MJPG == fccHandler  ||
        AVI_FOURCC_mjpx == fccHandler  ||
        AVI_FOURCC_MJPX == fccHandler  ||
        AVI_FOURCC_dmb1 == fccHandler)
    {
        if (AVI_FOURCC_VIDEOSTRM == m_pStreams[uiInd].sStrmHdr.fccType)
        {
            rvType    = MJPEG_VIDEO;

            m_info.m_video_info.stream_subtype = UNDEF_VIDEO_SUBTYPE;
            rvSubType = UNDEF_VIDEO_SUBTYPE;

        }

        return umcRes;
    }


    umcRes = UMC_BAD_STREAM;

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

    return umcRes;
}



UMC::Status UMC::BaseAVISplitter::CheckNextVideoData(MediaData* data)
{
    Status ret = UMC_NOT_IMPLEMENTED;
    return ret;
}

UMC::Status UMC::BaseAVISplitter::CheckNextAudioData(MediaData* data)
{
    Status ret = UMC_NOT_IMPLEMENTED;
    return ret;
}

UMC::Status UMC::BaseAVISplitter::Stop()
{
    Status ret = UMC_NOT_IMPLEMENTED;
    return ret;
}