Without dynamic - mad-dev

6 Jun 2005


      Hi everyone,
After many tries I've finally succeed decoding a mp3 file. But now the 
sound seems whitout dynamic, I don't know if the problem is the function 
that I'm using to scale the samples or the routine that I've used to 
save it to a file (using libsndfile). Can anyone help me ?
Thank you !
Daniel
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mad.h"
#include "sndfile.h"
#define INPUT_BUFFER_SIZE 65535
struct private_data {
    	FILE			*file;
    	unsigned char	*inputBuffer;
    	int 			numChannels;
    	int				samplerate;
    	int				len;
    	float 			*sample;
    	int				icount,
    					ocount;
    	bool			firstRun;
    	void 			*userData; //nao sei pra que vai usar...
};
/* The MAD callbacks */
enum mad_flow input_cb (void *_data, struct mad_stream *stream);
enum mad_flow output_cb(void *_data, struct mad_header const *header, struct mad_pcm *pcm);
enum mad_flow error_cb (void *_data, struct mad_stream *stream, struct mad_frame *frame);
inline float scale(mad_fixed_t sample)
{
   return (float) (sample / (float) (1L << MAD_F_FRACBITS));
}
int main(){
    
    struct private_data mPrivateData;
    mad_decoder mDecoder;	
    int	chn;
    const char 	*filename="saida.wav";
    SF_INFO 	info;
    SNDFILE		*outfile;
    
       /* Prepare decoder data, initialize decoder */
    mPrivateData.len = 0;
    mPrivateData.file = fopen("weapon2.mp3","rb");
    mPrivateData.inputBuffer = new unsigned char [INPUT_BUFFER_SIZE];
    mPrivateData.numChannels = 0;
    mPrivateData.samplerate = 0;
    mPrivateData.icount = mPrivateData.ocount = 0;
    mPrivateData.firstRun = true;
mad_decoder_init(&mDecoder, &mPrivateData, input_cb, 0, 0, output_cb, error_cb, 0);
if(mad_decoder_run(&mDecoder, MAD_DECODER_MODE_SYNC) == 0)
    {
    	/* success */
    	printf("success\n"); 
    	//GRAVAR O ARQUIVO COM A SNDFILE
    	info.samplerate = mPrivateData.samplerate;
    	info.channels   = mPrivateData.numChannels;
//printf("Sample rate %d\n",info.samplerate);
    	//printf("Channels %d\n",info.channels);
//info.samplerate = 44100;
    	//info.channels   = 1;
    	info.format	    = 65538;
    	info.sections   = 1;
    	info.seekable   = 1;
    	info.frames 	= 0;
    	
    	outfile = sf_open(filename , SFM_WRITE , &info);
    	sf_write_float( outfile, mPrivateData.sample , mPrivateData.len) ;
    	sf_close(outfile);
    	
    	mad_decoder_finish(&mDecoder);
    	
    	
    	
    	/* copy the WaveTrack pointers into the Track pointer list that
    	 * we are expected to fill */
            //*outTracks = new Track* [mPrivateData.numChannels];
            //for(chn = 0; chn < mPrivateData.numChannels; chn++) {
    	//       mPrivateData.channels[chn]->Flush();
    	//        (*outTracks)[chn] = mPrivateData.channels[chn];
    	//}
    	//*outNumTracks = mPrivateData.numChannels;
            //delete mPrivateData.inputBuffer;
    	//delete[] mPrivateData.channels;
                //return true;
        }
    else {
/* failure */
           	printf("failure\n");
mad_decoder_finish(&mDecoder);
/* delete everything */
            //for(chn = 0; chn < mPrivateData.numChannels; chn++)
    	//	delete mPrivateData.channels[chn];
            //delete[] mPrivateData.channels;
    	//delete mPrivateData.inputBuffer;
            //return false;
       }
//mad_decoder_finish(&mDecoder);
/* delete everything */
    	//for(chn = 0; chn < mPrivateData.numChannels; chn++)
    	//delete mPrivateData.channels[chn];
    printf("Input %d   Output %d\n",mPrivateData.icount, mPrivateData.ocount);
    
       	delete mPrivateData.inputBuffer;
    fclose(mPrivateData.file);
    return(0);
}
//
//   MAD Callbacks
//
/* The input callback is called when the decoder wants more data. */
enum mad_flow input_cb(void *_data, struct mad_stream *stream)
{
   struct private_data *data = (struct private_data *)_data;
data->icount += 1;
if(feof(data->file)) 
      return MAD_FLOW_STOP;
/* "Each time you refill your buffer, you need to preserve the data in
    *  your existing buffer from stream.next_frame to the end.
    *
    *  This usually amounts to calling memmove() on this unconsumed portion
    *  of the buffer and appending new data after it, before calling
    *  mad_stream_buffer()"
    *           -- Rob Leslie, on the mad-dev mailing list */
unsigned int unconsumedBytes;
   if(stream->next_frame) {
      unconsumedBytes = data->inputBuffer + INPUT_BUFFER_SIZE - stream->next_frame;
      memmove(data->inputBuffer, stream->next_frame, unconsumedBytes);
   }
   else
      unconsumedBytes = 0;
//off_t read = data->file->Read(data->inputBuffer + unconsumedBytes,
    //                             IsNPUT_BUFFER_SIZE - unconsumedBytes);
//size_t Read(void* buffer, size_t count)
   int read = fread(data->inputBuffer + unconsumedBytes,
    				1, 
    				INPUT_BUFFER_SIZE - unconsumedBytes,
    				data->file);
mad_stream_buffer(stream, data->inputBuffer, read + unconsumedBytes);
return MAD_FLOW_CONTINUE;
}
/* The output callback is called every time the decoder has finished decoding
 * a frame, allowing us to use the decoded data */
enum mad_flow output_cb(void *_data,
                        struct mad_header const *header,
                        struct mad_pcm *pcm)
{
int		channels,
    		samplerate,
    		samples;
    struct	private_data *data = (struct private_data *)_data;
    int		chn,
    		smpl,
    		cont;
float	*bufferL,
    		*bufferR;
samplerate= pcm->samplerate;
    channels  = pcm->channels;
    samples   = pcm->length;
    
    if (data->firstRun){
    	data->numChannels = channels;
    	data->samplerate  = samplerate;	
    	data->firstRun = false;
    }
if(data->ocount == 0) 
    	data->sample = (float *) malloc(channels*samples*sizeof(float) );
    else
    	data->sample = (float *) realloc (data->sample , (data->len + samples)*sizeof(float)*channels );
data->ocount += 1;
if (!data->sample){
    	printf("NAo alocou memo\n");
    	exit(1);
    }
    	
    float *buffer = new float[channels*samples];
    
    if (channels == 1){
    	for(smpl = 0; smpl < samples; smpl++)
    		 buffer[smpl] = scale(pcm->samples[0][smpl]);
    }
if (channels == 2){
    	bufferL = new float[samples];
    	bufferR = new float[samples];
    	
    	for(smpl = 0; smpl < samples; smpl++){
    		 bufferL[smpl] = scale(pcm->samples[0][smpl]);
    		 bufferR[smpl] = scale(pcm->samples[1][smpl]);
    	}
//Interleaving
    	cont = 0; 
    	while (cont < samples){
    		buffer[cont] = bufferL[cont];
    		cont++;
    		buffer[cont] = bufferR[cont];
    		cont++;
    	}
    }
    
    
    memcpy(data->sample + data->len ,buffer ,channels*samples);
    data->len +=channels*samples;
if (channels == 2){
    	delete [] bufferL;	
    	delete [] bufferR;
    }
    delete [] buffer;
//Codigo para somente 1 canal
    
    /*if(data->ocount == 0) 
    	data->sample = (float *) malloc(samples*sizeof(float) );
    else
    	data->sample = (float *) realloc (data->sample , (data->len + samples)*sizeof(float) );
    data->ocount += 1;
if (!data->sample){
    	printf("NAo alocou memo\n");
    	exit(1);
    }
    	
    float *buffer = new float[samples];
    for(smpl = 0; smpl < samples; smpl++)
    		 buffer[smpl] = scale(pcm->samples[0][smpl]);
memcpy(data->sample + data->len ,buffer ,samples);
    data->len +=samples;*/
/* If this is the first run, we need to create the WaveTracks that
    * will hold the data.  We do this now because now is the first
    * moment when we know how many channels there are. */
/*
   if(!data->channels) {
      data->channels = new WaveTrack* [channels];
for(chn = 0; chn < channels; chn++) {
         data->channels[chn] = data->trackFactory->NewWaveTrack(floatSample);
         data->channels[chn]->SetRate(samplerate);
         data->channels[chn]->SetChannel(Track::MonoChannel);
      }
/* special case: 2 channels is understood to be stereo 
      if(channels == 2) {
         data->channels[0]->SetChannel(Track::LeftChannel);
         data->channels[1]->SetChannel(Track::RightChannel);
         data->channels[0]->SetLinked(true);
      }
      data->numChannels = channels;
   }
   else {  
      // This is not the first run, protect us from libmad glitching
      // on the number of channels
      channels = data->numChannels;
   }
*/
   /* TODO: get rid of this by adding fixed-point support to SampleFormat.
    * For now, we allocate temporary float buffers to convert the fixed
    * point samples into something we can feed to the WaveTrack.  Allocating
    * big blocks of data like this isn't a great idea, but it's temporary.*/
    /*   
   float **channelBuffers = new float* [channels];
   for(chn = 0; chn < channels; chn++)
      channelBuffers[chn] = new float [samples];
for(smpl = 0; smpl < samples; smpl++)
      for(chn = 0; chn < channels; chn++)
         channelBuffers[chn][smpl] = scale(pcm->samples[chn][smpl]);
for(chn = 0; chn < channels; chn++)
      data->channels[chn]->Append((samplePtr)channelBuffers[chn],
                                  floatSample,
                                  samples);
for(chn = 0; chn < channels; chn++)
      delete[] channelBuffers[chn];
   delete[] channelBuffers;
*/
   return MAD_FLOW_CONTINUE;
}
enum mad_flow error_cb(void *_data, struct mad_stream *stream, 
                       struct mad_frame *frame)
{
/* enum mad_flow {
     MAD_FLOW_CONTINUE = 0x0000,
     MAD_FLOW_STOP     = 0x0010,
     MAD_FLOW_BREAK    = 0x0011,
     MAD_FLOW_IGNORE   = 0x0020
   }; */
   /*
   printf("decoding error 0x%04x (%s)\n",
      stream->error, mad_stream_errorstr(stream));
   */
return MAD_FLOW_CONTINUE;
/* return MAD_FLOW_BREAK; */
}
No virus found in this outgoing message.
Checked by AVG Anti-Virus.
Version: 7.0.323 / Virus Database: 267.6.2 - Release Date: 4/6/2005