transform_crossfade_regions() [2/2]

template<OperationReadyData DataType>

DataType MayaFlux::Yantra::transform_crossfade_regions	(	DataType &	input,
		const std::vector< std::pair< Kakshya::Region, Kakshya::Region > > &	fade_regions,
		uint32_t	fade_duration,
		std::vector< std::vector< double > > &	working_buffer
	)

Cross-fade between regions with smooth transitions (OUT-OF-PLACE)

Template Parameters

DataType

OperationReadyData type

Parameters

input	Input data - will NOT be modified
fade_regions	Pairs of regions to crossfade
fade_duration	Duration of fade in samples
working_buffer	Buffer for operations (will be resized if needed)

Returns

Crossfaded data

Definition at line 364 of file MatrixHelper.hpp.

{
    // OLD: auto [target_data, structure_info] = OperationHelper::setup_operation_buffer(input, working_buffer);
    auto setup_result = OperationHelper::setup_operation_buffer(input, working_buffer);
    auto& target_data = std::get<0>(setup_result);
    auto& structure_info = std::get<1>(setup_result);
 
    std::ranges::for_each(fade_regions, [&target_data, fade_duration](const auto& fade_pair) {
        const auto& [region_a, region_b] = fade_pair;
 
        auto start_a = static_cast<uint64_t>(region_a.start_coordinates[0]);
        auto end_a = static_cast<uint64_t>(region_a.end_coordinates[0]);
        auto start_b = static_cast<uint64_t>(region_b.start_coordinates[0]);
 
        uint64_t fade_start = (end_a > fade_duration) ? end_a - fade_duration : 0;
        uint64_t fade_end = std::min(start_b + fade_duration, static_cast<uint64_t>(target_data[0].size()));
 
        for (auto& channel_span : target_data) {
            if (fade_start < fade_end && fade_start < channel_span.size()) {
                auto fade_span = channel_span.subspan(fade_start, fade_end - fade_start);
 
                auto fade_indices = std::views::iota(size_t { 0 }, fade_span.size());
                std::ranges::for_each(fade_indices, [&fade_span](size_t i) {
                    double ratio = static_cast<double>(i) / (fade_span.size() - 1);
                    double smooth_ratio = 0.5 * (1.0 - std::cos(ratio * M_PI));
                    fade_span[i] *= (1.0 - smooth_ratio);
                });
            }
        }
    });
 
    return OperationHelper::reconstruct_from_double<DataType>(working_buffer, structure_info);
}

References MayaFlux::Yantra::OperationHelper::setup_operation_buffer().

Here is the call graph for this function: