A C++20 coroutine-based audio processing task with sample-accurate timing. More...

#include <Routine.hpp>

Inheritance diagram for MayaFlux::Vruta::SoundRoutine:

Collaboration diagram for MayaFlux::Vruta::SoundRoutine:

Public Types
using	promise_type = MayaFlux::Vruta::audio_promise
	Promise type used by this coroutine.

Public Member Functions
ProcessingToken	get_processing_token () const override
	Get the processing token that determines how this routine should be scheduled.

	SoundRoutine (std::coroutine_handle< promise_type > h)
	Constructs a SoundRoutine from a coroutine handle.

	SoundRoutine (const SoundRoutine &other)
	Copy constructor.

SoundRoutine &	operator= (const SoundRoutine &other)
	Copy assignment operator.

	SoundRoutine (SoundRoutine &&other) noexcept
	Move constructor.

SoundRoutine &	operator= (SoundRoutine &&other) noexcept
	Move assignment operator.

	~SoundRoutine () override

bool	is_active () const override
	Checks if the coroutine is still active.

bool	initialize_state (uint64_t current_sample=0U) override
	Initializes the coroutine's state for execution.

bool	try_resume (uint64_t current_context) override
	Attempts to resume the coroutine if it's ready to execute.

bool	try_resume_with_context (uint64_t current_value, DelayContext context) override
	Attempts to resume the coroutine with explicit temporal context.

DelayContext	get_delay_context () const override
	Get the active delay context for this routine.

void	set_delay_context (DelayContext context) override
	Set the active delay context for this routine.

bool	restart () override
	Restarts the coroutine from the beginning.

uint64_t	next_execution () const override
	Gets the sample position when this routine should next execute.

bool	requires_clock_sync () const override
	Check if the routine should synchronize with a clock.

bool	get_auto_resume () const override
	Get auto_resume flag from promise.

void	set_auto_resume (bool auto_resume) override
	Set auto_resume flag in promise.

bool	get_should_terminate () const override
	Get should_terminate flag from promise.

void	set_should_terminate (bool should_terminate) override
	Set should_terminate flag in promise.

bool	get_sync_to_clock () const override
	Get sync_to_clock flag from promise.

uint64_t	get_next_sample () const override
	Get next sample execution time (audio domain)

void	set_next_sample (uint64_t next_sample) override
	Set next sample execution time (audio domain)

uint64_t	get_next_frame () const override
	Get next frame execution time (graphics domain)

void	set_next_frame (uint64_t next_cycle) override
	Set next frame execution time (graphics domain)

Public Member Functions inherited from MayaFlux::Vruta::Routine
virtual	~Routine ()=default
	Destructor.

template<typename... Args>
void	update_params (Args... args)
	Updates multiple named parameters in the coroutine's state.

template<typename T >
void	set_state (const std::string &key, T value)
	Sets a named state value in the coroutine.

template<typename T >
T *	get_state (const std::string &key)
	Gets a named state value from the coroutine.

Protected Member Functions
void	set_state_impl (const std::string &key, std::any value) override

void *	get_state_impl_raw (const std::string &key) override

Protected Member Functions inherited from MayaFlux::Vruta::Routine
template<typename T >
T *	get_state_impl (const std::string &key)
	Implementation helper for get_state.

virtual void	update_params_impl ()
	brief Implementation helper for update_params

template<typename T , typename... Args>
void	update_params_impl (const std::string &key, T value, Args... args)
	Implementation helper for update_params.

Private Attributes
std::coroutine_handle< promise_type >	m_handle
	Handle to the underlying coroutine.

Detailed Description

A C++20 coroutine-based audio processing task with sample-accurate timing.

SoundRoutine encapsulates a coroutine that can execute audio processing logic with sample-accurate timing. It provides a powerful abstraction for writing time-based audio code that appears sequential but executes asynchronously in perfect sync with the audio timeline.

Key features:

Sample-accurate timing for precise audio scheduling
State persistence between suspensions and resumptions
Automatic management of coroutine lifetime
Ability to restart and reschedule tasks
Dynamic parameter updates during execution
Named state storage for flexible data management

This implementation leverages C++20 coroutines to create a cooperative multitasking system specifically designed for audio processing. Each routine can suspend itself at precise sample positions and be resumed exactly when needed, enabling complex temporal behaviors without blocking the audio thread.

Example usage:

auto fade_in = [](TaskScheduler& scheduler) -> SoundRoutine {
    float gain = 0.0f;
    for (int i = 0; i < 100; i++) {
        gain += 0.01f;
        set_volume(gain);
        co_await SampleDelay{441}; // Wait 10ms at 44.1kHz
    }
};

Definition at line 309 of file Routine.hpp.

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

Public Types

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description