process_output()

int MayaFlux::Core::AudioSubsystem::process_output	(	double *	output_buffer,
		unsigned int	num_frames
	)

Processes output data for audio interface.

Parameters

output_buffer	Pointer to interleaved output buffer
num_frames	Number of frames to process

Returns

Status code (0 for success)

Processes node graph and buffer operations, then fills the output buffer with processed audio data in interleaved format for the audio interface. This is the main processing entry point called by audio callbacks.

Definition at line 73 of file AudioSubsystem.cpp.

{
    m_callback_active.fetch_add(1, std::memory_order_acquire);
 
    if (output_buffer == nullptr) {
        MF_RT_ERROR(Journal::Component::Core, Journal::Context::AudioCallback,
            "No output available");
        m_callback_active.fetch_sub(1, std::memory_order_release);
        return 1;
    }
 
    if (!m_is_running.load(std::memory_order_acquire)) {
        if (output_buffer) {
            auto total_samples = static_cast<uint32_t>(num_frames * m_stream_info.output.channels);
            std::memset(output_buffer, 0, total_samples * sizeof(double));
        }
        m_callback_active.fetch_sub(1, std::memory_order_release);
        return 0;
    }
 
    if (m_handle == nullptr) {
        MF_RT_ERROR(Journal::Component::Core, Journal::Context::AudioCallback,
            "Invalid processing handle");
        m_callback_active.fetch_sub(1, std::memory_order_release);
        return 1;
    }
 
    try {
        uint32_t num_channels = m_stream_info.output.channels;
        size_t total_samples = static_cast<size_t>(num_frames) * num_channels;
        std::span<double> output_span(output_buffer, total_samples);
 
        m_handle->nodes.update_routing_states();
        m_handle->buffers.update_routing_states();
 
        std::vector<std::span<const double>> buffer_data(num_channels);
        std::vector<std::vector<std::vector<double>>> all_network_outputs(num_channels);
        bool has_underrun = false;
 
        m_handle->tasks.process_buffer_cycle();
 
        for (uint32_t channel = 0; channel < num_channels; channel++) {
            m_handle->buffers.process_channel(channel, num_frames);
            all_network_outputs[channel] = m_handle->nodes.process_audio_networks(num_frames, channel);
 
            auto channel_data = m_handle->buffers.read_channel_data(channel);
 
            if (channel_data.size() < num_frames) {
                MF_RT_WARN(Journal::Component::Core, Journal::Context::AudioCallback,
                    "Channel buffer underrun");
                has_underrun = true;
 
                buffer_data[channel] = std::span<const double>();
            } else {
                buffer_data[channel] = channel_data;
            }
        }
 
        for (size_t i = 0; i < num_frames; ++i) {
 
            m_handle->tasks.process(1);
 
            for (size_t j = 0; j < num_channels; ++j) {
                double buffer_sample = 0.0;
                if (!buffer_data[j].empty() && i < buffer_data[j].size()) {
                    buffer_sample = buffer_data[j][i];
                }
 
                double sample = m_handle->nodes.process_sample(j) + buffer_sample;
 
                for (const auto& network_buffer : all_network_outputs[j]) {
                    if (i < network_buffer.size()) {
                        sample += network_buffer[i];
                    }
                }
 
                size_t index = i * num_channels + j;
                output_span[index] = std::clamp(sample, -1., 1.);
            }
        }
 
        m_handle->nodes.cleanup_completed_routing();
        m_handle->buffers.cleanup_completed_routing();
 
        if (m_snapshot_copy.size() != total_samples)
            m_snapshot_copy.resize(total_samples);
 
        std::memcpy(m_snapshot_copy.data(), output_buffer, total_samples * sizeof(double));
        m_snapshot_size.store(static_cast<uint32_t>(total_samples), std::memory_order_release);
        m_snapshot_ptr.store(m_snapshot_copy.data(), std::memory_order_release);
        m_snapshot_generation.fetch_add(1, std::memory_order_release);
        m_snapshot_generation.notify_all();
 
        m_callback_active.fetch_sub(1, std::memory_order_release);
        return has_underrun ? 1 : 0;
 
    } catch (const std::exception& e) {
        MF_RT_ERROR(Journal::Component::Core, Journal::Context::AudioCallback,
            "Exception during audio output processing: {}", e.what());
 
        if (output_buffer) {
            auto total_samples = static_cast<uint32_t>(num_frames * m_stream_info.output.channels);
            std::memset(output_buffer, 0, total_samples * sizeof(double));
        }
 
        m_callback_active.fetch_sub(1, std::memory_order_release);
        return 1;
    }
}

References MayaFlux::Journal::AudioCallback, MayaFlux::Core::SubsystemProcessingHandle::buffers, MayaFlux::Core::GlobalStreamInfo::ChannelConfig::channels, MayaFlux::Core::BufferProcessingHandle::cleanup_completed_routing(), MayaFlux::Core::NodeProcessingHandle::cleanup_completed_routing(), MayaFlux::Journal::Core, m_callback_active, m_handle, m_is_running, m_snapshot_copy, m_snapshot_generation, m_snapshot_ptr, m_snapshot_size, m_stream_info, MF_RT_ERROR, MF_RT_WARN, MayaFlux::Core::SubsystemProcessingHandle::nodes, MayaFlux::Core::GlobalStreamInfo::output, MayaFlux::Core::TaskSchedulerHandle::process(), MayaFlux::Core::NodeProcessingHandle::process_audio_networks(), MayaFlux::Core::TaskSchedulerHandle::process_buffer_cycle(), MayaFlux::Core::BufferProcessingHandle::process_channel(), MayaFlux::Core::NodeProcessingHandle::process_sample(), MayaFlux::Core::BufferProcessingHandle::read_channel_data(), MayaFlux::Core::SubsystemProcessingHandle::tasks, MayaFlux::Core::BufferProcessingHandle::update_routing_states(), and MayaFlux::Core::NodeProcessingHandle::update_routing_states().

Referenced by process_audio(), and register_callbacks().

Here is the call graph for this function:

Here is the caller graph for this function: