reconstruct_grains_additive_stream

const ComputationGrammar::Rule::Executor MayaFlux::Yantra::Granular::reconstruct_grains_additive_stream

Grammar rule executor — OLA reconstruct into DynamicSoundStream.

Definition at line 270 of file GranularWorkflow.cpp.

                                                                   {
    auto datum = safe_any_cast_or_throw<Datum<Kakshya::RegionGroup>>(input);
    const auto& regions = datum.data.regions;
 
    if (regions.empty()) {
        error<std::runtime_error>(Journal::Component::Yantra, Journal::Context::ComputeMatrix,
            std::source_location::current(), "reconstruct_grains_additive_stream: RegionGroup contains no grains");
    }
 
    if (!datum.container || !*datum.container) {
        error<std::runtime_error>(Journal::Component::Yantra, Journal::Context::ComputeMatrix,
            std::source_location::current(), "reconstruct_grains_additive_stream: no source container in datum");
    }
 
    auto source = *datum.container;
    const auto num_ch = static_cast<uint32_t>(source->get_structure().get_channel_count());
    const uint32_t sample_rate = [&]() -> uint32_t {
        if (auto sc = std::dynamic_pointer_cast<Kakshya::SoundStreamContainer>(source))
            return sc->get_sample_rate();
        return 48000U;
    }();
 
    const auto grain_sz = safe_any_cast_or_default<uint32_t>(
        datum.data.get_attribute<uint32_t>("grain_size").has_value()
            ? std::any(datum.data.get_attribute<uint32_t>("grain_size").value())
            : std::any {},
        1024U);
    const auto hop_sz = safe_any_cast_or_default<uint32_t>(
        datum.data.get_attribute<uint32_t>("hop_size").has_value()
            ? std::any(datum.data.get_attribute<uint32_t>("hop_size").value())
            : std::any {},
        grain_sz);
 
    const auto taper = safe_any_cast_or_default<GrainTaper>(
        ctx.execution_metadata.contains("grain_taper")
            ? ctx.execution_metadata.at("grain_taper")
            : std::any {},
        GrainTaper {});
 
    const uint64_t out_frames = hop_sz * regions.size() + grain_sz;
    std::vector<std::vector<double>> channel_data(num_ch, std::vector<double>(out_frames, 0.0));
 
    Kakshya::iterate_region_channels(regions, source, num_ch, {},
        [&](size_t gi, uint32_t ch, std::span<double> samples) {
            std::vector<double> grain(samples.begin(), samples.end());
            if (taper)
                taper(grain);
            const uint64_t offset = gi * hop_sz;
            for (uint64_t i = 0; i < grain.size() && offset + i < out_frames; ++i)
                channel_data[ch][offset + i] += grain[i];
        });
 
    auto stream = std::make_shared<Kakshya::DynamicSoundStream>(sample_rate, num_ch);
 
    std::vector<std::span<const double>> spans;
    spans.reserve(num_ch);
    for (auto& ch : channel_data)
        spans.emplace_back(ch);
 
    stream->write_frames(spans, 0);
 
    return Datum<std::shared_ptr<Kakshya::SignalSourceContainer>> {
        std::dynamic_pointer_cast<Kakshya::SignalSourceContainer>(stream), {}
    };
};

Referenced by make_granular_matrix().