Realtime playback base. More...

#include <realtime_playback.h>

Inheritance diagram for Beatmup::Audio::BasicRealtimePlayback:

Public Member Functions
virtual	~BasicRealtimePlayback ()

void	initialize (Mode mode)
	Initializes the playback setting its main parameters. More...

bool	process (TaskThread &thread)
	Executes the task on CPU within a given thread. More...

virtual void	start ()
	Starts playback. More...

virtual void	stop ()=0
	Stops playback. More...

void	bufferQueueCallbackFunc ()

void	pullBuffer (sample8 *buffer, dtime numFrames)
	Called in pulling output mode to send data to output. More...

Public Member Functions inherited from Beatmup::Audio::AbstractPlayback
ThreadIndex	getMaxThreads () const
	Gives the upper limint on the number of threads the task may be performed by. More...

void	beforeProcessing (ThreadIndex threadCount, ProcessingTarget target, GraphicPipeline *gpu)
	Instruction called before the task is executed. More...

void	setSource (Source *source)
	Specifies a Source to sample. More...

Source *	getSource () const
	Returns the signal source to sample. More...

Public Member Functions inherited from Beatmup::AbstractTask
virtual void	afterProcessing (ThreadIndex threadCount, GraphicPipeline *gpu, bool aborted)
	Instruction called after the task is executed. More...

virtual bool	processOnGPU (GraphicPipeline &gpu, TaskThread &thread)
	Executes the task on GPU. More...

virtual TaskDeviceRequirement	getUsedDevices () const
	Communicates devices (CPU and/or GPU) the task is run on. More...

Public Member Functions inherited from Beatmup::Object
virtual	~Object ()

Protected Types
enum class	OutputMode { PULL , PUSH }
	Specifies how the output audio signal is handled by the audio backend. More...

Protected Member Functions
	BasicRealtimePlayback (OutputMode)

virtual sample8 *	createBuffer (const AbstractPlayback::Mode &mode) const
	Creates an atomic playing buffer. More...

virtual void	freeBuffer (sample8 *buffer) const
	Frees an atomic playing buffer. More...

virtual void	pushBuffer (sample8 *buffer, int bufferIndex)
	Pushes some data to the output. More...

Protected Member Functions inherited from Beatmup::Audio::AbstractPlayback
	AbstractPlayback ()

void	advanceTime ()
	Moves time pointer one buffer forward. More...

Protected Attributes
msize	bufferSize
	size of each buffer in bytes More...

Protected Attributes inherited from Beatmup::Audio::AbstractPlayback
Mode	mode

Source *	source

dtime	clock

Private Member Functions
void	prepareBuffers (const AbstractPlayback::Mode &mode)
	Allocates all the atomic buffers. More...

void	freeBuffers ()

Private Attributes
const OutputMode	outputMode

sample8 **	buffers
	buffers containing the data to play More...

int	numBuffers

int	fillIndex
	points to the buffer currently being filled More...

int	sendIndex
	points to the first buffer ready for playing More...

int	playIndex
	points to the buffer currently being played; updated only in the callback More...

dtime	playingBufferOffset
	when pulling output, offset in frames with respect to the currently playing buffer More...

dtime	skipFrames
	when pulling output, number of frames to skip to give some time to the rendering process More...

Additional Inherited Members
Public Types inherited from Beatmup::AbstractTask
enum class	TaskDeviceRequirement { CPU_ONLY , GPU_OR_CPU , GPU_ONLY }
	Specifies which device (CPU and/or GPU) is used to run the task. More...

Static Public Member Functions inherited from Beatmup::AbstractTask
static ThreadIndex	validThreadCount (int number)
	Valid thread count from a given integer value. More...

Detailed Description

Realtime playback base.

Manages a circular buffer queue storing a signal sampled from a Source.

Definition at line 33 of file realtime_playback.h.

Member Enumeration Documentation

◆ OutputMode

enum Beatmup::Audio::BasicRealtimePlayback::OutputMode

strongprotected

Specifies how the output audio signal is handled by the audio backend.

Enumerator
PULL	The output is requested by pullOutput(..) called by the audio backend.
PUSH	The output is sent to pushOutput(..) called by the rendering thread.

Definition at line 38 of file realtime_playback.h.

                                   {
                 PULL,       //!< The output is requested by pullOutput(..) called by the audio backend.
                 PUSH,       //!< The output is sent to pushOutput(..) called by the rendering thread.
             };

Constructor & Destructor Documentation

◆ BasicRealtimePlayback()

BasicRealtimePlayback::BasicRealtimePlayback ( OutputMode mode )

protected

Definition at line 26 of file realtime_playback.cpp.

26 : outputMode(mode), buffers(nullptr)

27 {}

Beatmup::Audio::AbstractPlayback::mode

Mode mode

Definition: abstract_playback.h:65

Beatmup::Audio::BasicRealtimePlayback::buffers

sample8 ** buffers

buffers containing the data to play

Definition: realtime_playback.h:45

Beatmup::Audio::BasicRealtimePlayback::outputMode

const OutputMode outputMode

Definition: realtime_playback.h:43

◆ ~BasicRealtimePlayback()

BasicRealtimePlayback::~BasicRealtimePlayback ( )

virtual

Definition at line 30 of file realtime_playback.cpp.

                                               {
     freeBuffers();
 }

Member Function Documentation

◆ prepareBuffers()

void BasicRealtimePlayback::prepareBuffers ( const AbstractPlayback::Mode & mode )

private

Allocates all the atomic buffers.

Definition at line 45 of file realtime_playback.cpp.

                                                                            {
     freeBuffers();
     numBuffers = mode.numBuffers;
     buffers = new sample8*[numBuffers];
     for (int i = 0; i < numBuffers; i++)
         buffers[i] = createBuffer(mode);
 }

◆ freeBuffers()

void BasicRealtimePlayback::freeBuffers ( )

private

Definition at line 35 of file realtime_playback.cpp.

                                         {
     if (buffers == nullptr)
         return;
     for (int i = 0; i < numBuffers; i++)
         freeBuffer(buffers[i]);
     delete[] buffers;
     buffers = nullptr;
 }

◆ createBuffer()

sample8 * BasicRealtimePlayback::createBuffer ( const AbstractPlayback::Mode & mode ) const

protectedvirtual

Creates an atomic playing buffer.

Parameters

mode	the playback mode

Definition at line 54 of file realtime_playback.cpp.

                                                                                    {
     sample8* buffer = (sample8*) malloc(bufferSize);
     std::memset(buffer, 0, bufferSize);
     return buffer;
 }

◆ freeBuffer()

void BasicRealtimePlayback::freeBuffer ( sample8 * buffer ) const

protectedvirtual

Frees an atomic playing buffer.

Definition at line 61 of file realtime_playback.cpp.

                                                             {
     free(buffer);
 }

◆ pushBuffer()

virtual void Beatmup::Audio::BasicRealtimePlayback::pushBuffer	(	sample8 *	buffer,
		int	bufferIndex
	)

inlineprotectedvirtual

Pushes some data to the output.

Reimplemented in Beatmup::Audio::Android::SLESPlayback.

Definition at line 96 of file realtime_playback.h.

96 {};

◆ initialize()

void BasicRealtimePlayback::initialize ( Mode mode )

virtual

Initializes the playback setting its main parameters.

Reimplemented from Beatmup::Audio::AbstractPlayback.

Reimplemented in Beatmup::Audio::Android::SLESPlayback, and Beatmup::Audio::Android::AAudioPlayback.

Definition at line 66 of file realtime_playback.cpp.

                                                 {
     AbstractPlayback::initialize(mode);
  
     // set default buffer size
     bufferSize = (msize) (mode.bufferLength * mode.numChannels * AUDIO_SAMPLE_SIZE[mode.sampleFormat]);
  
     // prepare buffers
     prepareBuffers(mode);
 }

◆ process()

bool BasicRealtimePlayback::process ( TaskThread & thread )

virtual

Executes the task on CPU within a given thread.

Generally called by multiple threads.

Parameters

thread associated task execution context

Returns: true if the execution is finished correctly, false otherwise

Implements Beatmup::AbstractTask.

Definition at line 85 of file realtime_playback.cpp.

                                                       {
     if (!source)
         return false;
  
     int myFillIndex = 0;
  
     while (!thread.isTaskAborted()) {
         source->render(thread, buffers[myFillIndex % numBuffers], mode.bufferLength);
         myFillIndex++;
         if (thread.isManaging()) {
             fillIndex = myFillIndex;
             advanceTime();
             // if pushing output mode, then push
             if (outputMode == OutputMode::PUSH && fillIndex - sendIndex > 0) {
                 pushBuffer(buffers[sendIndex % numBuffers], sendIndex);
                 sendIndex++;
             }
             // wait till some buffers are available
             while (fillIndex - playIndex >= numBuffers)
                 std::this_thread::yield();
         }
         thread.synchronize();
     }
  
     return true;
 }

◆ start()

void BasicRealtimePlayback::start ( )

virtual

Starts playback.

Reimplemented in Beatmup::Audio::Android::SLESPlayback, and Beatmup::Audio::Android::AAudioPlayback.

Definition at line 77 of file realtime_playback.cpp.

                                   {
     // setting up control variables
     playIndex = sendIndex = fillIndex = 0;
     playingBufferOffset = 0;
     skipFrames = mode.getLatency();
 }

◆ stop()

virtual void Beatmup::Audio::BasicRealtimePlayback::stop ( )

pure virtual

Stops playback.

Implemented in Beatmup::Audio::Android::SLESPlayback, and Beatmup::Audio::Android::AAudioPlayback.

◆ bufferQueueCallbackFunc()

void Beatmup::Audio::BasicRealtimePlayback::bufferQueueCallbackFunc ( )

inline

Definition at line 119 of file realtime_playback.h.

                                                   {
                 // a buffer is played, step forward
                 playIndex++;
             }

◆ pullBuffer()

void BasicRealtimePlayback::pullBuffer	(	sample8 *	buffer,
		dtime	numFrames
	)

Called in pulling output mode to send data to output.

Parameters

buffer	Pointer to a buffer to put data to
numFrames	Number of "frames" (samples per single channel) to put to the buffer

Definition at line 113 of file realtime_playback.cpp.

                                                                        {
     const dtime frameSize = AUDIO_SAMPLE_SIZE[mode.sampleFormat] * mode.numChannels;
  
     // skipping frames first
     if (skipFrames > 0) {
         if (numFrames < skipFrames) {
             skipFrames -= numFrames;
             return;
         }
         else {
             buffer += skipFrames * frameSize;
             numFrames -= skipFrames;
             skipFrames = 0;
         }
     }
  
     // copying data from internal buffers until the requested number of frames is reached or underrun occurs
     const dtime playingBufferSize = mode.bufferLength;
     while (numFrames > 0 && playIndex - fillIndex < 0) {
         const dtime
             chunk = std::min(numFrames, playingBufferSize - playingBufferOffset),
             numBytes = chunk * frameSize;
         std::memcpy(buffer, buffers[playIndex % numBuffers] + playingBufferOffset * frameSize, (size_t) numBytes);
         numFrames -= chunk;
         playingBufferOffset += chunk;
         buffer += numBytes;
         // switching to the next buffer if it is the moment
         if (playingBufferOffset >= playingBufferSize) {
             playIndex++;
             playingBufferOffset = 0;
         }
     }
  
     // check for underrun
     if (playIndex - fillIndex >= 0 && numFrames > 0) {
         skipFrames = mode.getLatency();
         BEATMUP_DEBUG_I("UNDERRUN");
     }
 }

Member Data Documentation

◆ outputMode

const OutputMode Beatmup::Audio::BasicRealtimePlayback::outputMode

private

Definition at line 43 of file realtime_playback.h.

◆ buffers

sample8** Beatmup::Audio::BasicRealtimePlayback::buffers

private

buffers containing the data to play

Definition at line 45 of file realtime_playback.h.

◆ numBuffers

int Beatmup::Audio::BasicRealtimePlayback::numBuffers

private

Definition at line 46 of file realtime_playback.h.

◆ fillIndex

int Beatmup::Audio::BasicRealtimePlayback::fillIndex

private

points to the buffer currently being filled

Definition at line 48 of file realtime_playback.h.

◆ sendIndex

int Beatmup::Audio::BasicRealtimePlayback::sendIndex

private

points to the first buffer ready for playing

Definition at line 49 of file realtime_playback.h.

◆ playIndex

int Beatmup::Audio::BasicRealtimePlayback::playIndex

private

points to the buffer currently being played; updated only in the callback

Definition at line 50 of file realtime_playback.h.

◆ playingBufferOffset

dtime Beatmup::Audio::BasicRealtimePlayback::playingBufferOffset

private

when pulling output, offset in frames with respect to the currently playing buffer

Definition at line 52 of file realtime_playback.h.

◆ skipFrames

dtime Beatmup::Audio::BasicRealtimePlayback::skipFrames

private

when pulling output, number of frames to skip to give some time to the rendering process

Definition at line 53 of file realtime_playback.h.

◆ bufferSize

msize Beatmup::Audio::BasicRealtimePlayback::bufferSize

protected

size of each buffer in bytes

Definition at line 79 of file realtime_playback.h.

The documentation for this class was generated from the following files:

core/audio/playback/realtime_playback.h
core/audio/playback/realtime_playback.cpp

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ OutputMode

Constructor & Destructor Documentation

◆ BasicRealtimePlayback()

◆ ~BasicRealtimePlayback()

Member Function Documentation

◆ prepareBuffers()

◆ freeBuffers()

◆ createBuffer()

◆ freeBuffer()

◆ pushBuffer()

◆ initialize()

◆ process()

◆ start()

◆ stop()

◆ bufferQueueCallbackFunc()

◆ pullBuffer()

Member Data Documentation

◆ outputMode

◆ buffers

◆ numBuffers

◆ fillIndex

◆ sendIndex

◆ playIndex

◆ playingBufferOffset

◆ skipFrames

◆ bufferSize