write_frames() [1/2]

uint64_t MayaFlux::Kakshya::DynamicSoundStream::write_frames	(	std::span< const double >	data,
		uint64_t	start_frame = 0,
		uint32_t	channel = 0
	)

Write audio frame data to the container with automatic capacity management.

Parameters

data	Span of interleaved audio samples to write
start_frame	Frame index where writing begins (default: append at end) %
channel	Channel index for planar data (default: 0)

Returns

Number of frames actually written

Definition at line 166 of file DynamicSoundStream.cpp.

{
    auto num_frames = validate_single_channel(data, start_frame, channel);
    if (!num_frames)
        return 0;
 
    if (m_is_circular && start_frame + num_frames > m_circular_capacity) {
        uint64_t frames_to_end = m_circular_capacity - start_frame;
        uint64_t frames_from_start = num_frames - frames_to_end;
        if (frames_to_end > 0)
            write_frames(data.subspan(0, frames_to_end), start_frame, channel);
        if (frames_from_start > 0)
            write_frames(data.subspan(frames_to_end, frames_from_start), 0, channel);
        return num_frames;
    }
 
    if (m_structure.organization == OrganizationStrategy::INTERLEAVED) {
        Memory::SeqlockWriteGuard g(m_data_lock);
        if (m_data.empty())
            expand_to(start_frame + num_frames);
 
        auto& interleaved_data = std::get<std::vector<double>>(m_data[0]);
        const uint32_t num_channels = get_num_channels();
 
        for (uint64_t frame = 0; frame < num_frames; ++frame) {
            uint64_t idx = (start_frame + frame) * num_channels + channel;
            if (idx < interleaved_data.size())
                interleaved_data[idx] = data[frame];
        }
    } else {
        Memory::SeqlockWriteGuard g(m_data_lock);
        if (channel >= m_data.size())
            return 0;
 
        auto dest_span = convert_variant<double>(m_data[channel]);
        if (start_frame + num_frames > dest_span.size()) {
            std::vector<double> current_data(dest_span.begin(), dest_span.end());
            current_data.resize(start_frame + num_frames, 0.0);
            m_data[channel] = DataVariant(std::move(current_data));
            dest_span = convert_variant<double>(m_data[channel]);
        }
 
        std::copy(data.begin(), data.begin() + num_frames,
            dest_span.begin() + start_frame);
    }
 
    if (m_is_circular)
        m_num_frames = std::min(m_circular_capacity, m_num_frames);
 
    invalidate_span_cache();
    m_double_extraction_dirty.store(true, std::memory_order_release);
    return num_frames;
}

References expand_to(), MayaFlux::Kakshya::SoundStreamContainer::get_num_channels(), MayaFlux::Kakshya::INTERLEAVED, MayaFlux::Kakshya::SoundStreamContainer::invalidate_span_cache(), m_circular_capacity, MayaFlux::Kakshya::SoundStreamContainer::m_data, MayaFlux::Kakshya::SoundStreamContainer::m_data_lock, MayaFlux::Kakshya::SoundStreamContainer::m_double_extraction_dirty, m_is_circular, MayaFlux::Kakshya::SoundStreamContainer::m_num_frames, MayaFlux::Kakshya::SoundStreamContainer::m_structure, MayaFlux::Kakshya::ContainerDataStructure::organization, validate_single_channel(), and write_frames().

Referenced by write_frames(), and write_frames().

Here is the call graph for this function:

Here is the caller graph for this function: