MayaFlux Namespace Reference

Main namespace for the Maya Flux audio engine. More...

Namespaces
namespace	Buffers
namespace	Config
	Globlal configuration for MayaFlux.
namespace	Core
namespace	internal
namespace	IO
namespace	Journal
namespace	Kakshya
namespace	Kriya
namespace	Nodes
	Contains the node-based computational processing system components.
namespace	Parallel
namespace	Portal
namespace	Registry
namespace	Utils
namespace	Vruta
namespace	Yantra

Classes
struct	CreationContext
class	CreationHandle
class	Creator
struct	MultiChannelFeatures
	Multi-channel feature analysis result. More...

Enumerations
enum	Domain : uint64_t {   AUDIO = (static_cast<uint64_t>(Nodes::ProcessingToken::AUDIO_RATE) << 32) | (static_cast<uint64_t>(Buffers::ProcessingToken::AUDIO_BACKEND) << 16) | (static_cast<uint64_t>(Vruta::ProcessingToken::SAMPLE_ACCURATE)) , AUDIO_PARALLEL = (static_cast<uint64_t>(Nodes::ProcessingToken::AUDIO_RATE) << 32) | (static_cast<uint64_t>(Buffers::ProcessingToken::AUDIO_PARALLEL) << 16) | (static_cast<uint64_t>(Vruta::ProcessingToken::SAMPLE_ACCURATE)) , GRAPHICS = (static_cast<uint64_t>(Nodes::ProcessingToken::VISUAL_RATE) << 32) | (static_cast<uint64_t>(Buffers::ProcessingToken::GRAPHICS_BACKEND) << 16) | (static_cast<uint64_t>(Vruta::ProcessingToken::FRAME_ACCURATE)) , GRAPHICS_ADAPTIVE = (static_cast<uint64_t>(Nodes::ProcessingToken::VISUAL_RATE) << 32) | (static_cast<uint64_t>(Buffers::ProcessingToken::GRAPHICS_BACKEND) << 16) | (static_cast<uint64_t>(Vruta::ProcessingToken::MULTI_RATE)) ,   CUSTOM_ON_DEMAND = (static_cast<uint64_t>(Nodes::ProcessingToken::CUSTOM_RATE) << 32) | (static_cast<uint64_t>(Buffers::ProcessingToken::SAMPLE_RATE | Buffers::ProcessingToken::CPU_PROCESS | Buffers::ProcessingToken::SEQUENTIAL) << 16) | (static_cast<uint64_t>(Vruta::ProcessingToken::ON_DEMAND)) , CUSTOM_FLEXIBLE = (static_cast<uint64_t>(Nodes::ProcessingToken::CUSTOM_RATE) << 32) | (static_cast<uint64_t>(Buffers::ProcessingToken::FRAME_RATE | Buffers::ProcessingToken::GPU_PPOCESS | Buffers::ProcessingToken::PARALLEL) << 16) | (static_cast<uint64_t>(Vruta::ProcessingToken::CUSTOM)) , AUDIO_VISUAL_SYNC = (static_cast<uint64_t>(Nodes::ProcessingToken::AUDIO_RATE) << 32) | (static_cast<uint64_t>(Buffers::ProcessingToken::SAMPLE_RATE | Buffers::ProcessingToken::CPU_PROCESS | Buffers::ProcessingToken::SEQUENTIAL) << 16) | (static_cast<uint64_t>(Vruta::ProcessingToken::FRAME_ACCURATE)) , AUDIO_GPU = (static_cast<uint64_t>(Nodes::ProcessingToken::AUDIO_RATE) << 32) | (static_cast<uint64_t>(Buffers::ProcessingToken::SAMPLE_RATE | Buffers::ProcessingToken::GPU_PPOCESS | Buffers::ProcessingToken::PARALLEL) << 16) | (static_cast<uint64_t>(Vruta::ProcessingToken::MULTI_RATE)) ,   WINDOWING , INPUT_EVENTS }
	Unified domain enum combining all three ProcessingToken subsystems. More...

Functions
std::shared_ptr< Vruta::TaskScheduler >	get_scheduler ()
	Gets the task scheduler from the default engine.
std::shared_ptr< Vruta::EventManager >	get_event_manager ()
	Gets the event manager from the default engine.
template<typename... Args>
bool	update_task_params (const std::string &name, Args... args)
	Updates parameters of a scheduled task.
Vruta::SoundRoutine	create_metro (double interval_seconds, std::function< void()> callback)
	Creates a simple task that calls a function at a specified interval.
void	schedule_metro (double interval_seconds, std::function< void()> callback, std::string name="")
	Creates a metronome task and addes it to the default scheduler list for evaluation.
Vruta::SoundRoutine	create_sequence (std::vector< std::pair< double, std::function< void()> > > sequence)
	Creates a sequence task that calls functions at specified times.
void	schedule_sequence (std::vector< std::pair< double, std::function< void()> > > sequence, std::string name="")
	Creates a sequence task that calls functions at specified times and addes it to the default scheduler list for evaluation.
Vruta::SoundRoutine	create_line (float start_value, float end_value, float duration_seconds, uint32_t step_duration, bool loop)
	Creates a line generator that interpolates between values over time.
Vruta::SoundRoutine	create_pattern (std::function< std::any(uint64_t)> pattern_func, std::function< void(std::any)> callback, double interval_seconds)
	Schedules a pattern generator that produces values based on a pattern function.
void	schedule_pattern (std::function< std::any(uint64_t)> pattern_func, std::function< void(std::any)> callback, double interval_seconds, std::string name="")
	Schedules a pattern generator that produces values based on a pattern function and addes it to the default scheduler list for evaluation.
float *	get_line_value (const std::string &name)
	Gets a pointer to a task's current value.
void	schedule_task (const std::string &name, Vruta::SoundRoutine &&task, bool initialize=false)
	Schedules a new sound routine task.
bool	cancel_task (const std::string &name)
	Cancels a scheduled task.
bool	restart_task (const std::string &name)
	Restarts a scheduled task.
Kriya::ActionToken	Play (std::shared_ptr< Nodes::Node > node)
	Creates an action to play a node.
Kriya::ActionToken	Wait (double seconds)
	Creates a wait action.
Kriya::ActionToken	Action (std::function< void()> func)
	Creates a custom action.
std::shared_ptr< Kriya::BufferPipeline >	create_buffer_pipeline ()
	Creates a new buffer pipeline instance.
template<typename... Args>
MAYAFLUX_API bool	update_task_params (const std::string &name, Args... args)
	Updates parameters of a scheduled task.
bool	is_engine_initialized ()
	Checks if the default audio engine is initialized.
bool	is_initialized ()
	Checks if the default engine has been initialized.
Core::Engine &	get_context ()
	Gets the default engine instance.
void	set_and_transfer_context (Core::Engine instance)
	Replaces the default engine with a new instance.
void	Init ()
	Initializes the default engine with default settings.
void	Init (uint32_t sample_rate, uint32_t buffer_size=512, uint32_t num_out_channels=2, uint32_t num_in_channels=0)
	Initializes the default engine with specified parameters.
void	Init (Core::GlobalStreamInfo stream_info)
	Initializes the default engine with specified stream info.
void	Init (Core::GlobalStreamInfo stream_info, Core::GlobalGraphicsConfig graphics_config)
	Initializes the default engine with specified stream and graphics info.
void	Start ()
	Starts audio processing on the default engine.
void	Pause ()
	Pauses audio processing on the default engine.
void	Resume ()
	Resumes audio processing on the default engine.
void	End ()
	Stops and cleans up the default engine.
std::shared_ptr< MayaFlux::Kakshya::SoundFileContainer >	load_audio_file (const std::string &filepath)
	Loads an audio file into a SoundFileContainer with automatic format detection.
std::vector< std::shared_ptr< Buffers::ContainerBuffer > >	hook_sound_container_to_buffers (const std::shared_ptr< MayaFlux::Kakshya::SoundFileContainer > &container)
	Connects a SoundFileContainer to the buffer system for immediate playback.
std::shared_ptr< Buffers::TextureBuffer >	load_image_file (const std::string &filepath)
	Loads an image file into a TextureBuffer.
bool	is_image (const fs::path &filepath)
bool	is_audio (const fs::path &filepath)
template<typename ContainerType , typename... Args> requires std::derived_from<ContainerType, Kakshya::SignalSourceContainer>
auto	create_container (Args &&... args) -> std::shared_ptr< ContainerType >
	creates a new container of the specified type
MAYAFLUX_API bool	is_audio (const std::filesystem::path &filepath)
	Checks if the given file is an audio file based on its extension.
MAYAFLUX_API bool	is_image (const std::filesystem::path &filepath)
	Checks if the given file is an image file based on its extension.
std::shared_ptr< Nodes::NodeGraphManager >	get_node_graph_manager ()
	Gets the node graph manager from the default engine.
void	register_audio_node (const std::shared_ptr< Nodes::Node > &node, uint32_t channel=0)
	Adds a node to the root node of a specific channel.
void	register_audio_node (const std::shared_ptr< Nodes::Node > &node, const std::vector< uint32_t > &channels)
	Adds a node to the root node of specified channels.
void	unregister_audio_node (const std::shared_ptr< Nodes::Node > &node, uint32_t channel=0)
	Removes a node from the root node of a specific channel.
void	unregister_audio_node (const std::shared_ptr< Nodes::Node > &node, const std::vector< uint32_t > &channels)
	Removes a node from the root node from list of channels.
void	unregister_node (const std::shared_ptr< Nodes::Node > &node, const Nodes::ProcessingToken &token, uint32_t channel=0)
	Removes a node from the root node of specified channels.
Nodes::RootNode &	get_audio_channel_root (uint32_t channel=0)
	Gets the root node for a specific channel.
void	register_node (const std::shared_ptr< Nodes::Node > &node, const Nodes::ProcessingToken &token, uint32_t channel)
std::shared_ptr< Buffers::BufferManager >	get_buffer_manager ()
	Gets the buffer manager from the default engine.
void	add_processor (const std::shared_ptr< Buffers::BufferProcessor > &processor, const std::shared_ptr< Buffers::Buffer > &buffer, Buffers::ProcessingToken token=Buffers::ProcessingToken::AUDIO_BACKEND)
	Adds a processor to a specific buffer.
void	add_processor (const std::shared_ptr< Buffers::BufferProcessor > &processor, Buffers::ProcessingToken token, uint32_t channel)
	Adds a processor to all buffers in a specific channel.
void	add_processor (const std::shared_ptr< Buffers::BufferProcessor > &processor, Buffers::ProcessingToken token=Buffers::ProcessingToken::AUDIO_BACKEND)
	Adds a processor to all buffers in a processing domain.
std::shared_ptr< Buffers::BufferProcessingChain >	create_processing_chain ()
	Creates a new processing chain for the default engine.
Buffers::RootAudioBuffer &	get_root_audio_buffer (uint32_t channel)
	Gets the audio buffer for a specific channel.
void	connect_node_to_channel (const std::shared_ptr< Nodes::Node > &node, uint32_t channel_index=0, float mix=0.5F, bool clear_before=false)
	Connects a node to a specific output channel.
void	connect_node_to_buffer (const std::shared_ptr< Nodes::Node > &node, const std::shared_ptr< Buffers::AudioBuffer > &buffer, float mix=0.5F, bool clear_before=true)
	Connects a node to a specific buffer.
void	register_node_network (const std::shared_ptr< Nodes::NodeNetwork > &network, const Nodes::ProcessingToken &token=Nodes::ProcessingToken::AUDIO_RATE)
	Registers a node network with the default engine's node graph manager.
void	unregister_node_network (const std::shared_ptr< Nodes::NodeNetwork > &network, const Nodes::ProcessingToken &token=Nodes::ProcessingToken::AUDIO_RATE)
	Unregisters a node network from the default engine's node graph manager.
std::shared_ptr< Buffers::BufferProcessor >	attach_quick_process (Buffers::BufferProcessingFunction processor, const std::shared_ptr< Buffers::AudioBuffer > &buffer)
	Attaches a processing function to a specific buffer.
std::shared_ptr< Buffers::BufferProcessor >	attach_quick_process (Buffers::BufferProcessingFunction processor, unsigned int channel_id=0)
	Attaches a processing function to a specific channel.
void	register_audio_buffer (const std::shared_ptr< Buffers::AudioBuffer > &buffer, uint32_t channel=0)
	Registers an AudioBuffer with the default engine's buffer manager.
void	unregister_audio_buffer (const std::shared_ptr< Buffers::AudioBuffer > &buffer, uint32_t channel=0)
	Unregisters an AudioBuffer from the default engine's buffer manager.
void	register_graphics_buffer (const std::shared_ptr< Buffers::VKBuffer > &buffer, Buffers::ProcessingToken token=Buffers::ProcessingToken::GRAPHICS_BACKEND)
	Registers a VKBuffer with the default engine's buffer manager.
void	unregister_graphics_buffer (const std::shared_ptr< Buffers::VKBuffer > &buffer)
	Unregisters a VKBuffer from the default engine's buffer manager.
void	read_from_audio_input (const std::shared_ptr< Buffers::AudioBuffer > &buffer, uint32_t channel=0)
	Reads audio data from the default input source into a buffer.
void	detach_from_audio_input (const std::shared_ptr< Buffers::AudioBuffer > &buffer, uint32_t channel=0)
	Stops reading audio data from the default input source.
std::shared_ptr< Buffers::AudioBuffer >	create_input_listener_buffer (uint32_t channel=0, bool add_to_output=false)
	Creates a new AudioBuffer for input listening.
std::vector< std::shared_ptr< Buffers::AudioBuffer > >	clone_buffer_to_channels (const std::shared_ptr< Buffers::AudioBuffer > &buffer, const std::vector< uint32_t > &channels)
	Clones a buffer to multiple channels.
std::vector< std::shared_ptr< Buffers::AudioBuffer > >	clone_buffer_to_channels (const std::shared_ptr< Buffers::AudioBuffer > &buffer, const std::vector< uint32_t > &channels, const Buffers::ProcessingToken &token)
void	supply_buffer_to_channel (const std::shared_ptr< Buffers::AudioBuffer > &buffer, uint32_t channel, double mix=1.0)
	Supplies a buffer to a single channel with mixing.
void	supply_buffer_to_channels (const std::shared_ptr< Buffers::AudioBuffer > &buffer, const std::vector< uint32_t > &channels, double mix=1.0)
	Supplies a buffer to multiple channels with mixing.
void	remove_supplied_buffer_from_channel (const std::shared_ptr< Buffers::AudioBuffer > &buffer, const uint32_t channel)
	Removes a supplied buffer from multiple channels.
void	remove_supplied_buffer_from_channels (const std::shared_ptr< Buffers::AudioBuffer > &buffer, const std::vector< uint32_t > &channels)
	Removes a supplied buffer from multiple channels.
template<typename NodeType , typename... Args> requires std::derived_from<NodeType, Nodes::Node>
auto	create_node (Args &&... args) -> std::shared_ptr< NodeType >
template<typename NodeNetworkType , typename... Args> requires std::derived_from<NodeNetworkType, Nodes::NodeNetwork>
auto	create_node_network (Args &&... args) -> std::shared_ptr< NodeNetworkType >
	Creates a new node network.
template<typename BufferType , typename... Args> requires std::derived_from<BufferType, Buffers::AudioBuffer>
auto	create_buffer (uint32_t channel, uint32_t buffer_size, Args &&... args) -> std::shared_ptr< BufferType >
	creates a new buffer of the specified type and registers it
template<typename BufferType , typename... Args> requires std::derived_from<BufferType, Buffers::VKBuffer>
auto	create_buffer (Args &&... args) -> std::shared_ptr< BufferType >
	creates a new graphics buffer of the specified type and registers it
template<typename ProcessorType , typename... Args> requires std::derived_from<ProcessorType, Buffers::BufferProcessor>
auto	create_processor (const std::shared_ptr< Buffers::AudioBuffer > buffer, Args &&... args) -> std::shared_ptr< ProcessorType >
	Creates a new processor and adds it to a buffer.
template<typename ProcessorType , typename... Args> requires std::derived_from<ProcessorType, Buffers::BufferProcessor>
auto	create_processor (const std::shared_ptr< Buffers::VKBuffer > buffer, Args &&... args) -> std::shared_ptr< ProcessorType >
void	register_node (const std::shared_ptr< Nodes::Node > &node, const CreationContext &ctx)
void	register_network (const std::shared_ptr< Nodes::NodeNetwork > &network, const CreationContext &ctx)
void	register_buffer (const std::shared_ptr< Buffers::Buffer > &buffer, const CreationContext &ctx)
void	register_container (const std::shared_ptr< Kakshya::SoundFileContainer > &container, const Domain &domain)
std::vector< std::shared_ptr< Buffers::ContainerBuffer > >	get_last_created_container_buffers ()
	Retrieves the last created container buffers from the Creator.
std::shared_ptr< Nodes::Node >	operator| (const std::shared_ptr< Nodes::Node > &node, Domain d)
std::shared_ptr< Nodes::NodeNetwork >	operator| (const std::shared_ptr< Nodes::NodeNetwork > &network, Domain d)
std::shared_ptr< Buffers::Buffer >	operator| (const std::shared_ptr< Buffers::Buffer > &buffer, Domain d)
template<typename T >
auto	operator| (std::shared_ptr< T > obj, Domain d) -> CreationHandle< T >
Core::SubsystemTokens	decompose_domain (Domain domain)
	Decomposes a Domain enum into its constituent ProcessingTokens.
Domain	create_custom_domain (Nodes::ProcessingToken node_token, Buffers::ProcessingToken buffer_token, Vruta::ProcessingToken task_token)
	Creates a custom domain from individual tokens with validation.
bool	is_domain_valid (Domain domain)
	Checks if a domain is valid (all constituent tokens are compatible)
std::string	domain_to_string (Domain domain)
	Gets a human-readable string representation of a domain.
Domain	compose_domain (Nodes::ProcessingToken node_token, Buffers::ProcessingToken buffer_token, Vruta::ProcessingToken task_token)
	Composes individual ProcessingTokens into a unified Domain.
MAYAFLUX_API Nodes::ProcessingToken	get_node_token (Domain domain)
	Extracts node processing token from domain.
MAYAFLUX_API Buffers::ProcessingToken	get_buffer_token (Domain domain)
	Extracts buffer processing token from domain.
MAYAFLUX_API Vruta::ProcessingToken	get_task_token (Domain domain)
	Extracts task processing token from domain.
double	get_uniform_random (double start=0, double end=1)
	Generates a uniform random number.
double	get_gaussian_random (double start=0, double end=1)
	Generates a gaussian (normal) random number.
double	get_exponential_random (double start=0, double end=1)
	Generates an exponential random number.
double	get_poisson_random (double start=0, double end=1)
	Generates a poisson random number.
Core::WindowManager &	get_window_manager ()
	Gets a handle to default window manager.
std::shared_ptr< Core::Window >	create_window (const Core::WindowCreateInfo &create_info)
static bool	is_same_size (const std::vector< std::span< double > > &data)
static std::vector< double >	concat_vectors (const std::vector< std::span< double > > &data)
double	mean (const std::vector< double > &data)
	Calculate mean of single-channel data.
double	mean (const Kakshya::DataVariant &data)
std::vector< double >	mean_per_channel (const std::vector< Kakshya::DataVariant > &channels)
	Calculate mean per channel for multi-channel data.
double	mean_combined (const std::vector< Kakshya::DataVariant > &channels)
	Calculate mean across all channels (mix then analyze)
double	rms (const std::vector< double > &data)
	Calculate RMS (Root Mean Square) energy of single-channel data.
double	rms (const Kakshya::DataVariant &data)
std::vector< double >	rms_per_channel (const std::vector< Kakshya::DataVariant > &channels)
	Calculate RMS energy per channel for multi-channel data.
double	rms_combined (const std::vector< Kakshya::DataVariant > &channels)
	Calculate RMS energy across all channels (mix then analyze)
double	std_dev (const std::vector< double > &data)
	Calculate standard deviation of single-channel data.
double	std_dev (const Kakshya::DataVariant &data)
std::vector< double >	std_dev_per_channel (const std::vector< Kakshya::DataVariant > &channels)
	Calculate standard deviation per channel for multi-channel data.
double	std_dev_combined (const std::vector< Kakshya::DataVariant > &channels)
	Calculate standard deviation across all channels (mix then analyze)
double	dynamic_range (const std::vector< double > &data)
	Calculate dynamic range (max/min ratio in dB) of single-channel data.
double	dynamic_range (const Kakshya::DataVariant &data)
std::vector< double >	dynamic_range_per_channel (const std::vector< Kakshya::DataVariant > &channels)
	Calculate dynamic range per channel for multi-channel data.
double	dynamic_range_global (const std::vector< Kakshya::DataVariant > &channels)
	Calculate dynamic range across all channels (global min/max)
double	peak (const std::vector< double > &data)
	Find peak amplitude in single-channel data.
double	peak (const Kakshya::DataVariant &data)
double	peak (const std::vector< Kakshya::DataVariant > &channels)
	Find peak amplitude across all channels (global peak)
std::vector< double >	peak_per_channel (const std::vector< Kakshya::DataVariant > &channels)
	Find peak amplitude per channel for multi-channel data.
double	peak_channel (const std::vector< Kakshya::DataVariant > &channels, size_t channel_index)
	Find peak amplitude in specific channel.
std::vector< size_t >	zero_crossings (const std::vector< double > &data, double threshold=0.0)
	Detect zero crossings in single-channel signal.
std::vector< size_t >	zero_crossings (const Kakshya::DataVariant &data, double threshold)
std::vector< std::vector< size_t > >	zero_crossings_per_channel (const std::vector< Kakshya::DataVariant > &channels, double threshold=0.0)
	Detect zero crossings per channel for multi-channel signal.
double	zero_crossing_rate (const std::vector< double > &data, size_t window_size=0)
	Calculate zero crossing rate for single-channel data.
double	zero_crossing_rate (const Kakshya::DataVariant &data, size_t window_size)
std::vector< double >	zero_crossing_rate_per_channel (const std::vector< Kakshya::DataVariant > &channels, size_t window_size=0)
	Calculate zero crossing rate per channel for multi-channel data.
double	spectral_centroid (const std::vector< double > &data, double sample_rate=48000.0)
	Find spectral centroid (brightness measure) for single-channel data.
double	spectral_centroid (const Kakshya::DataVariant &data, double sample_rate)
std::vector< double >	spectral_centroid_per_channel (const std::vector< Kakshya::DataVariant > &channels, double sample_rate=48000.0)
	Find spectral centroid per channel for multi-channel data.
std::vector< double >	detect_onsets (const std::vector< double > &data, double sample_rate=48000.0, double threshold=0.1)
	Detect onset times in single-channel signal.
std::vector< double >	detect_onsets (const Kakshya::DataVariant &data, double sample_rate, double threshold)
std::vector< std::vector< double > >	detect_onsets_per_channel (const std::vector< Kakshya::DataVariant > &channels, double sample_rate=48000.0, double threshold=0.1)
	Detect onset times per channel for multi-channel signal.
void	apply_gain (std::vector< double > &data, double gain_factor)
	Apply gain to single-channel data (in-place)
void	apply_gain (Kakshya::DataVariant &data, double gain_factor)
void	apply_gain_channels (std::vector< Kakshya::DataVariant > &channels, double gain_factor)
	Apply gain to multi-channel data (in-place)
void	apply_gain_per_channel (std::vector< Kakshya::DataVariant > &channels, const std::vector< double > &gain_factors)
	Apply different gain to each channel (in-place)
std::vector< double >	with_gain (const std::vector< double > &data, double gain_factor)
	Apply gain to single-channel data (non-destructive)
Kakshya::DataVariant	with_gain (const Kakshya::DataVariant &data, double gain_factor)
std::vector< Kakshya::DataVariant >	with_gain_channels (const std::vector< Kakshya::DataVariant > &channels, double gain_factor)
	Apply gain to multi-channel data (non-destructive)
void	normalize (std::vector< double > &data, double target_peak=1.0)
	Normalize single-channel data to specified peak level (in-place)
