transform_implementation()

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

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

inlineoverrideprotectedvirtual

Core transformation implementation for temporal operations.

Parameters

input

Input data to transform in the time domain

Returns

Transformed output data

Performs the temporal operation specified by m_operation on the input data. Operations modify the temporal characteristics of the data including timing, duration, ordering, and envelope shaping. Supports both in-place and out-of-place transformations based on transformer settings.

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

Definition at line 77 of file TemporalTransformer.hpp.

    {
        switch (m_operation) {
        case TemporalOperation::TIME_REVERSE: {
            if (this->is_in_place()) {
                return create_output(transform_time_reverse(input));
            }
 
            return create_output(transform_time_reverse(input, m_working_buffer));
        }
 
        case TemporalOperation::TIME_STRETCH: {
            auto stretch_factor = get_parameter_or<double>("stretch_factor", 1.0);
            if (this->is_in_place()) {
                return create_output(transform_time_stretch(input, stretch_factor));
            }
 
            return create_output(transform_time_stretch(input, stretch_factor, m_working_buffer));
        }
 
        case TemporalOperation::DELAY: {
            auto delay_samples = get_parameter_or<uint32_t>("delay_samples", 1000);
            auto fill_value = get_parameter_or<double>("fill_value", 0.0);
            if (this->is_in_place()) {
                return create_output(transform_delay(input, delay_samples, fill_value));
            }
 
            return create_output(transform_delay(input, delay_samples, fill_value, m_working_buffer));
        }
 
        case TemporalOperation::FADE_IN_OUT: {
            auto fade_in_ratio = get_parameter_or<double>("fade_in_ratio", 0.1);
            auto fade_out_ratio = get_parameter_or<double>("fade_out_ratio", 0.1);
            if (this->is_in_place()) {
                return create_output(transform_fade(input, fade_in_ratio, fade_out_ratio));
            }
 
            return create_output(transform_fade(input, fade_in_ratio, fade_out_ratio, m_working_buffer));
        }
 
        case TemporalOperation::SLICE: {
            auto start_ratio = get_parameter_or<double>("start_ratio", 0.0);
            auto end_ratio = get_parameter_or<double>("end_ratio", 1.0);
            if (this->is_in_place()) {
                return create_output(transform_slice(input, start_ratio, end_ratio));
            }
 
            return create_output(transform_slice(input, start_ratio, end_ratio, m_working_buffer));
        }
 
        case TemporalOperation::INTERPOLATE: {
            auto target_size = get_parameter_or<size_t>("target_size", 0);
            auto use_cubic = get_parameter_or<bool>("use_cubic", false);
            if (target_size > 0) {
                if (use_cubic) {
                    if (this->is_in_place()) {
                        return create_output(interpolate_cubic(input, target_size));
                    }
 
                    return create_output(interpolate_cubic(input, target_size, m_working_buffer));
                }
 
                if (this->is_in_place()) {
                    return create_output(interpolate_linear(input, target_size));
                }
                return create_output(interpolate_linear(input, target_size, m_working_buffer));
            }
            return create_output(input);
        }
 
        default:
            return create_output(input);
        }
    }

References MayaFlux::Yantra::interpolate_cubic(), MayaFlux::Yantra::interpolate_linear(), MayaFlux::Yantra::transform_delay(), MayaFlux::Yantra::transform_fade(), MayaFlux::Yantra::transform_slice(), MayaFlux::Yantra::transform_time_reverse(), and MayaFlux::Yantra::transform_time_stretch().

Here is the call graph for this function: