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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MadMP3Decoder.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: MadMP3Decoder.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 "MadMP3Decoder.hpp"
#include "Frame.hpp"
#include "UncompressedAudioFrame.hpp"


MadMP3Decoder::MadMP3Decoder(AudioESInfo* es) {

        this->es = es;
        strcpy(name,"MadMP3Decoder");
        FrameCount = 0;
        Status = 0;
        initialized = false;
        lastTS=0;
        inputBuffer = new unsigned char[MAD_INPUT_BUFFER_SIZE + MAD_BUFFER_GUARD];
}


MadMP3Decoder::~MadMP3Decoder() {
        if (initialized) {
                mad_synth_finish(&Synth);
                mad_frame_finish(&madFrame);
                mad_stream_finish(&Stream);
        }
        delete [] inputBuffer;
}


void MadMP3Decoder::initialize() {
        /* First the structures used by libmad must be initialized. */
        mad_stream_init(&Stream);
        mad_frame_init(&madFrame);
        mad_synth_init(&Synth);
#ifndef WINCE
        mad_timer_reset(&Timer);
#endif
        
        guardPtr = NULL;
        
        initialized=true;
        numInFrames = 0;
}



/***************************************************************/
list < Frame * > MadMP3Decoder::adapt(Frame * frm) {
        list < Frame * >tmp;
        u32 thisCTS;
        int thisSec;

        //initialize decoder
        if (numInFrames == 0) {
                initialize();
        }

        if (frm->getAU() == NULL) return tmp;
        
        thisCTS = frm->getAU()->cts;
        thisSec = (int)floor((double)thisCTS / es->getMediaTimeScale());
        dprintf_full("MadMP3Decoder::adapt frame %i (size %i) CTS %i, VOP increment %i, samplerate %i Hz Channels: %i\n", numInFrames, frm->getAU()->size, thisCTS, es->getVOPTimeIncrement(), es->getSampleRate(), es->getAudioChannels());

        numInFrames++;

        //FIXME: assert(isAudioFrame)

        assert(Stream.buffer==NULL || Stream.error==MAD_ERROR_BUFLEN);

        if(Stream.buffer==NULL || Stream.error==MAD_ERROR_BUFLEN) {
                size_t  ReadSize,       Remaining;
                unsigned char   *ReadStart;
                
                if(Stream.next_frame!=NULL)     {
                        Remaining = Stream.bufend - Stream.next_frame;
                        //dprintf_full("MadMP3Decoder::adapt ... pre-pend old data %i bytes (bufsize %i  offs %i)\n",Remaining, Stream.bufend - inputBuffer, Stream.next_frame - inputBuffer);
                        memmove(inputBuffer, Stream.next_frame, Remaining); //move to beginning
                        ReadStart = inputBuffer+Remaining; //add new data behind old data
                        ReadSize = MAD_INPUT_BUFFER_SIZE - Remaining; //space left
                }
                else {
                        ReadSize = MAD_INPUT_BUFFER_SIZE;
                        ReadStart = inputBuffer;
                        Remaining = 0;
                }
                //dprintf_full("MadMP3Decoder::adapt ... adding incoming frame to decoding buffer (adding %i bytes)\n",frm->getAU()->size);
                assert( frm->getAU()->size <= ReadSize);
                memcpy(ReadStart, frm->getAU()->payload, frm->getAU()->size);
                ReadSize = (size_t)frm->getAU()->size;
                
                if(0==1 /* EOF */) {
                        dprintf_full("MadMP3Decoder::adapt ... adding guard 8 zero bytes\n");
                        guardPtr=ReadStart+ReadSize;
                        memset(guardPtr,0,MAD_BUFFER_GUARD);
                        ReadSize+=MAD_BUFFER_GUARD;
                }
                
                /* Pipe the new buffer content to libmad's stream decoder
                 * facility.
                 */
                mad_stream_buffer(&Stream, inputBuffer, ReadSize+Remaining);
                Stream.error=MAD_ERROR_NONE;
        }


        lastTS = thisCTS;
        pAU = new AU(frm->getAU());
        pAU->cts = pAU->dts = lastTS; //we are always a little behind...
        //lastTS += (u32)((es->getMediaTimeScale()/(float)es->getSampleRate())*Synth.pcm.length);
        pAU->size = 0;
        u8 *outputBuffer = NULL;

        do {
                //dprintf_full("MadMP3Decoder::adapt ...decoding lastBufSize %i offs %i)\n",Stream.bufend - inputBuffer, Stream.next_frame - inputBuffer);

                if(mad_frame_decode(&madFrame, &Stream)) {
                        if(MAD_RECOVERABLE(Stream.error))       {
                                /* Do not print a message if the error is a loss of
                                 * synchronization and this loss is due to the end of
                                 * stream guard bytes. (See the comments marked {3}
                                 * supra for more informations about guard bytes.)
                                 */
                                if((Stream.error!=MAD_ERROR_LOSTSYNC) || (Stream.this_frame!=guardPtr)) {
                                        dprintf_err("MadMP3Decoder::adapt: recoverable frame level error (%s) at offs %i\n",mad_stream_errorstr(&Stream),Stream.next_frame-inputBuffer);
                                }
                                //lastTS += (u32)((es->getMediaTimeScale()/(float)es->getSampleRate())*1152);
                                continue;
                        }
                        else
                                if(Stream.error==MAD_ERROR_BUFLEN) {
                                        //this is not serious, just not enough data.... going into next round....

                                        //dprintf_err("MadMP3Decoder::adapt: recoverable frame level error BUFLEN (%s) at offs %i\n",mad_stream_errorstr(&Stream),Stream.next_frame-inputBuffer);
                                        break;
                                } else
                                        {
                                                dprintf_err("MadMP3Decoder::adapt: unrecoverable frame level error (%s).\n",mad_stream_errorstr(&Stream));
                                                Status=1;
                                                ::exit(1);
                                        }
                }
                
                
                if(FrameCount==0) //the first is representative for all other frames
                        PrintFrameInfo(&madFrame.header);
                        
                FrameCount++;
#ifndef WINCE
                mad_timer_add(&Timer,madFrame.header.duration);
#endif
                mad_synth_frame(&Synth,&madFrame);
                
                //dprintf_full("MadMP3Decoder::adapt sampling %i raw pcm samples\n", Synth.pcm.length);

                //DO NOT SEND 1st FRAME (the header) to the audio-output
#ifdef WINCE
                if (FrameCount == 1) {
                                outputBuffer = NULL;
                } else {
#endif
                        
                        u32 numChannels = es->getAudioChannels();
                        pAU->size += Synth.pcm.length * 2 * numChannels;  //if it's 16bit stereo --> * 4
                        outputBuffer = (u8*)realloc(outputBuffer, pAU->size); //get more space, if necessary
                        pAU->payload = outputBuffer;
                        u8  *outputPtr = outputBuffer + pAU->size - Synth.pcm.length * 2 * numChannels; // begin of new block

                        for(int i=0;i<Synth.pcm.length;i++)     {
                                signed short    Sample;
                                
                                /* Left channel */
                                Sample=MadFixedToSshort(Synth.pcm.samples[0][i]);
                                *(outputPtr++)=Sample&0xff;  //little endian, so toggle
                                *(outputPtr++)=Sample>>8;
                                
                                if (numChannels == 2) { //stereo
                                        /* Right channel. If the decoded stream is monophonic then
                                         * the right output channel is the same as the left one.
                                         */
                                        if(MAD_NCHANNELS(&madFrame.header)==2)
                                                Sample=MadFixedToSshort(Synth.pcm.samples[1][i]);
                                        *(outputPtr++)=Sample&0xff; //little endian, so toggle
                                        *(outputPtr++)=Sample>>8;
                                }
                        }
#ifdef WINCE
                }
#endif

        } while(1);


        if (outputBuffer) {
                dprintf_full("MadMP3Decoder::adapt got full decoded (raw pcm) frame number %li (CTS %i) size %i bytes!\n", FrameCount, pAU->cts, pAU->size);
                UncompressedAudioFrame * decFrame = new UncompressedAudioFrame(Frame::RAW_AUDIO);
                decFrame->setAU(pAU);
                decFrame->setMediaTimeScale(frm->getMediaTimeScale());
                tmp.push_back(decFrame);
        }
        return tmp;
}


