Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MP4audioDecoder.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       MP4audioDecoder.cpp                                           *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program is distributed in the hope that it will be useful,      *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         *
 * GNU General Public License for more details.                         *
 *                                                                      *
 * You should have received a copy of the GNU General Public License    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#include "MP4audioDecoder.hpp"
#include "ContainerInfo.hpp"
#include "ESInfo.hpp"
#include "UncompressedAudioFrame.hpp"
#include "IO.hpp"

#define readMarkerBit() readMarkerBitFunc(__LINE__)

// Table 6-3: Start code values
#define MPEG_AUDIO_HEADER_START_CODE            0xFFF

static u32 __inline
log2bin(u32 value)
{
/* Changed by Chenm001 */
// #if !defined(_MSC_VER)
        int n = 0;

        while (value) {
                value >>= 1;
                n++;
        }
        return n;
        /*
#else
        __asm {
                bsr eax, value 
                inc eax
        }
#endif
        */
}

bool MP4audioDecoder::isValidAudioFrame(const u8* payload) {
        return (payload && payload[0] == 0xFF && payload[1]>>5 == 0x07);

}

bool MP4audioDecoder::isValidDecoderConfig(const u8* payload) {
        return (payload && payload[0] == 0xFF && payload[1]>>5 == 0x07);
}


MP4audioDecoder::MP4audioDecoder(AudioESInfo * pESInfo, bool enableSwitching, meCoderType coderType) {
        mpDecoder = NULL;
        this->enableSwitching=enableSwitching;  
        es = pESInfo;
        mFrameSize = 0;
        decConfig=NULL;
        decConfigSize=0;
        newDecConfig=NULL;
        meCoder = coderType;
        initialized = false;
        strcpy(name,"MP4audioDecoder");
}


MP4audioDecoder::~MP4audioDecoder() {
  if (initialized)
                DecoderClose((char **) (&mpDecoder));
        if(decConfig)
                delete[] decConfig;
        if(newDecConfig)
                delete[] newDecConfig;
}


void MP4audioDecoder::initialize() {
        if (!es) {
                initialized = false;
                return;
        }
        if(initialized)
                return;
        
        mpDecoder = NULL;
        muiFrameNumber = 0;
        muiLastFrameStart = 0;
        muiLastFrameEnd = 0;
        decConfig=NULL;
        decConfigSize=0;
        newDecConfig=NULL;
  
        muiLastFrameEnd = es->getHeaders(&decConfig);
        decConfigSize=muiLastFrameEnd;
        
        if (decConfigSize > sizeof(mpBuffer)) {
                dprintf_err("MP4audioDecoder::initialize() decConfigSize %u > sizeof(mpBuffer) %u "
                                                                "-- initialization FAILED!\n", decConfigSize, sizeof(mpBuffer));
                return;
        }
        memcpy(mpBuffer,decConfig,decConfigSize);
        
        
        dprintf_full("MP4audioDecoder::initialize() %s\r\n",es->getEncodedDecoderConfig());
#ifdef VITOOKI_DEBUG
        for(uint i=0;i<(muiLastFrameEnd/4)||i<30;i+=4) {
                int res =0;
                for(int j = 0; j < 4; j++) {
                        res = (res << 8) | mpBuffer[j+i];
                }               
                dprintf_full("%x ", res);
        }
        dprintf("\r\n");
        fflush(stdout);
#endif
        
#if VITOOKI_DEBUG_LEVEL >= 2
        dprintf_full("MP4audioDecoder::initialize:: ");
        for (uint iiii = 0; iiii < muiLastFrameEnd; iiii++)
                dprintf_full("%x", mpBuffer[iiii]);
        dprintf("\n");    
#endif                          /*  */
        
        if (muiLastFrameEnd == 0) {
                dprintf_err("MP4audioDecoder::initialize: failed to get header for ESInfo object\n");
        }
        //initializeMPEGaudioHeaderStruct();    
        //initializeParser((u8 *) mpBuffer, muiLastFrameEnd);
        /* No need to parse the mp3 header as not a single information is required right now
         * we get it all from ffmpeg
         * HOWEVER if there are some errors in bitrate, channels etc then uncomment the following two line and 
         * set the parameters in the "else" portion... and ONLY for #ifndef ISOMP4
         */
        if (!parseMPEGaudioHeader((u8 *) mpBuffer, muiLastFrameEnd))
                dprintf_small("MP4audioDecoder::initialize : No Audio Frame Header found\n");
        
        DecoderInit((char **) (&mpDecoder), es->getCodecID());
        dprintf_small("MP4audioDecoder::initialize : Audio Decoder initialized \n");
        
        if (mpDecoder == NULL) {
                dprintf_err("MP4audioDecoder::initialize: Error creating decoder handle\n");
                exit(-1);
        }
        else
                {       
#ifndef ISOMP4 
                        es->setMediaTimeScale(90000);
                        if(mp4AudioHeader.sampling_rate>0)
                                es->setSampleRate(mp4AudioHeader.sampling_rate);
                        else {
                                dprintf_err("MP4AudioDecoder::initialize: Wrong sampling rate for audio in %s\n",es->getContainerInfo()->getLocalFile());
                                es->setSampleRate(44100);
                        }
                        dprintf_full("MP4AudioDecoder::initialize: using sampling rate %i Hz\n",es->getSampleRate());
                        
                        ((AudioESInfo*)es)->setChannelMod(mp4AudioHeader.channel_mod);
                        if(mp4AudioHeader.channel_mod == 3)
                                es->setAudioChannels(1);
                        else
                                es->setAudioChannels(2);
                        ((AudioESInfo*)es)->setAvgBandwidth(mp4AudioHeader.bitrate*1000);
                        //es->setMaxBandwidth(mp4AudioHeader.bitrate*1000*3/2); //MAXBANDWIDTH for audio is 1.5 times AVGBANDWIDTH
                        //es->setDuration((((es->getOrigMediaSize()*8)/(mp4AudioHeader.bitrate*1000))*mp4AudioHeader.sampling_rate));
                        //Process ONLY colorspaces definded in MP4audioDecoder.hpp
#endif
                        
                        mFrameSize = 4608; //XXX give it the appropiate value 
                        dprintf_full("MP4audioDecoder::initialize: Esinfo %llu BufferSize %i \n",
                                                                         es->getStreamId(), es->getBufferSize()); 
                }
        initialized = true;
}


list < Frame * >MP4audioDecoder::adapt(Frame * frm)  {
        if(es && enableSwitching) {
                if(decConfigSize>0) {
                        if(newDecConfig) {
                                delete[] newDecConfig;
                                newDecConfig=NULL;
                        }
                        
                        u32 nSize=es->getHeaders(&newDecConfig);
                        if(nSize != 0 && nSize != decConfigSize) {
                                // we have a new decConfig
                                if(decConfig)
                                        delete[] decConfig;
                                decConfig=newDecConfig;
                                newDecConfig=NULL;
                                initialized=false;
                        }
                        else if(nSize == decConfigSize) {
                                // same size but might be different
                                if(memcmp(decConfig,newDecConfig,decConfigSize)!=0) {
                                        // is different
                                        if(decConfig)
                                                delete[] decConfig;
                                        decConfig=newDecConfig;
                                        newDecConfig=NULL;
                                        initialized=false;
                                }
                        }
                }
        }
        
        if (!initialized)
                initialize();
        
        list < Frame * >frmList;
        if (!initialized)
                return frmList;
        
        muiFrameNumber++;
        
#ifndef WINCE
        if (dec != NULL) {
#endif //wince
                if (DecodeFrame((char *) mpDecoder, (char *) frm->getAU()->payload, frm->getAU()->size,
                                                                                (char *) mpBuffer, &mFrameSize) <= 0) {
                        u8 *pload = frm->getAU()->payload;
                        dprintf_err("MP4audioDecoder::adapt Error decoding frame %d\n", muiFrameNumber);
                        dprintf_full("MP4audioDecoder::adapt %i %i %i %i\r\n",
                                                                         pload[0], pload[1],pload[2],pload[3]);
                } else {
                        AU * pAU = new AU(frm->getAU());
                        pAU->size = mFrameSize;
                        pAU->payload = new u8[mFrameSize];
                        memcpy(pAU->payload, mpBuffer, mFrameSize);
                        dprintf_full("MP4audioDecoder::adapt Decode Frame No %d uncompressed size %d\n",
                                                                         muiFrameNumber, pAU->size);
                        UncompressedAudioFrame* wavFrame = new UncompressedAudioFrame(Frame::RAW_AUDIO);
                        wavFrame->setAU(pAU);
                        frmList.push_back(wavFrame);
                }
#ifndef WINCE
        }
#endif //wince
        return frmList;
}


list < Frame * >MP4audioDecoder::close() {
        list < Frame * >frmList;
        if (!initialized)
                return frmList;
        
        if (initialized) {
                DecoderClose((char **) (&mpDecoder));
                initialized = false;
        }
        
        return frmList;
}


Adaptor * MP4audioDecoder::clone()  {
        return new MP4audioDecoder(es,enableSwitching,meCoder);
}


bool MP4audioDecoder::parseMPEGaudioHeader(u8 * pFrame, u32 iSize) {
        initializeMPEGaudioHeaderStruct();
        initializeParser((u8 *) pFrame, iSize);
        
        int offset = 0; 
        if (getBits(11) == 0x07FF)
                {
                mp4AudioHeader.frame_sync = 0x07FF;
                mp4AudioHeader.mpeg_audio_version_ID = (MpegAudioVersionID)getBits(2);
                mp4AudioHeader.mpeg_audio_layer_no = (MpegAudioLayerNo)getBits(2);
                mp4AudioHeader.protection = getBits(1);
                switch(mp4AudioHeader.mpeg_audio_version_ID) {
                case MPEG_VERSION_2:
                        switch(mp4AudioHeader.mpeg_audio_layer_no) {
                        case LAYER_III: 
                        case LAYER_II : offset = 64; break;
                        case LAYER_I  : offset = 48; break;
                        default       : offset = 64; 
                        };
                        break;
                case MPEG_VERSION_1:
                        switch(mp4AudioHeader.mpeg_audio_layer_no) {
                        case LAYER_III: offset = 32; break;
                        case LAYER_II : offset = 16; break;
                        case LAYER_I  : offset = 0;  break;
                        default       : offset = 32; 
                        };
                        break;
                default: offset = 64;
                };
                mp4AudioHeader.bitrate = mp4AudioHeader.mpeg_audio_bitrate_index_table[offset + getBits(4)];
                switch(mp4AudioHeader.mpeg_audio_version_ID) {
                case MPEG_VERSION_2:
                        offset = 4; break;
                case MPEG_VERSION_1:
                        offset = 0; break;
                case MPEG_VESION_2_5:
                        offset = 8; break;
                default: offset = 4;
                };
                mp4AudioHeader.sampling_rate = mp4AudioHeader.mpeg_audio_sampling_rate_index_table[offset + getBits(2)];
                mp4AudioHeader.padding = getBits(1);
                mp4AudioHeader.private_bit = getBits(1);
                mp4AudioHeader.channel_mod = (ChannelMod)getBits(2);
                mp4AudioHeader.mode_extension = getBits(2);
                mp4AudioHeader.copyright = getBits(1);
                mp4AudioHeader.original = getBits(1);
                mp4AudioHeader.emphasis = (Emphasis)getBits(2);
                
                switch(mp4AudioHeader.mpeg_audio_layer_no) {
                case LAYER_I  :
                        mp4AudioHeader.frame_size_in_bytes = (12 * mp4AudioHeader.bitrate*1000 / mp4AudioHeader.sampling_rate + mp4AudioHeader.padding) * 4;
                        break;
                case LAYER_II :
                case LAYER_III: 
                        mp4AudioHeader.frame_size_in_bytes = 144 * mp4AudioHeader.bitrate*1000 / mp4AudioHeader.sampling_rate + mp4AudioHeader.padding;
                        break;
                default: 
                        mp4AudioHeader.frame_size_in_bytes = 418;
                };
                
                }
        else
                {
                        return false;
                }
        return true;
}


