umc_mp4_spl_int.cpp

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

        buferAD = (sParamThread*)ippsMalloc_8u(total_audio * sizeof(sParamThread));
        memset(buferAD,0,total_audio * sizeof(sParamThread));
    }
    if (total_video) {
        buferVC = (sParamThread*)ippsMalloc_8u(total_video * sizeof(sParamThread));
        memset(buferVC,0,total_video * sizeof(sParamThread));
    }
    // Type of stream (A/V/AV)
    if (total_video)
    {
        if(total_audio)
            m_splitter_flags_real = AV_SPLITTER;
        else
            m_splitter_flags_real = VIDEO_SPLITTER;
    }
    else
    {
        if(total_audio)
            m_splitter_flags_real = AUDIO_SPLITTER;
        else
            m_splitter_flags_real = UNDEF_SPLITTER;
    }

    if(total_video) m_splitter_flags |=  VIDEO_SPLITTER;
    else            m_splitter_flags &= ~VIDEO_SPLITTER;

    if(total_audio) m_splitter_flags |=  AUDIO_SPLITTER;
    else            m_splitter_flags &= ~AUDIO_SPLITTER;

    total_audio = total_video = 0;

    for(i = 0; i < headerMPEG4.moov.total_tracks; i++)
    {
        if ((headerMPEG4.moov.trak[i]->mdia.minf.is_audio == 1) &&
            (headerMPEG4.moov.trak[i]->tref.dpnd.idTrak == 0)   &&
            (m_splitter_flags & AUDIO_SPLITTER))
        {
            buferAD[total_audio].buf = (sBufferTrack*)ippsMalloc_8u(sizeof(sBufferTrack));
            if (NULL == buferAD[total_audio].buf) {
                return UMC_NULL_PTR;
            }
            memset(buferAD[total_audio].buf, 0, sizeof(sBufferTrack));

            unsigned int buff_size;
            for(j = 0; j < NUMBEROFFILLBUFFERS; j++) {
                buff_size = headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsz.entries_allocated;
                buferAD[total_audio].buf->bufersFrCompr[j] = (unsigned char *)ippsMalloc_8u(buff_size);

                if (NULL == buferAD[total_audio].buf->bufersFrCompr[j]) {
                    return UMC_NULL_PTR;
                }
                memset(buferAD[total_audio].buf->bufersFrCompr[j], 0, buff_size);
            }

            buferAD[total_audio].buf->idTrak = (unsigned char)i;
            buferAD[total_audio].buf->indW = 0;
            buferAD[total_audio].buf->indR = 0;
            buferAD[total_audio].buf->flag_Close = 0;
            buferAD[total_audio].buf->flag_End = 0;
            buferAD[total_audio].buf->flag_Start = 1;
            buferAD[total_audio].buf->numberOfSample_W = 0;
            buferAD[total_audio].buf->numberOfSample_R = 0;
            vm_semaphore_init(&buferAD[total_audio].buf->VfrComprSemR, 0);
            vm_semaphore_init(&buferAD[total_audio].buf->VfrComprSemW, NUMBEROFFILLBUFFERS - 1);

            vm_thread_set_invalid(&buferAD[total_audio].buf->read_thread);
            buferAD[total_audio].atoms = &headerMPEG4;
            buferAD[total_audio].buf->stream = m_pDataReader;
            buferAD[total_audio].resource = &stream_resource;
            vm_thread_create(&buferAD[total_audio].buf->read_thread, ReadThread, &buferAD[total_audio]);
            if (!vm_thread_is_valid(&buferAD[total_audio].buf->read_thread))
                return UMC_FAILED_TO_INITIALIZE;
            vm_thread_set_priority(&buferAD[total_audio].buf->read_thread, VM_THREAD_PRIORITY_NORMAL);
            total_audio++;
        }
        if ((headerMPEG4.moov.trak[i]->mdia.minf.is_video == 1) &&
            (headerMPEG4.moov.trak[i]->tref.dpnd.idTrak == 0)   &&
            (m_splitter_flags & VIDEO_SPLITTER))
        {
            buferVC[total_video].buf = (sBufferTrack*)ippsMalloc_8u(sizeof(sBufferTrack));
            if (NULL == buferVC[total_video].buf) {
                return UMC_NULL_PTR;
            }
            memset(buferVC[total_video].buf, 0, sizeof(sBufferTrack));

            unsigned int buff_size;
            for(j = 0; j < NUMBEROFFILLBUFFERS; j++) {
                buff_size = headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsz.entries_allocated;
                buferVC[total_video].buf->bufersFrCompr[j] = (unsigned char *)ippsMalloc_8u(buff_size);

                if (NULL == buferVC[total_video].buf->bufersFrCompr[j]) {
                    return UMC_NULL_PTR;
                }
                memset(buferVC[total_video].buf->bufersFrCompr[j], 0, buff_size);
            }

            buferVC[total_video].buf->idTrak = (unsigned char)i;
            buferVC[total_video].buf->indW = 0;
            buferVC[total_video].buf->indR = 0;
            buferVC[total_video].buf->flag_Close = 0;
            buferVC[total_video].buf->flag_End = 0;
            buferVC[total_video].buf->flag_Start = 1;
            buferVC[total_video].buf->numberOfSample_W = 0;
            buferVC[total_video].buf->numberOfSample_R = 0;
            vm_semaphore_init(&buferVC[total_video].buf->VfrComprSemR, 0);
            vm_semaphore_init(&buferVC[total_video].buf->VfrComprSemW, NUMBEROFFILLBUFFERS - 1);
            vm_thread_set_invalid(&buferVC[total_video].buf->read_thread);
            buferVC[total_video].atoms = &headerMPEG4;
            buferVC[total_video].buf->stream = m_pDataReader;
            buferVC[total_video].resource = &stream_resource;
            vm_thread_create(&buferVC[total_video].buf->read_thread, ReadThread, &buferVC[total_video]);
            if (!vm_thread_is_valid(&buferVC[total_video].buf->read_thread))
                return UMC_FAILED_TO_INITIALIZE;
            vm_thread_set_priority(&buferVC[total_video].buf->read_thread, VM_THREAD_PRIORITY_NORMAL);
            total_video++;
        }
    }

    return UMC_OK;
}


