reconstruct_grains_additive

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

Grammar rule executor for additive grain reconstruction.

Definition at line 159 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: 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: no source container in datum");
    }
 
    auto source = *datum.container;
    const auto num_ch = static_cast<uint32_t>(source->get_structure().get_channel_count());
    const auto org = source->get_structure().organization;
    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 size_t out_len = (regions.size() - 1) * hop_sz + grain_sz;
    std::vector<std::vector<double>> channel_data(num_ch, std::vector<double>(out_len, 0.0));
 
    Kakshya::iterate_region_channels(regions, source, num_ch, taper,
        [&channel_data, hop_sz](size_t gi, uint32_t ch, std::span<double> samples) {
            const size_t offset = gi * hop_sz;
            auto& dest = channel_data[ch];
            for (size_t s = 0; s < samples.size() && offset + s < dest.size(); ++s)
                dest[offset + s] += samples[s];
        });
 
    return Datum<std::shared_ptr<Kakshya::SignalSourceContainer>> {
        std::dynamic_pointer_cast<Kakshya::SignalSourceContainer>(
            Kakshya::make_sound_file_container(std::move(channel_data), num_ch, sample_rate, org)),
        {}
    };
};

Referenced by make_granular_matrix().