void MP4audioDecoder::initializeParser(u8 * pFrame, u32 iSize) {
        mcByte = 0;
        if (pFrame != NULL) {
                mpcData = pFrame;
                miSize = iSize;
                
                /*
                        u8 * bla = new u8[miSize*2+1];
                        ISOMP4ContainerFile::encodeDecoderConfig(bla, mpcData, miSize);
                        dprintf("---Decoder  %s\n", bla);
                        fflush(stdout);
                        fflush(stderr);
                */
        } else {
                mpcData = NULL;
                miSize = 0;
        }
        mbEOD = false;
        miCurrentNoBytes = 0;
        miCurrentBit = -1;
}


void MP4audioDecoder::initializeMPEGaudioHeaderStruct() {
        unsigned int mpeg_audio_bitrate_index_table[80] = {
                1,32,64,96,128,160,192,224,256,288,320,352,384,416,448,0,
                1,32,48,56,64,80,96,112,128,160,192,224,256,320,384,0,
                1,32,40,48,56,64,80,96,112,128,160,192,224,256,320,0,
                1,32,48,56,64,80,96,112,128,144,160,176,192,224,256,0,
                1,8,16,24,32,40,48,56,64,80,96,112,128,144,160,0
        };

        /*
        unsigned int mpeg_audio_bitrate_index_table[80] = {
                1,   1,   1,   1,   1,
                32,  32,  32,  32,  8,
                64,  48,  40,  48,  16,
                96,  56,  48,  56,  24,
                128, 64,  56,  64,  32,
                160, 80,  64,  80,  40,
                192, 96,  80,  96,  48,
                224, 112, 96,  112, 56,
                256, 128, 112, 128, 64,
                288, 160, 128, 144, 80,
                320, 192, 160, 160, 96,
                352, 224, 192, 176, 112,
                384, 256, 224, 192, 128,
                416, 320, 256, 224, 144,
                448, 384, 320, 256, 160,
                0,   0,   0,   0,   0 

        };
*/

        unsigned int mpeg_audio_sampling_rate_index_table[12] = {
                44100, 48000, 32000, 0,
                22050, 24000, 16000, 0,
                11025, 12000, 8000, 0
        };

        /*      unsigned int mpeg_audio_sampling_rate_index_table[12] = {
                                44100, 22050, 11025,
                                48000, 24000, 12000,
                                32000, 16000, 8000,
                                0,     0,     0
                                };
        */      

        mp4AudioHeader.frame_sync = 0;
        mp4AudioHeader.mpeg_audio_version_ID = MPEG_VERSION_2;
        mp4AudioHeader.mpeg_audio_layer_no = LAYER_III;
        mp4AudioHeader.protection = 1;
        mp4AudioHeader.bitrate = 0;
        mp4AudioHeader.sampling_rate = 44100;
        mp4AudioHeader.padding = 0;
        mp4AudioHeader.frame_size_in_bytes = 0;
        mp4AudioHeader.private_bit = 0;
        mp4AudioHeader.channel_mod = STEREO;
        mp4AudioHeader.mode_extension = 0; 
        mp4AudioHeader.copyright =  0;
        mp4AudioHeader.original = 0; 
        mp4AudioHeader.emphasis = NONE_;

        memcpy(mp4AudioHeader.mpeg_audio_bitrate_index_table, mpeg_audio_bitrate_index_table,
                                 sizeof(mp4AudioHeader.mpeg_audio_bitrate_index_table));
        memcpy(mp4AudioHeader.mpeg_audio_sampling_rate_index_table, mpeg_audio_sampling_rate_index_table,
                                 sizeof(mp4AudioHeader.mpeg_audio_sampling_rate_index_table));
}


void MP4audioDecoder::nextByte() {
        mcByte = mpcData[miCurrentNoBytes];
        miCurrentBit = 7;
        miCurrentNoBytes++;
        if (miCurrentNoBytes > miSize)
                mbEOD = true;
}