SplitterMP4::SplitterMP4()
{
    buferAD = NULL;
    buferVC = NULL;
    m_splitter_flags_real = 0;
    m_splitter_flags = 0;
    total_video = 0;
    total_audio = 0;
}


SplitterMP4::~SplitterMP4()
{
    Close();
}


Status SplitterMP4::Close()
{
    unsigned int i, j;

    if (buferAD) {
        for (i = 0; i < total_audio; i++) {
            buferAD[i].buf->flag_Close = 1;

            if (vm_thread_is_valid(&buferAD[i].buf->read_thread))
                vm_thread_wait(&buferAD[i].buf->read_thread);
            vm_thread_set_invalid(&buferAD[i].buf->read_thread);

            for (j = 0; j < NUMBEROFFILLBUFFERS; j++)
                if (buferAD[i].buf->bufersFrCompr[j] != NULL) {
                    if (buferAD[i].buf->bufersFrCompr[j])
                        ippsFree(buferAD[i].buf->bufersFrCompr[j]);
                    buferAD[i].buf->bufersFrCompr[j] = NULL;
                }

            if (vm_semaphore_is_valid(&buferAD[i].buf->VfrComprSemR))
                vm_semaphore_destroy(&buferAD[i].buf->VfrComprSemR);
            vm_semaphore_set_invalid(&buferAD[i].buf->VfrComprSemR);

            if (vm_semaphore_is_valid(&buferAD[i].buf->VfrComprSemW))
                vm_semaphore_destroy(&buferAD[i].buf->VfrComprSemW);
            vm_semaphore_set_invalid(&buferAD[i].buf->VfrComprSemR);

            ippsFree(buferAD[i].buf);
            buferAD[i].buf = NULL;
        }
        ippsFree(buferAD);

        buferAD     = NULL;
        total_audio = 0;
    }


    if (buferVC) {
        for (i = 0; i < total_video; i++) {
            buferVC[i].buf->flag_Close = 1;

            if (vm_thread_is_valid(&buferVC[i].buf->read_thread))
                vm_thread_wait(&buferVC[i].buf->read_thread);
            vm_thread_set_invalid(&buferVC[i].buf->read_thread);

            for (j = 0; j < NUMBEROFFILLBUFFERS; j++)
                if (buferVC[i].buf->bufersFrCompr[j] != NULL) {
                    if (buferVC[i].buf->bufersFrCompr[j])
                        ippsFree(buferVC[i].buf->bufersFrCompr[j]);
                    buferVC[i].buf->bufersFrCompr[j] = NULL;
                }

            if (vm_semaphore_is_valid(&buferVC[i].buf->VfrComprSemR))
                vm_semaphore_destroy(&buferVC[i].buf->VfrComprSemR);
            vm_semaphore_set_invalid(&buferVC[i].buf->VfrComprSemR);

            if (vm_semaphore_is_valid(&buferVC[i].buf->VfrComprSemW))
                vm_semaphore_destroy(&buferVC[i].buf->VfrComprSemW);
            vm_semaphore_set_invalid(&buferVC[i].buf->VfrComprSemR);

            ippsFree(buferVC[i].buf);
            buferVC[i].buf = NULL;
        }
        ippsFree(buferVC);

        buferVC     = NULL;
        total_video = 0;
    }


    for(i = 0; i < headerMPEG4.moov.total_tracks; i++)
    {
        if (headerMPEG4.moov.trak[i]) {
            for (j = 0; j < headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsd.total_entries; j++)
                if (!headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsd.table[j].esds.flags)
                    if(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsd.table[j].esds.decoderConfigLen) {
                        ippsFree(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsd.table[j].esds.decoderConfig);
                        headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsd.table[j].esds.decoderConfig = NULL;
                    }
            if (!(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsz.flags))
                if(!headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsz.sample_size) {
                    if (headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsz.table)
                        ippsFree(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsz.table);
                    headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsz.table = NULL;
                }

            if(!(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsc.flags)) {
                if (headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsc.table)
                    ippsFree(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsc.table);
                headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsc.table = NULL;
            }

            if(!(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stco.flags)) {
                if (headerMPEG4.moov.trak[i]->mdia.minf.stbl.stco.table)
                    ippsFree(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stco.table);
                headerMPEG4.moov.trak[i]->mdia.minf.stbl.stco.table = NULL;
            }

            if(!(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stts.flags)) {
                if (headerMPEG4.moov.trak[i]->mdia.minf.stbl.stts.table)
                    ippsFree(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stts.table);
                headerMPEG4.moov.trak[i]->mdia.minf.stbl.stts.table = NULL;
            }

            if(!(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsd.flags)) {
                if (headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsd.table)
                    ippsFree(headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsd.table);
                headerMPEG4.moov.trak[i]->mdia.minf.stbl.stsd.table = NULL;
            }

            if(!(headerMPEG4.moov.trak[i]->mdia.minf.dinf.dref.flags))
            {
                for (j = 0; j < headerMPEG4.moov.trak[i]->mdia.minf.dinf.dref.total_entries; j++)
                {
                    if (headerMPEG4.moov.trak[i]->mdia.minf.dinf.dref.table[j].data_reference)
                        ippsFree(headerMPEG4.moov.trak[i]->mdia.minf.dinf.dref.table[j].data_reference);
                    headerMPEG4.moov.trak[i]->mdia.minf.dinf.dref.table[j].data_reference = NULL;
                }
                if (headerMPEG4.moov.trak[i]->mdia.minf.dinf.dref.table) {
                    ippsFree(headerMPEG4.moov.trak[i]->mdia.minf.dinf.dref.table);
                }
                headerMPEG4.moov.trak[i]->mdia.minf.dinf.dref.table = NULL;
            }

            ippsFree(headerMPEG4.moov.trak[i]);
            headerMPEG4.moov.trak[i] = NULL;
        }

    }

    return UMC_OK;
}

double getTime(T_trak_data *trak, unsigned int num_sample)
{
    unsigned int    i;
    int             time_scale = trak->mdia.mdhd.time_scale;
    double          result = 0;
    T_stts_data stts = trak->mdia.minf.stbl.stts;

    for ( i = 0; i < stts.total_entries; i++ )
    {
        if ( num_sample > stts.table[i].sample_count )
        {
            result += (double)stts.table[i].sample_count * stts.table[i].sample_duration / time_scale;
            num_sample -= stts.table[i].sample_count;
        }
        else
        {
            result += (double)num_sample / time_scale * stts.table[i].sample_duration;
            break;
        }
    }
    return result;
}