/****************************************************************************
 * Converts a sample from libmad's fixed point number format to a signed        *
 * short (16 bits).                                                                                                                     *
 ****************************************************************************/
signed short MadMP3Decoder::MadFixedToSshort(mad_fixed_t Fixed) {
        /* A fixed point number is formed of the following bit pattern:
         *
         * SWWWFFFFFFFFFFFFFFFFFFFFFFFFFFFF
         * MSB                          LSB
         * S ==> Sign (0 is positive, 1 is negative)
         * W ==> Whole part bits
         * F ==> Fractional part bits
         *
         * This pattern contains MAD_F_FRACBITS fractional bits, one
         * should alway use this macro when working on the bits of a fixed
         * point number. It is not guaranteed to be constant over the
         * different platforms supported by libmad.
         *
         * The signed short value is formed, after clipping, by the least
         * significant whole part bit, followed by the 15 most significant
         * fractional part bits. Warning: this is a quick and dirty way to
         * compute the 16-bit number, madplay includes much better
         * algorithms.
         */
        
        /* Clipping */
        if(Fixed>=MAD_F_ONE)
                return(SHRT_MAX);
        if(Fixed<=-MAD_F_ONE)
                return(-SHRT_MAX);
        
        /* Conversion. */
        Fixed=Fixed>>(MAD_F_FRACBITS-15);
        return((signed short)Fixed);
}


