/CollidoscopeApp - Diff - Collidoscope

     #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 );
         bool readRecordWave( size_t waveIdx, RecordWaveMsg*, size_t count );
         /**
         * Called from the graphic thread. Reads 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 );
         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;
-...
         std::array< std::unique_ptr< RingBufferPack<CursorTriggerMsg> >, NUM_WAVES > mCursorTriggerRingBufferPacks;
     };
     };

     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:
-...
         //! 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; }

     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 mimics 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
          */
     	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.
+         *
          */
     	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;
+    	}
         /**
          * Informs this chunk that it's the last chunk of the selection.
          */
     	void setAsSelectionEnd(bool end){
     		isSelectionEnd = end;
+    	}

CollidoscopeApp/include/Config.h
6	6	#include "cinder/Xml.h"
7	7
8	8
	9	/**
	10	* Configuration class gathers in one place all the values recided at runtime
	11	*
	12	* Reading the configuration from an XML file is partially implemented but not used at the moment
	13	*
	14	*/
9	15	class Config
10	16	{
11	17	public:
...	...
21	27
22	28	std::string getInputDeviceKey() const
23	29	{
24		return mAudioInputDeviceKey; // Komplete 1/2
25		//return "{0.0.1.00000000}.{a043bc8c-1dd1-4c94-82b4-ad8320cac5a5}"; // Komplete 3/4
26		//return "{0.0.1.00000000}.{828b681b-cc0c-44e1-93c9-5f1f46f5926f}"; // Realtek
	30	return mAudioInputDeviceKey;
27	31	}
28	32
	33	/**
	34	* Returns number of chunks in a wave
	35	*/
29	36	std::size_t getNumChunks() const
30	37	{
31	38	return mNumChunks;
32	39	}
33	40
34		/* return wave lenght in seconds */
	41	/** returns wave lenght in seconds */
35	42	double getWaveLen() const
36	43	{
37	44	return mWaveLen;
38	45	}
39	46
	47	/**
	48	* Returns wave's selection color
	49	*/
40	50	ci::Color getWaveSelectionColor(size_t waveIdx) const
41	51	{
42	52	if (waveIdx == 0){
...	...
47	57	}
48	58	}
49	59
	60	/**
	61	* The size of the ring buffer used to trigger a visual cursor from the audio thread when a new grain is created
	62	*/
50	63	std::size_t getCursorTriggerMessageBufSize() const
51	64	{
52	65	return 512;
53	66	}
54	67
55		// returns the index of the wave associated to the MIDI channel passed as argument
	68	/** returns the index of the wave associated to the MIDI channel passed as argument */
56	69	size_t getWaveForMIDIChannel( unsigned char channelIdx )
57	70	{
58	71	return channelIdx;
59		/*for ( int i = 0; i < NUM_WAVES; i++ ){
60		if ( channelIdx == mMidiChannels[i] )
61		return i;
62		}*/
63	72	}
64	73
65	74	double getMaxGrainDurationCoeff() const
...	...
82	91	return 6;
83	92	}
84	93
	94	/**
	95	* Returns the maximum size of a wave selection in number of chunks.
	96	*/
85	97	size_t getMaxSelectionNumChunks() const
86	98	{
87	99	return 37;
88	100	}
89	101
	102	/**
	103	* The value returned is used when creating the oscilloscope.
	104	* The oscilloscope represents the audio output buffer graphically. However it doesn't need to be as refined as the
	105	* audio wave and it's downsampled using the following formula : number of oscilloscope points = size o audio output buffer / getOscilloscopeNumPointsDivider()
	106	*/
90	107	size_t getOscilloscopeNumPointsDivider() const
91	108	{
92	109	return 4;

     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
+    {
-...
     };
+    }
+    }

     #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 as an audio coordinate [-1.0, 1.0].
          * A reference to DrawInfo is passed to calculate the graphic coordinate of the point based on the audio value passed.
          */
         void  setPoint( int index, float audioVal, const DrawInfo &di ){
             if ( audioVal > 1.0f ){
-...
+        }
         /**
          * Draws this oscilloscope as a cinder::PolyLine2f
          */
         void draw()
+        {
             ci::gl::color(1.0f, 1.0f, 1.0f);

     using namespace ci::audio;
     /* Frequency ratios in the chromatic scale */
     double chromaticRatios[] = {
 ,
 .0594630943591,
-...
 .8877486253586
     };
     /*
      * Calculates the ratio between the frequency of the midi note passed as argument and middle C note ( MIDI value = 60 ).
      * This is used for pitch shifting the granular synth output, according to the key pressed by the user.
      * The middle C is taken as reference in pitch in the pitch shifting of Collidoscope output.
      * That is, with the middle C the output is not pitch shifted at all and is equal in frequency to the recorder sample.
+     *
      */
     inline double calculateMidiNoteRatio( int midiNote )
+    {
         int distanceFromCenter = midiNote - 60; // 60 is the central midi note
-...
         return mBufferRecorderNodes[waveIdx]->getRingBuffer().getAvailableRead();
+    }
     bool AudioEngine::readRecordWave( size_t waveIdx, RecordWaveMsg* buffer, size_t count )
+    {
         return mBufferRecorderNodes[waveIdx]->getRingBuffer().read( buffer, count );

CollidoscopeApp/src/Config.cpp
17	17
18	18	}
19	19
20
	20	// uses Cinder api to parse configuration in XML file
21	21	void Config::loadFromFile( std::string&& path )
22	22	{
23	23	try {

CollidoscopeApp/src/MIDI.cpp
131	131	msg.mData2 = (numBytes == 3 ? (*rtMidiMessage)[2] : 0);
132	132
133	133	return msg;
134		}
	134	}

Collidoscope

Revision 2:dd889fff8423 CollidoscopeApp