OStreamAudioEncoder.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 <string.h>
#include <stdlib.h>
#include "OStreamAudioEncoder.hh"


OStreamAudioEncoder::OStreamAudioEncoder( unsigned int io_buf_size, ostream_encoding_type encoding_type,
                                                                                 int num_channels /* = 2 */ ) :
                                                                        _internal_buffer_size( io_buf_size ),
                                                                        _encoding_type( encoding_type ),
                                                                        _num_channels( num_channels )
{
        _initialized = false;
        if ( io_buf_size <= 1 ) {
                DEBUG_PRINT ("io_buf_size is wrong\n.");
                return;
        }
        
        // allocate the internal buffer
        _internal_buffer = new unsigned char[_internal_buffer_size];

        _ready_to_encode_frame = NULL;
        if ( encoder_initialize () == true ) {
                _initialized = true;
        }
}

OStreamAudioEncoder::~OStreamAudioEncoder ()
{
        if ( _internal_buffer )
                delete _internal_buffer;

        if ( _ready_to_encode_frame )
                free( _ready_to_encode_frame );

        free_pcm_buffer ();
        av_close_input_file( _out_fmt_context );
// FIXME
// etc
//              avcodec_close(c);
//              av_free(c);

}



bool OStreamAudioEncoder::open_codec( AVStream *stream )
{
    AVCodec *codec;
    AVCodecContext *codec_context;

    codec_context = stream->codec;

    // NB: codec = AVCodec
    codec = avcodec_find_encoder( codec_context->codec_id );
    if ( !codec ) {
        DEBUG_PRINT ("codec not found\n");
                return false;
    }

    // lets open the codec
    if ( avcodec_open( codec_context, codec ) < 0 ) {
                return false;
    }
        
        return true;
}


AVStream* OStreamAudioEncoder::create_audio_stream( AVFormatContext *io_fmt_context, int codec_id )
{
    AVCodecContext *codec_context;
    AVStream *stream;

        // create a new stream given AVFormatContext [which in this case is set to
        // output]
        // With this call it's allocated also c = st->codec, the codec_context
    stream = av_new_stream( io_fmt_context, 0 );
    if ( !stream ) {
        DEBUG_PRINT ("Could not alloc stream\n");
                return NULL;
    }

    // AVCodecContext is a member of AVStream!
    // now we'll setup the parameters of AVCodecContext
    codec_context = stream->codec;
    codec_context->codec_id = (CodecID)codec_id;
    codec_context->codec_type = CODEC_TYPE_AUDIO;

    codec_context->bit_rate = 64000;
    codec_context->sample_rate = 44100;
    codec_context->channels = _num_channels;

    return stream;
}

bool OStreamAudioEncoder::encoder_initialize ()
{
        char *encoding_str;
        // register all codecs
        av_register_all();

        
        // initialize a circular bufffer. This will contain pcm_s16le data.
        if ( init_pcm_buffer( 2 * MAX_AUDIO_PACKET_SIZE ) == false )
                return false;
        
        
        switch ( _encoding_type ) {
                case OSTREAM_ENCODING_MP3:
                        encoding_str = "mp3";
                        _out_fmt = guess_format ( encoding_str, NULL, NULL);

                        if( !_out_fmt ) {
                                DEBUG_PRINT( "Could not find suitable output format.\n");
                                return false;
                        }
                        break;

                default:
                        DEBUG_PRINT ("could not find known OSTREAM_ENCODING type.\n" );
                        break;
        }

        _out_fmt_context = av_alloc_format_context ();
        if( !_out_fmt_context ) {
                DEBUG_PRINT( "Memory error.\n" );
                return false;
        }

        // set output format of AVFormatContext
        _out_fmt_context->oformat = _out_fmt;

        // check if we had a correct video_codec 
    if ( _out_fmt->audio_codec == CODEC_ID_NONE ) {
        DEBUG_PRINT( "CODEC_ID_NONE\n" );
                return false;
        }

        // add the stream
        if(!( _audio_stream = create_audio_stream( _out_fmt_context, _out_fmt->audio_codec ) )) {
                DEBUG_PRINT( "error in adding stream\n" );
                return false;
        }

    // set the output parameters (must be done even if no parameters)
    if ( av_set_parameters( _out_fmt_context, NULL ) < 0 ) {
        DEBUG_PRINT( "Invalid output format parameters\n" );
        return false;
    }

        // open codec associated with current video_stream
        if ( !open_codec( _audio_stream ) ) {
        DEBUG_PRINT( "could not open codec\n" );                
                return false;
        }

        // set the frame size
        _frame_size = _audio_stream->codec->frame_size;
        
        // and the encoded size
        _encoded_frame_size = _frame_size * 2 * _num_channels;  
        _ready_to_encode_frame = (unsigned char*) calloc( _encoded_frame_size, sizeof(unsigned char) );
        
        return true;
}

