#audio-processing #traits #component #synthesizer #signal-processing #oscillator #digital-signal-processing

nightly surge-traits

surge synthesizer -- traits for various synthesizer components

30 releases

0.2.12-alpha.0 Apr 7, 2023
0.2.11-alpha.0 Dec 19, 2022
0.2.5-alpha.0 Jun 21, 2022
0.2.4-alpha.0 Mar 14, 2022
0.1.42-alpha.0 Oct 27, 2021

#27 in #oscillator

Download history 143/week @ 2023-12-21 68/week @ 2023-12-28 100/week @ 2024-01-04 119/week @ 2024-01-11 96/week @ 2024-01-18 81/week @ 2024-01-25 73/week @ 2024-02-01 101/week @ 2024-02-08 147/week @ 2024-02-15 88/week @ 2024-02-22 107/week @ 2024-02-29 179/week @ 2024-03-07 107/week @ 2024-03-14 189/week @ 2024-03-21 432/week @ 2024-03-28 87/week @ 2024-04-04

847 downloads per month
Used in 58 crates (41 directly)

GPL-3.0 license

58KB
845 lines

surge-traits: Traits and Common Functionality for the Surge Synthesizer System

The surge-traits crate provides a collection of traits, structures, and utilities for the Surge synthesizer system, designed to streamline its components and ensure consistent behavior across different parts of the system.

Overview

The crate includes various tokens associated with different aspects of the synthesizer system, such as oscillators, presets, convolution, effect management, and more. Some of the key components are:

  • OscillatorProcessBlockCfg: This struct is responsible for configuring the processing block of an oscillator. It includes functionality for loading oscillator algorithms, setting oscillator parameters, and processing audio output.

  • PresetType: An enumeration representing different types of presets in the synthesizer. The crate provides methods for loading and saving presets, as well as managing snapshots of the current state.

  • ConvolutionCfg and ConvoluteArgs: These structs provide configuration and arguments for convolution operations, which are fundamental for implementing various audio effects such as reverb and convolution-based wavetable synthesis.

  • MaybeEffect and MaybeEffects: These traits define a common interface for audio effects in the synthesizer, including methods for initialization, buffer management, processing, and parameter control.

  • Ringout: A collection of methods and structures related to managing the ringout process in the synthesizer, which is responsible for gradually decreasing the output level of a sound until it becomes inaudible. This is particularly important for managing polyphony and CPU usage in the synthesizer.

  • Attack, Release, and related traits: These traits define common behavior for the attack and release stages of envelopes in the synthesizer, including enabling/disabling envelopes, setting bipolar/unipolar modes, and processing audio blocks.

  • UpdateDisplay: A trait that provides methods for updating the display of a synthesizer component, including loading coefficients, plotting magnitude responses, and managing the block size and sample rate.

The mathematical ideas and equations associated with these tokens are primarily related to digital signal processing (DSP) algorithms used in audio synthesis, such as convolution, wavetable synthesis, and envelope processing. While specific equations may vary depending on the implementation, the crate provides a foundation for working with these concepts in a consistent and efficient manner.

In summary, the surge-traits crate provides a collection of traits, structures, and utilities that streamline the implementation of the Surge synthesizer system, ensuring consistent behavior across its components and facilitating the development of new features and enhancements.

12> could we look at more of the traits? please list the trait name and a brief description for as many as you can

Here is a list of some traits found in the surge-traits crate, along with a brief description for each:

  1. Init: This trait provides a method called init for initializing the implementing struct. It is typically used to set initial values for struct members or allocate resources.

  2. NTables: This trait defines a method ntables which returns the number of waveshape tables used in the synthesizer. It helps manage the number of waveshapers needed for different components.

  3. LookupWaveshape: This trait provides a method lookup_waveshape which takes an entry index and a value, then returns a value from the waveshape table. It is useful for wavetable synthesis and processing.

  4. LookupWaveshapeWarp: Similar to LookupWaveshape, this trait provides a method lookup_waveshape_warp which takes an entry index and a value, then returns a value from the waveshape table with a warp applied. This is useful for implementing different waveshaping algorithms.

  5. ClearBuffers: This trait provides a method clear_buffers for clearing the internal buffers of an audio processing component. It is useful for resetting the state of a component, such as when stopping playback or changing parameters.

  6. Reset: This trait provides a method reset for resetting the state of an implementing struct. It is often used in conjunction with the Init trait to reinitialize a component after a change in configuration.

  7. Suspend: This trait provides a method suspend for temporarily disabling or deactivating an audio processing component. It is useful for conserving resources when a component is not in use.

  8. Process: This trait provides a method process for processing a block of audio data. It defines the core processing functionality of an audio component and is implemented by various components like oscillators, effects, and filters.

  9. ProcessControl: This trait provides a method process_control for processing control signals or events, such as MIDI messages or automation data. It is useful for components that need to respond to external input or changes in parameter values.

  10. AllowDisplay: This trait provides a method allow_display that returns a boolean value, indicating whether the implementing struct should be displayed in the user interface. It helps manage the visibility of components in the synthesizer's UI.

These are just a few of the many traits found in the surge-traits crate. They serve as building blocks for various components in the Surge synthesizer system, ensuring consistent behavior and a unified interface for interacting with the different parts of the system.

13> keep going! thanks!

I'm glad you found the previous list helpful! Here are some more traits from the surge-traits crate:

  1. LoadCoefficients: This trait provides a method load_coefficients for loading filter coefficients into a filter component. It is useful for components that need to update their internal state based on filter settings or other parameters.

  2. UpdateDisplay: This trait provides a method update_display for updating the display of an audio component in the user interface. Implementing this trait allows a component to update its visual representation based on internal state or parameter changes.

  3. SetBlocksize: This trait provides a method set_blocksize for setting the block size of an audio processing component. It is useful for managing the buffer size used for audio processing in the Surge synthesizer system.

  4. SetPitch: This trait provides a method set_pitch for setting the pitch of an audio component, such as an oscillator or a filter. It is useful for controlling the frequency of the component based on note or MIDI input.

  5. SetSamplerate: This trait provides a method set_samplerate for setting the sample rate of an audio processing component. It is useful for ensuring that all components in the Surge synthesizer system operate at the same sample rate.

  6. StoreCoefficients: This trait provides a method store_coefficients for storing filter coefficients from a filter component. It is useful for saving the current filter state or sharing filter settings between different components.

  7. PlotMagnitude: This trait provides a method plot_magnitude for plotting the magnitude response of a filter or other audio processing component. It is useful for visualizing the frequency response of a component in the user interface.

  8. Redo: This trait provides a method redo for reprocessing a block of audio data with the same settings as a previous process call. It is useful for components that need to reapply their processing, for example, after a change in internal state or parameters.

  9. GetRingout: This trait provides a method get_ringout for retrieving the ringout state of an audio processing component. It is useful for managing the release and decay of a component's output when it is no longer receiving input.

  10. RingoutCounter: This trait provides methods ringout_counter_incr, ringout_counter_reset, and get_ringout_counter for managing a counter related to the ringout state of an audio processing component. It helps keep track of the number of times a component has entered the ringout state.

These additional traits further demonstrate the flexibility and modularity of the surge-traits crate. By implementing these traits, various components within the Surge synthesizer system can be easily integrated and customized to create a powerful and feature-rich synthesizer.

Dependencies

~12–22MB
~299K SLoC