soundelf

An easy to use object oriented library for playing and recording sound.

Currently it uses 32-bit floating point data type and based on ALSA. However,
it is easy to implement other backends (see the classes SND::Device,
SND::DeviceHandler, and the ALSA implementation for more information).

It is based on the following libraries:

• Generic library: baselib https://github.com/kgy64/baselib
• Build system: makesys https://github.com/kgy64/makesys
• ALSA (see http://www.alsa-project.org)
• FFTW (see http://www.fftw.org)

The development packages are also necessary for ALSA and FFTW.

HOW TO USE IT

1) Include this header file:

#include <device-interface.h>

2) Instantiate the device handler singleton:

Auton<SND::DeviceHandler> handler;

(Note: the class Auton is documented in the project baselib)

This handler scans the hardware and provides the following information:

int no_of_palyer_devices = handler->getPlayers();
int no_of_recorder_devices = handler->getRecorders();

SND::Device * player = handler->getPlayer(player_index);        // 0 <= player_index < no_of_player_devices
SND::Device * recorder = handler->getRecorder(recorder_index);  // 0 <= recorder_index < no_of_recorder_devices

INSTANTIATE A PLAYER

3) Implement the sound frame handler virtual function of the player:

class MyPlayer: public SND::Player
{
    public:
        MyPlayer(SND::Device * dev):
            SND::Player(dev)
        {
        }

    private:
        virtual bool fillFrame(SND::BufferPtr & buf) override
        {
            // Fill the content of 'buf' here
            // (this is one sound frame)
            return true; // or false to stop playing
        }
};

MyPlayer player(handler->getPlayer(0));
player.setChannels(2).setSamplingRate(48000).Update();
player.Start();

Now you can hear the sound generated by the function fillFrame().

INSTANTIATE A RECORDER

3) Implement the sound frame handler virtual function of the recorder:

class MyRecorder: public SND::Recorder
{
    public:
        MyRecorder(SND::Device * dev):
            SND::Recorder(dev)
        {
        }

    private:
        virtual bool frameCaptured(SND::BufferPtr & buf) override
        {
            // Use the content of 'buf'
            // (this is one sound frame)
            return true; // or false to stop recording
        }
};

MyRecorder recorder(handler->getRecorder(0));
recorder.setChannels(2).setSamplingRate(48000).Update();
recorder.Start();

The function frameCaptured() will be called for each sound frame.
The SND::BufferPtr is a smart pointer. If you return it as is, then it will be used in
a ringbuffer. If you move its pointer out of it and return it as a null pointer, then
you can store the whole stream easily for further processing.

That's all.

HOW TO BUILD IT IN YOUR PROJECT

If you use makesys and put it in the right place (./modules directory), it is automatic.
If you have different build system, do the followings:

To build this library its include path must be added to the compiler.
Assuming you use gcc, these options are necessary:

-I/path/to/soundelf/include/public -I/path/to/soundelf/include/private -I/path/to/fftw/include

To use the library only one include file is necessary:

#include <device-interface.h>

which can be found on this path:
(gcc option)

-I/path/to/soundelf/include/public

For linking, the ALSA, FFTW, and pthread libraries must be used:
(gcc option)

-lfftw3f -lasound -lpthread