Synthesiser note array. More...

#include <klang.h>

Inheritance diagram for klang::Notes< SYNTH, NOTE >:

Public Types
typedef Array< NOTE *, 128 >	Array

Public Member Functions
	Notes (SYNTH *synth)

virtual	~Notes ()

template<class TYPE >
void	add (int count)

int	assign ()

unsigned int	size () const
	The current number of items in the array.

void	add (const Note *&item)
	Add the specified item to the end of the array.

Note **	add ()
	Add a blank item to the end of the array, returning a pointer that allows the item to be modified.

void	clear ()
	Clear the array contents. Only resets the item count, without wiping memory.

float	max () const
	Find the maximum value in the array.

float	mean () const
	Find the mean average of values in the array.

float	rms () const
	Find the root mean squared (RMS) average of values in the array.

void	normalise (float target=1.f, int mode=Peak)
	Normalises values in the array to the specified target, based on peak, mean, or RMS value;.

Note *&	operator[] (int index)
	Returns a reference to the array item at the given index.

const Note *&	operator[] (int index) const
	Returns a read-only reference to the array item at the given index.

Static Public Member Functions
static int	capacity ()
	The maximum capacity of the array.

Public Attributes
SYNTH *	synth

unsigned int	noteOns = 0

unsigned int	noteStart [128] = { 0 }

Note *	items [CAPACITY]

unsigned int	count

Detailed Description

template<class SYNTH, class NOTE = Note>
struct klang::Notes< SYNTH, NOTE >

Definition at line 3191 of file klang.h.

Member Typedef Documentation

◆ Array

template<class SYNTH , class NOTE = Note>

Array<NOTE*, 128> klang::Notes< SYNTH, NOTE >::Array

Definition at line 3193 of file klang.h.

Constructor & Destructor Documentation

◆ Notes()

template<class SYNTH , class NOTE = Note>

klang::Notes< SYNTH, NOTE >::Notes ( SYNTH * synth )

inline

Definition at line 3197 of file klang.h.

                        : synth(synth) {
      for (int n = 0; n < 128; n++)
        items[n] = nullptr;
    }

References klang::Notes< SYNTH, NOTE >::synth.

Referenced by klang::Synth::Synth().

◆ ~Notes()

template<class SYNTH , class NOTE >

klang::Notes< SYNTH, NOTE >::~Notes ( )

inlinevirtual

Definition at line 3294 of file klang.h.

                                    {
    for (unsigned int n = 0; n < count; n++) {
      NOTE* tmp = items[n];
      items[n] = nullptr;
      delete tmp;
    }
  }

Member Function Documentation

◆ add() [1/3]

Note * * klang::Array< Note *, CAPACITY >::add ( )

inlineinherited

Definition at line 255 of file klang.h.

                {
      if (count < CAPACITY)
        return &items[count++];
      return nullptr;
    }

◆ add() [2/3]

void klang::Array< Note *, CAPACITY >::add ( const Note * & item )

inlineinherited

Definition at line 249 of file klang.h.

                               {
      if(count < CAPACITY)
        items[count++] = item;
    }

◆ add() [3/3]

template<class SYNTH , class NOTE = Note>

template<class TYPE >

void klang::Notes< SYNTH, NOTE >::add ( int count )

inline

Definition at line 3204 of file klang.h.

                        {
      for (int n = 0; n < count; n++) {
        TYPE* note = new TYPE();
        note->attach(synth);
        Array::add(note);
      }
    }

◆ assign()

template<class SYNTH , class NOTE = Note>

int klang::Notes< SYNTH, NOTE >::assign ( )

inline

Definition at line 3216 of file klang.h.

                {
      // favour unused voices
      for (int i = 0; i < count; i++) {
        if (items[i]->stage == NOTE::Off){
          noteStart[i] = noteOns++;
          return i;
        }
      }
 
      // no free notes => steal oldest released note?
      int oldest = -1;
      unsigned int oldest_start = 0;
      for (int i = 0; i < count; i++) {
        if (items[i]->stage == NOTE::Release) {
          if(oldest == -1 || noteStart[i] < oldest_start){
            oldest = i;
            oldest_start = noteStart[i];
          }
        }
      }
      if(oldest != -1){
        noteStart[oldest] = noteOns++;
        return oldest;
      }
 
      // no available released notes => steal oldest playing note
      oldest = -1;
      oldest_start = 0;
      for (int i = 0; i < count; i++) {
        if(oldest == -1 || noteStart[i] < oldest_start){
          oldest = i;
          oldest_start = noteStart[i];
        }
      }
      noteStart[oldest] = noteOns++;
      return oldest;
    }

