Beispiel #1
0
static void
alsa_play (int argc, char *argv [])
{	static float buffer [BUFFER_LEN] ;
	SNDFILE *sndfile ;
	SF_INFO sfinfo ;
	snd_pcm_t * alsa_dev ;
	int		k, readcount, subformat ;

	for (k = 1 ; k < argc ; k++)
	{	memset (&sfinfo, 0, sizeof (sfinfo)) ;

		printf ("Playing %s\n", argv [k]) ;
		if (! (sndfile = sf_open (argv [k], SFM_READ, &sfinfo)))
		{	puts (sf_strerror (NULL)) ;
			continue ;
			} ;

		if (sfinfo.channels < 1 || sfinfo.channels > 2)
		{	printf ("Error : channels = %d.\n", sfinfo.channels) ;
			continue ;
			} ;

		if ((alsa_dev = alsa_open (sfinfo.channels, (unsigned) sfinfo.samplerate, SF_FALSE)) == NULL)
			continue ;

		subformat = sfinfo.format & SF_FORMAT_SUBMASK ;

		if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
		{	double	scale ;
			int 	m ;

			sf_command (sndfile, SFC_CALC_SIGNAL_MAX, &scale, sizeof (scale)) ;
			if (scale < 1e-10)
				scale = 1.0 ;
			else
				scale = 32700.0 / scale ;

			while ((readcount = sf_read_float (sndfile, buffer, BUFFER_LEN)))
			{	for (m = 0 ; m < readcount ; m++)
					buffer [m] *= scale ;
				alsa_write_float (alsa_dev, buffer, BUFFER_LEN / sfinfo.channels, sfinfo.channels) ;
				} ;
			}
		else
		{	while ((readcount = sf_read_float (sndfile, buffer, BUFFER_LEN)))
				alsa_write_float (alsa_dev, buffer, BUFFER_LEN / sfinfo.channels, sfinfo.channels) ;
			} ;

		snd_pcm_drain (alsa_dev) ;
		snd_pcm_close (alsa_dev) ;

		sf_close (sndfile) ;
		} ;

	return ;
} /* alsa_play */
Beispiel #2
0
void IQFileAudioSource::getSamples(Ipp32f* samples_buf)
{
	int len = sf_read_float(_f, samples_buf, 2*_nsamples);
	if(len == 0)
	{
		sf_seek(_f, 0, SEEK_SET);
		len = sf_read_float(_f, samples_buf, _nsamples);
		if(!_loop)	
			_done = true;
	}
	usleep(_block_delay);
}
Beispiel #3
0
std::vector<fpoint> get_samples_from_file(std::string filename)
{
    const int BUFFER_LEN = 1024;
    static float data[BUFFER_LEN];
    std::vector<fpoint> out;

    SNDFILE *infile;
    SF_INFO sfinfo;
    sfinfo.channels = 1;
    sfinfo.samplerate = Fs;
    sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_FLOAT;

    int readcount;

    filename.insert(0, "samples/");
    filename.append(".wav");

    if (! (infile = sf_open(filename.c_str(), SFM_READ, &sfinfo)))
    {
        std::cout << "no file named " << filename << std::endl;
        return out;
    }

    while ((readcount = sf_read_float(infile, data, BUFFER_LEN)))
    {
        for(int i = 0; i < readcount; ++i)
        {
            out.push_back(data[i]);
        }
    }

    sf_close (infile);

    return out;
}
Beispiel #4
0
static OSStatus
macosx_audio_out_callback (AudioDeviceID device, const AudioTimeStamp* current_time,
	const AudioBufferList* data_in, const AudioTimeStamp* time_in,
	AudioBufferList*	data_out, const AudioTimeStamp* time_out,
	void* client_data)
{	MacOSXAudioData	*audio_data ;
	int		k, size, sample_count, read_count ;
	float	*buffer, rate = 44100 ;
	
	audio_data = (MacOSXAudioData*) client_data ;

	size = data_out->mBuffers[0].mDataByteSize ;
	sample_count = size / sizeof(float) ;

	buffer = (float*) data_out->mBuffers [0].mData ;

	read_count = sf_read_float (audio_data->sndfile, buffer, sample_count) ;
	
	if (read_count < sample_count)
	{	memset (&(buffer [read_count]), 0, (sample_count - read_count) * sizeof (float)) ;
		/* Tell the main application to terminate. */
		audio_data->done_playing = SF_TRUE ;
		} ;
	
	return noErr ;
} /* macosx_audio_out_callback */
//------------------------------------------------------------
bool ofOpenALSoundPlayer::sfStream(string path,vector<short> & buffer,vector<float> & fftAuxBuffer){
	if(!streamf){
		SF_INFO sfInfo;
		streamf = sf_open(path.c_str(),SFM_READ,&sfInfo);
		if(!streamf){
			ofLogError("ofOpenALSoundPlayer") << "sfStream(): couldn't read \"" << path << "\"";
			return false;
		}

		stream_subformat = sfInfo.format & SF_FORMAT_SUBMASK ;
		if (stream_subformat == SF_FORMAT_FLOAT || stream_subformat == SF_FORMAT_DOUBLE){
			sf_command (streamf, SFC_CALC_SIGNAL_MAX, &stream_scale, sizeof (stream_scale)) ;
			if (stream_scale < 1e-10)
				stream_scale = 1.0 ;
			else
				stream_scale = 32700.0 / stream_scale ;
		}
		channels = sfInfo.channels;
		duration = float(sfInfo.frames) / float(sfInfo.samplerate);
		samplerate = sfInfo.samplerate;
		stream_samples_read = 0;
	}

	int curr_buffer_size = BUFFER_STREAM_SIZE*channels;
	if(speed>1) curr_buffer_size *= (int)round(speed);
	buffer.resize(curr_buffer_size);
	fftAuxBuffer.resize(buffer.size());
	if (stream_subformat == SF_FORMAT_FLOAT || stream_subformat == SF_FORMAT_DOUBLE){
		sf_count_t samples_read = sf_read_float (streamf, &fftAuxBuffer[0], fftAuxBuffer.size());
		stream_samples_read += samples_read;
		if(samples_read<(int)fftAuxBuffer.size()){
			fftAuxBuffer.resize(samples_read);
			buffer.resize(samples_read);
			setPosition(0);
			if(!bLoop) stopThread();
			stream_samples_read = 0;
			stream_end = true;
		}
		for (int i = 0 ; i < int(fftAuxBuffer.size()) ; i++){
			fftAuxBuffer[i] *= stream_scale ;
			buffer[i] = 32565.0 * fftAuxBuffer[i];
		}
	}else{
		sf_count_t frames_read = sf_readf_short(streamf,&buffer[0],curr_buffer_size/channels);
		stream_samples_read += frames_read*channels;
		if(frames_read<curr_buffer_size/channels){
			fftAuxBuffer.resize(frames_read*channels);
			buffer.resize(frames_read*channels);
			setPosition(0);
			if(!bLoop) stopThread();
			stream_samples_read = 0;
			stream_end = true;
		}
		for(int i=0;i<(int)buffer.size();i++){
			fftAuxBuffer[i]=float(buffer[i])/32565.0f;
		}
	}

	return true;
}
Beispiel #6
0
//-----------------------------------------------------------------------------
// name: int ReadSoundFile( char filename[], TS_FLOAT * data, int datasize )
// desc: Reads given sound file into data array
//-----------------------------------------------------------------------------
int TreesynthIO::ReadSoundFile( char filename[], TS_FLOAT * data, int datasize )
{
	if( !sfread ) {
		sfread = sf_open( filename, SFM_READ, &info );
		if( !sfread )
		{
			std::cerr << "TreesynthIO::ReadSoundFile : cannot open file '" << filename << "', quitting" << std::endl;
            char x[256];
			std::cin.getline( x, 256 );
			exit(1);
		}
	}

    datasize = rm_next_length;
	sf_seek( sfread, rm_next_pos, SEEK_SET );
	std::cerr << sfread << " " << data << " " << datasize << std::endl;
	int itemsread = sf_read_float( sfread, data, datasize );
	set_next_pos( filename );
    // rt audio
    /*if( !audio_initialize( info.samplerate ) ) {	// 44100
        std::cerr << "TreesynthIO::ReadSoundFile : cannot open audio interface, quitting" << std::endl;
		char x[256];
		std::cin.getline( x, 256 );
		exit(1);
    }*/

	return itemsread;
}
Beispiel #7
0
void reverse_audio_file(char* filepath, char* fileOutputPath){
    SF_INFO info;
    SNDFILE *input, *output;
    float *samples;
    int len, i;

    /* open input file */
    input = sf_open(filepath, SFM_READ, &info);

    /* allocate buffer */
    len = info.frames;
    samples = malloc(sizeof(float) * len);

    /* read in input file */
    sf_read_float(input, samples, len);

    /* close the input file */
    sf_close(input);

    /* open output file */
    output = sf_open(fileOutputPath, SFM_WRITE, &info);

    /* write samples in reverse order to output file */
    for (i=len-1; i>=0; i--)
    {
        sf_write_float(output, &samples[i], 1);
    }

    /* close output file */
    sf_close(output);

    /* deallocate buffer */
    free(samples);

}
long int lp_sndfile_in::read_frames(float *buffer, long int len)
{
    pv_sf_len = (sf_count_t)len;
    pv_sf_len = sf_read_float(pv_snd_fd, buffer, pv_sf_len);
    pv_sf_pos = pv_sf_pos + pv_sf_len;
    return (long int)pv_sf_len;
}
Beispiel #9
0
soundfile * readsoundfilechunk(char *path, int start, int len) {
    soundfile * ret;
    SF_INFO info;
    SNDFILE *snd;

    memset(&info, 0, sizeof(info));

    if ( (snd = sf_open(path, SFM_READ, &info)) == NULL )
        diem("Couldn't open sound file for reading", path);

    if ( info.channels != 1 )
        diem("Sound file has more than one channel", path);

    if ( (ret = malloc(sizeof(*ret))) == NULL )
        die("Couldn't malloc space for soundfile");

    if ( (ret->data = malloc(sizeof(float)*len)) == NULL )
        die("Couldn't malloc space for sound buffer");

    sf_seek(snd, start, SEEK_SET);
    int actuallen = sf_read_float(snd, ret->data, len); // assumption: channel count is 1, verified above

    ret->length = actuallen;
    ret->samplerate = info.samplerate;

    if ( sf_close(snd) )
        diem("Couldn't close sound file", path);

    return ret;
}
Beispiel #10
0
int OlaRandom::ReadSoundFile( char filename[] )
{
	// open file
	if( sfread )
	{
		sf_close( sfread );
	}
	sfread = sf_open( filename, SFM_READ, &readinfo );
	if( !sfread )
	{
		BB_log( BB_LOG_SEVERE, "[TreesynthIO]: Could not open input file '%s', %s", 
			filename, sf_error_number( sf_error( sfread ) ) );
		return 0;
	}
	strcpy( ifilename, filename );

	// determine number of buffers needed
	origsize = readinfo.frames;
	std::cerr << "frames: " << origsize << std::endl;
	SAFE_DELETE_ARRAY(origbuffer);
	origbuffer = new float[origsize];

	// read
	sf_seek( sfread, 0, SEEK_SET );
    int itemsread = sf_read_float( sfread, origbuffer, origsize);
	sf_close( sfread );
	sfread = NULL;

	return itemsread;
}
int prSFRead(struct VMGlobals *g, int numArgsPushed)
{
	PyrSlot *a, *b;

	a = g->sp - 1;
	b = g->sp;

	SNDFILE *file = (SNDFILE*)slotRawPtr(&slotRawObject(a)->slots[0]);

	if (!isKindOfSlot(b, class_rawarray)) return errWrongType;

	switch (slotRawObject(b)->obj_format) {
		case obj_int16 :
			slotRawObject(b)->size = (int)sf_read_short(file, (short*)slotRawInt8Array(b)->b, slotRawObject(b)->size);
			break;
		case obj_int32 :
			slotRawObject(b)->size = (int)sf_read_int(file, (int*)slotRawInt8Array(b)->b, slotRawObject(b)->size);
			break;
		case obj_float :
			slotRawObject(b)->size = (int)sf_read_float(file, (float*)slotRawInt8Array(b)->b, slotRawObject(b)->size);
			break;
		case obj_double :
			slotRawObject(b)->size = (int)sf_read_double(file, (double*)slotRawInt8Array(b)->b, slotRawObject(b)->size);
			break;
		default:
			error("sample format not supported.\n");
			return errFailed;
	}

	return errNone;
}
Beispiel #12
0
static int
opensoundsys_play (int argc, char *argv [])
{	static short buffer [BUFFER_LEN] ;
	SNDFILE *sndfile ;
	SF_INFO sfinfo ;
	int		k, audio_device, readcount, writecount, subformat ;

	for (k = 1 ; k < argc ; k++)
	{	memset (&sfinfo, 0, sizeof (sfinfo)) ;

		printf ("Playing %s\n", argv [k]) ;
		if (! (sndfile = sf_open (argv [k], SFM_READ, &sfinfo)))
		{	puts (sf_strerror (NULL)) ;
			continue ;
			} ;

		if (sfinfo.channels < 1 || sfinfo.channels > 2)
		{	printf ("Error : channels = %d.\n", sfinfo.channels) ;
			continue ;
			} ;

		audio_device = opensoundsys_open_device (sfinfo.channels, sfinfo.samplerate) ;

		subformat = sfinfo.format & SF_FORMAT_SUBMASK ;

		if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
		{	static float float_buffer [BUFFER_LEN] ;
			double	scale ;
			int 	m ;

			sf_command (sndfile, SFC_CALC_SIGNAL_MAX, &scale, sizeof (scale)) ;
			if (scale < 1e-10)
				scale = 1.0 ;
			else
				scale = 32700.0 / scale ;

			while ((readcount = sf_read_float (sndfile, float_buffer, BUFFER_LEN)))
			{	for (m = 0 ; m < readcount ; m++)
					buffer [m] = scale * float_buffer [m] ;
				writecount = write (audio_device, buffer, readcount * sizeof (short)) ;
				} ;
			}
		else
		{	while ((readcount = sf_read_short (sndfile, buffer, BUFFER_LEN)))
				writecount = write (audio_device, buffer, readcount * sizeof (short)) ;
			} ;

		if (ioctl (audio_device, SNDCTL_DSP_POST, 0) == -1)
			perror ("ioctl (SNDCTL_DSP_POST) ") ;

		if (ioctl (audio_device, SNDCTL_DSP_SYNC, 0) == -1)
			perror ("ioctl (SNDCTL_DSP_SYNC) ") ;

		close (audio_device) ;

		sf_close (sndfile) ;
		} ;

	return writecount ;
} /* opensoundsys_play */
Beispiel #13
0
f_cnt_t SampleBuffer::decodeSampleSF( const char * _f,
					int_sample_t * & _buf,
					ch_cnt_t & _channels,
					sample_rate_t & _samplerate )
{
	SNDFILE * snd_file;
	SF_INFO sf_info;
	f_cnt_t frames = 0;
	bool sf_rr = false;
	sample_t * fbuf = 0;

	if( ( snd_file = sf_open( _f, SFM_READ, &sf_info ) ) != NULL )
	{
		frames = sf_info.frames;

		// check if float
		if ( (sf_info.format & SF_FORMAT_SUBMASK) == SF_FORMAT_FLOAT ) // if yes, use float format for buffer
		{
			fbuf = new sample_t[sf_info.channels * frames];
			sf_rr = sf_read_float( snd_file, fbuf, sf_info.channels * frames );
		}
		else // otherwise, use int
		{
			_buf = new int_sample_t[sf_info.channels * frames];
			sf_rr = sf_read_short( snd_file, _buf, sf_info.channels * frames );
		}

		if( sf_rr < sf_info.channels * frames )
		{
#ifdef DEBUG_LMMS
			printf( "SampleBuffer::decodeSampleSF(): could not read"
				" sample %s: %s\n", _f, sf_strerror( NULL ) );
#endif
		}
		_channels = sf_info.channels;
		_samplerate = sf_info.samplerate;

		sf_close( snd_file );
	}
	else
	{
#ifdef DEBUG_LMMS
		printf( "SampleBuffer::decodeSampleSF(): could not load "
				"sample %s: %s\n", _f, sf_strerror( NULL ) );
#endif
	}
    //write down either directly or convert i->f depending on file type

    if ( frames > 0 && fbuf != NULL )
    {
        directFloatWrite ( fbuf, frames, _channels);
    }
    else if ( frames > 0 && _buf != NULL )
    {
        convertIntToFloat ( _buf, frames, _channels);
    }

	return frames;
}
Beispiel #14
0
sf_count_t xsf_read_float(SNDFILE *sndfile, float *ptr, sf_count_t items)
{
  sf_count_t err = sf_read_float(sndfile, ptr, items);
  if(err < 0) {
    xsf_handle_error(sndfile);
  }
  return err;
}
long int lp_sndfile_in::read_samples(float *buffer, long int len)
{
    pv_sf_len = (sf_count_t)(len / (long int)pv_sf_info.channels);
    pv_sf_len = sf_read_float(pv_snd_fd, buffer, pv_sf_len);
    pv_sf_pos = pv_sf_pos + pv_sf_len;
    pv_len = ((long int)pv_sf_len * (long int)pv_sf_info.channels);
    return pv_len;
}
Beispiel #16
0
static OSStatus
macosx_audio_out_callback (AudioDeviceID device, const AudioTimeStamp* current_time,
	const AudioBufferList* data_in, const AudioTimeStamp* time_in,
	AudioBufferList*	data_out, const AudioTimeStamp* time_out,
	void* client_data)
{	MacOSXAudioData	*audio_data ;
	int		size, sample_count, read_count, k ;
	float	*buffer ;

	/* Prevent compiler warnings. */
	device = device ;
	current_time = current_time ;
	data_in = data_in ;
	time_in = time_in ;
	time_out = time_out ;

	audio_data = (MacOSXAudioData*) client_data ;

	size = data_out->mBuffers [0].mDataByteSize ;
	sample_count = size / sizeof (float) ;

	buffer = (float*) data_out->mBuffers [0].mData ;

	if (audio_data->fake_stereo != 0)
	{	read_count = sf_read_float (audio_data->sndfile, buffer, sample_count / 2) ;

		for (k = read_count - 1 ; k >= 0 ; k--)
		{	buffer [2 * k	] = buffer [k] ;
			buffer [2 * k + 1] = buffer [k] ;
			} ;
		read_count *= 2 ;
		}
	else
		read_count = sf_read_float (audio_data->sndfile, buffer, sample_count) ;

	/* Fill the remainder with zeroes. */
	if (read_count < sample_count)
	{	if (audio_data->fake_stereo == 0)
			memset (&(buffer [read_count]), 0, (sample_count - read_count) * sizeof (float)) ;
		/* Tell the main application to terminate. */
		audio_data->done_playing = SF_TRUE ;
		} ;

	return noErr ;
} /* macosx_audio_out_callback */
Beispiel #17
0
    // TODO: Add streaming support.
    bool SoundCtor(JSContext *ctx, unsigned argc, JS::Value *vp){
        
        JS::CallArgs args = CallArgsFromVp(argc, vp);
        if(!Turbo::CheckForSingleArg(ctx, args, Turbo::String, __func__))
            return false;
                
        struct Turbo::JSStringHolder<> file(ctx, JS_EncodeString(ctx, args[0].toString()));
        
        const std::string full_path = std::string(TS_GetContextEnvironment(ctx)->directories->sound) + file.string;

        if(!t5::IsFile(full_path)){
            Turbo::SetError(ctx, std::string(BRACKNAME " SoundCtor Error no such file ") + file.string);
            return false;
        }
        
        SF_INFO info;
        SNDFILE *sound_file = sf_open(full_path.c_str(), SFM_READ, &info);
        //sf_command(sound_file, SFC_SET_SCALE_FLOAT_INT_READ, nullptr, SF_TRUE);
        
        if(!sound_file){
            Turbo::SetError(ctx, std::string(BRACKNAME " SoundCtor Error could not open file ") + file.string);
            return false;
        }
        
		int iters = 0;
		Sound *sound = nullptr;
		
		if(player.supportsFloat32()){
			float buffer[0x8000];
			sound = new Sound(player.load((float *)nullptr, 0, info.channels, info.samplerate, info.frames));
			
			while(unsigned long this_read = sf_read_float(sound_file, buffer, 0x10000)){
				player.addToSound(sound, buffer, SamplesToBytes(this_read));
				iters++;
			}
		}
		else if(player.supportsInt16()){
			short buffer[0x10000];
			sound  = new Sound(player.load((short *)nullptr, 0, info.channels, info.samplerate, info.frames));
			
			while(unsigned long this_read = sf_read_short(sound_file, buffer, 0x10000)){
				player.addToSound(sound, buffer, SamplesToBytes(this_read));
				iters++;
			}
        }
		else{
			puts(BRACKNAME " Error bad player on this platform");
		}
		
        printf(BRACKNAME " SoundCtor Info loaded file %s in %i iterations\n", file.string, iters);
        
        sf_close(sound_file);
        
        args.rval().set(OBJECT_TO_JSVAL(sound_proto.wrap(ctx, sound)));
        
        return true;
    }
Beispiel #18
0
void lsamp_add_file(lsamp_data *ls, const char *filename, const char *keyword) {
    sqlite3_stmt *pStmt;
    int rc;
    int rowid;
    int count;
    int bufsize = LSBUFSIZE;
    int blob_offset = 0;

    if(!lsamp_open_sfile(ls, filename)) {
        return;
    }
    rc = sqlite3_prepare_v2(ls->db,
            "INSERT INTO lsamp(keyword, data) VALUES(?,ZEROBLOB(?));",
            -1,
            &pStmt,
            NULL);
    if(rc) {
        fprintf(stderr, "SQL Error: %s\n", sqlite3_errmsg(ls->db));
        return;
    }
    sqlite3_bind_text(pStmt, 1, keyword, -1, SQLITE_STATIC);
    sqlite3_bind_int(pStmt, 2, ls->sfinfo.frames * sizeof(LSFLOAT));
    rc = sqlite3_step(pStmt);
    rc = sqlite3_finalize(pStmt);
    
    sqlite3_blob *pBlob;
    rc = sqlite3_blob_open(ls->db, "main", "lsamp", "data", 
            sqlite3_last_insert_rowid(ls->db), 1, &pBlob);
    if(rc) {
        fprintf(stderr, "Error opening blob: %s\n", sqlite3_errmsg(ls->db));
        return;
    }
    count = ls->sfinfo.frames;
    while(count != 0) {
#ifdef LS_DEBUG
        fprintf(stderr, "Reading buffersize %d.\n", bufsize);
        fflush(stderr);
#endif
        bufsize = sf_read_float(ls->sfile, ls->buf, bufsize);
        rc = sqlite3_blob_write(pBlob, ls->buf, 
                bufsize * sizeof(LSFLOAT), blob_offset * sizeof(LSFLOAT));

#ifdef LS_DEBUG
        fprintf(stderr, "%d bytes Written. Writing %d bytes.\n", 
                blob_offset, bufsize);
        fflush(stderr);
#endif
        if(rc) {
            fprintf(stderr, "SQL Error: %s\n", sqlite3_errmsg(ls->db));
            return;
        }
        blob_offset += bufsize;
        count -= bufsize;
    }
    lsamp_close_sfile(ls);
    sqlite3_blob_close(pBlob);
}
Beispiel #19
0
static void play_file (const char *filename) {
	SNDFILE *sndFile;
	SF_INFO sfInfo;
	sf_count_t count;

	PaError error;
	PaStreamParameters outputParameters;
	PaStream *stream;

	// open file
	if (! (sndFile = sf_open(filename, SFM_READ, &sfInfo))) {
		printf("Error: could not open file: %s\n", filename);
	}	

	// initialize portaudio
	Pa_Initialize();

	outputParameters.device = Pa_GetDefaultOutputDevice();
	outputParameters.channelCount = sfInfo.channels;
	outputParameters.sampleFormat = paFloat32;
	outputParameters.suggestedLatency = 0.2;
	outputParameters.hostApiSpecificStreamInfo = 0;

	error = Pa_OpenStream(
			&stream,
			NULL,
			&outputParameters,
			sfInfo.samplerate,
			paFramesPerBufferUnspecified,
			paNoFlag,
			NULL,
			NULL);

	if (error) {
		printf("Failed to open output, error: %i\n", error);
		Pa_Terminate();
	}

	error = Pa_StartStream(stream);
	if (error) {
		printf("Failed to start stream: %i\n", error);
	}

	// read and play file in segments
	int buffer_channel = BUFFER_LEN * sfInfo.channels;
	float *buffer = malloc(buffer_channel * sizeof(float));
	while ((count = sf_read_float(sndFile, buffer, buffer_channel)) > 0) {
		error = Pa_WriteStream(stream, buffer, BUFFER_LEN);
	}

	// clean up
	free(buffer);
	Pa_StopStream(stream);
	Pa_CloseStream(stream);
	Pa_Terminate();
	sf_close(sndFile);
}
Beispiel #20
0
CircularBuffer * __read_audio_file(AudioOptions audio_options)
{
    struct stat st;
    SF_INFO sf_info;
    long wav_file_size;

    float * buffer = NULL;
    CircularBuffer * input_buffer = NULL;
    SNDFILE * wav_file = NULL;

    if (stat(audio_options.wav_path, &st) == 0) {
        wav_file_size = st.st_size;
    } else {
        printf("Could not open wav file: %s\n", audio_options.wav_path);
        fflush(stdout);
        goto error;
    }

    input_buffer = CircularBuffer_create(wav_file_size);

    printf("Opening wave file %s with size %ld\n", audio_options.wav_path, wav_file_size);

    if (!(wav_file = sf_open(audio_options.wav_path, SFM_READ, &sf_info))) {
        printf("Could not open wav file: %s\n", audio_options.wav_path);
        fflush(stdout);
        goto error;
    }

    buffer =  (float *)malloc(sizeof(float) * WAV_BUFFER_SIZE);

    if (!buffer) {
        sf_close(wav_file);
        goto error;
    }

    int readcount;
    while ((readcount = sf_read_float(wav_file, buffer, WAV_BUFFER_SIZE))) {
        CircularBuffer_produce_blocking(input_buffer, buffer, readcount);
    }

    free(buffer);
    sf_close(wav_file);
    return input_buffer;

 error:
    if (buffer) {
        free(buffer);
    }
    if (input_buffer) {
        CircularBuffer_destroy(input_buffer);
    }
    if (wav_file) {
        sf_close(wav_file);
    }
    return NULL;
}
bool StreamTrack::stream(ALuint buffer)
{
    BOOST_ASSERT(m_audioEngine->getSettings().stream_buffer_size >= m_sfInfo.channels - 1);
#ifdef AUDIO_OPENAL_FLOAT
    std::vector<ALfloat> pcm(m_audioEngine->getSettings().stream_buffer_size);
#else
    std::vector<ALshort> pcm(m_audioEngine->getSettings().stream_buffer_size);
#endif
    size_t size = 0;

    // SBS - C + 1 is important to avoid endless loops if the buffer size isn't a multiple of the channels
    while(size < pcm.size() - m_sfInfo.channels + 1)
    {
        // we need to read a multiple of sf_info.channels here
        const size_t samplesToRead = (m_audioEngine->getSettings().stream_buffer_size - size) / m_sfInfo.channels * m_sfInfo.channels;
#ifdef AUDIO_OPENAL_FLOAT
        const sf_count_t samplesRead = sf_read_float(m_sndFile, pcm.data() + size, samplesToRead);
#else
        const sf_count_t samplesRead = sf_read_short(m_sndFile, pcm.data() + size, samplesToRead);
#endif

        if(samplesRead > 0)
        {
            BOOST_ASSERT(static_cast<std::make_unsigned<sf_count_t>::type>(samplesRead) <= std::numeric_limits<size_t>::max());
            size += static_cast<size_t>(samplesRead);
            continue;
        }

        int error = sf_error(m_sndFile);
        if(error != SF_ERR_NO_ERROR)
        {
            logSndfileError(error);
            return false;
        }

        if(m_streamType == StreamType::Background)
        {
            sf_seek(m_sndFile, 0, SEEK_SET);
        }
        else
        {
            break;   // Stream is ending - do nothing.
        }
    }

    if(size == 0)
        return false;

    alBufferData(buffer, m_format, pcm.data(), static_cast<ALsizei>(size * sizeof(pcm[0])), m_rate);
    DEBUG_CHECK_AL_ERROR();
    return true;
}
static int ReadSndSamples(Sound *s, Tcl_Interp *interp, Tcl_Channel ch, char *ibuf, float *obuf, int len)
{
	/* fprintf(stderr, "ReadSndSample(..., %d)\n", len); */
	if( ( ch == NULL ) || ( sf_error((SNDFILE*) ch) != 0 ) )
	{
		/* fprintf(stderr, "ReadSndSample ERROR %d\n", sf_error((SNDFILE*) ch)); */
		return -1;
	}
	/* int nframes = len / Snack_GetNumChannels(s); */
	/* nframes = sf_readf_float ((SNDFILE*) ch, obuf, nframes); */
	/* return nframes * Snack_GetNumChannels(s); */
	return sf_read_float ((SNDFILE*) ch, obuf, len);
}
bool ofxSoundFile::sfReadFile(ofSoundBuffer & buffer){
	samples_read = sf_read_float (sndFile, &buffer[0], buffer.size());
	/*if(samples_read<(int)buffer.size()){
		ofLogError() <<  "ofxSoundFile: couldnt read " << path;
		return false;
	}*/
	if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE){
		for (int i = 0 ; i < int(buffer.size()) ; i++){
			buffer[i] *= scale ;
		}
	}
	return true;
}
// ----------------------------------------------------------------------------
bool ofOpenALSoundPlayer::sfReadFile(string path, vector<short> & buffer, vector<float> & fftAuxBuffer){
	SF_INFO sfInfo;
	SNDFILE* f = sf_open(path.c_str(),SFM_READ,&sfInfo);
	if(!f){
		ofLogError("ofOpenALSoundPlayer") << "sfReadFile(): couldn't read \"" << path << "\"";
		return false;
	}

	buffer.resize(sfInfo.frames*sfInfo.channels);
	fftAuxBuffer.resize(sfInfo.frames*sfInfo.channels);

	int subformat = sfInfo.format & SF_FORMAT_SUBMASK ;
	if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE){
		double	scale ;
		sf_command (f, SFC_CALC_SIGNAL_MAX, &scale, sizeof (scale)) ;
		if (scale < 1e-10)
			scale = 1.0 ;
		else
			scale = 32700.0 / scale ;

		sf_count_t samples_read = sf_read_float (f, &fftAuxBuffer[0], fftAuxBuffer.size());
		if(samples_read<(int)fftAuxBuffer.size()){
			ofLogWarning("ofOpenALSoundPlayer") << "sfReadFile(): read " << samples_read << " float samples, expected "
			<< fftAuxBuffer.size() << " for \"" << path << "\"";
		}
		for (int i = 0 ; i < int(fftAuxBuffer.size()) ; i++){
			fftAuxBuffer[i] *= scale ;
			buffer[i] = 32565.0 * fftAuxBuffer[i];
		}
	}else{
		sf_count_t frames_read = sf_readf_short(f,&buffer[0],sfInfo.frames);
		if(frames_read<sfInfo.frames){
			ofLogError("ofOpenALSoundPlayer") << "sfReadFile(): read " << frames_read << " frames from buffer, expected "
			<< sfInfo.frames << " for \"" << path << "\"";
			return false;
		}
		sf_seek(f,0,SEEK_SET);
		frames_read = sf_readf_float(f,&fftAuxBuffer[0],sfInfo.frames);
		if(frames_read<sfInfo.frames){
			ofLogError("ofOpenALSoundPlayer") << "sfReadFile(): read " << frames_read << " frames from fft buffer, expected "
			<< sfInfo.frames << " for \"" << path << "\"";
			return false;
		}
	}
	sf_close(f);

	channels = sfInfo.channels;
	duration = float(sfInfo.frames) / float(sfInfo.samplerate);
	samplerate = sfInfo.samplerate;
	return true;
}
Beispiel #25
0
ssize_t
ad_read_sndfile_short(WfDecoder* d, WfBuf16* buf)
{
	SndfileDecoder* sf = (SndfileDecoder*)d->d;

	switch(d->info.bit_depth){
		case 8:
		case 16: {
			if(d->info.channels == 1){
				return sf_readf_short(sf->sffile, buf->buf[0], buf->size);
			}else{
				short* data = g_malloc0(d->info.channels * buf->size * sizeof(short));
				ssize_t r = sf_read_short(sf->sffile, data, d->info.channels * buf->size);
				int i, f; for(i=0,f=0;i<r;i+=d->info.channels,f++){
					int c; for(c=0;c<d->info.channels;c++){
						buf->buf[c][f] = data[i];
					}
				}
				g_free(data);
				return f;
			}
		}
		case 24: {
			int* data = g_malloc0(d->info.channels * buf->size * sizeof(int));
			ssize_t r = sf_read_int(sf->sffile, data, d->info.channels * buf->size);
			int i, f; for(i=0,f=0;i<r;i+=d->info.channels,f++){
				int c; for(c=0;c<d->info.channels;c++){
					buf->buf[c][f] = data[i] >> 16;
				}
			}
			g_free(data);
			return f;
		}
		case 32: {
			float* data = g_malloc0(d->info.channels * buf->size * sizeof(float));
			ssize_t r = sf_read_float(sf->sffile, data, d->info.channels * buf->size);
			int i, f; for(i=0,f=0;i<r;i+=d->info.channels,f++){
				int c; for(c=0;c<d->info.channels;c++){
					buf->buf[c][f] = AD_FLOAT_TO_SHORT(data[i]);
				}
			}
			g_free(data);
			return r;
		}
#ifdef DEBUG
		default:
			dbg(0, "!!! unhandled bit depth: %i", d->info.bit_depth);
#endif
	}
	return -1;
}
Beispiel #26
0
int SampleStream::getSamples(const char* file, float *buf, int channel, int startFrame, int endFrame)
{

	int numChannelsInFile = sfinfo.channels;
	if(numChannelsInFile < channel+1)
	{
		cout << "Error: " << file << " doesn't contain requested channel" << endl;
		return 1;
	}
    
    int frameLen = endFrame-startFrame;
    
    if(frameLen <= 0 || startFrame < 0 || endFrame <= 0 || endFrame > sfinfo.frames)
	{
	    cout << "Error: " << file << " invalid frame range requested" << endl;
		return 1;
	}
    
    sf_seek(sndfile,startFrame,SEEK_SET);
    
    float* tempBuf = new float[frameLen*numChannelsInFile];
    
	int subformat = sfinfo.format & SF_FORMAT_SUBMASK;
	int readcount = sf_read_float(sndfile, tempBuf, frameLen*numChannelsInFile); //FIXME

	// Pad with zeros in case we couldn't read whole file
	for(int k = readcount; k <frameLen*numChannelsInFile; k++)
		tempBuf[k] = 0;

	if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE) {
		double	scale ;
		int 	m ;

		sf_command (sndfile, SFC_CALC_SIGNAL_MAX, &scale, sizeof (scale)) ;
		if (scale < 1e-10)
			scale = 1.0 ;
		else
			scale = 32700.0 / scale ;
		cout << "File samples scale = " << scale << endl;

		for (m = 0; m < frameLen; m++)
			tempBuf[m] *= scale;
	}
	
	for(int n=0;n<frameLen;n++)
	    buf[n] = tempBuf[n*numChannelsInFile+channel];

    delete[] tempBuf;

	return 0;
}
Beispiel #27
0
int Wave::readData() {
	size = inHeader.frames * inHeader.channels;
	data = (float *) malloc(size * sizeof(float));
	if (data == NULL) {
		gLog("[wave] unable to allocate memory\n");
		return 0;
	}

	if (sf_read_float(fileIn, data, size) != size)
		gLog("[wave] warning: incomplete read!\n");

	sf_close(fileIn);
	return 1;
}
Beispiel #28
0
void SoundFile::loadFloatSamples(SNDFILE *f)
{
	QScopedArrayPointer<float> buffer(new float[Length]);
	double scale;

	sf_command(f, SFC_CALC_SIGNAL_MAX, &scale, sizeof(scale)) ;
	if (scale < 1e-10)
		scale = 1.0 ;
	else
		scale = 32700.0 / scale;

	int readcount = sf_read_float(f, buffer.data(), Length);
	for (int m = 0; m < readcount; ++m)
		Data[m] = (short int)(scale * buffer[m]);
}
/* Reques for writing length data */
static void sdlLibsndfileCb(void *userdata, Uint8 *stream, int len) {
    /* Just empty buffer for no reason.. fun yea */
    memset( stream, 0x00, len);

    /* Read with libsndfile */
#if SDL_MAJOR_VERSION == 2
    m_iReadcount = sf_read_float(m_SInfile, (float *)stream, len / 4);
#else
    m_iReadcount = sf_read_short(m_SInfile, (short int *)stream, len / 2);
#endif

    if( m_iReadcount <= 0 ) {
        l_iLoop = 1;
    }

}
Beispiel #30
0
void write_sample(SNDFILE *snd, FILE *fp, char *wav, char *name, 
        float *buf, int bufsize, uint32_t *pos, int sr)
{
    SF_INFO info;
    info.format = 0;
    int count;
    SNDFILE *in = sf_open(wav, SFM_READ, &info);
    fprintf(fp, "[%s]\npos = %g\n", name, 1.0 * (*pos) / sr);
    uint32_t start = *pos;
    while((count = sf_read_float(in, buf, bufsize))) {
        sf_write_float(snd, buf, count);
        *pos += count;
    }
    fprintf(fp, "size = %g\n\n", (1.0 * (*pos) - start) / sr);
    sf_close(in);
}