peek_sequential()

uint64_t MayaFlux::Kakshya::SoundStreamContainer::peek_sequential ( std::span< double >  output, uint64_t  count, uint64_t  offset = 0  ) const

overridevirtual

Peek at data without advancing the read position.

Parameters

output	Buffer to write data into
count	Number of elements to peek
offset	Offset from current position in primary dimension

Returns

Actual number of elements read

Enables lookahead, preview, or non-destructive inspection of stream data.

Implements MayaFlux::Kakshya::StreamContainer.

Definition at line 556 of file SoundStreamContainer.cpp.

{
    auto interleaved_span = get_data_as_double();
    if (interleaved_span.empty() || output.empty())
        return 0;
 
    uint64_t start_frame = m_read_position.empty() ? 0 : m_read_position[0].load();
    start_frame += offset;
    uint64_t elements_to_read = std::min<uint64_t>(count, static_cast<uint64_t>(output.size()));
 
    if (!m_looping_enabled) {
        uint64_t linear_start = start_frame * m_num_channels;
        if (linear_start >= interleaved_span.size()) {
            std::ranges::fill(output, 0.0);
            return 0;
        }
        auto view = interleaved_span
            | std::views::drop(linear_start)
            | std::views::take(elements_to_read);
 
        auto copied = std::ranges::copy(view, output.begin());
        std::ranges::fill(output.subspan(copied.out - output.begin()), 0.0);
        return static_cast<uint64_t>(copied.out - output.begin());
    }
 
    if (m_loop_region.start_coordinates.empty()) {
        std::ranges::fill(output, 0.0);
        return 0;
    }
 
    uint64_t loop_start_frame = m_loop_region.start_coordinates[0];
    uint64_t loop_end_frame = m_loop_region.end_coordinates[0];
    uint64_t loop_length_frames = loop_end_frame - loop_start_frame + 1;
 
    std::ranges::for_each(
        std::views::iota(0UZ, elements_to_read),
        [&](uint64_t i) {
            uint64_t element_pos = start_frame * m_num_channels + i;
            uint64_t frame_pos = element_pos / m_num_channels;
            uint64_t channel_offset = element_pos % m_num_channels;
 
            uint64_t wrapped_frame = ((frame_pos - loop_start_frame) % loop_length_frames) + loop_start_frame;
            uint64_t wrapped_element = wrapped_frame * m_num_channels + channel_offset;
 
            output[i] = (wrapped_element < interleaved_span.size()) ? interleaved_span[wrapped_element] : 0.0;
        });
 
    if (elements_to_read < output.size()) {
        std::ranges::fill(output.subspan(elements_to_read), 0.0);
    }
    return elements_to_read;
}

References MayaFlux::Kakshya::Region::end_coordinates, get_data_as_double(), m_loop_region, m_looping_enabled, m_num_channels, m_read_position, and MayaFlux::Kakshya::Region::start_coordinates.

Referenced by read_sequential().

Here is the call graph for this function:

Here is the caller graph for this function: