/CollidoscopeApp - Diff - Collidoscope

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #pragma once
     #include <array>
-...
     #include "Config.h"
     /**
      * Audio engine of the application. It uses the Cinder library to process audio in input and output.
      * The audio engine manages both waves. All methods have a waveIndx parameter to address a specific wave.
      */
     class AudioEngine
+    {
     public:
-...
         AudioEngine( const AudioEngine &copy ) = delete;
         AudioEngine & operator=(const AudioEngine &copy) = delete;
         /**
         * Set up of the audio engine.
         */
         void setup( const Config& Config );
         size_t getSampleRate();
-...
         void noteOff( size_t waveIdx, int note );
         /**
         * Returns the number of elements available to read in the wave ring buffer.
         * The wave ring buffer is used to pass the size of the wave chunks from the audio thread to the graphic thread,
         * when a new wave is recorded.
         */
         size_t getRecordWaveAvailable( size_t index );
         /**
         * Called from the graphic thread. Reads \a count elements from the wave ring buffer into \a buffer.
         * The wave ring buffer is used to pass the size of the wave chunks from the audio thread to the graphic thread,
         * when a new wave is recorded.
+        *
         */
         bool readRecordWave( size_t waveIdx, RecordWaveMsg* buffer, size_t count );
         bool readRecordWave( size_t waveIdx, RecordWaveMsg*, size_t count );
         void setSelectionSize( size_t waveIdx, size_t size );
-...
         void checkCursorTriggers( size_t waveIdx, std::vector<CursorTriggerMsg>& cursorTriggers );
         /**
          * Returns a const reference to the audio output buffer. This is the buffer that is sent off to the audio interface at each audio cycle.
          * It is used in the graphic thread to draw the oscilloscope.
          */
         const ci::audio::Buffer& getAudioOutputBuffer( size_t waveIdx ) const;
-...
         // nodes for recording audio input into buffer. Also sends chunks information through
         // non-blocking queue
         std::array< BufferToWaveRecorderNodeRef, NUM_WAVES > mBufferRecorderNodes;
         // pgranulars wrapped in a Cinder::Node
         // pgranulars for loop synths
         std::array< PGranularNodeRef, NUM_WAVES > mPGranularNodes;
-...
         std::array< std::unique_ptr< RingBufferPack<CursorTriggerMsg> >, NUM_WAVES > mCursorTriggerRingBufferPacks;
     };
     };

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
      This file incorporates work covered by the following copyright and permission notice:
         Copyright (c) 2014, The Cinder Project
         This code is intended to be used with the Cinder C++ library, http://libcinder.org
         Redistribution and use in source and binary forms, with or without modification, are permitted provided that
         the following conditions are met:
         * Redistributions of source code must retain the above copyright notice, this list of conditions and
         the following disclaimer.
         * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
         the following disclaimer in the documentation and/or other materials provided with the distribution.
         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
         WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
         PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
         ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
         TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
         HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
         NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
         POSSIBILITY OF SUCH DAMAGE.
     */
     #pragma once
     #include "cinder/Cinder.h"
-...
     #include "Messages.h"
     typedef std::shared_ptr<class BufferToWaveRecorderNode> BufferToWaveRecorderNodeRef;
     typedef std::shared_ptr<class BufferToWaveRecorderNode>	BufferToWaveRecorderNodeRef;
     typedef ci::audio::dsp::RingBufferT<RecordWaveMsg> RecordWaveMsgRingBuffer;
     /**
      * A \a Node in the audio graph of the Cinder audio library that records input in a buffer.
+     *
      * This class is similar to \a cinder::audio::BufferRecorderNode (it's a derivative work of this class indeed) but it has an additional feature:
      * when recording, it uses the audio input samples to compute the size values of the visual chunks.
      * The chunks values are stored in a ring buffer and fetched by the graphic thread to paint the wave as it gets recorded.
+     *
      */
     class BufferToWaveRecorderNode : public ci::audio::SampleRecorderNode {
     public:
-...
         void setNumSeconds(double numSeconds, bool shrinkToFit = false);
         //! Returns the length of the recording buffer in frames.
         size_t      getNumFrames() const    { return mRecorderBuffer.getNumFrames(); }
         size_t		getNumFrames() const	{ return mRecorderBuffer.getNumFrames(); }
         //! Returns the length of the recording buffer in seconds.
         double      getNumSeconds() const;
         double		getNumSeconds() const;
         //! \brief Returns a copy of the recored samples, up to the current write position.
         //!
         //! This method is non locking, and as such any resizing calls must be performed on the same thread or be otherwise synchronized.
         ci::audio::BufferRef    getRecordedCopy() const;
         ci::audio::BufferRef	getRecordedCopy() const;
         //! \brief Writes the currently recorded samples to a file at \a filePath
         //!
-...
         //! Returns the frame of the last buffer overrun or 0 if none since the last time this method was called. When this happens, it means the recorded buffer probably has skipped some frames.
         uint64_t getLastOverrun();
         //! returns a reference to the ring buffer when the size values of the chunks is stored, when a new wave is recorder
         RecordWaveMsgRingBuffer& getRingBuffer() { return mRingBuffer; }
         //!returns a pointer to the buffer where the audio is recorder. This is used by the PGranular to create the granular synthesis
         ci::audio::Buffer* getRecorderBuffer() { return &mRecorderBuffer; }
     protected:
         void initialize()               override;
         void process(ci::audio::Buffer *buffer) override;
         void initialize()				override;
         void process(ci::audio::Buffer *buffer)	override;
         void initBuffers(size_t numFrames);
         static const float kMinAudioVal;
         static const float kMaxAudioVal;
         ci::audio::BufferDynamic        mRecorderBuffer;
         ci::audio::BufferDynamicRef     mCopiedBuffer;
         std::atomic<uint64_t>   mLastOverrun;
         ci::audio::BufferDynamic		mRecorderBuffer;
         ci::audio::BufferDynamicRef		mCopiedBuffer;
         std::atomic<uint64_t>	mLastOverrun;
         RecordWaveMsgRingBuffer mRingBuffer;

     /*
      Copyright (C) 2015  Fiore Martin
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #pragma once
-...
     class DrawInfo;
     /**
+     *
      * A chunk of audio in Collidoscope low-fi visual wave.
+     *
      * The visual wave of Collidoscope is made out of a number of bars that mimic, in a low-fi fashion, the typical waveform-based representation of audio.
      * A Chunk is one of the bars of the visual wave.
+     *
      */
     class Chunk
+    {
-...
         const static float kWidth;
         const static float kHalfWidth;
         /**
          * Constructor, takes as argument the index of this chunk in the wave that contains it
          */
         Chunk( size_t index );
     	Chunk( size_t index );
         /**
          * Sets the top value of this chunk. The value is passed in audio coordinates : [-1.0, 1.0]
          */
         void inline setTop(float t) { mAudioTop = t; mAnimate = 0.0f; mResetting = false; /* startes the animation to crate a chunk */ }
         /**
          * Sets the bottom value of this chunk. The value is passed in audio coordinates : [-1.0, 1.0]
          */
         void inline setBottom(float b) { mAudioBottom = b; mAnimate = 0.0f; mResetting = false; }
         /**
          * Get the top value of this chunk. The value is returned in audio coordinates : [-1.0, 1.0]
          */
         float inline getTop() const { return mAudioTop; }
         /**
          * Get the bottom value of this chunk. The value is returned in audio coordinates : [-1.0, 1.0]
          */
         float inline getBottom() const { return mAudioBottom; }
         /**
          * Reset this chunks. When a chunk is reset, it starts shrinking until it disappears or setTop/setBottom are called again
+         *
          */
         void reset(){
             mResetting = true;
+        }
     	void reset(){
     		mResetting = true;
+    	}
         /**
          * Called in the graphic loop. It update this chunk.
          */
         void update( const DrawInfo& di );
         /**
          * Called in the graphic loop. It draws this chunk.
          */
         void draw( const DrawInfo& di, ci::gl::BatchRef &batch );
         /**
          * Called in the graphic loop. It draws this chunk all the way to the bottom of the screen.
          * This method is called when the chunk is the first or last in a selection.
          */
         void drawBar( const DrawInfo& di, ci::gl::BatchRef &batch );
         /**
          * Informs this chunk that it's the first chunk of the selection.
          */
         void setAsSelectionStart(bool start){
             isSelectionStart = start;
+        }
     	void setAsSelectionStart(bool start){
     		isSelectionStart = start;
+    	}
         /**
          * Informs this chunk that it's the last chunk of the selection.
          */
         void setAsSelectionEnd(bool end){
             isSelectionEnd = end;
+        }
     	void setAsSelectionEnd(bool end){
     		isSelectionEnd = end;
+    	}
     private:

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #pragma once
     #include <string>
-...
     #include "cinder/Xml.h"
     /**
      * Configuration class gathers in one place all the values recided at runtime
+     *
      * Reading the configuration from an XML file is partially implemented but not used at the moment
+     *
      */
     class Config
+    {
     public:
-...
         std::string getInputDeviceKey() const
+        {
             return mAudioInputDeviceKey;
             return mAudioInputDeviceKey;  // Komplete 1/2
             //return "{0.0.1.00000000}.{a043bc8c-1dd1-4c94-82b4-ad8320cac5a5}"; // Komplete 3/4
             //return "{0.0.1.00000000}.{828b681b-cc0c-44e1-93c9-5f1f46f5926f}"; // Realtek
+        }
         /**
          * Returns number of chunks in a wave
          */
         std::size_t getNumChunks() const
+        {
             return mNumChunks;
+        }
         /** returns wave lenght in seconds */
         /* return wave lenght in seconds */
         double getWaveLen() const
+        {
             return mWaveLen;
+        }
         /**
          * Returns wave selection color
          */
         ci::Color getWaveSelectionColor(size_t waveIdx) const
+        {
             if (waveIdx == 0){
-...
+            }
+        }
         /**
          * The size of the ring buffer used to trigger a visual cursor from the audio thread when a new grain is created
          */
         std::size_t getCursorTriggerMessageBufSize() const
+        {
             return 512;
+        }
         /** returns the index of the wave associated to the MIDI channel passed as argument */
         // returns the index of the wave associated to the MIDI channel passed as argument
         size_t getWaveForMIDIChannel( unsigned char channelIdx )
+        {
             return channelIdx;
             /*for ( int i = 0; i < NUM_WAVES; i++ ){
                 if ( channelIdx == mMidiChannels[i] )
                     return i;
             }*/
+        }
         double getMaxGrainDurationCoeff() const
-...
             return 6;
+        }
         /**
          * Returns the maximum size of a wave selection in number of chunks.
          */
         size_t getMaxSelectionNumChunks() const
+        {
             return 37;
+        }
         /**
          * The value returned is used when creating the oscilloscope.
          * The oscilloscope represents the audio output buffer graphically. However it doesn't need to be as refined as the
          * audio wave and it's downsampled using the following formula :  (number of oscilloscope points) = (size of audio output buffer) / getOscilloscopeNumPointsDivider()
          */
         size_t getOscilloscopeNumPointsDivider() const
+        {
             return 4;

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #pragma once
     #include "cinder/Area.h"
     /**
      * The DrawInfo class holds size information for drawing the waves in the screen.
      * Every time the screen is resized the draw info is updated with the new information about the window size.
+     *
      * Every wave has its own drawInfo.
+     *
      */
     class DrawInfo
+    {
     public:
         /**
          * Constructor. Takes the index of the wave as argument.
          */
         DrawInfo( size_t waveIndex ):
             mWaveIndex( waveIndex ),
             mWindowWidth(0),
-...
             mShrinkFactor(1)
         {}
         /**
          * Reset this DrawInfo using the new bounding area for the wave.  \a shrinkFactor
          * makes the wave shrink on the y axis with respect to the area. A factor 1 makes the wave as big as the area, whereas a factor >1 makes it shrink.
          */
         void reset( const ci::Area &bounds, float shrinkFactor )
+        {
             mWindowWidth = bounds.getWidth();
-...
             mShrinkFactor = shrinkFactor;
+        }
         /**
          * Maps a value in the audio space [-1.0, 1.0] to a position on the y axis of this DrawInfo's bounding area.
+         *
          */
         float audioToHeigt(float audioSample) const {
     	float audioToHeigt(float audioSample) const {
             /* clip into range [-1.1] */
             if (audioSample < -1.0f) {
                 audioSample = -1.0f;
-...
+            }
             /* map from [-1,1] to [0,1] */
             float ratio = (audioSample - (-1.0f)) * 0.5f; // 2 = 1 - (-1)
     		float ratio = (audioSample - (-1.0f)) * 0.5f; // 2 = 1 - (-1)
             /* get bottom and add the scaled height */
     		/* get bottom and add the scaled height */
             return ratio * mSelectionBarHeight; //remove  bounds.getY1() bound only needed for size of tier
+        }
+    	}
         float getMaxChunkHeight() const
+        {
-...
             return mSelectionBarHeight;
+        }
         /**
          * Returns the center position on the y axis of this DrawInfo's the bounding area.
          */
         int32_t getWaveCenterY() const
+        {
             if ( mWaveIndex == 0 )
                 return mWindowHeight - ( mWindowHeight / ( 2 * NUM_WAVES ) ) + 1;
                 return mWindowHeight * 0.75f + 1;
             else
                 return mWindowHeight / (NUM_WAVES * 2);
+        }
         /**
          * Flips y according to the index of the wave. It is needed because the second wave in collidoscope is drawn upside down in the screen.
          */
         int flipY(int y) const
     	int flipY(int y) const
+        {
             if ( mWaveIndex == 0)
                 return mWindowHeight - y;
     		    return mWindowHeight - y /*+ 24*/;
             else
                 return y;
+        }
                 return y /*- 24*/;
+    	}
         /**
          * Returns x. not used at the moment.
+         *
          */
         int flipX(int x) const
     	int flipX(int x) const
+        {
             return x;
+        }
+    	}
         // how much the wave is shrunk on the y axis with respect to the wave's tier
-...
             return mWindowHeight;
+        }
         /**
          * Draw infos cannot be copied and should be passed as const reference.
          */
         DrawInfo( const DrawInfo &original ) = delete;
         DrawInfo & operator=( const DrawInfo &original ) = delete;

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin, based on CCRMA STK ADSR.h (https://ccrma.stanford.edu/software/stk/classstk_1_1ADSR.html)
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
      This file incorporates work covered by the following copyright and permission notice:
         The Synthesis ToolKit in C++ (STK)
         Copyright (c) 1995--2016 Perry R. Cook and Gary P. Scavone
         Permission is hereby granted, free of charge, to any person obtaining
         a copy of this software and associated documentation files (the
         "Software"), to deal in the Software without restriction, including
         without limitation the rights to use, copy, modify, merge, publish,
         distribute, sublicense, and/or sell copies of the Software, and to
         permit persons to whom the Software is furnished to do so, subject to
         the following conditions:
         The above copyright notice and this permission notice shall be
         included in all copies or substantial portions of the Software.
         Any person wishing to distribute modifications to the Software is
         asked to send the modifications to the original developer so that they
         can be incorporated into the canonical version.  This is, however, not
         a binding provision of this license.
         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
         EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
         MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
         IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
         ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
         CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
         WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     */
     #pragma once
     namespace collidoscope {
     /*
      * An ASR envelope with linear shape. It is modeled after the STK envelope classes.
      * The tick() method advances the computation of the envelope one sample and returns the computed sample
      * The class is templated for the type of the samples that each tick of the envelope produces.
+     *
      * Client classes can set/get the current state of the envelope with the
      * respective getter/setter methods
+     *
      */
     template <typename T>
     class EnvASR
+    {
     public:
         /** Possible states of the envelope. Idle means the envelope ouputs 0 */
         enum class State {
             eAttack,
             eSustain,
-...
             mReleaseRate = T( 1.0 ) / (releaseTime * sampleRate);
+        }
         /** Produces one sample worth of envelope */
         T tick()
+        {
-...
     };
+    }
+    }

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #pragma once
     /**
      * Utility function to log errors using the cinder::log library.
      * Errors are logged to collidoscope_error.log file.
+     *
      */
     void logError( const std::string &errorMsg );
     /**
      * Utility function to log info using the cinder::log library.
      * Errors are logged to the terminal. Used only for debugging.
+     *
      */
     void logInfo( const std::string &infoMsg );
     void logInfo( const std::string &infoMsg );

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #pragma once
     #include "RtMidi.h"
-...
     namespace collidoscope {
     // Exception thrown by MIDI system
     class MIDIException : public std::exception
+    {
     public:
-...
         std::string mMessage;
     };
     /**
      * A MIDI message
      */
     class MIDIMessage
+    {
         friend class MIDI;
-...
         unsigned char getChannel() { return mChannel; }
         /**
          * First byte of MIDI data
          */
         unsigned char getData_1() { return mData1; }
         /**
          * Second byte of MIDI data
          */
         unsigned char getData_2() { return mData2; }
     private:
-...
     };
     /**
      * Handles MIDI messages from the keyboards and Teensy. It uses RtMidi library.
+     *
      */
     class MIDI
+    {
-...
         void setup( const Config& );
         /**
          * Check new incoming messages and stores them into the vector passed as argument by reference.
          */
         void checkMessages( std::vector< MIDIMessage >&  );
     private:
         // callback passed to RtMidi library
         static void RtMidiInCallback( double deltatime, std::vector<unsigned char> *message, void *userData );
         // parse RtMidi messages and turns them into more readable collidoscope::MIDIMessages
         MIDIMessage parseRtMidiMessage( std::vector<unsigned char> *message );
         // messages to pass to checkMessages caller
         // messages to pass to checkMessages caller
         std::vector< MIDIMessage > mMIDIMessages;
         // use specific variables for pitch bend messages. Pitch bend messages are coming
         // from the strip sensors that are very jerky and send a lot of values. So instead
         // of saving all the messages in mMIDIMessages just save the last received in mPitchBendMessages
         // and optimize away redundant messages.
         std::array< MIDIMessage, NUM_WAVES > mPitchBendMessages;
         // Same principle as mPitchBendMessages
         std::array< MIDIMessage, NUM_WAVES > mFilterMessages;
         // vector containing all the MIDI input devices detected.
         std::vector< std::unique_ptr <RtMidiIn> > mInputs;
         // Used for mutual access to the MIDI messages by the MIDI thread and the graphic thread.
         std::mutex mMutex;
     };

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #pragma once
     /**
      * Enumeration of all the possible commands exchanged between audio thread and graphic thread.
+     *
      */
     enum class Command {
         // message carrying info about one chunk of recorder audio.
         WAVE_CHUNK,
         // message sent when a new recording starts. The gui resets the wave upon receiving it.
         WAVE_START,
         // new grain created
         TRIGGER_UPDATE,
         // synth became idle
         TRIGGER_END,
         NOTE_ON,
-...
         LOOP_OFF
     };
     /** Message sent from the audio thread to the graphic wave when a new wave is recorded.
+     *
      *  The graphic thread sets the chunks of the wave to reflect the level of the recorded audio.
      *  The algorithm takes the maximum and minimum value of a group of samples and this becomes the top and bottom of the chunk.
      *  The message carries also the index of the chunk it refers to
      */
     /* Messages sent from the audio thread to the graphic wave.
        This includes the wave chunks when the audio is recorder in the buffer and
        the cursor position when the grains are reset.
     */
     struct RecordWaveMsg
+    {
         Command cmd; // WAVE_CHUNK or WAVE_START
         Command cmd;
         std::size_t index;
         float arg1;
         float arg2;
     };
     /**
      * Utility function to create a new RecordWaveMsg.
      */
     inline RecordWaveMsg makeRecordWaveMsg( Command cmd, std::size_t index, float arg1, float arg2 )
+    {
         RecordWaveMsg msg;
-...
         return msg;
+    }
     /**
      * Message sent from the audio thread to the graphic thread when a new grain is triggered in the granular synthesizer.
      * This creates a new cursor that travels from the beginning to the end of the selection to graphically represent the evolution of the grain in time.
+     *
      */
     struct CursorTriggerMsg
+    {
         Command cmd; // TRIGGER_UPDATE or TRIGGER_END
         Command cmd;
         int synthID;
     };
     /**
      * Utility function to create a new CursorTriggerMsg.
      */
     inline CursorTriggerMsg makeCursorTriggerMsg( Command cmd, std::uint8_t synthID )
+    {
         CursorTriggerMsg msg;
-...
         return msg;
+    }
     /**
      * Message sent from the graphic (main) thread to the audio thread to start a new voice of the granular synthesizer.
      */
     struct NoteMsg
+    {
         Command cmd; // NOTE_ON/OFF ot LOOP_ON/OFF
         Command cmd;
         int midiNote;
         double rate;
     };
     /**
      * Utility function to create a new NoteMsg.
      */
     inline NoteMsg makeNoteMsg( Command cmd, int midiNote, double rate )
+    {
         NoteMsg msg;
-...
         msg.rate = rate;
         return msg;
+    }
+    }

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #pragma once
     #include "cinder/gl/gl.h"
     #include "DrawInfo.h"
     /**
      * The oscilloscope that oscillates when Collidoscope is played
      */
     class Oscilloscope
+    {
     public:
         /**
          * Constructor, accepts as argument the number of points that make up the oscilloscope line
          */
         Oscilloscope( size_t numPoints ):
             mNumPoints( numPoints ),
             mLine( std::vector<ci::vec2>( numPoints, ci::vec2() ) )
             {}
         /**
          * Sets the value of a point of the oscilloscope. The value is passed in audio coordinates [-1.0, 1.0].
          * A reference to DrawInfo is passed to calculate the graphic coordinate of the point based on the audio values passed.
          */
         void  setPoint( int index, float audioVal, const DrawInfo &di ){
             if ( audioVal > 1.0f ){
-...
+            }
             audioVal *= 0.8f;
             // map audio val from [-1.0, 1.0] to [0.0, 1.0]
             // then map the value obtained to the height of the wave tier ( window height / NUM_WAVES )
             // this yRatio is for the bottom scope, the top will be drawn with a translation/4
             // because it's half of the half of the tier where the wave is drawn
             float yRatio = ((1 + audioVal) / 2.0f) * (di.getWindowHeight() / NUM_WAVES );
             float xRatio = index * (di.getWindowWidth() / (float)mLine.size());
             // this flips the coordinates for the second wave
             mLine.getPoints()[index].x = float( di.flipX( int(xRatio) ) );
             mLine.getPoints()[index].y = float( di.flipY( int(yRatio) ) );
             // add the missing line to reach the right of the window.
             // Indeed, the scope starts from 0 to size-1 and adds xRatio
             // to each new point. The line from n-1 to n is therefore missing.
             // add the missing line to reach the right of the window
             // indeed the scope starts from 0 to size -1 and adds xRatio
             // to each new point to the line from n-1 to n is missing
             if (index == mNumPoints - 1){
                 xRatio += ( di.getWindowWidth() / mNumPoints );
                 xRatio = ceil( xRatio ); // ceil because the division might left one pixel out
-...
+        }
         /**
          * Draws this oscilloscope as a cinder::PolyLine2f
          */
         void draw()
+        {
             ci::gl::color(1.0f, 1.0f, 1.0f);

     /*
      Copyright (C) 2002 James McCartney.
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin, based on Supercollider's (http://supercollider.github.io) TGrains code and Ross Bencina's "Implementing Real-Time Granular Synthesis"
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #pragma once
     #include <array>
-...
     using std::size_t;
     /**
      * The very core of the Collidoscope audio engine: the granular synthesizer.
      * Based on SuperCollider's TGrains and Ross Bencina's "Implementing Real-Time Granular Synthesis"
+     *
      * It implements Collidoscope's selection-based approach to granular synthesis.
      * A grain is basically a selection of a recorded sample of audio.
      * Grains are played in a loop: they are re-triggered each time they reach the end of the selection.
      * However, if the duration coefficient is greater than one, a new grain is re-triggered before the previous one is done,
      * the grains start to overlap with each other and create the typical eerie sound of grnular synthesis.
      * Also every time a new grain is triggered, it is offset of a few samples from the initial position to make the timbre more interesting.
+     *
+     *
      * PGranular uses a linear ASR envelope with 10 milliseconds attack and 50 milliseconds release.
+     *
      * Note that PGranular is header based and only depends on std library and on "EnvASR.h" (also header based).
      * This means you can embedd it in two your project just by copying these two files over.
+     *
      * Template arguments:
      * T: type of the audio samples (normally float or double)
      * RandOffsetFunc: type of the callable passed as argument to the contructor
      * TriggerCallbackFunc: type of the callable passed as argument to the contructor
+     *
      */
     template <typename T, typename RandOffsetFunc, typename TriggerCallbackFunc>
     class PGranular
+    {
-...
             return static_cast<T> ((1 - decimal) * xn + decimal * xn_1);
+        }
         /**
          * A single grain of the granular synthesis
          */
         struct PGrain
+        {
             double phase;    // read pointer to mBuffer of this grain
             double rate;     // rate of the grain. e.g. rate = 2 the grain will play twice as fast
             bool alive;      // whether this grain is alive. Not alive means it has been processed and can be replaced by another grain
             bool alive;      // whether this grain is alive. Not alive means it has been processed and can be replanced by another grain
             size_t age;      // age of this grain in samples
             size_t duration; // duration of this grain in samples. minimum = 4
             double b1;       // hann envelope from Ross Becina's "Implementing real time Granular Synthesis"
             double b1;       // hann envelope from Ross Becina "Implementing real time Granular Synthesis"
             double y1;
             double y2;
         };
         /**
          * Constructor.
+         *
          * \param buffer a pointer to an array of T that contains the original sample that will be granulized
          * \param bufferLen length of buffer in samples
          * \rand function of type size_t ()(void) that is called back each time a new grain is generated. The returned value is used
          * to offset the starting sample of the grain. This adds more colour to the sound especially with small selections.
          * \triggerCallback function of type void ()(char, int) that is called back each time a new grain is generated.
          *      The function is passed the character 't' as first parameter when a new grain is triggered and the characted 'e' when the synth becomes idle (no sound).
          * \ID id of this PGrain. Passed to the triggerCallback function as second parameter to identify this PGranular as the caller.
          */
         PGranular( const T* buffer, size_t bufferLen, size_t sampleRate, RandOffsetFunc & rand, TriggerCallbackFunc & triggerCallback, int ID ) :
             mBuffer( buffer ),
             mBufferLen( bufferLen ),
-...
         ~PGranular(){}
         /** Sets multiplier of duration of grains in seconds */
         /* sets multiplier of duration of grains in seconds */
         void setGrainsDurationCoeff( double coeff )
+        {
             mGrainsDurationCoeff = coeff;
             mGrainsDuration = std::lround( mTriggerRate * coeff );
             mGrainsDuration = std::lround( mTriggerRate * coeff ); // FIXME check if right rounding
             if ( mGrainsDuration < kMinGrainsDuration )
                 mGrainsDuration = kMinGrainsDuration;
+        }
         /** Sets rate of grains. e.g rate = 2 means one octave higer */
         /* sets rate of grains. e.g rate = 2 means one octave higer */
         void setGrainsRate( double rate )
+        {
             mGrainsRate = rate;
+        }
         /** sets the selection start in samples */
         // sets trigger rate in samples
         void setSelectionStart( size_t start )
+        {
             mGrainsStart = start;
+        }
         /** Sets the selection size ( and therefore the trigger rate) in samples */
         void setSelectionSize( size_t size )
+        {
-...
+        }
         /** Sets the attenuation of the grains with respect to the level of the recorded sample
          *  attenuation is in amp value and defaule value is 0.25118864315096 (-12dB) */
         void setAttenuation( T attenuation )
+        {
             mAttenuation = attenuation;
+        }
         /** Starts the synthesis engine */
         void noteOn( double rate )
+        {
             if ( mEnvASR.getState() == EnvASR<T>::State::eIdle ){
-...
+            }
+        }
         /** Stops the synthesis engine */
         void noteOff()
+        {
             if ( mEnvASR.getState() != EnvASR<T>::State::eIdle ){
-...
+            }
+        }
         /** Whether the synthesis engine is active or not. After noteOff is called the synth stays active until the envelope decays to 0 */
         bool isIdle()
+        {
             return mEnvASR.getState() == EnvASR<T>::State::eIdle;
+        }
         /**
          * Runs the granular engine and stores the output in \a audioOut
+         *
          * \param pointer to an array of T. This will be filled with the output of PGranular. It needs to be at least \a numSamples long
          * \param tempBuffer a temporary buffer used to store the envelope value. It needs to be at least \a numSamples long
          * \param numSamples number of samples to be processed
          */
         void process( T* audioOut, T* tempBuffer, size_t numSamples )
+        {
-...
             size_t envSamples = 0;
             bool becameIdle = false;
             // process the envelope first and store it in the tempBuffer
             // do the envelope first and store it in the tempBuffer
             for ( size_t i = 0; i < numSamples; i++ ){
                 tempBuffer[i] = mEnvASR.tick();
                 envSamples++;
-...
+                }
+            }
             // does the actual grains processing
             processGrains( audioOut, tempBuffer, envSamples );
             // becomes idle if the envelope goes to idle state
             if ( becameIdle ){
                 mTriggerCallback( 'e', mID );
                 reset();
-...
                 synthesizeGrain( mGrains[grainIdx], audioOut, envelopeValues, numSamples );
                 if ( !mGrains[grainIdx].alive ){
                     // this grain is dead so copy the last of the active grains here
                     // this grain is dead so copyu the last of the active grains here
                     // so as to keep all active grains at the beginning of the array
                     // don't increment grainIdx so the last active grain is processed next cycle
                     // if this grain is the last active grain then mNumAliveGrains is decremented
-...
+            }
+        }
         // synthesize a single grain
         // audioOut = pointer to audio block to fill
         // numSamples = number of samples to process for this block
         // numSamples = numpber of samples to process for this block
         void synthesizeGrain( PGrain &grain, T* audioOut, T* envelopeValues, size_t numSamples )
+        {
             // copy all grain data into local variable for faster processing
             // copy all grain data into local variable for faster porcessing
             const auto rate = grain.rate;
             auto phase = grain.phase;
             auto age = grain.age;
-...
+            }
             if ( age == duration ){
                 // if it processed all the samples left to leave ( numSamplesToOut = duration-age)
                 // then the grain is finished
                 // if it porocessed all the samples left to leave ( numSamplesToOut = duration-age)
                 // then the grain is had finished
                 grain.alive = false;
+            }
             else{
-...
         // length of mBuffer in samples
         const size_t mBufferLen;
         // offset in the buffer where the grains start. a.k.a. selection start
         // offset in the buffer where the grains start. a.k.a. seleciton start
         size_t mGrainsStart;
         // attenuates signal prevents clipping of grains (to some degree)
         // attenuates signal prevents clipping of grains
         T mAttenuation;
         // grain duration in samples
         double mGrainsDurationCoeff;
         // duration of grains is selection size * duration coeff
         // duration of grains is selcection size * duration coeff
         size_t mGrainsDuration;
         // rate of grain, affects pitch
         double mGrainsRate;

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #pragma once
     #include "cinder/Cinder.h"
-...
     struct RandomGenerator;
     /*
     A node in the Cinder audio graph that holds PGranulars for loop and keyboard playing
     A node in the Cinder audio graph that holds a PGranular
     */
     class PGranularNode : public ci::audio::Node
+    {
-...
         explicit PGranularNode( ci::audio::Buffer *grainBuffer, CursorTriggerMsgRingBuffer &triggerRingBuffer );
         ~PGranularNode();
         /** Set selection size in samples */
         // set selection size in samples
         void setSelectionSize( size_t size )
+        {
             mSelectionSize.set( size );
+        }
         /** Set selection start in samples */
         void setSelectionStart( size_t start )
+        {
             mSelectionStart.set( start );
-...
             mGrainDurationCoeff.set( coeff );
+        }
         /* PGranularNode passes itself as trigger callback in PGranular */
         // used for trigger callback in PGRanular
         void operator()( char msgType, int ID );
         ci::audio::dsp::RingBufferT<NoteMsg>& getNoteRingBuffer() { return mNoteMsgRingBufferPack.getBuffer(); }
     protected:
         void initialize()                           override;
         void initialize()							override;
         void process( ci::audio::Buffer *buffer )   override;
         void process( ci::audio::Buffer *buffer )	override;
     private:
         // Wraps a std::atomic but get() returns a boost::optional that is set to a real value only when the atomic has changed.
         //  It is used to avoid calling PGranular setter methods with the same value at each audio callback.
         template< typename T>
         class LazyAtomic
+        {
-...
             T mPreviousVal;
         };
         // creates or re-start a PGranular and sets the pitch according to the MIDI note passed as argument
         void handleNoteMsg( const NoteMsg &msg );
         // pointers to PGranular objects
         // pointer to PGranular object
         std::unique_ptr < collidoscope::PGranular<float, RandomGenerator, PGranularNode > > mPGranularLoop;
         std::array<std::unique_ptr < collidoscope::PGranular<float, RandomGenerator, PGranularNode > >, kMaxVoices> mPGranularNotes;
         // maps midi notes to pgranulars. When a noteOff is received makes sure the right PGranular is turned off
         std::array<int, kMaxVoices> mMidiNotes;
         // pointer to the random generator struct passed over to PGranular
         std::unique_ptr< RandomGenerator > mRandomOffset;
         // buffer containing the recorded audio, to pass to PGranular in initialize()
         /* buffer containing the recorder audio, to pass to PGranular in initialize() */
         ci::audio::Buffer *mGrainBuffer;
         ci::audio::BufferRef mTempBuffer;

     /*
      Copyright (C) 2015  Fiore Martin
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #pragma once
     #include "cinder/gl/gl.h"
     #include <vector>
     /**
      * The ParticleController creates/updates/draws and destroys particles
      */
     class ParticleController {
         struct Particle {
             ci::vec2	mCloudCenter; // initial positin of the particle
             ci::vec2	mVel;         // velocity
             float       mCloudSize;   // how big is the area where particle float around. When a particle hits the
                                       // border of the area it gets deflected
             ci::vec2	mCloudCenter;
             ci::vec2	mVel;
             float       mCloudSize;
             int			mAge;      // when mAge == mLifeSpan the particle is disposed
             int			mLifespan; // how long a particle lives
             bool        mFlyOver;  // some particles last longer and fly over the screen and reach the other user
             int			mAge;
             int			mLifespan;
             bool        mFlyOver;
         };
-...
     	std::vector<Particle> mParticles;
         std::vector< ci::vec2 > mParticlePositions;
         // current number of active particles
         size_t mNumParticles;
         ci::gl::VboRef			mParticleVbo;    // virtual buffer object
         ci::gl::VboRef			mParticleVbo;
         ci::gl::BatchRef		mParticleBatch;
      public:
         /**
          * Every time addParticles is run, up to kMaxParticleAdd are added at once
          */
         static const int kMaxParticleAdd = 22;
         ParticleController();
         /**
          * Adds \a amount particles and places them in \a initialLocation.
          * \cloudSize determines how far the particles can go
          */
     	void addParticles(int amount, const ci::vec2 &initialLocation, const float cloudSize);
         /**
          * Updates position and age of the particles
          */
         void updateParticles();
         /**
          * Draws all the particles
          */
         inline void draw()

Collidoscope

Revision 0:02467299402e CollidoscopeApp