process()

void MayaFlux::Kakshya::CursorAccessProcessor::process ( const std::shared_ptr< SignalSourceContainer > &  container )

overridevirtual

Extract one block of frames into container processed_data[0].

If inactive, fills processed_data[0] with silence and returns. Advances m_cursor by m_frames_per_block after each active read. On reaching the loop end, wraps to m_loop_start if looping, otherwise deactivates and fires m_on_end if set.

Parameters

container

Must be the DynamicSoundStream passed to on_attach.

Implements MayaFlux::Kakshya::DataProcessor.

Definition at line 48 of file CursorAccessProcessor.cpp.

{
    m_is_processing.store(true, std::memory_order_relaxed);
 
    auto stream = std::dynamic_pointer_cast<DynamicSoundStream>(container);
    if (!stream) {
        MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "CursorAccessProcessor requires a DynamicSoundStream");
        m_is_processing.store(false, std::memory_order_relaxed);
        return;
    }
 
    auto& pd = stream->get_dynamic_data(m_slot_index);
 
    if (!m_active) {
        const uint64_t num_channels = m_structure.get_channel_count();
        if (m_structure.organization == OrganizationStrategy::INTERLEAVED) {
            pd.resize(1);
            std::get<std::vector<double>>(pd[0]).assign(m_frames_per_block * num_channels, 0.0);
        } else {
            pd.resize(num_channels);
            for (auto& ch : pd)
                std::get<std::vector<double>>(ch).assign(m_frames_per_block, 0.0);
        }
        m_is_processing.store(false, std::memory_order_relaxed);
        return;
    }
 
    if (m_time_map && m_time_map->fn) {
        process_mapped(*stream, pd);
        m_is_processing.store(false, std::memory_order_relaxed);
        return;
    }
 
    const uint64_t frame = m_cursor.empty() ? 0 : m_cursor[0];
 
    const uint64_t total_frames = m_structure.get_samples_count_per_channel();
    const uint64_t read_end = std::min(frame + m_frames_per_block - 1, total_frames - 1);
 
    const Region region {
        std::vector<uint64_t> { frame, 0 },
        std::vector<uint64_t> { read_end, m_structure.get_channel_count() - 1 }
    };
 
    auto region_data = container->get_region_data(region);
 
    if (m_structure.organization == OrganizationStrategy::INTERLEAVED) {
        pd.resize(1);
        if (!region_data.empty())
            safe_copy_data_variant(region_data[0], pd[0]);
    } else {
        const uint64_t ch_count = std::min(
            static_cast<uint64_t>(region_data.size()),
            m_structure.get_channel_count());
        pd.resize(ch_count);
        for (size_t c = 0; c < ch_count; ++c)
            safe_copy_data_variant(region_data[c], pd[c]);
    }
 
    const double raw_advance = static_cast<double>(m_frames_per_block) * m_speed + m_speed_remainder;
    const auto int_advance = static_cast<uint64_t>(raw_advance);
    m_speed_remainder = raw_advance - static_cast<double>(int_advance);
 
    const uint64_t next = frame + int_advance;
    const uint64_t loop_end = m_loop_end;
 
    if (next >= loop_end) {
        if (m_looping) {
            if (m_loop_count > 0) {
                --m_loops_remaining;
                if (m_loops_remaining == 0) {
                    m_active = false;
                    m_speed_remainder = 0.0;
                    m_cursor.assign(m_cursor.size(), m_loop_start);
                    if (m_on_end)
                        m_on_end();
                    m_is_processing.store(false, std::memory_order_relaxed);
                    return;
                }
            }
            m_speed_remainder = 0.0;
            m_cursor.assign(m_cursor.size(), m_loop_start);
        } else {
            m_active = false;
            m_speed_remainder = 0.0;
            m_cursor.assign(m_cursor.size(), m_loop_start);
            if (m_on_end)
                m_on_end();
        }
    } else {
        m_cursor.assign(m_cursor.size(), next);
    }
 
    m_is_processing.store(false, std::memory_order_relaxed);
}

References MayaFlux::Journal::ContainerProcessing, MayaFlux::Kakshya::ContainerDataStructure::get_channel_count(), MayaFlux::Kakshya::ContainerDataStructure::get_samples_count_per_channel(), MayaFlux::Kakshya::INTERLEAVED, MayaFlux::Journal::Kakshya, loop_end(), m_active, m_cursor, m_frames_per_block, m_is_processing, m_loop_count, m_loop_end, m_loop_start, m_looping, m_loops_remaining, m_on_end, m_slot_index, m_speed, m_speed_remainder, m_structure, m_time_map, MF_RT_ERROR, MayaFlux::Kakshya::ContainerDataStructure::organization, process_mapped(), MayaFlux::Kakshya::safe_copy_data_variant(), and stream.

Here is the call graph for this function: