├── Source
    ├── Util.cpp
    ├── CompileSwitches.h
    ├── PluginEditor.h
    ├── PluginProcessor.h
    ├── Util.h
    ├── TeensyJuce.h
    ├── TeensyJuce.cpp
    ├── PluginEditor.cpp
    ├── GlitchDelayEffect.h
    ├── PluginProcessor.cpp
    └── GlitchDelayEffect.cpp
├── README.md
└── TeensyJuce.jucer


/Source/Util.cpp:
--------------------------------------------------------------------------------
1 | #include "Util.h"
2 | 
3 | #ifdef DEBUG_OUTPUT
4 | bool serial_port_initialised = false;
5 | #endif // DEBUG_OUTPUT
6 | 


--------------------------------------------------------------------------------
/Source/CompileSwitches.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | #define DEBUG_OUTPUT
4 | //#define STANDALONE_AUDIO
5 | #define PERF_CHECK
6 | //#define SET_TEMPO
7 | 
8 | //#define TARGET_TEENSY
9 | #define TARGET_JUCE


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # TeensyJuce
 2 | 
 3 | TeensyJuce is intended as a way to prototype Teensy effects in a more fully featured dev environment, to make debugging possible. It uses the JUCE API, so can be compiled on Mac, PC and Linux. It will allow you to compile your Teensy effects as VSTs or Audio Units.
 4 | 
 5 | First, install Juce from here https://www.juce.com/get-juce
 6 | 
 7 | Simply derive your effect from `TEENSY_AUDIO_STREAM_WRAPPER` rather than `AudioStream`. This parent class handles the internal audio_block_t queue data, so you don't need to define that. Then, rather than making any Teensy audio library calls in your code, call
 8 | 
 9 | ```
10 | bool                            process_audio_in( int channel )
11 | bool                            process_audio_out( int channel )
12 | ```
13 | 
14 | This will then do the Teensy or Juce based audio handling, and call the functions below that you can override with your audio code.
15 | 
16 | ```
17 | // add audio processing code in these 2 functions
18 | virtual void                    process_audio_in_impl( int channel, const int16_t* sample_data, int num_samples ) = 0;
19 | virtual void                    process_audio_out_impl( int channel, int16_t* sample_data, int num_samples ) = 0;
20 | ```
21 | 
22 | Then simply add one of the following defines to switch between Teensy and Juce
23 | 
24 | ```
25 | //#define TARGET_TEENSY
26 | #define TARGET_JUCE
27 | ```
28 | 
29 | I've ported my Glitch Delay Effect to this system, so have a look at the source code for an example of how to use it. I use ProJucer to create a project file for my compiler/IDE (xcode in my case).
30 | 
31 | NOTE: You will pay the cost of a handful more virtual function calls. I was happy with that for prototyping purposes, but once the code is working it would be straightforward to remove them.
32 | 


--------------------------------------------------------------------------------
/Source/PluginEditor.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |   ==============================================================================
 3 | 
 4 |     This file was auto-generated!
 5 | 
 6 |     It contains the basic framework code for a JUCE plugin editor.
 7 | 
 8 |   ==============================================================================
 9 | */
10 | 
11 | #pragma once
12 | 
13 | #include "../JuceLibraryCode/JuceHeader.h"
14 | #include "PluginProcessor.h"
15 | 
16 | 
17 | //==============================================================================
18 | /**
19 | */
20 | 
21 | // forward declarations
22 | 
23 | ///////////////////////////////////////////////////////////////////////////
24 | 
25 | class TeensyJuceAudioProcessorEditor  : public AudioProcessorEditor,
26 |                                         public Slider::Listener,
27 |                                         private Timer
28 | {
29 | public:
30 |     TeensyJuceAudioProcessorEditor (TeensyJuceAudioProcessor&, const GLITCH_DELAY_EFFECT&);
31 |     ~TeensyJuceAudioProcessorEditor();
32 |     
33 |     AudioParameterFloat*                            get_parameter_for_slider( Slider* slider );
34 | 
35 |     //==============================================================================
36 |     void paint (Graphics&) override;
37 |     void resized() override;
38 |     
39 |     //// Slider::Listener ////
40 |     void sliderValueChanged (Slider* slider) override;
41 |     void sliderDragStarted (Slider* slider) override;
42 |     void sliderDragEnded (Slider* slider) override;
43 |     /////////////////////////
44 | 
45 | private:
46 |     // This reference is provided as a quick way for your editor to
47 |     // access the processor object that created it.
48 |     
49 |     static const int                                DIAL_ROW_COUNT;
50 |     static const int                                DIAL_SIZE;
51 |     static const int                                DIAL_SEPARATION;
52 |     static const int                                LABEL_HEIGHT;
53 |     static const int                                BORDER;
54 |     
55 |     TeensyJuceAudioProcessor&                       m_processor;
56 |     const GLITCH_DELAY_EFFECT&                      m_effect;
57 |     
58 |     OwnedArray<Slider>                              m_param_sliders;
59 |     OwnedArray<Label>                               m_param_labels;
60 |     
61 |     int                                             m_num_dial_rows;
62 |     
63 |     void                                            timerCallback() override;
64 | 
65 |     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (TeensyJuceAudioProcessorEditor)
66 | };
67 | 


--------------------------------------------------------------------------------
/Source/PluginProcessor.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |   ==============================================================================
 3 | 
 4 |     This file was auto-generated!
 5 | 
 6 |     It contains the basic framework code for a JUCE plugin processor.
 7 | 
 8 |   ==============================================================================
 9 | */
10 | 
11 | #pragma once
12 | 
13 | #include "../JuceLibraryCode/JuceHeader.h"
14 | 
15 | #include "GlitchDelayEffect.h"
16 | 
17 | 
18 | //==============================================================================
19 | /**
20 | */
21 | class TeensyJuceAudioProcessor  : public AudioProcessor
22 | {
23 | public:
24 |     //==============================================================================
25 |     TeensyJuceAudioProcessor();
26 |     ~TeensyJuceAudioProcessor();
27 | 
28 |     //==============================================================================
29 |     void prepareToPlay (double sampleRate, int samplesPerBlock) override;
30 |     void releaseResources() override;
31 | 
32 |    #ifndef JucePlugin_PreferredChannelConfigurations
33 |     bool isBusesLayoutSupported (const BusesLayout& layouts) const override;
34 |    #endif
35 | 
36 |     void processBlock (AudioSampleBuffer&, MidiBuffer&) override;
37 | 
38 |     //==============================================================================
39 |     AudioProcessorEditor* createEditor() override;
40 |     bool hasEditor() const override;
41 | 
42 |     //==============================================================================
43 |     const String getName() const override;
44 | 
45 |     bool acceptsMidi() const override;
46 |     bool producesMidi() const override;
47 |     bool isMidiEffect () const override;
48 |     double getTailLengthSeconds() const override;
49 | 
50 |     //==============================================================================
51 |     int getNumPrograms() override;
52 |     int getCurrentProgram() override;
53 |     void setCurrentProgram (int index) override;
54 |     const String getProgramName (int index) override;
55 |     void changeProgramName (int index, const String& newName) override;
56 | 
57 |     //==============================================================================
58 |     void getStateInformation (MemoryBlock& destData) override;
59 |     void setStateInformation (const void* data, int sizeInBytes) override;
60 | 
61 | private:
62 | 
63 |     static float                                                MAX_FEEDBACK;
64 |     
65 |     std::unique_ptr<GLITCH_DELAY_EFFECT>                        m_effect;
66 |     AudioSampleBuffer                                           m_prev_buffer;
67 |     
68 |     AudioParameterFloat*                                        m_mix;
69 |     AudioParameterFloat*                                        m_loop_size;
70 |     AudioParameterFloat*                                        m_jitter;
71 | 	AudioParameterFloat*                                        m_feedback;
72 |     
73 |     //==============================================================================
74 |     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (TeensyJuceAudioProcessor)
75 | };
76 | 


--------------------------------------------------------------------------------
/Source/Util.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "CompileSwitches.h"
  4 | 
  5 | #ifdef DEBUG_OUTPUT
  6 | 
  7 | #ifdef TARGET_TEENSY
  8 | 
  9 | extern bool serial_port_initialised;
 10 | 
 11 | bool _assert_fail( const char* assert, const char* msg )
 12 | {
 13 |   if( serial_port_initialised )
 14 |   {
 15 |     Serial.print(assert);
 16 |     Serial.print(" ");
 17 |     Serial.print(msg);
 18 |     Serial.print("\n");
 19 |   }
 20 |   
 21 |   return true;
 22 | }
 23 | 
 24 | #define ASSERT_MSG(x, msg) ((void)((x) || (_assert_fail(#x,msg))))
 25 | #define DEBUG_TEXT(x) if(serial_port_initialised) Serial.print(x);
 26 | 
 27 | #else // !TARGET_TEENSY
 28 | 
 29 | #include <iostream>
 30 | 
 31 | #define ASSERT_MSG(x, msg)      jassert( x )
 32 | 
 33 | template<typename T> void DEBUG_TEXT( T t )
 34 | {
 35 |     std::cout << t;
 36 | }
 37 | 
 38 | #endif // !TARGET_TEENSY
 39 | 
 40 | #else // !DEBUG_OUPUT
 41 | 
 42 | #define ASSERT_MSG(x, msg)
 43 | #define DEBUG_TEXT(x)
 44 | 
 45 | #endif // !DEBUG_OUTPUT
 46 | 
 47 | 
 48 | #ifdef TARGET_JUCE
 49 | #include <stdint.h>
 50 | #endif
 51 | 
 52 | /////////////////////////////////////////////////////
 53 | 
 54 | template <typename T>
 55 | T clamp( const T& value, const T& min, const T& max )
 56 | {
 57 |   if( value < min )
 58 |   {
 59 |     return min;
 60 |   }
 61 |   if( value > max )
 62 |   {
 63 |     return max;
 64 |   }
 65 |   return value;
 66 | }
 67 | 
 68 | template <typename T>
 69 | T max_val( const T& v1, const T& v2 )
 70 | {
 71 |   if( v1 > v2 )
 72 |   {
 73 |     return v1;
 74 |   }
 75 |   else
 76 |   {
 77 |     return v2;
 78 |   }
 79 | }
 80 | 
 81 | template <typename T>
 82 | T min_val( const T& v1, const T& v2 )
 83 | {
 84 |   if( v1 < v2 )
 85 |   {
 86 |     return v1;
 87 |   }
 88 |   else
 89 |   {
 90 |     return v2;
 91 |   }
 92 | }
 93 | 
 94 | /////////////////////////////////////////////////////
 95 | 
 96 | template <typename T>
 97 | T lerp( const T& v1, const T& v2, float t )
 98 | {
 99 |   return v1 + ( (v2 - v1) * t );
100 | }
101 | 
102 | /////////////////////////////////////////////////////
103 | 
104 | inline int trunc_to_int( float v )
105 | {
106 |   return static_cast<int>( v );
107 | }
108 | 
109 | /////////////////////////////////////////////////////
110 | 
111 | template < typename TYPE, int CAPACITY >
112 | class RUNNING_AVERAGE
113 | {
114 |   TYPE                    m_values[ CAPACITY ];
115 |   int                     m_current;
116 |   int                     m_size;
117 | 
118 | public:
119 | 
120 |   RUNNING_AVERAGE() :
121 |     m_values(),
122 |     m_current(0),
123 |     m_size(0)
124 |   {
125 |   }
126 | 
127 |   void add( TYPE value )
128 |   {
129 |     m_values[ m_current ] = value;
130 |     m_current             = ( m_current + 1 ) % CAPACITY;
131 |     ++m_size;
132 |     if( m_size > CAPACITY )
133 |     {
134 |       m_size              = CAPACITY;
135 |     }
136 |   }
137 | 
138 |   void reset()
139 |   {
140 |     m_size                = 0;
141 |     m_current             = 0;
142 |   }
143 |   
144 |   TYPE average() const
145 |   {
146 |     if( m_size == 0 )
147 |     {
148 |       return 0;  
149 |     }
150 |     
151 |     TYPE avg = 0;
152 |     for( int x = 0; x < m_size; ++x )
153 |     {
154 |       avg += m_values[ x ];
155 |     }
156 | 
157 |     return avg / m_size;
158 |   }
159 | 
160 |   int size() const
161 |   {
162 |     return m_size;
163 |   }
164 | };
165 | 
166 | #ifdef TARGET_JUCE
167 | /*
168 | #include "maths/juce_Random.h"
169 | int random( int max )
170 | {
171 |     static Random r;
172 |     static_cast<int>( r.nextFloat() * max );
173 | }
174 |  */
175 | #include <stdlib.h>
176 | #include <memory>
177 | inline int random( int max )
178 | {
179 |     return static_cast<int>( ( static_cast<float>( rand() ) / RAND_MAX ) * max );
180 | }
181 | 
182 | /////////////////////////////////////////////////////
183 | 
184 | // no c++14 on xcode 7
185 | template<typename T, typename... Args>
186 | std::unique_ptr<T> make_unique(Args&&... args)
187 | {
188 |     return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
189 | }
190 | 
191 | #endif
192 | 


--------------------------------------------------------------------------------
/Source/TeensyJuce.h:
--------------------------------------------------------------------------------
  1 | //
  2 | //  TeensyJuce.h
  3 | //  TeensyJuce
  4 | //
  5 | //  Created by Scott Pitkethly on 23/09/2017.
  6 | //
  7 | //
  8 | 
  9 | #ifndef TeensyJuce_h
 10 | #define TeensyJuce_h
 11 | 
 12 | #include <stdint.h>
 13 | #include "CompileSwitches.h"
 14 | 
 15 | #ifdef TARGET_TEENSY
 16 | 
 17 | #include <Audio.h>
 18 | 
 19 | class TEENSY_AUDIO_STREAM_WRAPPER : public AudioStream
 20 | {
 21 |     audio_block_t*                  m_input_queue_array[1];
 22 |     
 23 | protected:
 24 |     
 25 |     // these are the only functions that require bespoke Teensy code
 26 |     bool                            process_audio_in( int channel )
 27 |     {
 28 |         audio_block_t* read_block        = receiveReadOnly();
 29 |         
 30 |         if( read_block != nullptr )
 31 |         {
 32 |             process_audio_in_impl( channel, read_block->data, AUDIO_BLOCK_SAMPLES );
 33 |             release( read_block );
 34 |             
 35 |             return true;
 36 |         }
 37 |         
 38 |         return false;
 39 |     }
 40 |     
 41 |     bool                            process_audio_out( int channel )
 42 |     {
 43 |         audio_block_t* write_block = allocate();
 44 |         
 45 |         if( write_block != nullptr )
 46 |         {
 47 |             process_audio_out_impl( channel, write_block->data, AUDIO_BLOCK_SAMPLES );
 48 |             
 49 |             transmit( write_block, channel );
 50 |             
 51 |             release( write_block );
 52 |             
 53 |             return true;
 54 |         }
 55 |         
 56 |         return false;
 57 |     }
 58 |     
 59 |     // add audio processing code in these 2 functions
 60 |     virtual void                    process_audio_in_impl( int channel, const int16_t* sample_data, int num_samples ) = 0;
 61 |     virtual void                    process_audio_out_impl( int channel, int16_t* sample_data, int num_samples ) = 0;
 62 |     
 63 | public:
 64 |     
 65 |     TEENSY_AUDIO_STREAM_WRAPPER() :
 66 |         AudioStream( 1, m_input_queue_array ),
 67 |         m_input_queue_array()
 68 |     {
 69 |         
 70 |     }
 71 |     
 72 |     virtual ~TEENSY_AUDIO_STREAM_WRAPPER()      {;}
 73 |     
 74 |     virtual int                     num_input_channels() const = 0;
 75 |     virtual int                     num_output_channels() const = 0;
 76 | };
 77 | 
 78 | #endif // TARGET_TEENSY
 79 | 
 80 | #ifdef TARGET_JUCE
 81 | 
 82 | #include <vector>
 83 | #include "../JuceLibraryCode/JuceHeader.h"
 84 | 
 85 | class TEENSY_AUDIO_STREAM_WRAPPER
 86 | {
 87 |     int                             m_num_input_channels;
 88 |     int                             m_num_output_channels;
 89 |     
 90 | protected:
 91 |  
 92 |     // store the 16-bit in/out buffers
 93 |     typedef std::vector< int16_t >  SAMPLE_BUFFER;
 94 |     std::vector< SAMPLE_BUFFER >    m_channel_buffers;
 95 |     
 96 |     // these are the only functions that require bespoke JUCE code
 97 |     bool                            process_audio_in( int channel );
 98 |     bool                            process_audio_out( int channel );
 99 |     
100 |     // add audio processing code in these 2 functions
101 |     virtual void                    process_audio_in_impl( int channel, const int16_t* sample_data, int num_samples ) = 0;
102 |     virtual void                    process_audio_out_impl( int channel, int16_t* sample_data, int num_samples ) = 0;
103 |     
104 | public:
105 |     
106 |     TEENSY_AUDIO_STREAM_WRAPPER();
107 |     virtual ~TEENSY_AUDIO_STREAM_WRAPPER();
108 |     
109 |     
110 |     void                            pre_process_audio( const AudioSampleBuffer& audio_in, int num_input_channels, int num_output_channels );
111 |     void                            post_process_audio( AudioSampleBuffer& audio_out );
112 |     
113 |     virtual int                     num_input_channels() const = 0;
114 |     virtual int                     num_output_channels() const = 0;
115 |     
116 |     virtual void                    update() = 0;
117 | };
118 | 
119 | #endif // TARGET_JUCE
120 | 
121 | #endif /* TeensyJuce_h */
122 | 


--------------------------------------------------------------------------------
/Source/TeensyJuce.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   ==============================================================================
  3 | 
  4 |     TeensyJuce.cpp
  5 |     Created: 30 Sep 2017 3:05:37pm
  6 |     Author:  Scott Pitkethly
  7 | 
  8 |   ==============================================================================
  9 | */
 10 | 
 11 | #include <limits>
 12 | 
 13 | #include "TeensyJuce.h"
 14 | #include "Util.h"
 15 | 
 16 | namespace
 17 | {
 18 |     // convert float sample [-1..1] to int16
 19 | 	int16_t sample_convert_float_to_int16( float s )
 20 | 	{
 21 | 		if( s > 0.0f )
 22 | 		{
 23 | 			return s * std::numeric_limits< int16_t >::max();
 24 | 		}
 25 | 		else
 26 | 		{
 27 | 			return -s * std::numeric_limits< int16_t >::min();
 28 | 		}
 29 | 	}
 30 |     
 31 |     // convert in16 sample to float [-1..1]
 32 |     float sample_convert_int16_to_float( int16_t s )
 33 |     {
 34 |         float sf = s / static_cast<float>( std::numeric_limits< int16_t >::max() );
 35 |         ASSERT_MSG( sf >= -1.0f && sf <= 1.0f, "Sample out of range" );
 36 |         
 37 |         return sf;
 38 |     }
 39 | }
 40 | 
 41 | ////////////////////////////////////////////////////////////////////////
 42 | 
 43 | #ifdef TARGET_JUCE
 44 | 
 45 | TEENSY_AUDIO_STREAM_WRAPPER::TEENSY_AUDIO_STREAM_WRAPPER() :
 46 |     m_num_input_channels(0),
 47 |     m_num_output_channels(0),
 48 |     m_channel_buffers()
 49 | {
 50 |     
 51 | }
 52 | 
 53 | TEENSY_AUDIO_STREAM_WRAPPER::~TEENSY_AUDIO_STREAM_WRAPPER()
 54 | {
 55 | }
 56 | 
 57 | bool TEENSY_AUDIO_STREAM_WRAPPER::process_audio_in( int channel )
 58 | {
 59 |     const SAMPLE_BUFFER& sample_buffer = m_channel_buffers[ channel ];
 60 |     
 61 |     if( !sample_buffer.empty() )
 62 |     {
 63 |         process_audio_in_impl( channel, sample_buffer.data(), static_cast<int>(sample_buffer.size()) );
 64 |         
 65 |         return true;
 66 |     }
 67 |     
 68 |     return false;
 69 | }
 70 | 
 71 | bool TEENSY_AUDIO_STREAM_WRAPPER::process_audio_out( int channel )
 72 | {
 73 |     SAMPLE_BUFFER& sample_buffer = m_channel_buffers[ channel ];
 74 |     
 75 |     if( !sample_buffer.empty() )
 76 |     {
 77 |         process_audio_out_impl( channel, sample_buffer.data(), static_cast<int>(sample_buffer.size()) );
 78 |         
 79 |         return true;
 80 |     }
 81 |     
 82 |     return false;
 83 |     
 84 | }
 85 | 
 86 | void TEENSY_AUDIO_STREAM_WRAPPER::pre_process_audio( const AudioSampleBuffer& audio_in, int num_input_channels, int num_output_channels )
 87 | {
 88 |     ASSERT_MSG( m_num_input_channels == 0 || num_input_channels == m_num_input_channels, "Num input channels has changed" );
 89 |     ASSERT_MSG( m_num_output_channels == 0 || num_output_channels == m_num_output_channels, "Num output channels has changed" );
 90 |     
 91 |     m_num_input_channels    = num_input_channels;
 92 |     m_num_output_channels   = num_output_channels;
 93 |     
 94 |     m_channel_buffers.clear();
 95 |     const int max_channels = max_val( num_input_channels, num_output_channels );
 96 |     
 97 |     m_channel_buffers.reserve( max_channels );
 98 |     
 99 |     const int num_samples   = audio_in.getNumSamples();
100 |     
101 |     for( int c = 0; c < max_channels; ++c )
102 |     {
103 |         SAMPLE_BUFFER samples;
104 |         samples.reserve( num_samples );
105 |         
106 |         // is this an input/output channel
107 |         if( c < num_input_channels )
108 |         {
109 |             for( int s = 0; s < num_samples; ++s )
110 |             {
111 |                 const float sample = audio_in.getSample( 0, s );
112 |                 samples.push_back( sample_convert_float_to_int16( sample ) );
113 |             }
114 |         }
115 |         // this is an output only channel
116 |         else
117 |         {
118 |             samples.resize( num_samples, 0.0f );
119 |         }
120 |         
121 |         m_channel_buffers.emplace_back( samples );
122 |     }
123 |     
124 | }
125 | 
126 | void TEENSY_AUDIO_STREAM_WRAPPER::post_process_audio( AudioSampleBuffer& audio_out )
127 | {
128 |     for( int c = 0; c < m_channel_buffers.size(); ++c )
129 |     {
130 |         const SAMPLE_BUFFER& sample_buffer = m_channel_buffers[ c ];
131 |         for( int s = 0; s < sample_buffer.size(); ++s )
132 |         {
133 |             audio_out.setSample( c, s, sample_convert_int16_to_float( sample_buffer[s] ) );
134 |         }
135 |     }
136 | }
137 | 
138 | #endif // TARGET_JUCE
139 | 


--------------------------------------------------------------------------------
/TeensyJuce.jucer:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | 
 3 | <JUCERPROJECT id="DzydsG" name="TeensyJuce" displaySplashScreen="1" reportAppUsage="1"
 4 |               splashScreenColour="Dark" projectType="audioplug" version="1.0.0"
 5 |               bundleIdentifier="com.yourcompany.TeensyJuce" includeBinaryInAppConfig="1"
 6 |               cppLanguageStandard="11" buildVST="1" buildVST3="0" buildAU="1"
 7 |               buildAUv3="0" buildRTAS="0" buildAAX="0" buildStandalone="1"
 8 |               enableIAA="0" pluginName="TeensyJuce" pluginDesc="TeensyJuce"
 9 |               pluginManufacturer="yourcompany" pluginManufacturerCode="Manu"
10 |               pluginCode="Dzyd" pluginChannelConfigs="" pluginIsSynth="0" pluginWantsMidiIn="0"
11 |               pluginProducesMidiOut="0" pluginIsMidiEffectPlugin="0" pluginEditorRequiresKeys="0"
12 |               pluginAUExportPrefix="TeensyJuceAU" pluginRTASCategory="" aaxIdentifier="com.yourcompany.TeensyJuce"
13 |               pluginAAXCategory="AAX_ePlugInCategory_Dynamics" jucerVersion="5.1.2">
14 |   <MAINGROUP id="HSjYTo" name="TeensyJuce">
15 |     <GROUP id="{F36DAE87-76F9-80B5-F9AD-77AFED34B051}" name="Source">
16 |       <FILE id="oV70iI" name="TeensyJuce.cpp" compile="1" resource="0" file="Source/TeensyJuce.cpp"/>
17 |       <FILE id="upJzGH" name="TeensyJuce.h" compile="0" resource="0" file="Source/TeensyJuce.h"/>
18 |       <FILE id="JqP7PQ" name="CompileSwitches.h" compile="0" resource="0"
19 |             file="Source/CompileSwitches.h"/>
20 |       <FILE id="lWCEIK" name="GlitchDelayEffect.cpp" compile="1" resource="0"
21 |             file="Source/GlitchDelayEffect.cpp"/>
22 |       <FILE id="WOpL7j" name="GlitchDelayEffect.h" compile="0" resource="0"
23 |             file="Source/GlitchDelayEffect.h"/>
24 |       <FILE id="SxBTSR" name="Util.cpp" compile="1" resource="0" file="Source/Util.cpp"/>
25 |       <FILE id="hQqqmD" name="Util.h" compile="0" resource="0" file="Source/Util.h"/>
26 |       <FILE id="CBIPWp" name="PluginProcessor.cpp" compile="1" resource="0"
27 |             file="Source/PluginProcessor.cpp"/>
28 |       <FILE id="zptXEu" name="PluginProcessor.h" compile="0" resource="0"
29 |             file="Source/PluginProcessor.h"/>
30 |       <FILE id="GFKB5t" name="PluginEditor.cpp" compile="1" resource="0"
31 |             file="Source/PluginEditor.cpp"/>
32 |       <FILE id="C3H8sN" name="PluginEditor.h" compile="0" resource="0" file="Source/PluginEditor.h"/>
33 |     </GROUP>
34 |   </MAINGROUP>
35 |   <EXPORTFORMATS>
36 |     <XCODE_MAC targetFolder="Builds/MacOSX">
37 |       <CONFIGURATIONS>
38 |         <CONFIGURATION name="Debug" isDebug="1" optimisation="1" targetName="TeensyJuce"
39 |                        osxCompatibility="10.10 SDK"/>
40 |         <CONFIGURATION name="Release" isDebug="0" optimisation="3" targetName="TeensyJuce"
41 |                        osxCompatibility="10.10 SDK"/>
42 |       </CONFIGURATIONS>
43 |       <MODULEPATHS>
44 |         <MODULEPATH id="juce_core" path="../../Developer/SDKs/JUCE/modules"/>
45 |         <MODULEPATH id="juce_events" path="../../Developer/SDKs/JUCE/modules"/>
46 |         <MODULEPATH id="juce_graphics" path="../../Developer/SDKs/JUCE/modules"/>
47 |         <MODULEPATH id="juce_data_structures" path="../../Developer/SDKs/JUCE/modules"/>
48 |         <MODULEPATH id="juce_gui_basics" path="../../Developer/SDKs/JUCE/modules"/>
49 |         <MODULEPATH id="juce_gui_extra" path="../../Developer/SDKs/JUCE/modules"/>
50 |         <MODULEPATH id="juce_cryptography" path="../../Developer/SDKs/JUCE/modules"/>
51 |         <MODULEPATH id="juce_video" path="../../Developer/SDKs/JUCE/modules"/>
52 |         <MODULEPATH id="juce_opengl" path="../../Developer/SDKs/JUCE/modules"/>
53 |         <MODULEPATH id="juce_audio_basics" path="../../Developer/SDKs/JUCE/modules"/>
54 |         <MODULEPATH id="juce_audio_devices" path="../../Developer/SDKs/JUCE/modules"/>
55 |         <MODULEPATH id="juce_audio_formats" path="../../Developer/SDKs/JUCE/modules"/>
56 |         <MODULEPATH id="juce_audio_processors" path="../../Developer/SDKs/JUCE/modules"/>
57 |         <MODULEPATH id="juce_audio_plugin_client" path="../../Developer/SDKs/JUCE/modules"/>
58 |         <MODULEPATH id="juce_audio_utils" path="../../Developer/SDKs/JUCE/modules"/>
59 |       </MODULEPATHS>
60 |     </XCODE_MAC>
61 |   </EXPORTFORMATS>
62 |   <MODULES>
63 |     <MODULE id="juce_audio_basics" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
64 |     <MODULE id="juce_audio_devices" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
65 |     <MODULE id="juce_audio_formats" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
66 |     <MODULE id="juce_audio_plugin_client" showAllCode="1" useLocalCopy="0"
67 |             useGlobalPath="1"/>
68 |     <MODULE id="juce_audio_processors" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
69 |     <MODULE id="juce_audio_utils" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
70 |     <MODULE id="juce_core" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
71 |     <MODULE id="juce_cryptography" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
72 |     <MODULE id="juce_data_structures" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
73 |     <MODULE id="juce_events" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
74 |     <MODULE id="juce_graphics" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
75 |     <MODULE id="juce_gui_basics" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
76 |     <MODULE id="juce_gui_extra" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
77 |     <MODULE id="juce_opengl" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
78 |     <MODULE id="juce_video" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
79 |   </MODULES>
80 |   <JUCEOPTIONS JUCE_QUICKTIME="disabled"/>
81 | </JUCERPROJECT>
82 | 


--------------------------------------------------------------------------------
/Source/PluginEditor.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   ==============================================================================
  3 | 
  4 |     This file was auto-generated!
  5 | 
  6 |     It contains the basic framework code for a JUCE plugin editor.
  7 | 
  8 |   ==============================================================================
  9 | */
 10 | 
 11 | #include "GlitchDelayEffect.h"
 12 | #include "PluginProcessor.h"
 13 | #include "PluginEditor.h"
 14 | 
 15 | //==============================================================================
 16 | 
 17 | ///////////////////////////////////////////////////////////////////////////
 18 | 
 19 | const int TeensyJuceAudioProcessorEditor::DIAL_ROW_COUNT        = 4;
 20 | const int TeensyJuceAudioProcessorEditor::DIAL_SEPARATION       = 30;
 21 | const int TeensyJuceAudioProcessorEditor::DIAL_SIZE             = 95;
 22 | const int TeensyJuceAudioProcessorEditor::LABEL_HEIGHT          = 10;
 23 | const int TeensyJuceAudioProcessorEditor::BORDER                = 40;
 24 | 
 25 | TeensyJuceAudioProcessorEditor::TeensyJuceAudioProcessorEditor (TeensyJuceAudioProcessor& p,const GLITCH_DELAY_EFFECT& effect) :
 26 |     AudioProcessorEditor(&p),
 27 |     Slider::Listener(),
 28 |     Timer(),
 29 |     m_processor(p),
 30 |     m_effect(effect),
 31 |     m_param_sliders(),
 32 |     m_param_labels(),
 33 |     m_num_dial_rows(0)
 34 | {
 35 |     const OwnedArray<AudioProcessorParameter>& params = p.getParameters();
 36 |     
 37 |     for( int i = 0; i < params.size(); ++i )
 38 |     {
 39 |         if( const AudioParameterFloat* param = dynamic_cast<AudioParameterFloat*>(params[i]) )
 40 |         {
 41 |             Slider* slider;
 42 |             
 43 |             m_param_sliders.add( slider = new Slider (param->name) );
 44 |             slider->setRange( param->range.start, param->range.end );
 45 |             slider->setSliderStyle( Slider::RotaryHorizontalDrag );
 46 |             slider->setValue( *param );
 47 |             slider->setTextBoxStyle( Slider::NoTextBox, false, 0, 0 );
 48 |             
 49 |             slider->addListener( this );
 50 |             addAndMakeVisible(slider );
 51 |             
 52 |             Label* label;
 53 |             m_param_labels.add( label = new Label (param->name, param->name) );
 54 |             label->setJustificationType( Justification::centred );
 55 |             label->setFont( Font(LABEL_HEIGHT) );
 56 |             addAndMakeVisible( label );
 57 |         }
 58 |     }
 59 | 	
 60 |     m_num_dial_rows         = m_param_sliders.size() / DIAL_ROW_COUNT;
 61 |     if( m_param_sliders.size() % DIAL_ROW_COUNT != 0 )
 62 |     {
 63 |         ++m_num_dial_rows;
 64 |     }
 65 |     
 66 |     const float width       = ( BORDER * 2.0f ) + DIAL_SIZE * DIAL_ROW_COUNT;
 67 |     const float height      = ( BORDER * 2.0f ) + ( DIAL_SIZE * m_num_dial_rows ) + (DIAL_SEPARATION * m_num_dial_rows);
 68 |     setSize( width, height );
 69 |     
 70 |     // start the callback timer
 71 |     startTimer (100);
 72 |     
 73 | }
 74 | 
 75 | TeensyJuceAudioProcessorEditor::~TeensyJuceAudioProcessorEditor()
 76 | {
 77 | }
 78 | 
 79 | AudioParameterFloat* TeensyJuceAudioProcessorEditor::get_parameter_for_slider( Slider* slider )
 80 | {
 81 |     const OwnedArray<AudioProcessorParameter>& params = getAudioProcessor()->getParameters();
 82 |     return dynamic_cast<AudioParameterFloat*> (params[ m_param_sliders.indexOf(slider) ]);
 83 | }
 84 | 
 85 | //==============================================================================
 86 | void TeensyJuceAudioProcessorEditor::paint (Graphics& g)
 87 | {
 88 |     // (Our component is opaque, so we must completely fill the background with a solid colour)
 89 |     g.fillAll (getLookAndFeel().findColour (ResizableWindow::backgroundColourId));
 90 | 
 91 |     g.setColour (Colours::white);
 92 |     g.setFont (15.0f);
 93 | }
 94 | 
 95 | void TeensyJuceAudioProcessorEditor::resized()
 96 | {
 97 |     Rectangle<int> reduced = getLocalBounds().reduced( BORDER );
 98 |     
 99 |     int dial = 0;
100 |     
101 |     for( int row = 0; row < m_num_dial_rows; ++row )
102 |     {
103 |         Rectangle<int> row_rect = reduced.removeFromTop( DIAL_SIZE );
104 |         
105 |         const int row_size      = min_val( DIAL_ROW_COUNT, m_param_sliders.size() - dial );
106 |         const int remainder     = ( DIAL_ROW_COUNT - row_size ) * DIAL_SIZE;
107 |         row_rect.reduce( remainder / 2, 0 );
108 |         
109 |         for( int col = 0; col < row_size; ++col )
110 |         {
111 |             Rectangle<int> dial_bounds          = row_rect.removeFromLeft( DIAL_SIZE );
112 |             const Rectangle<int> label_bounds   = dial_bounds.removeFromBottom( LABEL_HEIGHT );
113 |             
114 |             m_param_labels[dial]->setBounds( label_bounds );
115 |             m_param_sliders[dial]->setBounds( dial_bounds );
116 |             ++dial;
117 |         }
118 |         
119 |         // leave space between each row
120 |         reduced.removeFromTop( DIAL_SEPARATION );
121 |     }
122 | }
123 | 
124 | void TeensyJuceAudioProcessorEditor::sliderValueChanged (Slider* slider)
125 | {
126 |     if( AudioParameterFloat* param = get_parameter_for_slider(slider) )
127 |     {
128 |         *param = slider->getValue();
129 |     }
130 | }
131 | 
132 | void TeensyJuceAudioProcessorEditor::sliderDragStarted (Slider* slider)
133 | {
134 |     if( AudioParameterFloat* param = get_parameter_for_slider( slider ) )
135 |     {
136 |         param->beginChangeGesture();
137 |     }
138 | }
139 | 
140 | void TeensyJuceAudioProcessorEditor::sliderDragEnded (Slider* slider)
141 | {
142 |     if( AudioParameterFloat* param = get_parameter_for_slider( slider ) )
143 |     {
144 |         param->endChangeGesture();
145 |     }
146 | }
147 | 
148 | void TeensyJuceAudioProcessorEditor::timerCallback()
149 | {
150 |     const OwnedArray<AudioProcessorParameter>& params = getAudioProcessor()->getParameters();
151 |     
152 |     for( int i = 0; i < params.size(); ++i )
153 |     {
154 |         if( const AudioParameterFloat* param = dynamic_cast<AudioParameterFloat*> (params[i]) )
155 |         {
156 |             if( i < m_param_sliders.size() )
157 |             {
158 |                 m_param_sliders[i]->setValue(*param);
159 |             }
160 |         }
161 |     }
162 |     
163 |     repaint();
164 | }
165 | 


--------------------------------------------------------------------------------
/Source/GlitchDelayEffect.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "TeensyJuce.h"
  4 | #include "Util.h"
  5 | 
  6 | static const int DELAY_BUFFER_SIZE_IN_BYTES(1024*240);      // 240k
  7 | 
  8 | ////////////////////////////////////
  9 | 
 10 | class DELAY_BUFFER;
 11 | 
 12 | ////////////////////////////////////
 13 | 
 14 | class PLAY_HEAD
 15 | {
 16 |     const DELAY_BUFFER&         m_delay_buffer;     // TODO pass in to save storage?
 17 |     
 18 |     float                       m_current_play_head;
 19 |     float                       m_destination_play_head;
 20 |     float                       m_play_speed;       // negative means play in reverse (loop sections currently not supported)
 21 |     int                         m_fade_samples_remaining;
 22 |     
 23 |     int                         m_loop_start;
 24 |     int                         m_loop_end;
 25 |     int                         m_unjittered_loop_start;
 26 |     int                         m_shift_speed;
 27 |     
 28 |     float                       m_next_loop_size_ratio;
 29 |     float                       m_next_shift_speed_ratio;
 30 |     float                       m_jitter_ratio;
 31 |     
 32 |     bool                        m_initial_loop_crossfade_complete;
 33 |     
 34 |     int                         play_head_to_write_head_buffer_size() const;
 35 |     int16_t                     read_sample_with_cross_fade();
 36 |     
 37 | public:
 38 |     
 39 |     PLAY_HEAD( const DELAY_BUFFER& delay_buffer, float play_speed );
 40 |     
 41 |     int                         current_position() const;
 42 |     int                         destination_position() const;
 43 |     
 44 |     int                         loop_start() const;
 45 |     int                         loop_end() const;
 46 |     int                         buffered_loop_start() const;
 47 |     int                         current_loop_size() const;
 48 |     
 49 |     bool                        looping() const;
 50 |     bool                        position_inside_section( int position, int start, int end ) const;
 51 |     bool                        position_inside_next_read( int position, int read_size ) const;
 52 |     bool                        crossfade_active() const;
 53 |     bool                        initial_loop_crossfade_complete() const;
 54 |     bool                        play_forwards() const;
 55 |     
 56 |     void                        set_loop_size( float loop_size_ratio );
 57 |     void                        set_shift_speed( float speed );
 58 |     void                        set_jitter( float jitter );
 59 |     void                        set_play_head( int offset_from_write_head );
 60 |     void                        set_next_loop();
 61 |     
 62 |     void                        set_loop_behind_write_head();
 63 |     
 64 |     void                        read_from_play_head( int16_t* dest, int size );
 65 |     
 66 |     void                        enable_loop( int start, int end );
 67 |     void                        disable_loop();
 68 |     
 69 | #ifdef DEBUG_OUTPUT
 70 |     void                        debug_output();
 71 | #endif
 72 | };
 73 | 
 74 | ////////////////////////////////////
 75 | 
 76 | class DELAY_BUFFER
 77 | {
 78 |     friend PLAY_HEAD;
 79 |     
 80 |     uint8_t                     m_buffer[DELAY_BUFFER_SIZE_IN_BYTES];
 81 |     int                         m_buffer_size_in_samples;
 82 |     int                         m_sample_size_in_bits;
 83 |     
 84 |     int                         m_write_head;
 85 |     
 86 |     int                         m_fade_samples_remaining;
 87 |     
 88 | public:
 89 |     
 90 |     DELAY_BUFFER();
 91 |     
 92 |     int                         position_offset_from_head( int offset ) const;
 93 |     int                         delay_offset_from_ratio( float ratio ) const;
 94 |     int                         delay_offset_from_time( int time_in_ms ) const;
 95 |     int                         write_head() const;
 96 |     int                         wrap_to_buffer( int position ) const;
 97 |     bool                        write_buffer_fading_in() const;
 98 |     
 99 |     void                        write_sample( int16_t sample, int index );
100 |     int16_t                     read_sample( int index ) const;
101 |     int16_t                     read_sample_with_speed( float index, float speed ) const;
102 |     
103 |     void                        increment_head( int& head ) const;
104 |     void                        increment_head( float& head, float speed ) const;
105 |     
106 |     void                        write_to_buffer( const int16_t* source, int size );
107 |     
108 |     void                        set_bit_depth( int sample_size_in_bits );
109 |     
110 |     void                        fade_in_write();
111 |     
112 |     void                        set_write_head( int new_head );
113 |     
114 | #ifdef DEBUG_OUTPUT
115 |     void                        debug_output();
116 | #endif
117 | };
118 | 
119 | ////////////////////////////////////
120 | 
121 | class GLITCH_DELAY_EFFECT : public TEENSY_AUDIO_STREAM_WRAPPER
122 | {
123 |     static const int NUM_PLAY_HEADS = 4;
124 |     
125 |     DELAY_BUFFER          m_delay_buffer;
126 |     
127 |     PLAY_HEAD             m_play_heads[NUM_PLAY_HEADS];
128 |     
129 |     float                 m_speed_ratio;
130 |     int                   m_speed_in_samples;
131 |     
132 |     float                 m_loop_size_ratio;
133 |     int                   m_loop_size_in_samples;
134 |     
135 |     bool                  m_loop_moving;
136 |     
137 |     // store 'next' values, otherwise interrupt could be called during calculation of values
138 |     int                   m_next_sample_size_in_bits;
139 |     bool                  m_next_loop_moving;
140 |     bool                  m_next_beat;
141 |     
142 | protected:
143 |     
144 |     void                process_audio_in_impl( int channel, const int16_t* sample_data, int num_samples ) override;
145 |     void                process_audio_out_impl( int channel, int16_t* sample_data, int num_samples ) override;
146 |     
147 | public:
148 |     
149 |     GLITCH_DELAY_EFFECT();
150 |     
151 |     int                   num_input_channels() const override;
152 |     int                   num_output_channels() const override;
153 |     
154 |     void                  update() override;
155 |     
156 |     void                  set_bit_depth( int sample_size_in_bits );
157 |     void                  set_speed( float speed );
158 |     void                  set_loop_size( float loop_size );
159 |     void                  set_loop_moving( bool moving );
160 |     
161 |     void                  set_beat();
162 | };
163 | 
164 | 
165 | 


--------------------------------------------------------------------------------
/Source/PluginProcessor.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   ==============================================================================
  3 | 
  4 |     This file was auto-generated!
  5 | 
  6 |     It contains the basic framework code for a JUCE plugin processor.
  7 | 
  8 |   ==============================================================================
  9 | */
 10 | 
 11 | #include <array>
 12 | 
 13 | #include "JuceHeader.h"
 14 | 
 15 | #include "PluginProcessor.h"
 16 | #include "PluginEditor.h"
 17 | 
 18 | #include "GlitchDelayEffect.h"
 19 | 
 20 | namespace
 21 | {
 22 |     // mixdown N channels of buffer into channel 0, using the weights array
 23 |     template< size_t N >
 24 |     void mix_down( AudioSampleBuffer& buffer, std::array<float, N > weights )
 25 |     {
 26 |         jassert( buffer.getNumChannels() == N );
 27 |         
 28 |         for( int s = 0; s < buffer.getNumSamples(); ++s )
 29 |         {
 30 |             float mixed = 0.0f;
 31 |             for( int c = 0; c < buffer.getNumChannels(); ++c )
 32 |             {
 33 |                 mixed += buffer.getSample( c, s ) * weights[ c ];
 34 |             }
 35 |             
 36 |             buffer.setSample( 0, s, mixed );
 37 |         }
 38 |     }
 39 |     
 40 |     // mix buffer b2 into b1 using weights w1, w2
 41 |     void mix_into( AudioSampleBuffer& b1, AudioSampleBuffer& b2, int channel, float w1, float w2 )
 42 |     {
 43 |         jassert( b1.getNumChannels() > channel && b2.getNumChannels() > channel );
 44 |         
 45 |         for( int s = 0; s < b1.getNumSamples(); ++s )
 46 |         {
 47 |             float mixed = ( b1.getSample( channel, s ) * w1 ) + ( b2.getSample( channel, s ) * w2 );
 48 |             
 49 |             b1.setSample( channel, s, mixed );
 50 |         }
 51 |     }
 52 | }
 53 | 
 54 | //==============================================================================
 55 | 
 56 | float TeensyJuceAudioProcessor::MAX_FEEDBACK = 0.85f;
 57 | 
 58 | TeensyJuceAudioProcessor::TeensyJuceAudioProcessor()
 59 | #ifndef JucePlugin_PreferredChannelConfigurations
 60 |      : AudioProcessor (BusesProperties()
 61 |                      #if ! JucePlugin_IsMidiEffect
 62 |                       #if ! JucePlugin_IsSynth
 63 |                        .withInput  ("Input",  AudioChannelSet::mono(), true)
 64 |                       #endif
 65 |                        .withOutput ("Output", AudioChannelSet::mono(), true)
 66 |                      #endif
 67 |                        ),
 68 | #endif
 69 |     m_mix( nullptr ),
 70 |     m_loop_size( nullptr ),
 71 |     m_jitter( nullptr ),
 72 |     m_feedback( nullptr )
 73 | {
 74 |     // create the wrapped effect
 75 |     m_effect = make_unique< GLITCH_DELAY_EFFECT >();
 76 |     
 77 |     addParameter( m_mix = new AudioParameterFloat(          "mix",          // parameterID
 78 |                                                             "Mix",          // parameter name
 79 |                                                             0.0f,           // minimum value
 80 |                                                             1.0f,           // maximum value
 81 |                                                             0.5f ) );       // default value
 82 |     
 83 |     addParameter( m_loop_size = new AudioParameterFloat(    "loop_size",    // parameterID
 84 |                                                             "Loop Size",    // parameter name
 85 |                                                             0.0f,           // minimum value
 86 |                                                             1.0f,           // maximum value
 87 |                                                             0.5f ) );       // default value
 88 |     
 89 |     addParameter( m_jitter = new AudioParameterFloat(       "jitter",       // parameterID
 90 |                                                             "Jitter",       // parameter name
 91 |                                                             0.0f,           // minimum value
 92 |                                                             1.0f,           // maximum value
 93 |                                                             0.5f ) );       // default value
 94 |     
 95 |     addParameter( m_feedback = new AudioParameterFloat(     "feedback",     // parameterID
 96 |                                                             "Feedback",     // parameter name
 97 |                                                             0.0f,           // minimum value
 98 |                                                             MAX_FEEDBACK,   // maximum value
 99 |                                                             0.5f ) );       // default value
100 | }
101 | 
102 | TeensyJuceAudioProcessor::~TeensyJuceAudioProcessor()
103 | {
104 | }
105 | 
106 | //==============================================================================
107 | const String TeensyJuceAudioProcessor::getName() const
108 | {
109 |     return JucePlugin_Name;
110 | }
111 | 
112 | bool TeensyJuceAudioProcessor::acceptsMidi() const
113 | {
114 |    #if JucePlugin_WantsMidiInput
115 |     return true;
116 |    #else
117 |     return false;
118 |    #endif
119 | }
120 | 
121 | bool TeensyJuceAudioProcessor::producesMidi() const
122 | {
123 |    #if JucePlugin_ProducesMidiOutput
124 |     return true;
125 |    #else
126 |     return false;
127 |    #endif
128 | }
129 | 
130 | bool TeensyJuceAudioProcessor::isMidiEffect() const
131 | {
132 |    #if JucePlugin_IsMidiEffect
133 |     return true;
134 |    #else
135 |     return false;
136 |    #endif
137 | }
138 | 
139 | double TeensyJuceAudioProcessor::getTailLengthSeconds() const
140 | {
141 |     return 0.0;
142 | }
143 | 
144 | int TeensyJuceAudioProcessor::getNumPrograms()
145 | {
146 |     return 1;   // NB: some hosts don't cope very well if you tell them there are 0 programs,
147 |                 // so this should be at least 1, even if you're not really implementing programs.
148 | }
149 | 
150 | int TeensyJuceAudioProcessor::getCurrentProgram()
151 | {
152 |     return 0;
153 | }
154 | 
155 | void TeensyJuceAudioProcessor::setCurrentProgram (int index)
156 | {
157 | }
158 | 
159 | const String TeensyJuceAudioProcessor::getProgramName (int index)
160 | {
161 |     return {};
162 | }
163 | 
164 | void TeensyJuceAudioProcessor::changeProgramName (int index, const String& newName)
165 | {
166 | }
167 | 
168 | //==============================================================================
169 | void TeensyJuceAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)
170 | {
171 |     // Use this method as the place to do any pre-playback
172 |     // initialisation that you need..
173 | }
174 | 
175 | void TeensyJuceAudioProcessor::releaseResources()
176 | {
177 |     // When playback stops, you can use this as an opportunity to free up any
178 |     // spare memory, etc.
179 | }
180 | 
181 | #ifndef JucePlugin_PreferredChannelConfigurations
182 | bool TeensyJuceAudioProcessor::isBusesLayoutSupported (const BusesLayout& layouts) const
183 | {
184 |   #if JucePlugin_IsMidiEffect
185 |     ignoreUnused (layouts);
186 |     return true;
187 |   #else
188 |     // This is the place where you check if the layout is supported.
189 |     // In this template code we only support mono or stereo.
190 |     if (layouts.getMainOutputChannelSet() != AudioChannelSet::mono()
191 |      && layouts.getMainOutputChannelSet() != AudioChannelSet::stereo())
192 |         return false;
193 | 
194 |     // This checks if the input layout matches the output layout
195 |    #if ! JucePlugin_IsSynth
196 |     if (layouts.getMainOutputChannelSet() != layouts.getMainInputChannelSet())
197 |         return false;
198 |    #endif
199 | 
200 |     return true;
201 |   #endif
202 | }
203 | #endif
204 | 
205 | void TeensyJuceAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
206 | {
207 |     ScopedNoDenormals no_denormals;
208 |     
209 |     if( m_prev_buffer.getNumChannels() != 1 || m_prev_buffer.getNumSamples() != buffer.getNumSamples() )
210 |     {
211 |         // set size of prev_buffer if not correct dimensions
212 |         m_prev_buffer.setSize( 1, buffer.getNumSamples() );
213 |         m_prev_buffer.clear( 0, 0, m_prev_buffer.getNumSamples() );
214 |     }
215 |     else
216 |     {
217 |         // blend feedback into input
218 |         mix_into( buffer, m_prev_buffer, 0, 1.0f - (*m_feedback), *m_feedback );
219 |     }
220 |     
221 |     m_effect->pre_process_audio( buffer, m_effect->num_input_channels(), m_effect->num_output_channels() );
222 |     
223 |     m_effect->set_speed( *m_jitter );
224 |     m_effect->set_loop_size( *m_loop_size );
225 |     m_effect->set_loop_moving(false);
226 |     m_effect->update();
227 |     
228 |     AudioSampleBuffer output( m_effect->num_output_channels(), buffer.getNumSamples() );
229 |     m_effect->post_process_audio( output );
230 |     
231 |     // mix down effect output to 1 channel
232 |     std::array<float, 4> mix_weights = {0.33f, 0.33f, 0.33f, 0.0f };
233 |     mix_down( output, mix_weights );
234 |     
235 |     // mix output with original input
236 |     mix_into( output, buffer, 0, *m_mix, 1.0f - *(m_mix) );
237 |     
238 |     // copy our mixed output to channel 0 of buffer
239 |     buffer.copyFrom( 0, 0, output, 0, 0, output.getNumSamples() );
240 |     
241 |     // setup feedback for next block
242 |     m_prev_buffer.copyFrom( 0, 0, output, 0, 0, output.getNumSamples() );
243 | }
244 | 
245 | //==============================================================================
246 | bool TeensyJuceAudioProcessor::hasEditor() const
247 | {
248 |     return true; // (change this to false if you choose to not supply an editor)
249 | }
250 | 
251 | AudioProcessorEditor* TeensyJuceAudioProcessor::createEditor()
252 | {
253 |     return new TeensyJuceAudioProcessorEditor (*this, *m_effect);
254 | }
255 | 
256 | //==============================================================================
257 | void TeensyJuceAudioProcessor::getStateInformation (MemoryBlock& destData)
258 | {
259 |     // You should use this method to store your parameters in the memory block.
260 |     // You could do that either as raw data, or use the XML or ValueTree classes
261 |     // as intermediaries to make it easy to save and load complex data.
262 | }
263 | 
264 | void TeensyJuceAudioProcessor::setStateInformation (const void* data, int sizeInBytes)
265 | {
266 |     // You should use this method to restore your parameters from this memory block,
267 |     // whose contents will have been created by the getStateInformation() call.
268 | }
269 | 
270 | //==============================================================================
271 | // This creates new instances of the plugin..
272 | AudioProcessor* JUCE_CALLTYPE createPluginFilter()
273 | {
274 |     return new TeensyJuceAudioProcessor();
275 | }
276 | 


--------------------------------------------------------------------------------
/Source/GlitchDelayEffect.cpp:
--------------------------------------------------------------------------------
  1 | #ifdef TARGET_TEENSY
  2 | #include <Audio.h>
  3 | #include <Wire.h>
  4 | #include <SPI.h>
  5 | #include <SD.h>
  6 | #include <SerialFlash.h>
  7 | #endif // TARGET_TEENSY
  8 | 
  9 | #include <string.h>
 10 | #include <Math.h>
 11 | #include "GlitchDelayEffect.h"
 12 | #include "CompileSwitches.h"
 13 | 
 14 | 
 15 | const float MIN_SPEED( 0.25f );
 16 | const float MAX_SPEED( 4.0f );
 17 | 
 18 | #ifdef TARGET_JUCE
 19 | const int AUDIO_BLOCK_SAMPLES( 512 );           // TODO need a value in JUCE, is it even constant?
 20 | const int AUDIO_SAMPLE_RATE( 44100 );           // TODO need a value in JUCE
 21 | #endif
 22 | 
 23 | const int FIXED_FADE_TIME_SAMPLES( (AUDIO_SAMPLE_RATE / 1000.0f ) * 4 ); // 4ms cross fade
 24 | const int MIN_LOOP_SIZE_IN_SAMPLES( (FIXED_FADE_TIME_SAMPLES * 2) + AUDIO_BLOCK_SAMPLES );
 25 | const int MAX_LOOP_SIZE_IN_SAMPLES( AUDIO_SAMPLE_RATE * 0.5f );
 26 | const int MIN_SHIFT_SPEED( 0 );
 27 | const int MAX_SHIFT_SPEED( 100 );
 28 | const int MAX_JITTER_SIZE( AUDIO_SAMPLE_RATE * 0.2f );
 29 | 
 30 | 
 31 | /////////////////////////////////////////////////////////////////////
 32 | 
 33 | int delay_buffer_size_in_samples( int sample_size_in_bits )
 34 | {
 35 |     const float bytes_per_sample = sample_size_in_bits / 8.0f;
 36 |     return static_cast<int>(DELAY_BUFFER_SIZE_IN_BYTES / bytes_per_sample);
 37 | }
 38 | 
 39 | int convert_time_in_ms_to_samples( int time_in_ms )
 40 | {
 41 |     static int num_samples_per_ms = AUDIO_SAMPLE_RATE / 1000;
 42 |     return num_samples_per_ms * time_in_ms;
 43 | }
 44 | 
 45 | int fade_out_in( int x, int y, float t )
 46 | {
 47 |     // fade down then back up
 48 |     if( t < 0.5f )
 49 |     {
 50 |         // t = 0.0 -> 1, t = 0.5 -> 0
 51 |         t = 1.0f - ( t * 2.0f );
 52 |         
 53 |         return round( x * t );
 54 |     }
 55 |     else
 56 |     {
 57 |         // t = 0.5 -> 0, t = 1 -> 1
 58 |         t = ( t * 2.0f ) - 1.0f;
 59 |         
 60 |         return round( y * t );
 61 |     }
 62 | }
 63 | 
 64 | int cross_fade_samples( int x, int y, float t )
 65 | {
 66 |     return round( lerp<float>( x, y, t ) );
 67 | }
 68 | 
 69 | /////////////////////////////////////////////////////////////////////
 70 | 
 71 | PLAY_HEAD::PLAY_HEAD( const DELAY_BUFFER& delay_buffer, float play_speed ) :
 72 |     m_delay_buffer( delay_buffer ),
 73 |     m_current_play_head( 0.0f ),
 74 |     m_destination_play_head( 0.0f ),
 75 |     m_play_speed( play_speed ),
 76 |     m_fade_samples_remaining( 0 ),
 77 |     m_loop_start( -1 ),
 78 |     m_loop_end( -1 ),
 79 |     m_unjittered_loop_start( -1 ),
 80 |     m_shift_speed( 0 ),
 81 |     m_next_loop_size_ratio( 1.0f ),
 82 |     m_next_shift_speed_ratio( 0.0f ),
 83 |     m_jitter_ratio( 0.0f ),
 84 |     m_initial_loop_crossfade_complete(false)
 85 | {
 86 |     if( play_forwards() )
 87 |     {
 88 |         // all forward playing heads default to looping
 89 |         m_loop_start                    = 0;
 90 |         m_loop_end                      = MAX_LOOP_SIZE_IN_SAMPLES;
 91 |     }
 92 |     
 93 |     set_loop_behind_write_head();
 94 |     
 95 |     // set head immediately (don't want to crossfade initially)
 96 |     m_current_play_head                 = m_destination_play_head;
 97 |     m_initial_loop_crossfade_complete   = true;
 98 |     m_fade_samples_remaining            = 0;
 99 | }
100 | 
101 | int PLAY_HEAD::current_position() const
102 | {
103 |     return m_current_play_head;
104 | }
105 | 
106 | int PLAY_HEAD::destination_position() const
107 | {
108 |     return m_destination_play_head;
109 | }
110 | 
111 | int PLAY_HEAD::loop_start() const
112 | {
113 |     return m_loop_start;
114 | }
115 | 
116 | int PLAY_HEAD::loop_end() const
117 | {
118 |     return m_loop_end;
119 | }
120 | 
121 | int PLAY_HEAD::play_head_to_write_head_buffer_size() const
122 | {
123 |     const int half_jitter     = ( MAX_JITTER_SIZE / 2 ) + 1;
124 |     const int buffer_samples  = FIXED_FADE_TIME_SAMPLES + FIXED_FADE_TIME_SAMPLES + AUDIO_BLOCK_SAMPLES + half_jitter;
125 |     
126 |     return buffer_samples;
127 | }
128 | 
129 | int PLAY_HEAD::buffered_loop_start() const
130 | {
131 |     const int extended_start  = m_delay_buffer.wrap_to_buffer( m_loop_start - play_head_to_write_head_buffer_size() );
132 |     return extended_start;
133 | }
134 | 
135 | int PLAY_HEAD::current_loop_size() const
136 | {
137 |     if( m_loop_end > m_loop_start )
138 |     {
139 |         return m_loop_end - m_loop_start;
140 |     }
141 |     else
142 |     {
143 |         return ( m_delay_buffer.m_buffer_size_in_samples - m_loop_start ) + m_loop_end;
144 |     }
145 | }
146 | 
147 | bool PLAY_HEAD::looping() const
148 | {
149 |     if( m_loop_start < 0 )
150 |     {
151 |         ASSERT_MSG( m_loop_end < 0, "Inconsistent loop state" );
152 |         return false;
153 |     }
154 |     
155 |     return true;
156 | }
157 | 
158 | bool PLAY_HEAD::position_inside_section( int position, int start, int end ) const
159 | {
160 |     if( end < start )
161 |     {
162 |         // current and destination are wrapped around
163 |         if( position >= start || position <= end )
164 |         {
165 |             return true;
166 |         }
167 |     }
168 |     else if( position >= start && position <= end )
169 |     {
170 |         return true;
171 |     }
172 |     
173 |     return false;
174 | }
175 | 
176 | bool PLAY_HEAD::position_inside_next_read( int position, int read_size ) const
177 | {
178 |     // standard delay (or crossfading into a loop)
179 |     if( m_loop_end < 0 || (!m_initial_loop_crossfade_complete && m_fade_samples_remaining > 0) )
180 |     {
181 |         // cross-fading
182 |         if( play_forwards() )
183 |         {
184 |             if( m_current_play_head != m_destination_play_head )
185 |             {
186 |                 const int fade_read_size = min_val<int>( read_size, m_fade_samples_remaining ) - 1; // read_size -1 because if 1 sample is read start == end
187 |                 
188 |                 const int current_cf_end = m_delay_buffer.wrap_to_buffer( m_current_play_head + fade_read_size );
189 |                 if( position_inside_section( position, m_current_play_head, current_cf_end ) )
190 |                 {
191 |                     // inside the cross fade from current to destination
192 |                     return true;
193 |                 }
194 |                 
195 |                 const int destination_end = m_delay_buffer.wrap_to_buffer( m_destination_play_head + read_size - 1 ); // after fading, destination will become current, read_size samples will be read
196 |                 if( position_inside_section( position, m_destination_play_head, destination_end ) )
197 |                 {
198 |                     // inside the cross fade from current to destination
199 |                     return true;
200 |                 }
201 |             }
202 |             else
203 |             {
204 |                 // not cross-fading
205 |                 const int read_end = m_delay_buffer.wrap_to_buffer( m_current_play_head + read_size - 1);
206 |                 if( position_inside_section( position, m_current_play_head, read_end ) )
207 |                 {
208 |                     return true;
209 |                 }
210 |             }
211 |         }
212 |         else
213 |         {
214 |             if( m_current_play_head != m_destination_play_head )
215 |             {
216 |                 const int fade_read_size = min_val<int>( read_size, m_fade_samples_remaining ) - 1; // read_size -1 because if 1 sample is read start == end
217 |                 
218 |                 const int current_cf_start = m_delay_buffer.wrap_to_buffer( m_current_play_head - fade_read_size );
219 |                 if( position_inside_section( position, current_cf_start, m_current_play_head ) )
220 |                 {
221 |                     // inside the cross fade from current to destination
222 |                     return true;
223 |                 }
224 |                 
225 |                 const int destination_end = m_delay_buffer.wrap_to_buffer( m_destination_play_head - read_size - 1 ); // after fading, destination will become current, read_size samples will be read
226 |                 if( position_inside_section( position, destination_end, m_destination_play_head ) )
227 |                 {
228 |                     // inside the cross fade from current to destination
229 |                     return true;
230 |                 }
231 |             }
232 |             else
233 |             {
234 |                 // not cross-fading
235 |                 const int read_end = m_delay_buffer.wrap_to_buffer( m_current_play_head - read_size - 1);
236 |                 if( position_inside_section( position, read_end, m_current_play_head ) )
237 |                 {
238 |                     return true;
239 |                 }
240 |             }
241 |         }
242 |     }
243 |     // otherwise looping
244 |     else
245 |     {
246 |         ASSERT_MSG( play_forwards(), "Loop not supported playing forwards" );
247 |         
248 |         // NOTE this tests entire loop NOT next read per-se
249 |         const int loop_end_cf_end = m_delay_buffer.wrap_to_buffer( m_loop_end + FIXED_FADE_TIME_SAMPLES - 1 );
250 |         if( position_inside_section( position, m_loop_start, loop_end_cf_end ) )
251 |         {
252 |             return true;
253 |         }
254 |         /*
255 |          // cross-fading
256 |          if( m_current_play_head != m_destination_play_head )
257 |          {
258 |          
259 |          }
260 |          
261 |          const int loop_end_cf_end = m_delay_buffer.wrap_to_buffer( m_loop_end + FIXED_FADE_TIME_SAMPLES - 1 );
262 |          int samples_left_of_loop( 0 );
263 |          if( loop_end_cf_end > m_loop_start )
264 |          {
265 |          samples_left_of_loop = loop_end_cf_end - m_destination_play_head;
266 |          }
267 |          else
268 |          {
269 |          samples_left_of_loop = ( m_delay_buffer.m_buffer_size_in_samples - m_destination_play_head ) + loop_end_cf_end;
270 |          }
271 |          const int samples_to_read = min( read_size, samples_left_of_loop );
272 |          const int read_end = m_delay_buffer.wrap_to_buffer( m_destination_play_head + samples_to_read );
273 |          if( position_inside_section( position, m_destination_play_head, read_end ) )
274 |          {
275 |          // inside the cross fade from current to destination
276 |          return true;
277 |          }
278 |          */
279 |     }
280 |     
281 |     return false;
282 | }
283 | 
284 | bool PLAY_HEAD::initial_loop_crossfade_complete() const
285 | {
286 |     return m_initial_loop_crossfade_complete;
287 | }
288 | 
289 | bool PLAY_HEAD::play_forwards() const
290 | {
291 |     return m_play_speed > 0.0f;
292 | }
293 | 
294 | bool PLAY_HEAD::crossfade_active() const
295 | {
296 |     return m_current_play_head != m_destination_play_head;
297 | }
298 | 
299 | void PLAY_HEAD::set_next_loop()
300 | {
301 |     ASSERT_MSG( play_forwards(), "Loop not supported playing forwards" );
302 |     ASSERT_MSG( m_loop_start >= 0, "PLAY_HEAD::read_from_play_head() invalid loop start" );
303 |     ASSERT_MSG( m_initial_loop_crossfade_complete, "looping before we've finished the cross-fade into the loop\n" );
304 |     ASSERT_MSG( !crossfade_active(), "starting new loop whist still cross fading" );
305 |     
306 |     // set next loop parameters
307 |     float r                               = (random(1000) / 1000.0f) * 0.25f;
308 |     r                                     = 1.0f + ( r - 0.125f ); // r = 0.875 => 1.125
309 |     
310 |     const int loop_size                   = round( lerp<float>( MIN_LOOP_SIZE_IN_SAMPLES, MAX_LOOP_SIZE_IN_SAMPLES, m_next_loop_size_ratio * r ) );
311 |     
312 |     if( m_next_shift_speed_ratio > 0.0f )
313 |     {
314 |         m_shift_speed                       = round( lerp<float>( MIN_SHIFT_SPEED, MAX_SHIFT_SPEED, m_next_shift_speed_ratio * r ) );
315 |     }
316 |     else
317 |     {
318 |         m_shift_speed                       = 0;
319 |         
320 |         r                                   = (random(1000) / 1000.0f);
321 |         r                                   -= 0.5f; // r = -0.5 => 0.5
322 |         int jitter_offset                   = MAX_JITTER_SIZE * r * m_jitter_ratio;
323 |         
324 |         m_loop_start                        = m_delay_buffer.wrap_to_buffer( m_unjittered_loop_start + jitter_offset );
325 |     }
326 |     
327 |     m_loop_end                           = m_delay_buffer.wrap_to_buffer( m_loop_start + loop_size );
328 |     
329 |     ASSERT_MSG( current_loop_size() == loop_size, "Error in loop size calculation" );
330 |     
331 |     // check whether the write head is about to run over the read head, in which case cross fade read head to new position
332 |     if( position_inside_section( m_delay_buffer.write_head(), buffered_loop_start(), m_loop_end ) )
333 |     {
334 |         set_loop_behind_write_head();
335 |     }
336 |     
337 |     set_play_head( m_loop_start );
338 | }
339 | 
340 | int16_t PLAY_HEAD::read_sample_with_cross_fade()
341 | {
342 |     ASSERT_MSG( m_fade_samples_remaining >= 0, "PLAY_HEAD::read_sample_with_cross_fade()" );
343 |     
344 |     int16_t sample(0);
345 |     
346 |     // cross-fading
347 |     if( m_fade_samples_remaining > 0 )
348 |     {
349 |         int16_t current_sample            = m_delay_buffer.read_sample_with_speed( m_current_play_head, m_play_speed );
350 |         
351 |         int16_t destination_sample        = m_delay_buffer.read_sample_with_speed( m_destination_play_head, m_play_speed );
352 |         
353 |         const float t                     = static_cast<float>(m_fade_samples_remaining) / FIXED_FADE_TIME_SAMPLES; // t=0 at destination, t=1 at current
354 |         --m_fade_samples_remaining;
355 |         
356 |         sample                            = cross_fade_samples( destination_sample, current_sample, t );
357 |         
358 |         m_delay_buffer.increment_head( m_current_play_head, m_play_speed );
359 |         m_delay_buffer.increment_head( m_destination_play_head, m_play_speed );
360 |     }
361 |     // not cross-fading
362 |     else
363 |     {
364 |         m_initial_loop_crossfade_complete = true;
365 |         
366 |         m_current_play_head               = m_destination_play_head;
367 |         sample                            = m_delay_buffer.read_sample( m_current_play_head );
368 |         
369 |         m_delay_buffer.increment_head( m_current_play_head, m_play_speed );
370 |         m_destination_play_head           = m_current_play_head;
371 |     }
372 |     
373 |     return sample;
374 | }
375 | 
376 | void PLAY_HEAD::set_loop_size( float loop_size_ratio )
377 | {
378 |     m_next_loop_size_ratio = loop_size_ratio;
379 | }
380 | 
381 | void PLAY_HEAD::set_shift_speed( float speed )
382 | {
383 |     m_next_shift_speed_ratio = speed;
384 | }
385 | 
386 | void PLAY_HEAD::set_jitter( float jitter )
387 | {
388 |     m_jitter_ratio = jitter;
389 | }
390 | 
391 | void PLAY_HEAD::set_play_head( int new_play_head )
392 | {
393 |     // already at this offset (or currently fading to it)
394 |     if( new_play_head == m_destination_play_head )
395 |     {
396 |         return;
397 |     }
398 |     
399 |     // currently cross fading
400 |     if( m_current_play_head != m_destination_play_head )
401 |     {
402 |         return;
403 |     }
404 |     
405 |     m_destination_play_head       = new_play_head;
406 |     
407 |     m_fade_samples_remaining      = FIXED_FADE_TIME_SAMPLES;
408 | }
409 | 
410 | void PLAY_HEAD::set_loop_behind_write_head()
411 | {
412 |     if( looping() )
413 |     {
414 |         const int loop_size                     = current_loop_size();
415 |         int loop_end                            = m_delay_buffer.write_head() - ( play_head_to_write_head_buffer_size() + m_shift_speed );
416 |         loop_end                                = m_delay_buffer.wrap_to_buffer( loop_end );
417 |         const int loop_start                    = m_delay_buffer.wrap_to_buffer( loop_end - loop_size );
418 |         
419 |         ASSERT_MSG( loop_size + FIXED_FADE_TIME_SAMPLES + 1 < DELAY_BUFFER_SIZE_IN_BYTES, "Loop size too large\n" );
420 |         ASSERT_MSG( loop_size > FIXED_FADE_TIME_SAMPLES * 2, "Loop size too small\n" );
421 |         
422 |         enable_loop( loop_start, loop_end );
423 |     }
424 |     else
425 |     {
426 |         int position                           = m_delay_buffer.write_head() - ( play_head_to_write_head_buffer_size() + m_shift_speed );
427 |         m_destination_play_head                = m_delay_buffer.wrap_to_buffer( position );
428 |         m_current_play_head                    = m_destination_play_head;
429 |         m_fade_samples_remaining               = FIXED_FADE_TIME_SAMPLES;
430 |     }
431 | }
432 | 
433 | void PLAY_HEAD::read_from_play_head( int16_t* dest, int size )
434 | {
435 |     for( int x = 0; x < size; ++x )
436 |     {
437 |         if( m_loop_end >= 0  && !position_inside_section( m_destination_play_head, m_loop_start, m_loop_end ) )
438 |         {
439 |             set_next_loop();
440 |         }
441 |         
442 |         dest[x] = read_sample_with_cross_fade();
443 |     }
444 |     
445 |     if( m_shift_speed > 0 && !crossfade_active() )
446 |     {
447 |         m_loop_start      = m_delay_buffer.wrap_to_buffer( m_loop_start + m_shift_speed );
448 |         m_loop_end        = m_delay_buffer.wrap_to_buffer( m_loop_end + m_shift_speed );
449 |     }
450 | }
451 | 
452 | void PLAY_HEAD::enable_loop( int start, int end )
453 | {
454 |     ASSERT_MSG( play_forwards(), "Looping only currently supported on playing forwards" );
455 |     
456 |     m_loop_start            = start;
457 |     m_loop_end              = end;
458 |     m_unjittered_loop_start = start;
459 |     
460 |     m_initial_loop_crossfade_complete = false;
461 |     
462 |     // force a new cross fade
463 |     m_destination_play_head           = m_loop_start;
464 |     m_fade_samples_remaining          = FIXED_FADE_TIME_SAMPLES;
465 | }
466 | 
467 | 
468 | void PLAY_HEAD::disable_loop()
469 | {
470 |     m_loop_start                      = -1;
471 |     m_loop_end                        = -1;
472 | }
473 | 
474 | #ifdef DEBUG_OUTPUT
475 | void PLAY_HEAD::debug_output()
476 | {
477 |     DEBUG_TEXT("PLAY_HEAD current:");
478 |     DEBUG_TEXT(m_current_play_head);
479 |     DEBUG_TEXT(" destination:");
480 |     DEBUG_TEXT(m_destination_play_head);
481 |     DEBUG_TEXT(" loop start:");
482 |     DEBUG_TEXT(m_loop_start);
483 |     DEBUG_TEXT(" loop end:");
484 |     DEBUG_TEXT(m_loop_end);
485 |     DEBUG_TEXT(" fade samples:");
486 |     DEBUG_TEXT(m_fade_samples_remaining);
487 |     if( !m_initial_loop_crossfade_complete )
488 |     {
489 |         DEBUG_TEXT(" INITIAL CF");
490 |     }
491 |     DEBUG_TEXT("\n");
492 | }
493 | #endif
494 | 
495 | /////////////////////////////////////////////////////////////////////
496 | 
497 | DELAY_BUFFER::DELAY_BUFFER() :
498 |     m_buffer(),
499 |     m_buffer_size_in_samples(0),
500 |     m_sample_size_in_bits(0),
501 |     m_write_head(0),
502 |     m_fade_samples_remaining(0)
503 | {
504 |     set_bit_depth( 16 );
505 | }
506 | 
507 | int DELAY_BUFFER::position_offset_from_head( int offset ) const
508 | {
509 |     ASSERT_MSG( offset >= 0 && offset < m_buffer_size_in_samples - 1, "DELAY_BUFFER::position_offset_from_head()" );
510 |     
511 |     int position = wrap_to_buffer( m_write_head - offset );
512 |     
513 |     ASSERT_MSG( position >= 0 && position < m_buffer_size_in_samples, "DELAY_BUFFER::position_offset_from_head()" );
514 |     return position;
515 | }
516 | 
517 | int DELAY_BUFFER::delay_offset_from_ratio( float ratio_of_max_delay ) const
518 | {
519 |     int offset = trunc_to_int( ratio_of_max_delay * ( m_buffer_size_in_samples - AUDIO_BLOCK_SAMPLES ) );
520 |     ASSERT_MSG( offset >= 0 && offset <= m_buffer_size_in_samples - AUDIO_BLOCK_SAMPLES, "DELAY_BUFFER::delay_offset_from_ratio()" );
521 |     return offset;
522 | }
523 | 
524 | int DELAY_BUFFER::delay_offset_from_time( int time_in_ms ) const
525 | {
526 |     int offset   = convert_time_in_ms_to_samples( time_in_ms );
527 |     
528 |     if( offset > m_buffer_size_in_samples - AUDIO_BLOCK_SAMPLES )
529 |     {
530 |         offset = m_buffer_size_in_samples - AUDIO_BLOCK_SAMPLES;
531 |     }
532 |     
533 |     ASSERT_MSG( offset >= 0 && offset <= m_buffer_size_in_samples - AUDIO_BLOCK_SAMPLES, "DELAY_BUFFER::delay_offset_from_time()" );
534 |     return offset;
535 | }
536 | 
537 | int DELAY_BUFFER::write_head() const
538 | {
539 |     return m_write_head;
540 | }
541 | 
542 | int DELAY_BUFFER::wrap_to_buffer( int position ) const
543 | {
544 |     if( position < 0 )
545 |     {
546 |         return m_buffer_size_in_samples + position;
547 |     }
548 |     else if( position >= m_buffer_size_in_samples )
549 |     {
550 |         return position - m_buffer_size_in_samples;
551 |     }
552 |     
553 |     return position;
554 | }
555 | 
556 | bool DELAY_BUFFER::write_buffer_fading_in() const
557 | {
558 |     return m_fade_samples_remaining > 0;
559 | }
560 | 
561 | void DELAY_BUFFER::write_sample( int16_t sample, int index )
562 | {
563 |     ASSERT_MSG( index >= 0 && index < m_buffer_size_in_samples, "DELAY_BUFFER::write_sample() writing outside buffer" );
564 |     
565 |     switch( m_sample_size_in_bits )
566 |     {
567 |         case 8:
568 |         {
569 |             int8_t sample8                          = (sample >> 8) & 0x00ff;
570 |             int8_t* sample_buffer                   = reinterpret_cast<int8_t*>(m_buffer);
571 |             sample_buffer[ index ]                  = sample8;
572 |             break;
573 |         }
574 |         case 12:
575 |         {
576 |             int8_t* sample_buffer                   = reinterpret_cast<int8_t*>(m_buffer);
577 |             
578 |             const int offset_index                  = static_cast<int>( index * 1.5f );
579 |             
580 |             ASSERT_MSG( offset_index + 1 < DELAY_BUFFER_SIZE_IN_BYTES, "Buffer overrun" );
581 |             
582 |             if( index & 1 )
583 |             {
584 |                 // odd indices
585 |                 const uint8_t prev_byte                  = sample_buffer[ offset_index ];
586 |                 sample_buffer[ offset_index ]            = ( (sample & 0xf000) >> 12 ) | (prev_byte & 0x00f0);
587 |                 sample_buffer[ offset_index + 1 ]        = (( sample & 0x0ff0 ) >> 4);
588 |             }
589 |             else
590 |             {
591 |                 // even indices
592 |                 sample_buffer[ offset_index ]            = (sample >> 8);
593 |                 const uint8_t prev_byte                  = sample_buffer[ offset_index + 1 ];
594 |                 sample_buffer[ offset_index + 1 ]        = ( sample & 0x00f0 ) | ( prev_byte & 0x000f );
595 |                 
596 |                 // read sample asserts if you read at the write head ASSERT_MSG( abs( read_sample( index ) - sample ) < 16, "EVEN 12 bit converison failure" );
597 |             }
598 |             
599 |             break;
600 |         }
601 |         case 16:
602 |         {
603 |             int16_t* sample_buffer                  = reinterpret_cast<int16_t*>(m_buffer);
604 |             sample_buffer[ index ]                  = sample;
605 |             break;
606 |         }
607 |     }
608 | }
609 | 
610 | int16_t DELAY_BUFFER::read_sample( int index ) const
611 | {
612 |     ASSERT_MSG( index >= 0 && index < m_buffer_size_in_samples, "DELAY_BUFFER::read_sample() writing outside buffer" );
613 |     ASSERT_MSG( index != m_write_head, "Reading from the write head position, expect a glitch" );
614 |     
615 |     switch( m_sample_size_in_bits )
616 |     {
617 |         case 8:
618 |         {
619 |             const int8_t* sample_buffer    = reinterpret_cast<const int8_t*>(m_buffer);
620 |             const int8_t sample            = sample_buffer[ index ];
621 |             
622 |             int16_t sample16               = sample;
623 |             sample16                       <<= 8;
624 |             
625 |             return sample16;
626 |         }
627 |         case 12:
628 |         {
629 |             const int8_t* sample_buffer    = reinterpret_cast<const int8_t*>(m_buffer);
630 |             
631 |             const int offset_index         = static_cast<int>( index * 1.5f );
632 |             
633 |             if( index & 1 )
634 |             {
635 |                 // odd indices
636 |                 const uint8_t top           = sample_buffer[offset_index] & 0x000f;
637 |                 const uint8_t bottom        = sample_buffer [offset_index + 1 ];
638 |                 return ( (top << 12) | (bottom << 4) );
639 |             }
640 |             else
641 |             {
642 |                 // even indices
643 |                 const uint8_t top           = sample_buffer[offset_index];
644 |                 const uint8_t bottom        = sample_buffer [offset_index + 1 ] & 0x00f0;
645 |                 return ( (top << 8) | bottom );
646 |             }
647 |             
648 |             break;
649 |         }
650 |         case 16:
651 |         {
652 |             const int16_t* sample_buffer    = reinterpret_cast<const int16_t*>(m_buffer);
653 |             const int16_t sample            = sample_buffer[ index ];
654 |             return sample;
655 |         }
656 |     }
657 |     
658 |     return 0;
659 | }
660 | 
661 | int16_t DELAY_BUFFER::read_sample_with_speed( float index, float speed ) const
662 | {
663 |     if( speed < 1.0f )
664 |     {
665 |         float nif = index;
666 |         increment_head( nif, speed );
667 |         
668 |         int curr_index = index;
669 |         int next_index = nif;
670 |         
671 |         if( curr_index == next_index )
672 |         {
673 |             // both current and next are in the same sample
674 |             return read_sample( curr_index );
675 |         }
676 |         else
677 |         {
678 |             // crossing 2 samples - calculate how much of each sample to use, then lerp between them
679 |             // use the fractional part - if 0.3 'into' next sample, then we mix 0.3 of next and 0.7 of current
680 |             float int_part;
681 |             float rem             = modff( nif, &int_part );
682 |             const float t         = rem / speed;
683 |             return lerp( read_sample(curr_index), read_sample(next_index), t );
684 |         }
685 |     }
686 |     else
687 |     {
688 |         return read_sample( index );
689 |     }
690 | }
691 | 
692 | void DELAY_BUFFER::increment_head( int& head ) const
693 | {
694 |     ++head;
695 |     
696 |     if( head >= m_buffer_size_in_samples )
697 |     {
698 |         head = 0;
699 |     }
700 | }
701 | 
702 | void DELAY_BUFFER::increment_head( float& head, float speed ) const
703 | {
704 |     head                        += speed;
705 |     if( head >= m_buffer_size_in_samples )
706 |     {
707 |         const float rem         = head - m_buffer_size_in_samples;
708 |         head                    = rem;
709 |     }
710 |     else if( head < 0.0f )
711 |     {
712 |         head                    = m_buffer_size_in_samples + head;
713 |     }
714 |     
715 |     ASSERT_MSG( truncf(head) >= 0 && truncf(head) < m_buffer_size_in_samples, "DELAY_BUFFER::increment_head()" );
716 |     
717 | }
718 | 
719 | void DELAY_BUFFER::write_to_buffer( const int16_t* source, int size )
720 | {
721 |     ASSERT_MSG( m_write_head >= 0 && m_write_head < m_buffer_size_in_samples, "GLITCH_DELAY_EFFECT::write_to_buffer()" );
722 |     
723 |     for( int x = 0; x < size; ++x )
724 |     {
725 |         // fading in the write head
726 |         if( m_fade_samples_remaining > 0 )
727 |         {
728 |             int16_t old_sample       = read_sample( m_write_head );
729 |             int16_t new_sample       = source[x];
730 |             
731 |             const float t            = static_cast<float>(m_fade_samples_remaining) / FIXED_FADE_TIME_SAMPLES; // t=1 at old t=0 at new
732 |             --m_fade_samples_remaining;
733 |             
734 |             int16_t cf_sample         = cross_fade_samples( new_sample, old_sample, t );
735 |             
736 |             write_sample( cf_sample, m_write_head );
737 |         }
738 |         else
739 |         {
740 |             write_sample( source[x], m_write_head );
741 |         }
742 |         
743 |         // increment write head
744 |         increment_head( m_write_head );
745 |     }
746 | }
747 | 
748 | void DELAY_BUFFER::set_bit_depth( int sample_size_in_bits )
749 | {
750 |     // NOTE - do not print in this function, it is called before Serial is configured
751 |     if( sample_size_in_bits != m_sample_size_in_bits )
752 |     {
753 |         m_sample_size_in_bits       = sample_size_in_bits;
754 |         m_buffer_size_in_samples    = delay_buffer_size_in_samples( m_sample_size_in_bits );
755 |         
756 |         m_write_head                = 0;
757 |         
758 |         memset( m_buffer, 0, sizeof(m_buffer) );
759 |     }
760 | }
761 | 
762 | void DELAY_BUFFER::fade_in_write()
763 | {
764 |     ASSERT_MSG( m_fade_samples_remaining == 0, "DELAY_BUFFER::fade_in_write() trying to start a fade during a fade" );
765 |     m_fade_samples_remaining = FIXED_FADE_TIME_SAMPLES;
766 | }
767 | 
768 | void DELAY_BUFFER::set_write_head( int new_write_head )
769 | {
770 |     m_write_head = new_write_head;
771 | }
772 | 
773 | #ifdef DEBUG_OUTPUT
774 | void DELAY_BUFFER::debug_output()
775 | {
776 |     DEBUG_TEXT("DELAY_BUFFER write head:");
777 |     DEBUG_TEXT(m_write_head);
778 |     DEBUG_TEXT(" fade samples:");
779 |     DEBUG_TEXT(m_fade_samples_remaining);
780 |     DEBUG_TEXT(" bit depth:");
781 |     DEBUG_TEXT(m_sample_size_in_bits);
782 |     DEBUG_TEXT("\n");
783 | }
784 | #endif
785 | 
786 | /////////////////////////////////////////////////////////////////////
787 | 
788 | GLITCH_DELAY_EFFECT::GLITCH_DELAY_EFFECT() :
789 |     m_delay_buffer(),
790 |     m_play_heads{ PLAY_HEAD( m_delay_buffer, 0.5f ), PLAY_HEAD( m_delay_buffer, 1.0f ), PLAY_HEAD( m_delay_buffer, 2.0f ), PLAY_HEAD( m_delay_buffer, -1.0f ) },
791 |     m_speed_ratio(1.0f),
792 |     m_speed_in_samples(MAX_SHIFT_SPEED),
793 |     m_loop_size_ratio(1.0f),
794 |     m_loop_size_in_samples(MAX_LOOP_SIZE_IN_SAMPLES),
795 |     m_loop_moving(true),
796 |     m_next_sample_size_in_bits(12),
797 |     m_next_loop_moving(true),
798 |     m_next_beat(false)
799 | {
800 |     
801 | }
802 | 
803 | void GLITCH_DELAY_EFFECT::process_audio_in_impl( int channel, const int16_t* sample_data, int num_samples )
804 | {
805 |     ASSERT_MSG( channel == 0, "Only mono input supported" );
806 |     
807 |     m_delay_buffer.write_to_buffer( sample_data, num_samples );
808 | }
809 | 
810 | void GLITCH_DELAY_EFFECT::process_audio_out_impl( int channel, int16_t* sample_data, int num_samples )
811 | {
812 |     
813 |     ASSERT_MSG( !m_play_heads[channel].position_inside_next_read( m_delay_buffer.write_head(), num_samples ), "Non - reading over write buffer\n" ); // position after write head is OLD DATA
814 |     m_play_heads[channel].read_from_play_head( sample_data, num_samples );
815 | }
816 | 
817 | int GLITCH_DELAY_EFFECT::num_input_channels() const
818 | {
819 |     return 1;
820 | }
821 | 
822 | int GLITCH_DELAY_EFFECT::num_output_channels() const
823 | {
824 |     return NUM_PLAY_HEADS;
825 | }
826 | 
827 | void GLITCH_DELAY_EFFECT::update()
828 | {
829 |     static int num_updates(0);
830 |     ++num_updates;
831 |     
832 |     m_delay_buffer.set_bit_depth( m_next_sample_size_in_bits );
833 |     m_loop_moving               = m_next_loop_moving;
834 |     
835 |     for( int pi = 0; pi < NUM_PLAY_HEADS; ++pi )
836 |     {
837 |         PLAY_HEAD& play_head = m_play_heads[pi];
838 |         if( m_loop_moving )
839 |         {
840 |             play_head.set_shift_speed( m_speed_ratio );
841 |         }
842 |         else
843 |         {
844 |             play_head.set_shift_speed( 0.0f );
845 |             play_head.set_jitter( m_speed_ratio );
846 |         }
847 |         
848 |         play_head.set_loop_size( m_loop_size_ratio );
849 |         
850 |         if( m_next_beat && play_head.play_forwards() && !play_head.crossfade_active() ) // let the reverse head play regardless of beats
851 |         {
852 |             play_head.set_next_loop();
853 |             play_head.set_loop_behind_write_head();
854 |         }
855 |         else
856 |         {
857 |             // TODO Move to PLAY_HEAD object
858 |             // check whether the write head is about to run over the read head, in which case cross fade read head to new position
859 |             if( play_head.looping() )
860 |             {
861 |                 if( play_head.position_inside_section( m_delay_buffer.write_head(), play_head.buffered_loop_start(), play_head.loop_end() ) )
862 |                 {
863 |                     play_head.set_loop_behind_write_head();
864 |                 }
865 |             }
866 |             else
867 |             {
868 |                 if( play_head.position_inside_next_read( m_delay_buffer.write_head(), AUDIO_BLOCK_SAMPLES * 2 ) )
869 |                 {
870 |                     play_head.set_loop_behind_write_head();
871 |                 }
872 |             }
873 |         }
874 |     }
875 |     m_next_beat = false;
876 |     
877 |     // read in on channel 0
878 |     process_audio_in( 0 );
879 |     
880 |     // write out all the playheads TODO this uses more output than there are channels!!
881 |     for( int pi = 0; pi < NUM_PLAY_HEADS; ++pi )
882 |     {
883 |         process_audio_out( pi );
884 |     }
885 | }
886 | 
887 | void GLITCH_DELAY_EFFECT::set_bit_depth( int sample_size_in_bits )
888 | {
889 |     m_next_sample_size_in_bits = sample_size_in_bits;
890 |     //set_bit_depth_impl( sample_size_in_bits );
891 | }
892 | 
893 | void GLITCH_DELAY_EFFECT::set_speed( float speed )
894 | {
895 |     m_speed_ratio = speed;
896 | }
897 | 
898 | void GLITCH_DELAY_EFFECT::set_loop_size( float loop_size )
899 | {
900 |     m_loop_size_ratio = loop_size;
901 | }
902 | 
903 | void GLITCH_DELAY_EFFECT::set_loop_moving( bool moving )
904 | {
905 |     m_next_loop_moving = moving;
906 | }
907 | 
908 | void GLITCH_DELAY_EFFECT::set_beat()
909 | {
910 |     m_next_beat = true;
911 | }
912 | 


--------------------------------------------------------------------------------