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
bool	force_resume () override
	Force resume the coroutine, bypassing all checks Used only during shutdown to push coroutines to final_suspend.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	SoundRoutine (const SoundRoutine &other)
	Copy constructor.

	SoundRoutine (SoundRoutine &&other) noexcept
	Move constructor.

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

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.

	~SoundRoutine () override

Public Member Functions inherited from MayaFlux::Vruta::Routine
template<typename T >
T *	get_state (const std::string &key)
	Gets a named state value from the coroutine.

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

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

virtual	~Routine ()=default
	Destructor.

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

void	set_state_impl (const std::string &key, std::any value) 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 316 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