reconstruct_grains_stream

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

Grammar rule executor — concatenative reconstruct into DynamicSoundStream.

Definition at line 218 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_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_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);
 
    std::vector<std::vector<double>> channel_data(num_ch);
    for (uint32_t ch = 0; ch < num_ch; ++ch)
        channel_data[ch].reserve(regions.size() * grain_sz);
 
    Kakshya::iterate_region_channels(regions, source, num_ch, {},
        [&channel_data](size_t /*gi*/, uint32_t ch, std::span<double> samples) {
            channel_data[ch].insert(channel_data[ch].end(), samples.begin(), samples.end());
        });
 
    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().