MP3FromPCM.cpp

Go to the documentation of this file.

/*
 *  Copyright (C) Massimo Cora' 2006 <maxcvs@email.it>
 *
 *  This program 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 Library 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.
 */


#include "MP3FromPCM.hh"

#include <cv.h>
#include <highgui.h>




MP3FromPCM* MP3FromPCM::createNew( UsageEnvironment& env, FramedSource *audio_source ) 
{
        return new MP3FromPCM( env, audio_source );
}


MP3FromPCM::~MP3FromPCM ()
{
        
        if ( _audio_encoder )
                delete _audio_encoder;
        _audio_encoder = NULL;

        if ( _input_buffer )
                delete _input_buffer;
        _input_buffer = NULL;

        _initialized = false;
}

MP3FromPCM::MP3FromPCM( UsageEnvironment& env, FramedSource *audio_source ) : 
                                        FramedFilter( env, audio_source ),
                                        _audio_source( audio_source ),
                                        _input_buffer( NULL ),
                                        _input_buffer_size ( 0 )
{
        _initialized = false;
        _audio_encoder = new OStreamAudioEncoder( MAX_AUDIO_PACKET_SIZE * 4, OSTREAM_ENCODING_MP3 );

        if ( _audio_encoder != NULL )
                _initialized = true;
}

// Redefined virtual functions:
void MP3FromPCM::doGetNextFrame() 
{
        unsigned int bytes_to_read = AUDIO_BLOCK_SIZE;

        if ( bytes_to_read > _input_buffer_size ) {
        delete[] _input_buffer; 
                _input_buffer = new unsigned char[bytes_to_read];
        _input_buffer_size = bytes_to_read;
        }

        // be sure to give a clean buffer where to store the
        memset( _input_buffer, 0, _input_buffer_size );

        // Arrange to read samples into the input buffer:
        _audio_source->getNextFrame( _input_buffer, bytes_to_read,
                                                        afterGettingFrame, this, FramedSource::handleClosure, 
                                                                this);
}

void MP3FromPCM::afterGettingFrame(void* clientData, unsigned frameSize,
                                        unsigned numTruncatedBytes, struct timeval presentationTime,                                    
                                        unsigned durationInMicroseconds) 
{
        MP3FromPCM* klass = (MP3FromPCM*)clientData;
        klass->afterGettingFrame1( frameSize, numTruncatedBytes,
                                                                presentationTime, durationInMicroseconds );
}

void MP3FromPCM::afterGettingFrame1( unsigned frameSize, unsigned numTruncatedBytes,
                                                struct timeval presentationTime,  unsigned durationInMicroseconds)
{

        int encoded_frame_size;
        const unsigned char* encoded_frame;

        // encode the buffer
        encoded_frame = _audio_encoder->encode_audio_frame( _input_buffer, 
                                                                                _input_buffer_size, &encoded_frame_size );

        if ( (unsigned int) encoded_frame_size > fMaxSize ) {
                DEBUG_PRINT( "error: if ( encoded_frame_size > fMaxSize )\n");
        }

        memcpy( fTo, encoded_frame, encoded_frame_size );

        // Complete delivery to the client:
        fFrameSize = encoded_frame_size;
        fNumTruncatedBytes = numTruncatedBytes;
        fPresentationTime = presentationTime;
        fDurationInMicroseconds = durationInMicroseconds;
        afterGetting(this);
}


char const* MP3FromPCM::MIMEtype() const {
        return "audio/MPEG";
}

---