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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MP3Parser.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: MP3Parser.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 "MP3Parser.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
        */
}

MP3Parser::MP3Parser() {
}


MP3Parser::~MP3Parser() {
}


structMPEGaudioHeader MP3Parser::parseMPEGaudioHeader(u8 * pFrame, u32 iSize) {
    initializeMPEGaudioHeaderStruct();
    initializeParser((u8 *) pFrame, iSize);
        
    int offset = 0, num_channels = 2;
    if (getBits(11) == 0x07FF)
        {
                mp3Header.frame_sync = 0x07FF;
                mp3Header.mpeg_audio_version_ID = (MpegAudioVersionID)getBits(2);
                mp3Header.mpeg_audio_layer_no = (MpegAudioLayerNo)getBits(2);
                mp3Header.protection = getBits(1);
                switch(mp3Header.mpeg_audio_version_ID) {
                        case MPEG_VERSION_2:
                                switch(mp3Header.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(mp3Header.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;
                };
                mp3Header.bitrate = mp3Header.mpeg_audio_bitrate_index_table[offset + getBits(4)];
                switch(mp3Header.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;
                };
                mp3Header.sampling_rate = mp3Header.mpeg_audio_sampling_rate_index_table[offset + getBits(2)];
                mp3Header.padding = getBits(1);
                mp3Header.private_bit = getBits(1);
                mp3Header.channel_mod = (ChannelMod)getBits(2);
                mp3Header.mode_extension = getBits(2);
                mp3Header.copyright = getBits(1);
                mp3Header.original = getBits(1);
                mp3Header.emphasis = (Emphasis)getBits(2);

                switch(mp3Header.mpeg_audio_layer_no) {
                        case LAYER_I  :
                                mp3Header.frame_size_in_bytes = (12 * mp3Header.bitrate*1000 / mp3Header.sampling_rate + mp3Header.padding) * 4;
                        break;
                        case LAYER_II :
                        case LAYER_III: 
                                mp3Header.frame_size_in_bytes = 144 * mp3Header.bitrate*1000 / mp3Header.sampling_rate + mp3Header.padding;
                                break;
                        default: 
                                mp3Header.frame_size_in_bytes = 418;
                };
                
                if(mp3Header.channel_mod == 3)
                        num_channels = 1;
                else
                        num_channels = 2;
                /* bits per sample is calculated as:
                 * (uncompressed frame_size_in_bits)/(num of samples per frame*num_channels);
                 * where frame_size_in_bits = 4608*8 for each wav frame
                 */
                switch(mp3Header.mpeg_audio_version_ID) {
                        case MPEG_VERSION_2:
                                switch(mp3Header.mpeg_audio_layer_no) {
                                        case LAYER_III: mp3Header.frame_duration = (576*90000)/mp3Header.sampling_rate;
                                                        mp3Header.bits_per_sample = (36864)/(576*num_channels); break;
                                        case LAYER_II : mp3Header.frame_duration = (1152*90000)/mp3Header.sampling_rate;
                                                        mp3Header.bits_per_sample = (36864)/(1152*num_channels); break;
                                        case LAYER_I  : mp3Header.frame_duration = (192*90000)/mp3Header.sampling_rate;
                                                        mp3Header.bits_per_sample = (36864)/(192*num_channels); break;
                                        default       : mp3Header.frame_duration = (576*90000)/mp3Header.sampling_rate;
                                                        mp3Header.bits_per_sample = (36864)/(576*num_channels); break;
                                };
                                break;
                        case MPEG_VERSION_1:
                                switch(mp3Header.mpeg_audio_layer_no) {
                                        case LAYER_III: mp3Header.frame_duration = (1152*90000)/mp3Header.sampling_rate;
                                                        mp3Header.bits_per_sample = (36864)/(1152*num_channels); break;
                                        case LAYER_II : mp3Header.frame_duration = (1152*90000)/mp3Header.sampling_rate;
                                                        mp3Header.bits_per_sample = (36864)/(1152*num_channels); break;
                                        case LAYER_I  : mp3Header.frame_duration = (384*90000)/mp3Header.sampling_rate;
                                                        mp3Header.bits_per_sample = (36864)/(384*num_channels); break;
                                        default       : mp3Header.frame_duration = (1152*90000)/mp3Header.sampling_rate;
                                                        mp3Header.bits_per_sample = (36864)/(1152*num_channels); break;
                                };
                                break;
                        default: mp3Header.frame_duration = (1152*90000)/mp3Header.sampling_rate; break;
                                 mp3Header.bits_per_sample = (36864)/(1152*num_channels); break;
                };
                

        }
    else
        {
                return mp3Header;
        }
    return mp3Header;
}


void MP3Parser::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 MP3Parser::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_sampling_rate_index_table[12] = {
                44100, 48000, 32000, 0,
                22050, 24000, 16000, 0,
                11025, 12000, 8000, 0
        };
        
        mp3Header.frame_sync = 0;
        mp3Header.mpeg_audio_version_ID = MPEG_VERSION_2;
        mp3Header.mpeg_audio_layer_no = LAYER_III;
        mp3Header.protection = 1;
        mp3Header.bitrate = 0;
        mp3Header.sampling_rate = 44100;
        mp3Header.padding = 0;
        mp3Header.frame_size_in_bytes = 0;
        mp3Header.private_bit = 0;
        mp3Header.channel_mod = STEREO;
        mp3Header.mode_extension = 0; 
        mp3Header.copyright =  0;
        mp3Header.original = 0; 
        mp3Header.emphasis = NONE_;
        mp3Header.bits_per_sample = 16;
        
        memcpy(mp3Header.mpeg_audio_bitrate_index_table, mpeg_audio_bitrate_index_table,
                                 sizeof(mp3Header.mpeg_audio_bitrate_index_table));
        memcpy(mp3Header.mpeg_audio_sampling_rate_index_table, mpeg_audio_sampling_rate_index_table,
                                 sizeof(mp3Header.mpeg_audio_sampling_rate_index_table));
}


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


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


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


int MP3Parser::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 MP3Parser::nextBits(int noBits) {
    int ret = 0;
    bookmark();
    ret = getBits(32);
    restore();
    if (mbEOD == false)
                return ret;
    
    else
                return EOF;
}


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


void MP3Parser::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 MP3Parser::readMarkerBitFunc(int iLine) {
    if (getBit() != 1)
        {
                dprintf_small("Marker bit invalid at line %d\n", iLine);
        }
}


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


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

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