Sound Recorder

ChenXu

Hello, I am new to Bela + BBB. I plan to record sound from a microphone connected to Audio_In and save it as .wav file. Is there any example code I can refer to? Thanks.

ryjobil

I don't know where to find example code to do what you are asking, but I'm sure it has been done by several Bela users. Here's what I do have in mind that may help.

This goes the opposite direction you want to go (loads a wav file and plays it back). However you may be able to extend the example to write a wav file. The block processing and buffering procedure is the same, so if you have coding experience it won't be hard to re-apply the concepts you learn from this example.
https://github.com/BelaPlatform/Bela/tree/master/examples/04-Audio/sample-loader

I recall some discussion here that may give some leads to help:
https://forum.bela.io/d/304-logging-data-in-bela-io/3
Particularly the WriteFile class that @giuliomoro refers to in that thread.

There is a good example for the WriteFile class, but unless it has been recently extended I don't think it writes .wav format. Again, you have to take what you can learn from that example and extend it to write the desired format.

The main point no matter what way you go is this: all the audio thread does is to write data into a circular buffer. An auxiliary task (separate thread) writes blocks of data to the disk, always trying to keep up with the realtime thread. You will want to keep a large enough buffer to make sure the realtime thread doesn't wrap around and overwrite data that hasn't been recorded to disk.

giuliomoro

Oh, so no PureData.
It seems that write_word() tries to write straight to the file handler?

You are basically trying to do I/O from within the audio thread, which is one of the most important caveats of real-time programming, see here for a detailed explanation of this and other real-time unsafe practices.

Basically, you should follow @ryjobil's recommendation:

ryjobil The main point no matter what way you go is this: all the audio thread does is to write data into a circular buffer. An auxiliary task (separate thread) writes blocks of data to the disk, always trying to keep up with the realtime thread. You will want to keep a large enough buffer to make sure the realtime thread doesn't wrap around and overwrite data that hasn't been recorded to disk.

which is what we did in the WriteFile class. In fact, for your purpose, you may look into extending the WriteFile class as an easy starting point.

giuliomoro

Confirmed, WriteFile does not support writing audio files yet, but it should not be too difficut to implement, just need to learn the libsndfile API!

ChenXu

Thanks guys @ryjobil @giuliomoro . I figured it out by taking look at the example.
However, I meet another problem on running my project from command line. When I run mu project from web IDE, the sound recorded and saved to wav file is perfect. However, if I run from command line, for example ./myproject in myproject folder or ./run_project myproject (the executable file myproject is generated by clicking run button in IDE), the sound in wav file is faster than it should be. For example, I record 10 seconds, while the wav file is only 4-second long.

Do I use the correct way to run a project from command line?

giuliomoro

When running from the command line you have to specify all the options manually, so a difference in behaviour between the IDE and the command line may be due to the fact that you specified some non-default options from the IDE and you should duplicate those on the command line

ChenXu

giuliomoro Thanks very much for the reply.
When running the program, I always get "Underrun detected: 1 blocks dropped" message on the screen. Does this mean the analog in buffer is not large enough? But it seems this has no effect on the sound I record.

giuliomoro

how often does that happen?

ChenXu

giuliomoro When I run my code, this message will be kept printed on the screen.

giuliomoro

As in, does it print multiple times when the program is running, or only once per execution?
If it is the former case, how often does it print it? Multiple times per second or just once every so often? If it prints every so often, can you see a correlation between the message being printed and some event happening in your code?

If it happens every so often and you are using [soundfiler], then here is a possible explanation: every time you send a [read( or [write( message to [soundfiler], this will cause a glitch (or silence) in the audio and a message similar to the one you report. This is because upon receiving one of those messages, [soundfiler] will actually stop the audio and read or write the file from / to disk. If this is the case, try using [writesf~] instead.

ChenXu

giuliomoro It is the former case. The message is printed multiple times per second. I attached the main parts of my code. I read the value from analog 0 and write the value to the file.

namespace little_endian_io
{
	template <typename Word>
	std::ostream& write_word( std::ostream& outs, Word value, unsigned size = sizeof( Word ) )
	{
		for (; size; --size, value >>= 8)
			outs.put( static_cast <char> (value & 0xFF) );
		return outs;
	}
}

void render(BelaContext *context, void *userData)
{
	for(unsigned int n = 0; n < context->analogFrames; n++) {
		// get values from channel 0
		float tmp = analogRead(context, n, 0);
		int intVal = (int)(tmp * 2147483647.0) >> 16;
		write_word(f, intVal, 2); // f is the file(open as stream) handler
		write_word(f, intVal, 2);
	}
}

ChenXu

giuliomoro Thanks for your help. I have solved the problem by create a new thread handling the writing process. Then it will not affect the audio thread.

adrienr

Hi @[deleted]
I have been trying to implement this wav writting for some days but haven't managed to yet.
Would it be possible for you to share your code please?
Thanks in advance!

eventuate

I'm working on my own version of a sound recorder similar to the OP. I took a break from C programming to do some javascript/web work for my undergrad capstone, and now I'm using Bela as a way to re-familiarize myself with C and C++ specifics, and venture into audio/DSP territory as well.

My code below is a quick adaptation/combination of the basic sine-tone and the sample-streamer examples, along with an auxiliary function to handle writing the WAV file with libsndfile. The main issue I'm having is that my resulting Wav file is silence, except for what appears to be the very last chunk written to the file by the buffer. I've also attached a screenshot from the file loaded into a Max/MSP buffer display, labeled in milliseconds. My buffer is 22050 samples long (like the sample streamer example), so based on the display, it does look like only the last time through the buffer is being written.

What am I missing? I'm sure it's some small silly error or misunderstanding of libsndfile's writing operations on my part

alt text

#include <Bela.h>
#include <cmath>
#include <SampleData.h>
#include <sndfile.h>			
#include <cstdlib>

#define NUM_CHANNELS 1   
#define BUFFER_LEN 22050   

float gFrequency = 440.0;
float gPhase;
float gInverseSampleRate;

float gDuration = 5 * 44100;
float gCount = 0;

SampleData gSampleBuf[2][NUM_CHANNELS];

int gPos = 0;
int gActiveBuffer = 0;
int gDoneLoadingBuffer = 1;
int gChunk = 0;

AuxiliaryTask gFillBufferTask;

void writeFile(float *buf, int startSamp, int endSamp){
    SF_INFO sfinfo ;
    sfinfo.channels = NUM_CHANNELS;
    sfinfo.samplerate = 44100;
    sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16;

    const char* path = "./test.wav";

    int frameLen = endSamp - startSamp;

    SNDFILE * outfile = sf_open(path, SFM_WRITE, &sfinfo);

    sf_seek(outfile, startSamp, SEEK_SET);

    sf_count_t count = sf_write_float(outfile, &buf[0], frameLen);

    sf_write_sync(outfile);

    sf_close(outfile);
}

void fillBuffer(void*) {

    gChunk += BUFFER_LEN;
    int end = gChunk + BUFFER_LEN;

    writeFile(gSampleBuf[!gActiveBuffer][0].samples, gChunk, end);

    gDoneLoadingBuffer = 1;
}

bool setup(BelaContext *context, void *userData) {
    gInverseSampleRate = 1.0 / context->audioSampleRate;
    gPhase = 0.0;

    if((gFillBufferTask = Bela_createAuxiliaryTask(&fillBuffer, 90, "fill-buffer")) == 0) {
        return false;
    }

    for(int ch=0;ch<NUM_CHANNELS;ch++) {
        for(int i=0;i<2;i++) {
            gSampleBuf[i][ch].sampleLen = BUFFER_LEN;
            gSampleBuf[i][ch].samples = new float[BUFFER_LEN];
        }
    }

    return true;
}

void render(BelaContext *context, void *userData) {
    for(unsigned int n = 0; n < context->audioFrames; n++) {

		float out = 0.8f * sinf(gPhase);
		gPhase += 2.0f * (float)M_PI * gFrequency * gInverseSampleRate;
		if(gPhase > M_PI) {
			gPhase -= 2.0f * (float)M_PI;
        }

        if(gPos == 0) {
            if(!gDoneLoadingBuffer && gCount <= gDuration) {
                printf("increase buffer size!\n");
            }
            gDoneLoadingBuffer = 0;
            gActiveBuffer = !gActiveBuffer;
            if (gCount <= gDuration) {
                Bela_scheduleAuxiliaryTask(gFillBufferTask);
            }
        }

        if (gCount > gDuration) {
            for(unsigned int channel = 0; channel < context->audioOutChannels; channel++) {
                audioWrite(context, n, channel, 0);
            }
        } else {
            gSampleBuf[gActiveBuffer][0].samples[gPos] = out;
            for(unsigned int channel = 0; channel < context->audioOutChannels; channel++) {
                audioWrite(context, n, channel, out);
            }
        }

        gCount++;
        gPos = (gPos + 1)%BUFFER_LEN;
    }
}

void cleanup(BelaContext *context, void *userData) {
    for(int ch=0;ch<NUM_CHANNELS;ch++) {
        for(int i=0;i<2;i++) {
            delete[] gSampleBuf[i][ch].samples;
        }
    }
}