bool MP4audioDecoder::bytealigned() {
        if (miCurrentBit == 7)
                return true;
        else {
                nextByte();
                return true;
        }
}


int MP4audioDecoder::getBit() {
        int ret = 0;
        if (miCurrentBit == -1)
                nextByte();
        ret = (mcByte >> miCurrentBit) & 0x01;
        miCurrentBit--;
        if (mbEOD == false)
                return ret;
        
        else
                return EOF;
}


int MP4audioDecoder::getBits(int iNumber) {
        int ret = 0;
        int i;
        for (i = 0; i < iNumber; i++)
                ret = (ret << 1) | getBit();
        if (mbEOD == false)
                return ret;
        
        else
                return EOF;
}


int MP4audioDecoder::nextBits(int noBits) {
        int ret = 0;
        bookmark();
        ret = getBits(32);
        restore();
        if (mbEOD == false)
                return ret;
        
        else
                return EOF;
}


void MP4audioDecoder::nextStartCode() {
        while (!bytealigned())
                getBit();
}


void MP4audioDecoder::loadQuantizerMatrix(unsigned int puiMatrix[]) {
        int i;                  // row counter
        int j;                  // column counter
        int lastValue = 0;
        bool readLastValue = false;
        for (i = 0; i < 8; i++) {
                for (j = 0; j < 8; j++) {
                        if (!readLastValue)     {
                                puiMatrix[j + i * 8] = getBits(8);
                                if (puiMatrix[j + i * 8] == 0)
                                        readLastValue = true;
                                else
                                        lastValue = puiMatrix[j + i * 8];
                        }
                        else
                                puiMatrix[j + i * 8] = lastValue;
                }
        }
}


void MP4audioDecoder::readMarkerBitFunc(int iLine) {
        if (getBit() != 1) {
                dprintf_small("Marker bit invalid at line %d\n", iLine);
        }
}


void MP4audioDecoder::bookmark() {
        miBookmarkedCurrentBit = miCurrentBit;
        miBookmarkedByte = mcByte;
        miBookmarkedCurrentNoBytes = miCurrentNoBytes;
}


void MP4audioDecoder::restore() {
        miCurrentBit = miBookmarkedCurrentBit;
        mcByte = miBookmarkedByte;
        miCurrentNoBytes = miBookmarkedCurrentNoBytes;
}


void MP4audioDecoder::setCoderType(MP4audioDecoder::eCoderType coderType) {
        meCoder = coderType;
}


void MP4audioDecoder::DecoderClose(char **pDecoderHandle) {
        switch (meCoder) {
        case (MP4audioDecoder::XVID):
#ifndef WINCE
        case (MP4audioDecoder::FFMPEG):
                FFMPEGaudioDecoderClose(pDecoderHandle);
                break;
#endif
        default:
                dprintf_err("Invalid Coder selected\n");
                break;
        }
}


void MP4audioDecoder::DecoderInit(char **pDecoderHandle, CodecID codecID) {
        switch (meCoder) {
        case (MP4audioDecoder::XVID):
#ifndef WINCE
        case (MP4audioDecoder::FFMPEG):
                FFMPEGaudioDecoderInit(pDecoderHandle, codecID);
                break;
#endif
        default:
                dprintf_err("Invalid Coder selected\n");
        }
}


int MP4audioDecoder::DecodeFrame(char *pDecoderHandle, char *pCompressedFrame, 
                                int iCFSize, char* PCMFrame, u32 *mFrameSize) {
        int ret = 0;
        switch (meCoder) {
        case (MP4audioDecoder::XVID):
#ifndef WINCE
        case (MP4audioDecoder::FFMPEG):
                dprintf_full("Audio Decoding : using FFMPEG\n");
                ret = FFMPEGaudioDecodeFrame(pDecoderHandle, pCompressedFrame, iCFSize, 
                                                                                                                                 PCMFrame, (int*)mFrameSize);
                break;
#endif
        default:
                dprintf_err("Invalid Coder selected\n");
        }
        return ret;
}

© ViTooKi 2003 :: [Lite version] Created with Doxygen