const unsigned char* OStreamAudioEncoder::encode_audio_frame( unsigned char* in_pcm_buffer, 
                                                                                                                         int in_pcm_buffer_size, int *out_size )
{
    AVCodecContext *codec_context;      

        *out_size = 0;
        
        if ( in_pcm_buffer  == NULL )
                return NULL;
        
        if ( !_initialized ) {
                DEBUG_PRINT( "initializing class failed.\n" );
                return NULL;
        }

        // we need to add the pcm_data to the _pcm_internal_buffer. We will then read back 
        // a good _frame_size frame of data. Infact we can encode only on right data size,
        // otherwise we will have broken encoded audio data. Three days to discover this... -_-
        write_pcm_buffer ( in_pcm_buffer, in_pcm_buffer_size );

        if ( _ready_to_encode_frame == NULL )  {
                DEBUG_PRINT( "_ready_to_encode_frame == NULL\n");
                return NULL;
        }
        
        // ok, read back a _encoded_frame_size frame
        read_pcm_buffer( _ready_to_encode_frame, _encoded_frame_size );

        if( in_pcm_buffer_size > _internal_buffer_size ) {
                DEBUG_PRINT( "in_buffer_size too big\n" );
                return NULL;
        }
        
        codec_context = _audio_stream->codec;
                
        *out_size = avcodec_encode_audio( codec_context, _internal_buffer, in_pcm_buffer_size, (short*)_ready_to_encode_frame );
        
        return _internal_buffer;
}



bool OStreamAudioEncoder::init_pcm_buffer ( int size )
{
    _pcm_internal_buffer = (unsigned char*)calloc( size, sizeof(unsigned char) );
    
        if (!_pcm_internal_buffer)
        return false;
        
    _pcm_end_ptr =  _pcm_internal_buffer + size;
    _pcm_write_ptr = _pcm_read_ptr = _pcm_internal_buffer;
        
    return true;                
}

void OStreamAudioEncoder::free_pcm_buffer ()
{
        if ( _pcm_internal_buffer != NULL )
                free( _pcm_internal_buffer );
}

int OStreamAudioEncoder::read_pcm_buffer( unsigned char *buf, int buf_size )
{
    int len;
    int size = _pcm_write_ptr - _pcm_read_ptr;
    if (size < 0)
        size += _pcm_end_ptr - _pcm_internal_buffer;

    if (size < buf_size)
        return -1;
        
    while (buf_size > 0) {
        len = ( _pcm_end_ptr - _pcm_read_ptr ) > ( buf_size ) ? 
                        ( buf_size ) : ( _pcm_end_ptr - _pcm_read_ptr );
                
        memcpy( buf, _pcm_read_ptr, len );
        buf += len;
        _pcm_read_ptr += len;
                
        if ( _pcm_read_ptr >= _pcm_end_ptr )
            _pcm_read_ptr = _pcm_internal_buffer;
                
        buf_size -= len;
    }
        
    return 0;
}


void OStreamAudioEncoder::write_pcm_buffer( const unsigned char *buf, int size )
{
    int len;

    while (size > 0) {
        len = ( _pcm_end_ptr - _pcm_write_ptr ) > ( size ) ? 
                        ( size ) : ( _pcm_end_ptr - _pcm_write_ptr );

        memcpy( _pcm_write_ptr, buf, len );
        _pcm_write_ptr += len;
                
        if ( _pcm_write_ptr >= _pcm_end_ptr )
            _pcm_write_ptr = _pcm_internal_buffer;
        buf += len;
        size -= len;
    }
}

---