/****************************************************************************
 * Print human readable informations about an audio MPEG frame.                         *
 ****************************************************************************/
void MadMP3Decoder::PrintFrameInfo(struct mad_header *Header) {
        const char      *Layer,
                *Mode,
                *Emphasis;
        
        /* Convert the layer number to it's printed representation. */
        switch(Header->layer) {
        case MAD_LAYER_I:
                Layer="I";
                break;
        case MAD_LAYER_II:
                Layer="II";
                break;
        case MAD_LAYER_III:
                Layer="III";
                break;
        default:
                Layer="(unexpected layer value)";
                break;
        }
        
        /* Convert the audio mode to it's printed representation. */
        switch(Header->mode) {
        case MAD_MODE_SINGLE_CHANNEL:
                Mode="single channel";
                break;
        case MAD_MODE_DUAL_CHANNEL:
                Mode="dual channel";
                break;
        case MAD_MODE_JOINT_STEREO:
                Mode="joint (MS/intensity) stereo";
                break;
        case MAD_MODE_STEREO:
                Mode="normal LR stereo";
                break;
        default:
                Mode="(unexpected mode value)";
                break;
        }
        
        /* Convert the emphasis to it's printed representation. Note that
         * the MAD_EMPHASIS_RESERVED enumeration value appeared in libmad
         * version 0.15.0b.
         */
        switch(Header->emphasis) {
        case MAD_EMPHASIS_NONE:
                Emphasis="no";
                break;
        case MAD_EMPHASIS_50_15_US:
                Emphasis="50/15 us";
                break;
        case MAD_EMPHASIS_CCITT_J_17:
                Emphasis="CCITT J.17";
                break;
#if (MAD_VERSION_MAJOR>=1) ||                                                                                                   \
        ((MAD_VERSION_MAJOR==0) && (MAD_VERSION_MINOR>=15))
        case MAD_EMPHASIS_RESERVED:
                Emphasis="reserved(!)";
                break;
#endif
        default:
                Emphasis="(unexpected emphasis value)";
                break;
        }
        
        dprintf_full("MadMP3Decoder::PrintFrame %lu kb/s audio MPEG layer %s stream %s CRC, "
                                                         "%s with %s emphasis at %d Hz sample rate\n",
                                                         Header->bitrate,Layer,
                                                         Header->flags&MAD_FLAG_PROTECTION?"with":"without",
                                                         Mode,Emphasis,Header->samplerate);
        return;
}

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