umc_mp4_spl_int.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) 2004-2005 Intel Corporation. All Rights Reserved.
//
*/

#include "ippdefs.h"
#include "vm_semaphore.h"
#include "vm_thread.h"
#include "vm_types.h"
#include "vm_time.h"
#include "umc_media_data.h"
#include "umc_cyclic_buffer.h"

#include "umc_mp4_spl_int.h"
#include "umc_mp4_spl.h"
#include "umc_mp4_parser.h"

#include "mp4cmn_config.h"
#include "bstream.h"
#include <ipps.h>


#define BYTE_BIT    8

enum
{
#ifndef _WIN32_WCE
    TIME_TO_SLEEP          = 5,
#else
    TIME_TO_SLEEP          = 0,
#endif
};

namespace UMC
{

Status GetBits(int *data, int   nbits, int *ptr, unsigned char *buf)
{
    int             num, maxNum, curNum;
    unsigned long   bits;

    num = 0;
    *data = 0;
    maxNum = BYTE_BIT - *ptr % BYTE_BIT;
    while (num < nbits)
    {
        curNum = min(nbits - num, maxNum);
        bits = (buf[*ptr / BYTE_BIT] >> (BYTE_BIT - *ptr % BYTE_BIT - curNum)) & ((1 << curNum) - 1);
        *data |= bits << (nbits - num - curNum);
        num += curNum;
        *ptr += curNum;
        maxNum = BYTE_BIT;
    }
    return UMC::UMC_OK;
}


AudioStreamType ObjectIDType(int idType)
{
    switch(idType)
    {
        case 0xe0:
            return UMC::PCM_AUDIO;
        case 0xe2:
            return UMC::AC3_AUDIO;
        case 0x05:
        case 0x07:
            return UMC::TWINVQ_AUDIO;
        case 0x6b:
            return UMC::MPEG1_AUDIO;
        case 0x69:
            return UMC::MPEG2_AUDIO;
        case 0xe1:
            return UMC::VORBIS_AUDIO;
        case 0x66:
        case 0x67:
        case 0x68:
        case 0x01:
        case 0x02:
        case 0x03:
        case 0x04:
        case 0x06:
            return UMC::AAC_MPEG4_STREAM;
        default:
            return UMC::UNDEF_AUDIO;
    }
}


AudioStreamType AudioDataType(int idType)
{
    if (idType > 5 && idType < 13)
        return (UMC::AudioStreamType)(idType + 4);
    else
        return UMC::UNDEF_AUDIO;
}


int GetSamplingFrequency(int ind)
{
    switch (ind)
    {
        case 0x0:
            return 96000;
        case 0x1:
            return 88200;
        case 0x2:
            return 64000;
        case 0x3:
            return 48000;
        case 0x4:
            return 44100;
        case 0x5:
            return 32000;
        case 0x6:
            return 24000;
        case 0x7:
            return 22050;
        case 0x8:
            return 16000;
        case 0x9:
            return 12000;
        case 0xa:
            return 11025;
        case 0xb:
            return 8000;
        case 0xc:
            return 7350;
        case 0xf:
            return 0;
    }
    return -1;
}


vm_var64u FindPosOfSamples(info_atoms *headerMPEG4, unsigned int number, int id_trak)
{
    unsigned int i;
    unsigned int chunk = 0;
    unsigned int samples = 0;
    unsigned int block_chunk = 0;
    unsigned int stsc_total_entries;
    unsigned int first_chunk;
    unsigned int first_sample;
    unsigned int samples_per_chunk;
    vm_var64u    offset;

    // check correct of input data
    if (headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stsz.total_entries < number)
        if (headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stco.flags != 0)
            headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.co64.table[0].offset;
        else
            return headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stco.table[0].offset;

    stsc_total_entries = headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stsc.total_entries;

    for (chunk = 0; chunk < stsc_total_entries; chunk++)
    {
        if (number < headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stsc.table[chunk].first_sample)
        {
            chunk -= 1;
            break;
        }
    }
    if (chunk == stsc_total_entries)
        chunk -= 1;
    first_chunk = headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stsc.table[chunk].chunk;
    first_sample = headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stsc.table[chunk].first_sample;
    samples_per_chunk = headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stsc.table[chunk].samples;
    block_chunk = first_chunk + ((number - first_sample) / samples_per_chunk);
    if (headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stco.flags != 0)
        offset = headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.co64.table[block_chunk - 1].offset;
    else {
        offset = 0;
        if (headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stco.table) {
            offset = headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stco.table[block_chunk - 1].offset;
        } else if (headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.co64.table) {
            offset = headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.co64.table[block_chunk - 1].offset;
        }
    }

     samples = number - ((number - first_sample) % samples_per_chunk);
    if (!headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stsz.sample_size)
        for (i = samples; i < number; i++)
            offset += headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stsz.table[i].size;
    else
        offset += (number - samples) * headerMPEG4->moov.trak[id_trak]->mdia.minf.stbl.stsz.sample_size;

    return offset;
}


unsigned char * GetFreeBuffer_Audio(sBufferTrack *bufer)
{
    vm_semaphore_wait(&(bufer->VfrComprSemW));
    return (bufer->bufersFrCompr)[bufer->indW++];
}

unsigned int ReadThread(void* ptr)
{
    unsigned int       readsize;
    vm_sizet           setpos;
    unsigned char*     buf;
    UMC::sParamThread  param = *(sParamThread*)ptr;

    while (!param.buf->flag_Close)
    {
        if (param.buf->numberOfSample_W >= param.atoms->moov.trak[param.buf->idTrak]->mdia.minf.stbl.stsz.total_entries)
        {
            param.buf->flag_End = 1;
            vm_thread_set_priority(&param.buf->read_thread, VM_THREAD_PRIORITY_LOWEST);
        }
        while (param.buf->flag_End)
        {
            //vm_debug_trace(-1,VM_STRING("MP4 spl: sleep %d\n"),param.buf->idTrak);
            vm_time_sleep(TIME_TO_SLEEP);
            if (param.buf->flag_Close == 1)
                return 0;
        }
        while ((param.buf->numberOfSample_W - param.buf->numberOfSample_R) >= NUMBEROFFILLBUFFERS - 1)
        {
            //vm_debug_trace(-1,VM_STRING("MP4 spl: sleep %d\n"),param.buf->idTrak);
            vm_time_sleep(TIME_TO_SLEEP);
            if (param.buf->flag_Close == 1)
                return 0;
        }

        buf = GetFreeBuffer_Audio(param.buf);

        if (param.buf->indW == NUMBEROFFILLBUFFERS)
            param.buf->indW = 0;
        setpos = FindPosOfSamples(param.atoms, param.buf->numberOfSample_W, param.buf->idTrak);
        //setpos /= (double)(vm_var64s)param.buf->stream->GetSize();

        if (param.atoms->moov.trak[param.buf->idTrak]->mdia.minf.stbl.stsz.sample_size)
            readsize = param.atoms->moov.trak[param.buf->idTrak]->mdia.minf.stbl.stsz.sample_size;
        else
            readsize = param.atoms->moov.trak[param.buf->idTrak]->mdia.minf.stbl.stsz.table[param.buf->numberOfSample_W].size;

        param.resource->Lock();
        assert(setpos<param.buf->stream->GetSize());
        param.buf->stream->SetPosition(setpos);
        param.buf->stream->GetData(buf,(vm_var32*) &readsize);
        param.resource->Unlock();

        vm_semaphore_post(&param.buf->VfrComprSemR);

        param.buf->numberOfSample_W++;
    }

    return 0;
}


Status SplitterMP4::Init(SplitterParams& init)
{
    unsigned int i, j;

    if (init.m_pDataReader == NULL)
        return UMC_NOT_ENOUGH_DATA;
    else
        m_pDataReader = init.m_pDataReader;

    stream_resource.Init();

    m_pDataReader->Reset();

    m_splitter_flags = init.m_lFlags;

    memset(&headerMPEG4,0,sizeof(info_atoms));

    // parse audio and video tracks
    if (ParceMP4Header() != UMC_OK)
        return UMC_BAD_STREAM;

    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))
            total_audio++;
        if ((headerMPEG4.moov.trak[i]->mdia.minf.is_video == 1) && (headerMPEG4.moov.trak[i]->tref.dpnd.idTrak == 0))
            total_video++;
    }

    buferAD = NULL;
    buferVC = NULL;

    // create semaphors and buffers allocate for each trak
    if (total_audio) {