◆ capacity()

static int klang::Array< Note *, CAPACITY >::capacity ( )

inlinestaticinherited

Definition at line 243 of file klang.h.

243{ return CAPACITY; }

◆ clear()

void klang::Array< Note *, CAPACITY >::clear ( )

inlineinherited

Definition at line 262 of file klang.h.

262{ count = 0; }

◆ max()

float klang::Array< Note *, CAPACITY >::max ( ) const

inlineinherited

Definition at line 265 of file klang.h.

                      {
      float max = 0.f;
      for (unsigned int i = 0; i < count; i++)
        if (abs(items[i]) > max)
          max = items[i];
      return max;
    }

◆ mean()

float klang::Array< Note *, CAPACITY >::mean ( ) const

inlineinherited

Definition at line 274 of file klang.h.

                       {
      float sum = 0.f;
      for (unsigned int i = 0; i < count; i++)
        sum += abs(items[i]);
      return sum / count;
    }

◆ normalise()

void klang::Array< Note *, CAPACITY >::normalise	(	float	target = 1.f,
		int	mode = Peak )

inlineinherited

Definition at line 290 of file klang.h.

                                                        {
      if (!count) return;
      
      const float current = (mode == Peak) ? max() : (mode == Mean) ? mean() : rms();
      const float scale = current == 0.f ? 0.f : target / current;
      for (int i = 0; i < count; i++)
        items[i] *= scale;
    }

◆ operator[]() [1/2]

Note * & klang::Array< Note *, CAPACITY >::operator[] ( int index )

inlineinherited

Definition at line 300 of file klang.h.

300{ return items[index]; }

◆ operator[]() [2/2]

const Note * & klang::Array< Note *, CAPACITY >::operator[] ( int index ) const

inlineinherited

Definition at line 303 of file klang.h.

303{ return items[index]; }

◆ rms()

float klang::Array< Note *, CAPACITY >::rms ( ) const

inlineinherited

Definition at line 282 of file klang.h.

                      {
      float sum = 0.f;
      for (unsigned int i = 0; i < count; i++)
        sum += items[i] * items[i];
      return sqrt(sum / count);
    }

◆ size()

unsigned int klang::Array< Note *, CAPACITY >::size ( ) const

inlineinherited

Definition at line 246 of file klang.h.

246{ return count; }

Member Data Documentation

◆ count

unsigned int klang::Array< Note *, CAPACITY >::count

inherited

Definition at line 240 of file klang.h.

◆ items

Note * klang::Array< Note *, CAPACITY >::items[CAPACITY]

inherited

Definition at line 239 of file klang.h.

◆ noteOns

template<class SYNTH , class NOTE = Note>

unsigned int klang::Notes< SYNTH, NOTE >::noteOns = 0

Definition at line 3213 of file klang.h.

◆ noteStart

template<class SYNTH , class NOTE = Note>

unsigned int klang::Notes< SYNTH, NOTE >::noteStart[128] = { 0 }

Definition at line 3214 of file klang.h.

3214{ 0 }; // track age of notes (for note stealing)

◆ synth

template<class SYNTH , class NOTE = Note>

SYNTH* klang::Notes< SYNTH, NOTE >::synth

Definition at line 3192 of file klang.h.

Referenced by klang::Notes< SYNTH, NOTE >::Notes().

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

◆ Array

Constructor & Destructor Documentation

◆ Notes()

◆ ~Notes()

Member Function Documentation

◆ add() [1/3]

◆ add() [2/3]

◆ add() [3/3]

◆ assign()

◆ capacity()

◆ clear()

◆ max()

◆ mean()

◆ normalise()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ rms()

◆ size()

Member Data Documentation

◆ count

◆ items

◆ noteOns

◆ noteStart

◆ synth