process_mapped()

void MayaFlux::Kakshya::CursorAccessProcessor::process_mapped ( DynamicSoundStream &  stream, std::vector< DataVariant > &  pd  )

private

Definition at line 144 of file CursorAccessProcessor.cpp.

{
    const uint64_t block = m_frames_per_block;
    const uint64_t channels = m_structure.get_channel_count();
    const bool interleaved = m_structure.organization == OrganizationStrategy::INTERLEAVED;
 
    const auto rate = static_cast<double>(stream.get_sample_rate());
    const auto lo = static_cast<double>(m_loop_start);
    const auto hi = static_cast<double>(m_loop_end);
    m_gather_frames.resize(2 * block);
    m_gather_weights.resize(block);
 
    const bool repeating = m_repeat && m_repeat->fn;
    bool exited = m_loop_end <= m_loop_start;
    double last_position = lo;
    uint64_t valid = 0;
 
    while (!exited && valid < block) {
        const uint64_t clock = m_clock_frames + valid;
        uint64_t stop = block;
 
        if (repeating) {
            if (m_repeat_length == 0 || clock - m_repeat_start >= m_repeat_length) {
                m_repeat_start = clock;
                const double seconds = std::max((*m_repeat)(static_cast<double>(clock) / rate), 0.0);
                m_repeat_length = std::max<uint64_t>(1, static_cast<uint64_t>(std::llround(seconds * rate)));
            }
 
            stop = std::min(block, valid + (m_repeat_start + m_repeat_length - clock));
        }
 
        const uint64_t origin = repeating ? m_repeat_start : 0;
        const uint64_t begin = valid;
        const uint64_t frames = stop - begin;
        const auto span = static_cast<double>(frames);
        const double p_a = (*m_time_map)(static_cast<double>(clock - origin) / rate);
        const double p_b = (*m_time_map)(static_cast<double>(clock + frames - origin) / rate);
        last_position = p_b;
 
        for (; valid < stop; ++valid) {
            const double u = p_a + (p_b - p_a) * static_cast<double>(valid - begin) / span;
 
            if (!m_looping && (u < lo || u >= hi)) {
                exited = true;
                break;
            }
 
            const double s = m_looping ? Kinesis::wrap<double>(u, lo, hi) : u;
            const double whole = std::floor(s);
            const uint64_t i = std::min(static_cast<uint64_t>(whole), m_loop_end - 1);
            const uint64_t next = i + 1 < m_loop_end ? i + 1 : (m_looping ? m_loop_start : i);
 
            m_gather_frames[2 * valid] = i;
            m_gather_frames[2 * valid + 1] = next;
            m_gather_weights[valid] = s - whole;
        }
    }
 
    m_gather_taps.resize(2 * block * channels);
    stream.gather_frames(
        std::span<const uint64_t>(m_gather_frames.data(), 2 * valid),
        std::span<double>(m_gather_taps.data(), 2 * valid * channels));
 
    const auto blend = [&](uint64_t n, uint64_t c) {
        const double w = m_gather_weights[n];
        return m_gather_taps[(2 * n) * channels + c] * (1.0 - w)
            + m_gather_taps[(2 * n + 1) * channels + c] * w;
    };
 
    if (interleaved) {
        pd.resize(1);
        auto& out = std::get<std::vector<double>>(pd[0]);
        out.assign(block * channels, 0.0);
        for (uint64_t n = 0; n < valid; ++n) {
            for (uint64_t c = 0; c < channels; ++c) {
                out[n * channels + c] = blend(n, c);
            }
        }
    } else {
        pd.resize(channels);
        for (uint64_t c = 0; c < channels; ++c) {
            auto& out = std::get<std::vector<double>>(pd[c]);
            out.assign(block, 0.0);
            for (uint64_t n = 0; n < valid; ++n) {
                out[n] = blend(n, c);
            }
        }
    }
 
    m_clock_frames += block;
 
    if (exited) {
        m_active = false;
        m_clock_frames = 0;
        m_cursor.assign(m_cursor.size(), m_loop_start);
        if (m_on_end)
            m_on_end();
        return;
    }
 
    const double end = m_looping ? Kinesis::wrap<double>(last_position, lo, hi) : std::clamp(last_position, lo, hi - 1.0);
    m_cursor.assign(m_cursor.size(), static_cast<uint64_t>(std::max(end, lo)));
}

References channels, MayaFlux::Kakshya::ContainerDataStructure::get_channel_count(), MayaFlux::Kakshya::INTERLEAVED, m_active, m_clock_frames, m_cursor, m_frames_per_block, m_gather_frames, m_gather_taps, m_gather_weights, m_loop_end, m_loop_start, m_looping, m_on_end, m_repeat, m_repeat_length, m_repeat_start, m_structure, MayaFlux::Kakshya::ContainerDataStructure::organization, out, rate, stop(), and stream.

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function: