transform_implementation()

template<ComputeData InputType = std::vector<Kakshya::DataVariant>, ComputeData OutputType = InputType>

output_type MayaFlux::Yantra::SpectralTransformer< InputType, OutputType >::transform_implementation ( input_type &  input )

inlineoverrideprotectedvirtual

Applies the configured spectral operation.

Parameters

input

Input data

Returns

Transformed output

Extracts per-channel double spans, calls the corresponding Kinesis::Discrete::Spectral primitive on each channel, then reconstructs the typed output via OperationHelper.

FREQUENCY_SHIFT is implemented as a bandpass repositioning matching the prior behaviour. True single-sideband frequency shift (complex exponential modulation) is a separate primitive.

Implements MayaFlux::Yantra::UniversalTransformer< InputType, OutputType >.

Definition at line 80 of file SpectralTransformer.hpp.

    {
        switch (m_operation) {
 
        case SpectralOperation::FREQUENCY_SHIFT: {
            const auto shift_hz = get_parameter_or<double>("shift_hz", 0.0);
            const auto window_size = get_parameter_or<uint32_t>("window_size", 1024);
            const auto hop_size = get_parameter_or<uint32_t>("hop_size", 512);
            const auto sample_rate = get_parameter_or<double>("sample_rate", 48000.0);
            const double lo = std::max(0.0, shift_hz);
            const double hi = sample_rate / 2.0 + shift_hz;
 
            return apply_per_channel(input,
                [lo, hi, sample_rate, window_size, hop_size](std::span<double> ch) {
                    return D::spectral_filter(ch, lo, hi, sample_rate, window_size, hop_size);
                });
        }
 
        case SpectralOperation::PITCH_SHIFT: {
            const auto pitch_ratio = get_parameter_or<double>("pitch_ratio", 1.0);
            const auto window_size = get_parameter_or<uint32_t>("window_size", 2048);
            const auto hop_size = get_parameter_or<uint32_t>("hop_size", 512);
            const double semitones = 12.0 * std::log2(pitch_ratio);
 
            return apply_per_channel(input,
                [semitones, window_size, hop_size](std::span<double> ch) {
                    return D::pitch_shift(ch, semitones, window_size, hop_size);
                });
        }
 
        case SpectralOperation::SPECTRAL_FILTER: {
            const auto lo_freq = get_parameter_or<double>("low_freq", 20.0);
            const auto hi_freq = get_parameter_or<double>("high_freq", 20000.0);
            const auto sample_rate = get_parameter_or<double>("sample_rate", 48000.0);
            const auto window_size = get_parameter_or<uint32_t>("window_size", 1024);
            const auto hop_size = get_parameter_or<uint32_t>("hop_size", 512);
 
            return apply_per_channel(input,
                [lo_freq, hi_freq, sample_rate, window_size, hop_size](std::span<double> ch) {
                    return D::spectral_filter(ch, lo_freq, hi_freq, sample_rate, window_size, hop_size);
                });
        }
 
        case SpectralOperation::HARMONIC_ENHANCE: {
            const auto factor = get_parameter_or<double>("enhancement_factor", 2.0);
            const auto window_size = get_parameter_or<uint32_t>("window_size", 1024);
            const auto hop_size = get_parameter_or<uint32_t>("hop_size", 512);
 
            return apply_per_channel(input,
                [factor, window_size, hop_size](std::span<double> ch) {
                    return D::harmonic_enhance(ch, factor, window_size, hop_size);
                });
        }
 
        case SpectralOperation::SPECTRAL_GATE: {
            const auto threshold = get_parameter_or<double>("threshold", -40.0);
            const auto window_size = get_parameter_or<uint32_t>("window_size", 1024);
            const auto hop_size = get_parameter_or<uint32_t>("hop_size", 512);
 
            return apply_per_channel(input,
                [threshold, window_size, hop_size](std::span<double> ch) {
                    return D::spectral_gate(ch, threshold, window_size, hop_size);
                });
        }
 
        default:
            return create_output(input);
        }
    }