void	normalize (Kakshya::DataVariant &data, double target_peak)
void	normalize_channels (std::vector< Kakshya::DataVariant > &channels, double target_peak=1.0)
	Normalize each channel independently to specified peak level (in-place)
void	normalize_together (std::vector< Kakshya::DataVariant > &channels, double target_peak=1.0)
	Normalize multi-channel data relative to global peak (in-place)
std::vector< double >	normalized (const std::vector< double > &data, double target_peak=1.0)
	Normalize single-channel data (non-destructive)
Kakshya::DataVariant	normalized (const Kakshya::DataVariant &data, double target_peak)
std::vector< Kakshya::DataVariant >	normalized_channels (const std::vector< Kakshya::DataVariant > &channels, double target_peak=1.0)
	Normalize each channel independently (non-destructive)
void	reverse (std::vector< double > &data)
	Reverse time order of single-channel data (in-place)
void	reverse (Kakshya::DataVariant &data)
void	reverse_channels (std::vector< Kakshya::DataVariant > &channels)
	Reverse time order of multi-channel data (in-place)
std::vector< double >	reversed (const std::vector< double > &data)
	Reverse time order of single-channel data (non-destructive)
Kakshya::DataVariant	reversed (const Kakshya::DataVariant &data)
std::vector< Kakshya::DataVariant >	reversed_channels (const std::vector< Kakshya::DataVariant > &channels)
	Reverse time order of multi-channel data (non-destructive)
std::vector< double >	magnitude_spectrum (const std::vector< double > &data, size_t window_size=0)
	Compute magnitude spectrum for single-channel data.
std::vector< double >	magnitude_spectrum (const Kakshya::DataVariant &data, size_t window_size)
std::vector< std::vector< double > >	magnitude_spectrum_per_channel (const std::vector< Kakshya::DataVariant > &channels, size_t window_size=0)
	Compute magnitude spectrum per channel for multi-channel data.
std::vector< double >	power_spectrum (const std::vector< double > &data, size_t window_size=0)
	Compute power spectrum for single-channel data.
std::vector< double >	power_spectrum (const Kakshya::DataVariant &data, size_t window_size)
std::vector< std::vector< double > >	power_spectrum_per_channel (const std::vector< Kakshya::DataVariant > &channels, size_t window_size=0)
	Compute power spectrum per channel for multi-channel data.
double	estimate_pitch (const std::vector< double > &data, double sample_rate=48000.0, double min_freq=80.0, double max_freq=2000.0)
	Estimate fundamental frequency using autocorrelation for single-channel data.
double	estimate_pitch (const Kakshya::DataVariant &data, double sample_rate, double min_freq, double max_freq)
std::vector< double >	estimate_pitch_per_channel (const std::vector< Kakshya::DataVariant > &channels, double sample_rate=48000.0, double min_freq=80.0, double max_freq=2000.0)
	Estimate fundamental frequency per channel for multi-channel data.
std::vector< double >	extract_silent_data (const std::vector< double > &data, double threshold, size_t min_silence_duration)
	Extract silent regions from single-channel data.
std::vector< double >	extract_silent_data (const Kakshya::DataVariant &data, double threshold, size_t min_silence_duration)
std::vector< double >	extract_zero_crossing_regions (const std::vector< double > &data, double threshold, size_t region_size)
	Extract zero crossing regions from single-channel data.
std::vector< double >	extract_zero_crossing_regions (const Kakshya::DataVariant &data, double threshold, size_t region_size)
void	apply_window (std::vector< double > &data, const std::string &window_type="hann")
	Apply window function to single-channel data (in-place)
void	apply_window (Kakshya::DataVariant &data, const std::string &window_type)
void	apply_window_channels (std::vector< Kakshya::DataVariant > &channels, const std::string &window_type="hann")
	Apply window function to multi-channel data (in-place)
std::vector< std::vector< double > >	windowed_segments (const std::vector< double > &data, size_t window_size, size_t hop_size)
	Split single-channel data into overlapping windows.
std::vector< std::vector< double > >	windowed_segments (const Kakshya::DataVariant &data, size_t window_size, size_t hop_size)
std::vector< std::vector< std::vector< double > > >	windowed_segments_per_channel (const std::vector< Kakshya::DataVariant > &channels, size_t window_size, size_t hop_size)
	Split multi-channel data into overlapping windows per channel.
std::vector< std::pair< size_t, size_t > >	detect_silence (const std::vector< double > &data, double threshold=0.01, size_t min_silence_duration=1024)
	Detect silence regions in single-channel data.
std::vector< std::pair< size_t, size_t > >	detect_silence (const Kakshya::DataVariant &data, double threshold, size_t min_silence_duration)
std::vector< std::vector< std::pair< size_t, size_t > > >	detect_silence_per_channel (const std::vector< Kakshya::DataVariant > &channels, double threshold=0.01, size_t min_silence_duration=1024)
	Detect silence regions per channel for multi-channel data.
std::vector< double >	mix (const std::vector< std::vector< double > > &streams)
	Mix multiple data streams with equal weighting.
std::vector< double >	mix (const std::vector< Kakshya::DataVariant > &streams)
std::vector< double >	mix_with_gains (const std::vector< std::vector< double > > &streams, const std::vector< double > &gains)
	Mix multiple data streams with specified gains.
std::vector< double >	mix_with_gains (const std::vector< Kakshya::DataVariant > &streams, const std::vector< double > &gains)
std::vector< double >	to_double_vector (const Kakshya::DataVariant &data)
	Convert DataVariant to vector<double> if possible.
Kakshya::DataVariant	to_data_variant (const std::vector< double > &data)
	Convert vector<double> to DataVariant.
std::vector< std::vector< double > >	to_double_vectors (const std::vector< Kakshya::DataVariant > &channels)
	Convert multi-channel data to vector of double vectors.
std::vector< Kakshya::DataVariant >	to_data_variants (const std::vector< std::vector< double > > &channel_data)
	Convert vector of double vectors to multi-channel DataVariant format.
void	initialize_yantra ()
	Initialize Yantra subsystem with default configuration.
MAYAFLUX_API Kakshya::DataVariant	mix_to_mono (const std::vector< Kakshya::DataVariant > &channels)
	Mix multi-channel data to mono using equal weighting.
MAYAFLUX_API std::pair< Kakshya::DataVariant, Kakshya::DataVariant >	stereo_to_mid_side (const std::vector< Kakshya::DataVariant > &lr_channels)
	Convert stereo L/R channels to Mid/Side format.
MAYAFLUX_API std::pair< Kakshya::DataVariant, Kakshya::DataVariant >	mid_side_to_stereo (const std::vector< Kakshya::DataVariant > &ms_channels)
	Convert Mid/Side channels to stereo L/R format.
MAYAFLUX_API double	stereo_width (const std::vector< Kakshya::DataVariant > &lr_channels)
	Calculate stereo width measure for L/R channels.
MAYAFLUX_API std::vector< double >	channel_correlation_matrix (const std::vector< Kakshya::DataVariant > &channels)
	Calculate correlation matrix between all channel pairs.
MAYAFLUX_API double	phase_correlation (const Kakshya::DataVariant &channel1, const Kakshya::DataVariant &channel2)
	Calculate phase correlation between two channels.
MAYAFLUX_API MultiChannelFeatures	analyze_channels (const std::vector< Kakshya::DataVariant > &channels)
	Comprehensive multi-channel analysis in single operation.

Variables
Creator	vega {}
	Global Creator instance for creating nodes, buffers, and containers.
static constexpr auto	Audio = Domain::AUDIO
	Domain constant for Audio domain.
static constexpr auto	Graphics = Domain::GRAPHICS
	Domain constant for Graphics domain.
static std::vector< std::shared_ptr< Buffers::ContainerBuffer > >	s_last_created_container_buffers

Detailed Description

Main namespace for the Maya Flux audio engine.

This namespace provides convenience wrappers around the core functionality of the Maya Flux audio engine. These wrappers simplify access to the centrally managed components and common operations, making it easier to work with the engine without directly managing the Engine instance.

All functions in this namespace operate on the default Engine instance and its managed components. For custom or non-default components, use their specific handles and methods directly rather than these wrappers.