diff options
Diffstat (limited to 'src/midiio/include')
39 files changed, 4395 insertions, 0 deletions
diff --git a/src/midiio/include/Array.cpp b/src/midiio/include/Array.cpp new file mode 100644 index 0000000..044ed2d --- /dev/null +++ b/src/midiio/include/Array.cpp @@ -0,0 +1,378 @@ +// +// Copyright 1997-1999 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Wed Feb 5 19:42:53 PST 1997 +// Last Modified: Sun May 11 20:41:28 GMT-0800 1997 +// Last Modified: Wed Jul 7 11:44:50 PDT 1999 (added setAll() function) +// Filename: ...sig/maint/code/base/Array/Array.cpp +// Web Address: http://sig.sapp.org/src/sigBase/Array.cpp +// Syntax: C++ +// +// Description: An array which can grow dynamically. Array is derived from +// the Collection class and adds various mathematical operators +// to the Collection class. The Array template class is used for +// storing numbers of any type which can be added, multiplied +// and divided into one another. +// + +#ifndef _ARRAY_CPP_INCLUDED +#define _ARRAY_CPP_INCLUDED + +#include "Array.h" +#include <iostream> +#include <stdlib.h> + + +////////////////////////////// +// +// Array::Array +// + +template<class type> +Array<type>::Array(void) : Collection<type>(4) { } + +template<class type> +Array<type>::Array(int arraySize) : Collection<type>(arraySize) { } + +template<class type> +Array<type>::Array(Array<type>& anArray) : Collection<type>(anArray) { } + +template<class type> +Array<type>::Array(int arraySize, type *anArray) : + Collection<type>(arraySize, anArray) { } + + + + +////////////////////////////// +// +// Array::~Array +// + +template<class type> +Array<type>::~Array() { } + + + +////////////////////////////// +// +// Array::setAll -- sets the contents of each element to the +// specified value +// + +template<class type> +void Array<type>::setAll(type aValue) { + for (int i=0; i<getSize(); i++) { + array[i] = aValue; + } +} + + + +////////////////////////////// +// +// Array::sum +// + +template<class type> +type Array<type>::sum(void) { + type theSum = 0; + for (int i=0; i<getSize(); i++) { + theSum += array[i]; + } + return theSum; +} + +template<class type> +type Array<type>::sum(int loIndex, int hiIndex) { + type theSum = 0; + for (int i=loIndex; i<=hiIndex; i++) { + theSum += array[i]; + } + return theSum; +} + + + +////////////////////////////// +// +// Array::zero(-1, -1) +// + +template<class type> +void Array<type>::zero(int minIndex, int maxIndex) { + if (size == 0) return; + if (minIndex == -1) minIndex = 0; + if (maxIndex == -1) maxIndex = size-1; + + if (minIndex < 0 || maxIndex < 0 || minIndex > maxIndex || + maxIndex >= size) { + cerr << "Error in zero function: min = " << minIndex + << " max = " << maxIndex << " size = " << size << endl; + exit(1); + } + + for (int i=minIndex; i<=maxIndex; i++) { + array[i] = 0; + } +} + + +//////////////////////////////////////////////////////////////////////////// +// +// operators +// + + +template<class type> +int Array<type>::operator==(const Array<type>& aArray) { + if (getSize() != aArray.getSize()) { + return 0; + } + Array<type>& t = *this; + int i; + for (i=0; i<getSize(); i++) { + if (t[i] != aArray[i]) { + return 0; + } + } + return 1; +} + + + +////////////////////////////// +// +// Array::operator= +// + +template<class type> +Array<type>& Array<type>::operator=(const Array<type>& anArray) { + if (allocSize < anArray.size) { + if (allocSize != 0) { + delete [] array; + } + allocSize = anArray.size; + size = anArray.size; + array = new type[size]; + allowGrowthQ = anArray.allowGrowthQ; + growthAmount = anArray.growthAmount; + maxSize = anArray.maxSize; + } + size = anArray.size; + for (int i=0; i<size; i++) { + array[i] = anArray.array[i]; + } + + return *this; +} + + + +////////////////////////////// +// +// Array::operator+= +// + +template<class type> +Array<type>& Array<type>::operator+=(const Array<type>& anArray) { + if (size != anArray.size) { + cerr << "Error: different size arrays " << size << " and " + << anArray.size << endl; + exit(1); + } + + for (int i=0; i<size; i++) { + array[i] += anArray.array[i]; + } + + return *this; +} + + + +////////////////////////////// +// +// Array::operator+ +// + +template<class type> +Array<type> Array<type>::operator+(const Array<type>& anArray) const { + if (size != anArray.size) { + cerr << "Error: different size arrays " << size << " and " + << anArray.size << endl; + exit(1); + } + + Array<type> bArray(*this); + bArray += anArray; + return bArray; +} + + +template<class type> +Array<type> Array<type>::operator+(type aNumber) const { + Array<type> anArray(*this); + for (int i=0; i<size; i++) { + anArray[i] += aNumber; + } + return anArray; +} + + + +////////////////////////////// +// +// Array::operator-= +// + +template<class type> +Array<type>& Array<type>::operator-=(const Array<type>& anArray) { + if (size != anArray.size) { + cerr << "Error: different size arrays " << size << " and " + << anArray.size << endl; + exit(1); + } + + for (int i=0; i<size; i++) { + array[i] -= anArray.array[i]; + } + + return *this; +} + + + +////////////////////////////// +// +// Array::operator- +// + +template<class type> +Array<type> Array<type>::operator-(const Array<type>& anArray) const { + if (size != anArray.size) { + cerr << "Error: different size arrays " << size << " and " + << anArray.size << endl; + exit(1); + } + + Array<type> bArray(*this); + bArray -= anArray; + return bArray; +} + + +template<class type> +Array<type> Array<type>::operator-(void) const { + Array<type> anArray(*this); + for (int i=0; i<size; i++) { + anArray[i] = -anArray[i]; + } + return anArray; +} + +template<class type> +Array<type> Array<type>::operator-(type aNumber) const { + Array<type> anArray(*this); + for (int i=0; i<size; i++) { + anArray[i] -= aNumber; + } + return anArray; +} + + + +////////////////////////////// +// +// Array::operator*= +// + +template<class type> +Array<type>& Array<type>::operator*=(const Array<type>& anArray) { + if (size != anArray.size) { + cerr << "Error: different size arrays " << size << " and " + << anArray.size << endl; + exit(1); + } + + for (int i=0; i<size; i++) { + array[i] *= anArray.array[i]; + } + + return *this; +} + + + +////////////////////////////// +// +// Array::operator* +// + +template<class type> +Array<type> Array<type>::operator*(const Array<type>& anArray) const { + if (size != anArray.size) { + cerr << "Error: different size arrays " << size << " and " + << anArray.size << endl; + exit(1); + } + + Array<type> bArray(*this); + bArray *= anArray; + return bArray; +} + + +template<class type> +Array<type> Array<type>::operator*(type aNumber) const { + Array<type> anArray(*this); + for (int i=0; i<size; i++) { + anArray[i] *= aNumber; + } + return anArray; +} + +////////////////////////////// +// +// Array::operator/= +// + +template<class type> +Array<type>& Array<type>::operator/=(const Array<type>& anArray) { + if (size != anArray.size) { + cerr << "Error: different size arrays " << size << " and " + << anArray.size << endl; + exit(1); + } + + for (int i=0; i<size; i++) { + array[i] /= anArray.array[i]; + } + + return *this; +} + +////////////////////////////// +// +// Array::operator/ +// + +template<class type> +Array<type> Array<type>::operator/(const Array<type>& anArray) const { + if (size != anArray.size) { + cerr << "Error: different size arrays " << size << " and " + << anArray.size << endl; + exit(1); + } + + Array<type> bArray(*this); + bArray /= anArray; + return bArray; +} + + +#endif /* _ARRAY_CPP_INCLUDED */ + + + +// md5sum: 8f52a167c93f51702ce316204fd6e722 - Array.cpp =css= 20030102 diff --git a/src/midiio/include/Array.h b/src/midiio/include/Array.h new file mode 100644 index 0000000..75e08eb --- /dev/null +++ b/src/midiio/include/Array.h @@ -0,0 +1,67 @@ +// +// Copyright 1997-1999 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Wed Feb 5 19:42:53 PST 1997 +// Last Modified: Sun May 11 20:33:13 GMT-0800 1997 +// Last Modified: Wed Jul 7 11:44:50 PDT 1999 (added setAll() function) +// Last Modified: Mon Jul 29 22:08:32 PDT 2002 (added operator==) +// Filename: ...sig/maint/code/base/Array/Array.h +// Web Address: http://sig.sapp.org/include/sigBase/Array.h +// Documentation: http://sig.sapp.org/doc/classes/Array +// Syntax: C++ +// +// Description: An array which can grow dynamically. Array is derived from +// the Collection class and adds various mathematical operators +// to the Collection class. The Array template class is used for +// storing numbers of any type which can be added, multiplied +// and divided into one another. +// + +#ifndef _ARRAY_H_INCLUDED +#define _ARRAY_H_INCLUDED + +#include "Collection.h" + + +template<class type> +class Array : public Collection<type> { + public: + Array (void); + Array (int arraySize); + Array (Array<type>& aArray); + Array (int arraySize, type *anArray); + ~Array (); + + void setAll (type aValue); + type sum (void); + type sum (int lowIndex, int hiIndex); + void zero (int minIndex = -1, int maxIndex = -1); + + int operator== (const Array<type>& aArray); + Array<type>& operator= (const Array<type>& aArray); + Array<type>& operator+= (const Array<type>& aArray); + Array<type>& operator-= (const Array<type>& aArray); + Array<type>& operator*= (const Array<type>& aArray); + Array<type>& operator/= (const Array<type>& aArray); + + Array<type> operator+ (const Array<type>& aArray) const; + Array<type> operator+ (type aNumber) const; + Array<type> operator- (const Array<type>& aArray) const; + Array<type> operator- (void) const; + + Array<type> operator- (type aNumber) const; + Array<type> operator* (const Array<type>& aArray) const; + Array<type> operator* (type aNumber) const; + Array<type> operator/ (const Array<type>& aArray) const; +}; + + +#include "Array.cpp" /* necessary for templates */ + + + +#endif /* _ARRAY_H_INCLUDED */ + + + +// md5sum: 09d1b1f8e70ecde53f484548e48f33c3 - Array.h =css= 20030102 diff --git a/src/midiio/include/CircularBuffer.cpp b/src/midiio/include/CircularBuffer.cpp new file mode 100644 index 0000000..9f4aca6 --- /dev/null +++ b/src/midiio/include/CircularBuffer.cpp @@ -0,0 +1,291 @@ +// +// Copyright 1997-1998 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: 19 December 1997 +// Last Modified: Wed Jan 21 23:16:54 GMT-0800 1998 +// Filename: ...sig/maint/code/base/CircularBuffer/CircularBuffer.cpp +// Web Address: http://sig.sapp.org/src/sigBase/CircularBuffer.cpp +// Syntax: C++ +// +// Description: A Circular buffer designed to handle MIDI input, +// but able to store any type of object. Elements +// can be read out of the buffer in two ways. +// (1) from a read pointer which extracts the +// elements in order by following the write pointer, +// and (2) from an index operator related to the +// write pointer's location, for example, +// object[0] is the last value written into the +// buffer and object[-1] (or object[1]) is the +// item written just before that. +// +// + +#ifndef _CIRCULARBUFFER_CPP_INCLUDED +#define _CIRCULARBUFFER_CPP_INCLUDED + +#include "CircularBuffer.h" +#include <stdlib.h> +#include <iostream> + + +////////////////////////////// +// +// CircularBuffer::CircularBuffer -- Constructor. +// + +template<class type> +CircularBuffer<type>::CircularBuffer(void) { + size = 0; + buffer = NULL; + reset(); +} + + +template<class type> +CircularBuffer<type>::CircularBuffer(int maxElements) { + if (maxElements < 0) { + std::cerr << "Error: cannot have a negative number of elements: " + << maxElements << std::endl; + exit(1); + } + if (maxElements == 0) { + size = 0; + buffer = NULL; + reset(); + } else { + size = maxElements; + buffer = new type[maxElements]; + reset(); + } +} + + +template<class type> +CircularBuffer<type>::CircularBuffer(const CircularBuffer<type>& anotherBuffer) { + size = anotherBuffer.size; + if (getSize() == 0) { + buffer = NULL; + reset(); + } else { + buffer = new type[getSize()]; + writeIndex = anotherBuffer.writeIndex; + readIndex = anotherBuffer.readIndex; + itemCount = anotherBuffer.itemCount; + for (int i=0; i<getSize(); i++) { + buffer[i] = anotherBuffer.buffer[i]; + } + } +} + + + +////////////////////////////// +// +// CircularBuffer::~CircularBuffer -- Destructor. +// deallocates buffer memory. +// + +template<class type> +CircularBuffer<type>::~CircularBuffer() { + if (buffer != NULL) { + delete [] buffer; + } +} + + + +////////////////////////////// +// +// CircularBuffer::capacity -- returns the number of items which +// can be added to the buffer. Returns a positive number +// if the buffer has empty locations available. Returns 0 if the +// buffer is 100% full. Returns a negative number if the +// buffer has overflowed. + +template<class type> +int CircularBuffer<type>::capacity(void) const { + return getSize() - getCount(); +} + + + +////////////////////////////// +// +// CircularBuffer::extract -- reads the next value from the buffer. +// + +template<class type> +type CircularBuffer<type>::extract(void) { + itemCount--; + if (itemCount < 0) { + std::cerr << "Error: no elements in buffer to extract." << std::endl; + exit(1); + } + increment(readIndex); + return buffer[readIndex]; +} + + + +////////////////////////////// +// +// CircularBuffer::getCount -- returns the number of elements +// between the write index and the read index. +// + +template<class type> +int CircularBuffer<type>::getCount(void) const { + return itemCount; +} + + + +////////////////////////////// +// +// CircularBuffer::getSize -- returns the allocated size of the buffer. +// + +template<class type> +int CircularBuffer<type>::getSize(void) const { + return size; +} + + + +////////////////////////////// +// +// CircularBuffer::insert -- add an element to the circular buffer +// + +template<class type> +void CircularBuffer<type>::insert(const type& anItem) { + itemCount++; + increment(writeIndex); + buffer[writeIndex] = anItem; +} + + + +////////////////////////////// +// +// CircularBuffer::operator[] -- access an element relative to the +// currently written element +// + +template<class type> +type& CircularBuffer<type>::operator[](int index) { + if (buffer == NULL) { + std::cerr << "Error: buffer has no allocated space" << std::endl; + exit(1); + } + int realIndex = (index < 0) ? -index : index; + if (realIndex >= getSize()) { + std::cerr << "Error: Invalid access: " << realIndex << ", maximum is " + << getSize()-1 << std::endl; + exit(1); + } + realIndex = writeIndex - realIndex; + + // should need to go through this loop a max of one time: + while (realIndex < 0) { + realIndex += getSize(); + } + + return buffer[realIndex]; +} + + + +////////////////////////////// +// +// CircularBuffer::read -- an alias for the extract function. +// + +template<class type> +type CircularBuffer<type>::read(void) { + return extract(); +} + + + +////////////////////////////// +// +// CircularBuffer::reset -- throws out all previous data and +// sets the read/write/count to initial values. The size +// data variable must be valid before this function is +// called. +// + +template<class type> +void CircularBuffer<type>::reset(void) { + readIndex = writeIndex = getSize() - 1; + itemCount = 0; +} + + + +////////////////////////////// +// +// CircularBuffer::setSize -- warning: will throw out all previous data +// stored in buffer. +// + +template<class type> +void CircularBuffer<type>::setSize(int aSize) { + if (aSize < 0) { + std::cerr << "Error: cannot have a negative buffer size: " << aSize << std::endl; + exit(1); + } + if (buffer != NULL) { + delete [] buffer; + } + + if (aSize == 0) { + size = aSize; + buffer = NULL; + reset(); + } else { + size = aSize; + buffer = new type[aSize]; + reset(); + } +} + + + +////////////////////////////// +// +// CircularBuffer::write -- an alias for the insert function. +// + +template<class type> +void CircularBuffer<type>::write(const type& anElement) { + write(anElement); +} + + +/////////////////////////////////////////////////////////////////////////// +// +// private functions +// + +////////////////////////////// +// +// CircularBuffer::increment -- adds one to specified index and +// will automatically wrap the index when it gets too large. +// + +template<class type> +void CircularBuffer<type>::increment(int& index) { + index++; + if (index >= getSize()) { + index = 0; + } +} + + +#endif /* _CIRCULARBUFFER_CPP_INCLUDED */ + + + +// md5sum: 31b2e8d6efe7398a12ddb0a1b5680ca2 - CircularBuffer.cpp =css= 20030102 diff --git a/src/midiio/include/CircularBuffer.h b/src/midiio/include/CircularBuffer.h new file mode 100644 index 0000000..6bb3071 --- /dev/null +++ b/src/midiio/include/CircularBuffer.h @@ -0,0 +1,66 @@ +// +// Copyright 1997-1998 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: 19 December 1997 +// Last Modified: Wed Jan 21 23:08:13 GMT-0800 1998 +// Filename: ...sig/maint/code/base/CircularBuffer/CircularBuffer.h +// Web Address: http://sig.sapp.org/include/sigBase/CircularBuffer.cpp +// Documentation: http://sig.sapp.org/doc/classes/CircularBuffer +// Syntax: C++ +// +// Description: A Circular buffer designed to handle MIDI input, +// but able to store any type of object. Elements +// can be read out of the buffer in two ways. +// (1) from a read pointer which extracts the +// elements in order by following the write pointer, +// and (2) from an index operator related to the +// write pointer's location, for example, +// object[0] is the last value written into the +// buffer and object[-1] (or object[1]) is the +// item written just before that. +// + +#ifndef _CIRCULARBUFFER_H_INCLUDED +#define _CIRCULARBUFFER_H_INCLUDED + + +template<class type> +class CircularBuffer { + public: + CircularBuffer (void); + CircularBuffer (int maxElements); + CircularBuffer (const CircularBuffer<type>& + anotherBuffer); + ~CircularBuffer (); + + int capacity (void) const; + type extract (void); + int getCount (void) const; + int getSize (void) const; + void insert (const type& aMessage); + type& operator[] (int index); + type read (void); + void reset (void); + void setSize (int aSize); + void write (const type& aMessage); + + protected: + type* buffer; + int size; + int writeIndex; + int readIndex; + int itemCount; + + void increment (int& index); +}; + + +#include "CircularBuffer.cpp" + + + +#endif /* _CIRCULARBUFFER_H_INCLUDED */ + + + +// md5sum: 2857693ec37fdcb6df09db479faf110b - CircularBuffer.h =css= 20030102 diff --git a/src/midiio/include/Collection.cpp b/src/midiio/include/Collection.cpp new file mode 100644 index 0000000..74eef16 --- /dev/null +++ b/src/midiio/include/Collection.cpp @@ -0,0 +1,355 @@ +// +// Copyright 1997 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Wed Feb 5 19:42:53 PST 1997 +// Last Modified: Wed Apr 23 22:08:34 GMT-0800 1997 +// Last Modified: Fri Sep 14 15:50:52 PDT 2001 (added last() function) +// Filename: ...sig/maint/code/base/Collection/Collection.cpp +// Web Address: http://sig.sapp.org/src/sigBase/Collection.cpp +// Syntax: C++ +// +// Description: A dynamic array which can grow as necessary. +// This class can hold any type of item, but the +// derived Array class is specifically for collections +// of numbers. +// + +#ifndef _COLLECTION_CPP_INCLUDED +#define _COLLECTION_CPP_INCLUDED + +#include "Collection.h" +#include <iostream> +#include <stdlib.h> + + +////////////////////////////// +// +// Collection::Collection +// + +template<class type> +Collection<type>::Collection(void) { + allocSize = 0; + size = 0; + array = NULL; + allowGrowthQ = 0; + growthAmount = 8; + maxSize = 0; +} + +template<class type> +Collection<type>::Collection(int arraySize) { + array = new type[arraySize]; + size = arraySize; + allocSize = arraySize; + allowGrowthQ = 0; + growthAmount = arraySize; + maxSize = 0; +} + + +template<class type> +Collection<type>::Collection(int arraySize, type *aCollection) { + size = arraySize; + allocSize = arraySize; + array = new type[size]; + for (int i=0; i<size; i++) { + array[i] = aCollection[i]; + } + growthAmount = arraySize; + allowGrowthQ = 0; + maxSize = 0; +} + + +template<class type> +Collection<type>::Collection(Collection<type>& aCollection) { + size = aCollection.size; + allocSize = size; + array = new type[size]; + for (int i=0; i<size; i++) { + array[i] = aCollection.array[i]; + } + allowGrowthQ = aCollection.allowGrowthQ; + growthAmount = aCollection.growthAmount; + maxSize = aCollection.maxSize; +} + + + +////////////////////////////// +// +// Collection::~Collection +// + +template<class type> +Collection<type>::~Collection() { + if (getAllocSize() != 0) { + delete [] array; + } +} + + + +////////////////////////////// +// +// Collection::allowGrowth +// default value: status = 1 +// + +template<class type> +void Collection<type>::allowGrowth(int status) { + if (status == 0) { + allowGrowthQ = 0; + } else { + allowGrowthQ = 1; + } +} + + + +////////////////////////////// +// +// Collection::append +// + +template<class type> +void Collection<type>::append(type& element) { + if (size == getAllocSize()) { + grow(); + } + array[size] = element; + size++; +} + +template<class type> +void Collection<type>::appendcopy(type element) { + if (size == getAllocSize()) { + grow(); + } + array[size] = element; + size++; +} + +template<class type> +void Collection<type>::append(type *element) { + if (size == getAllocSize()) { + grow(); + } + array[size] = *element; + size++; +} + + + +////////////////////////////// +// +// Collection::grow +// default parameter: growamt = -1 +// + +template<class type> +void Collection<type>::grow(long growamt) { + allocSize += growamt > 0 ? growamt : growthAmount; + if (maxSize != 0 && getAllocSize() > maxSize) { + std::cerr << "Error: Maximum size allowed for array exceeded." << std::endl; + exit(1); + } + + type *temp = new type[getAllocSize()]; + for (int i=0; i<size; i++) { + temp[i] = array[i]; + } + array = temp; +} + + + +////////////////////////////// +// +// Collection::pointer +// + +template<class type> +type* Collection<type>::pointer(void) { + return array; +} + + + +////////////////////////////// +// +// Collection::getBase +// + +template<class type> +type* Collection<type>::getBase(void) { + return array; +} + + + +////////////////////////////// +// +// Collection::getAllocSize +// + +template<class type> +long Collection<type>::getAllocSize(void) const { + return allocSize; +} + + + +////////////////////////////// +// +// Collection::getSize -- +// + +template<class type> +long Collection<type>::getSize(void) const { + return size; +} + + + +////////////////////////////// +// +// Collection::last -- +// + +template<class type> +type& Collection<type>::last(void) { + return array[getSize()-1]; +} + + + +////////////////////////////// +// +// Collection::setAllocSize +// + +template<class type> +void Collection<type>::setAllocSize(long aSize) { + if (aSize < getSize()) { + std::cerr << "Error: cannot set allocated size smaller than actual size." + << std::endl; + exit(1); + } + + if (aSize <= getAllocSize()) { + shrinkTo(aSize); + } else { + grow(aSize-getAllocSize()); + size = aSize; + } +} + + + +////////////////////////////// +// +// Collection::setGrowth +// default parameter: growth = -1 +// + +template<class type> +void Collection<type>::setGrowth(long growth) { + if (growth > 0) { + growthAmount = growth; + } +} + + + +////////////////////////////// +// +// Collection::setSize +// + +template<class type> +void Collection<type>::setSize(long newSize) { + if (newSize <= getAllocSize()) { + size = newSize; + } else { + grow(newSize-getAllocSize()); + size = newSize; + } +} + + + +//////////////////////////////////////////////////////////////////////////////// +// +// Collection operators +// + +////////////////////////////// +// +// Collection::operator[] +// + +template<class type> +type& Collection<type>::operator[](int elementIndex) { + if (allowGrowthQ && elementIndex == size) { + if (size == getAllocSize()) { + grow(); + } + size++; + } else if (elementIndex >= size) { + std::cerr << "Error: accessing invalid array location " + << elementIndex + << " Maximum is " << size-1 << std::endl; + exit(1); + } + return array[elementIndex]; +} + + +////////////////////////////// +// +// Collection::operator[] const +// + +template<class type> +type Collection<type>::operator[](int elementIndex) const { + if (elementIndex >= size) { + std::cerr << "Error: accessing invalid array location " + << elementIndex + << " Maximum is " << size-1 << std::endl; + exit(1); + } + return array[elementIndex]; +} + +////////////////////////////// +// +// shrinkTo +// + +template<class type> +void Collection<type>::shrinkTo(long aSize) { + if (aSize < getSize()) { + exit(1); + } + + type *temp = new type[aSize]; + for (int i=0; i<size; i++) { + temp[i] = array[i]; + } + delete [] array; + array = temp; + + allocSize = aSize; + if (size > allocSize) { + size = allocSize; + } +} + + +#endif /* _COLLECTION_CPP_INCLUDED */ + + + +// md5sum: 9929fee30b1bede4305e1fb46303ddc1 - Collection.cpp =css= 20030102 diff --git a/src/midiio/include/Collection.h b/src/midiio/include/Collection.h new file mode 100644 index 0000000..6775366 --- /dev/null +++ b/src/midiio/include/Collection.h @@ -0,0 +1,70 @@ +// +// Copyright 1997 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Wed Feb 5 19:42:53 PST 1997 +// Last Modified: Tue Apr 22 20:28:16 GMT-0800 1997 +// Last Modified: Fri Sep 14 15:50:52 PDT 2001 (added last() function) +// Filename: ...sig/maint/code/base/Collection/Collection.h +// Web Address: http://sig.sapp.org/include/sigBase/Collection.h +// Documentation: http://sig.sapp.org/doc/classes/Collection +// Syntax: C++ +// +// Description: A dynamic array which can grow as necessary. +// This class can hold any type of item, but the +// derived Array class is specifically for collections +// of numbers. +// + +#ifndef _COLLECTION_H_INCLUDED +#define _COLLECTION_H_INCLUDED + + +template<class type> +class Collection { + public: + Collection (void); + Collection (int arraySize); + Collection (int arraySize, type *aCollection); + Collection (Collection<type>& aCollection); + ~Collection (); + + void allowGrowth (int status = 1); + void append (type& element); + void appendcopy (type element); + void append (type* element); + type *getBase (void); + long getAllocSize (void) const; + long getSize (void) const; + type *pointer (void); + void setAllocSize (long aSize); + void setGrowth (long growth); + void setSize (long newSize); + type& operator[] (int arrayIndex); + type operator[] (int arrayIndex) const; + void grow (long growamt = -1); + type& last (void); + + + protected: + long size; // actual array size + long allocSize; // maximum allowable array size + type *array; // where the array data is stored + char allowGrowthQ; // allow/disallow growth + long growthAmount; // number of elements to grow by if index + // element one beyond max size is accessed + long maxSize; // the largest size the array is allowed + // to grow to, if 0, then ignore max + + void shrinkTo (long aSize); +}; + + +#include "Collection.cpp" + + + +#endif /* _COLLECTION_H_INCLUDED */ + + + +// md5sum: 01bec04835c0bd117f40c2bfe51c4abd - Collection.h =css= 20030102 diff --git a/src/midiio/include/FileIO.h b/src/midiio/include/FileIO.h new file mode 100644 index 0000000..fdec5de --- /dev/null +++ b/src/midiio/include/FileIO.h @@ -0,0 +1,148 @@ +// +// Copyright 1997 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Fri May 9 22:30:32 PDT 1997 +// Last Modified: Sun Dec 14 05:26:16 GMT-0800 1997 +// Filename: ...sig/maint/code/base/FileIO/FileIO.h +// Web Address: http://sig.sapp.org/include/sigBase/FileIO.h +// Documentation: http://sig.sapp.org/doc/classes/FileIO +// Syntax: C++ +// +// Description: Derived from the fstream class, this class has +// functions which allow writing binary files in +// both little and big endian formats. Useful for +// writing files such as soundfiles and MIDI files +// which require numbers to be stored in a particular +// endian format. +// + +#ifndef _FILEIO_H_INCLUDED +#define _FILEIO_H_INCLUDED + + +#include <fstream> + +typedef unsigned char uchar; +typedef unsigned short ushort; +typedef unsigned long ulong; +typedef unsigned int uint; + +// templates would be nice to use here, but they don't seem +// to work intuitively... + +class FileIO : public std::fstream { + public: + FileIO (void); + FileIO (const char* filename, std::ios::openmode state); + ~FileIO (); + + void readBigEndian (char& aNumber); + void readBigEndian (uchar& aNumber); + void readBigEndian (short& aNumber); + void readBigEndian (ushort& aNumber); + void readBigEndian (long& aNumber); + void readBigEndian (ulong& aNumber); + void readBigEndian (int& aNumber); + void readBigEndian (uint& aNumber); + void readBigEndian (float& aNumber); + void readBigEndian (double& aNumber); + + void readLittleEndian (char& aNumber); + void readLittleEndian (uchar& aNumber); + void readLittleEndian (short& aNumber); + void readLittleEndian (ushort& aNumber); + void readLittleEndian (long& aNumber); + void readLittleEndian (ulong& aNumber); + void readLittleEndian (int& aNumber); + void readLittleEndian (uint& aNumber); + void readLittleEndian (float& aNumber); + void readLittleEndian (double& aNumber); + + void readMachineEndian (char& aNumber); + void readMachineEndian (uchar& aNumber); + void readMachineEndian (short& aNumber); + void readMachineEndian (ushort& aNumber); + void readMachineEndian (long& aNumber); + void readMachineEndian (ulong& aNumber); + void readMachineEndian (int& aNumber); + void readMachineEndian (uint& aNumber); + void readMachineEndian (float& aNumber); + void readMachineEndian (double& aNumber); + + void readNotMachineEndian (char& aNumber); + void readNotMachineEndian (uchar& aNumber); + void readNotMachineEndian (short& aNumber); + void readNotMachineEndian (ushort& aNumber); + void readNotMachineEndian (long& aNumber); + void readNotMachineEndian (ulong& aNumber); + void readNotMachineEndian (int& aNumber); + void readNotMachineEndian (uint& aNumber); + void readNotMachineEndian (float& aNumber); + void readNotMachineEndian (double& aNumber); + + void writeBigEndian (char aNumber); + void writeBigEndian (uchar aNumber); + void writeBigEndian (short aNumber); + void writeBigEndian (ushort aNumber); + void writeBigEndian (long aNumber); + void writeBigEndian (ulong aNumber); + void writeBigEndian (int aNumber); + void writeBigEndian (uint aNumber); + void writeBigEndian (float aNumber); + void writeBigEndian (double aNumber); + + void writeLittleEndian (char aNumber); + void writeLittleEndian (uchar aNumber); + void writeLittleEndian (short aNumber); + void writeLittleEndian (ushort aNumber); + void writeLittleEndian (long aNumber); + void writeLittleEndian (ulong aNumber); + void writeLittleEndian (int aNumber); + void writeLittleEndian (uint aNumber); + void writeLittleEndian (float aNumber); + void writeLittleEndian (double aNumber); + + void writeMachineEndian (char aNumber); + void writeMachineEndian (uchar aNumber); + void writeMachineEndian (short aNumber); + void writeMachineEndian (ushort aNumber); + void writeMachineEndian (long aNumber); + void writeMachineEndian (ulong aNumber); + void writeMachineEndian (int aNumber); + void writeMachineEndian (uint aNumber); + void writeMachineEndian (float aNumber); + void writeMachineEndian (double aNumber); + + void writeNotMachineEndian (char aNumber); + void writeNotMachineEndian (uchar aNumber); + void writeNotMachineEndian (short aNumber); + void writeNotMachineEndian (ushort aNumber); + void writeNotMachineEndian (long aNumber); + void writeNotMachineEndian (ulong aNumber); + void writeNotMachineEndian (int aNumber); + void writeNotMachineEndian (uint aNumber); + void writeNotMachineEndian (float aNumber); + void writeNotMachineEndian (double aNumber); + + protected: + + char flipBytes (char aNumber); + uchar flipBytes (uchar aNumber); + short flipBytes (short aNumber); + ushort flipBytes (ushort aNumber); + long flipBytes (long aNumber); + ulong flipBytes (ulong aNumber); + int flipBytes (int aNumber); + uint flipBytes (uint aNumber); + float flipBytes (float aNumber); + double flipBytes (double aNumber); + +}; + + + +#endif /* _FILEIO_H_INCLUDED */ + + + +// md5sum: 0a146ebe5c6bd0850be973f612827d20 - FileIO.h =css= 20030102 diff --git a/src/midiio/include/MidiFile.h b/src/midiio/include/MidiFile.h new file mode 100644 index 0000000..10794d5 --- /dev/null +++ b/src/midiio/include/MidiFile.h @@ -0,0 +1,108 @@ +// +// Copyright 1999-2000 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Fri Nov 26 14:12:01 PST 1999 +// Last Modified: Fri Dec 2 13:26:44 PST 1999 +// Last Modified: Fri Nov 10 12:13:15 PST 2000 (added some more editing cap.) +// Last Modified: Thu Jan 10 10:03:39 PST 2002 (added allocateEvents()) +// Last Modified: Mon Jun 10 22:43:10 PDT 2002 (added clear()) +// Filename: ...sig/include/sigInfo/MidiFile.h +// Web Address: http://sig.sapp.org/include/sigInfo/MidiFile.h +// Syntax: C++ +// +// Description: A class which can read/write Standard MIDI files. +// MIDI data is stored by track in an array. This +// class is used for example in the MidiPerform class. +// + +#ifndef _MIDIfILE_H_INCLUDED +#define _MIDIfILE_H_INCLUDED + +#include "FileIO.h" +#include "Array.h" +#include "Collection.h" + +typedef unsigned char uchar; +typedef unsigned short ushort; +typedef unsigned long ulong; + +#define TIME_STATE_DELTA 0 +#define TIME_STATE_ABSOLUTE 1 + +#define TRACK_STATE_SPLIT 0 +#define TRACK_STATE_JOINED 1 + + +class _MFEvent { + public: + _MFEvent (void); + _MFEvent (int command); + _MFEvent (int command, int param1); + _MFEvent (int command, int param1, int param2); + _MFEvent (int track, int command, int param1, int param2); + _MFEvent (int aTime, int aTrack, int command, int param1, int param2); + ~_MFEvent (); + int time; + int track; + Array<uchar> data; +}; + + + +class MidiFile { + public: + MidiFile (void); + MidiFile (char* aFile); + ~MidiFile (); + + void absoluteTime (void); + int addEvent (int aTrack, int aTime, + Array<uchar>& midiData); + int addTrack (void); + int addTrack (int count); + void allocateEvents (int track, int aSize); + void deltaTime (void); + void deleteTrack (int aTrack); + void erase (void); + void clear (void); + _MFEvent& getEvent (int aTrack, int anIndex); + int getTimeState (void); + int getTrackState (void); + int getTicksPerQuarterNote (void); + int getTrackCount (void); + int getNumTracks (void); + int getNumEvents (int aTrack); + void joinTracks (void); + void mergeTracks (int aTrack1, int aTrack2); + int read (char* aFile); + void setTicksPerQuarterNote (int ticks); + void sortTrack (Collection<_MFEvent>& trackData); + void sortTracks (void); + void splitTracks (void); + int write (const char* aFile); + + protected: + Collection<Collection<_MFEvent>*> events; // midi file events + int ticksPerQuarterNote; // time base of file + int trackCount; // # of tracks in file + int theTrackState; // joined or split + int theTimeState; // absolute or delta + char* readFileName; // read file name + + private: + void extractMidiData (FileIO& inputfile, Array<uchar>& array, + uchar& runningCommand); + ulong extractVlvTime (FileIO& inputfile); + ulong unpackVLV (uchar a, uchar b, uchar c, uchar d, uchar e); + void writeVLValue (long aValue, Array<uchar>& data); +}; + + +int eventcompare(const void* a, const void* b); +std::ostream& operator<<(std::ostream& out, MidiFile& aMidiFile); + +#endif /* _MIDIfILE_H_INCLUDED */ + + + +// md5sum: ff46e64698e2d9e88ebeef3efa9927d0 - MidiFile.h =css= 20030102 diff --git a/src/midiio/include/MidiFileWrite.h b/src/midiio/include/MidiFileWrite.h new file mode 100644 index 0000000..a213fdf --- /dev/null +++ b/src/midiio/include/MidiFileWrite.h @@ -0,0 +1,61 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sun Mar 15 10:55:56 GMT-0800 1998 +// Last Modified: Sun Mar 15 10:55:56 GMT-0800 1998 +// Filename: ...sig/code/control/MidiFileWrite/MidiFileWrite.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/MidiFileWrite.h +// Syntax: C++ +// +// Description: The MidiFileWrite class will write out a Type 0 MidiFile. +// Used for recording MIDI data streams into Standard +// MIDI files. +// + +#ifndef _MIDIFILEWRITE_INCLUDED +#define _MIDIFILEWRITE_INCLUDED + + +#include "FileIO.h" + + +class MidiFileWrite { + public: + MidiFileWrite (void); + MidiFileWrite (const char* aFilename, int startTime = -1); + ~MidiFileWrite (); + + void close (void); + void setup (const char* aFilename, int startTime = -1); + void start (int startTime = -1); + void writeAbsolute (int aTime, int command, int p1, int p2); + void writeAbsolute (int aTime, int command, int p1); + void writeAbsolute (int aTime, int command); + void writeRaw (uchar aByte); + void writeRaw (uchar aByte, uchar Byte); + void writeRaw (uchar aByte, uchar Byte, uchar cByte); + void writeRaw (uchar aByte, uchar Byte, uchar cByte, + uchar dByte); + void writeRaw (uchar aByte, uchar Byte, uchar cByte, + uchar dByte, uchar eByte); + void writeRaw (uchar* anArray, int arraySize); + void writeRelative (int aTime, int command, int p1, int p2); + void writeRelative (int aTime, int command, int p1); + void writeRelative (int aTime, int command); + void writeVLValue (long aValue); + + + protected: + FileIO *midifile; // file stream for MIDI file + long trackSize; // size count for MIDI track + int lastPlayTime; // for calculating delta times + int openQ; // for checking file status + +}; + + + +#endif /* _MIDIFILEWRITE_INCLUDED */ + + + +// md5sum: 44ac572078bff648d096c7e7867d1b3c - MidiFileWrite.h =css= 20030102 diff --git a/src/midiio/include/MidiIO.h b/src/midiio/include/MidiIO.h new file mode 100644 index 0000000..80c9168 --- /dev/null +++ b/src/midiio/include/MidiIO.h @@ -0,0 +1,58 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: 21 December 1997 +// Last Modified: Sun Jan 25 15:44:35 GMT-0800 1998 +// Filename: ...sig/code/control/MidiIO/MidiIO.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/MidiIO.h +// Syntax: C++ +// +// Description: A unified class for MidiInput and MidiOutput that handles +// MIDI input and output connections. The Synthesizer +// and RadioBaton classes are derived from this class. +// + +#ifndef _MIDIIO_H_INCLUDED +#define _MIDIIO_H_INCLUDED + + +#include "MidiInput.h" +#include "MidiOutput.h" + + +class MidiIO : public MidiOutput, public MidiInput { + public: + MidiIO (void); + MidiIO (int outPort, int inPort); + ~MidiIO (); + + void close (void); + void closeInput (void); + void closeOutput (void); + int getChannelInOffset (void) const; + int getChannelOutOffset (void) const; + int getInputPort (void); + int getInputTrace (void); + int getNumInputPorts (void); + int getNumOutputPorts (void); + int getOutputPort (void); + int getOutputTrace (void); + int open (void); + int openInput (void); + int openOutput (void); + void setChannelOffset (int anOffset); + void setInputPort (int aPort); + void setInputTrace (int aState); + void setOutputPort (int aPort); + void setOutputTrace (int aState); + void toggleInputTrace (void); + void toggleOutputTrace (void); + +}; + + + +#endif /* _MIDIIO_H_INCLUDED */ + + + +// md5sum: 9f6122405c4d9e83994457210217ff22 - MidiIO.h =css= 20030102 diff --git a/src/midiio/include/MidiInPort.h b/src/midiio/include/MidiInPort.h new file mode 100644 index 0000000..ac225c4 --- /dev/null +++ b/src/midiio/include/MidiInPort.h @@ -0,0 +1,98 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Wed Jan 21 22:35:31 GMT-0800 1998 +// Last Modified: Thu Jan 22 23:13:54 GMT-0800 1998 +// Last Modified: Sat Nov 7 16:09:18 PST 1998 +// Last Modified: Tue Jun 29 16:14:50 PDT 1999 (added Sysex input) +// Last Modified: Tue May 23 23:08:44 PDT 2000 (oss/alsa selection added) +// Filename: ...sig/maint/code/control/MidiInPort/MidiInPort.h +// Web Address: http://sig.sapp.org/include/sig/MidiInPort.h +// Syntax: C++ +// +// Description: An interface for MIDI input capabilities of an +// operating-system specific MIDI input method. +// Provides control of all low-level MIDI input +// functionality such that it will work on all +// computers in the same manner. +// + +#ifndef _MIDIINPORT_H_INCLUDED +#define _MIDIINPORT_H_INCLUDED + + +#include "MidiMessage.h" + +#ifdef VISUAL + #define MIDIINPORT MidiInPort_visual + #include "MidiInPort_visual.h" +#elif defined(LINUX) && defined(ALSA) && defined(OSS) + #define MIDIINPORT MidiInPort_linux + #include "MidiInPort_linux.h" +#elif defined(LINUX) && defined(ALSA) && !defined(OSS) + #define MIDIINPORT MidiInPort_alsa + #include "MidiInPort_alsa.h" +#elif defined (LINUX) && defined(OSS) && !defined(ALSA) + #define MIDIINPORT MidiInPort_oss + #include "MidiInPort_oss.h" +#elif defined(LINUX) + #define MIDIINPORT MidiInPort_oss + #include "MidiInPort_oss.h" +#else + #define MIDIINPORT MidiInPort_unsupported + #include "MidiInPort_unsupported.h" +#endif + + +class MidiInPort : protected MIDIINPORT { + public: + MidiInPort (void) : MIDIINPORT() {} + MidiInPort (int aPort, int autoOpen = 1) : + MIDIINPORT(aPort, autoOpen) {} + ~MidiInPort() { } + + void clearSysex(void) { MIDIINPORT::clearSysex(); } + void clearSysex(int buffer) { MIDIINPORT::clearSysex(buffer); } + void close(void) { MIDIINPORT::close(); } + void closeAll(void) { MIDIINPORT::closeAll(); } + MidiMessage extract(void) { return MIDIINPORT::extract(); } + int getBufferSize(void) { return MIDIINPORT::getBufferSize(); } + int getChannelOffset(void) const { + return MIDIINPORT::getChannelOffset(); } + int getCount(void) { return MIDIINPORT::getCount(); } + const char* getName(void) { return MIDIINPORT::getName(); } + static const char* getName(int i) { return MIDIINPORT::getName(i); } + static int getNumPorts(void) { + return MIDIINPORT::getNumPorts(); } + int getPort(void) { return MIDIINPORT::getPort(); } + int getPortStatus(void){ + return MIDIINPORT::getPortStatus(); } + uchar* getSysex(int buffer) { return MIDIINPORT::getSysex(buffer); } + int getSysexSize(int buffer) { return MIDIINPORT::getSysexSize(buffer); } + int getTrace(void) { return MIDIINPORT::getTrace(); } + void insert(const MidiMessage& aMessage) { + MIDIINPORT::insert(aMessage); } + int installSysex(uchar* anArray, int aSize) { + return MIDIINPORT::installSysex(anArray, aSize); } + int open(void) { return MIDIINPORT::open(); } + MidiMessage& operator[](int index) { + return MIDIINPORT::message(index); } + void pause(void) { MIDIINPORT::pause(); } + void setBufferSize(int aSize) { + MIDIINPORT::setBufferSize(aSize); } + void setChannelOffset(int anOffset) { + MIDIINPORT::setChannelOffset(anOffset); } + void setAndOpenPort(int aPort) { setPort(aPort); open(); } + void setPort(int aPort) { MIDIINPORT::setPort(aPort); } + int setTrace(int aState) { + return MIDIINPORT::setTrace(aState); } + void toggleTrace(void) { MIDIINPORT::toggleTrace(); } + void unpause(void) { MIDIINPORT::unpause(); } +}; + + + +#endif /* _MIDIINPORT_H_INCLUDED */ + + + +// md5sum: 96f8a2b4411a356d1b73cd96421b8931 - MidiInPort.h =css= 20030102 diff --git a/src/midiio/include/MidiInPort_alsa.h b/src/midiio/include/MidiInPort_alsa.h new file mode 100644 index 0000000..b321600 --- /dev/null +++ b/src/midiio/include/MidiInPort_alsa.h @@ -0,0 +1,107 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sun May 14 22:05:27 PDT 2000 +// Last Modified: Sat Oct 13 16:11:24 PDT 2001 (updated for ALSA 0.9) +// Last Modified: Sat Nov 2 20:35:50 PST 2002 (added #ifdef ALSA) +// Filename: ...sig/maint/code/control/MidiInPort/linux/MidiInPort_alsa.h +// Web Address: http://sig.sapp.org/include/sig/MidiInPort_alsa.h +// Syntax: C++ +// +// Description: An interface for MIDI input capabilities of +// linux ALSA sound driver's specific MIDI input methods. +// This class is inherited privately by the MidiInPort class. +// + +#ifndef _MIDIINPORT_ALSA_H_INCLUDED +#define _MIDIINPORT_ALSA_H_INCLUDED + +#ifdef LINUX +#ifdef ALSA + +#include "MidiMessage.h" +#include "CircularBuffer.h" +#include "Array.h" +#include "Sequencer_alsa.h" +#include "SigTimer.h" +#include <pthread.h> + +typedef unsigned char uchar; +typedef void (*MIDI_Callback_function)(int arrivalPort); + + +class MidiInPort_alsa : public Sequencer_alsa { + public: + MidiInPort_alsa (void); + MidiInPort_alsa (int aPort, int autoOpen = 1); + ~MidiInPort_alsa (); + + void clearSysex (int buffer); + void clearSysex (void); + void close (void); + void closeAll (void); + MidiMessage extract (void); + int getBufferSize (void); + int getChannelOffset (void) const; + int getCount (void); + const char* getName (void); + static const char* getName (int i); + static int getNumPorts (void); + int getPort (void); + int getPortStatus (void); + uchar* getSysex (int buffer); + int getSysexSize (int buffer); + int getTrace (void); + void insert (const MidiMessage& aMessage); + int installSysex (uchar* anArray, int aSize); + MidiMessage& message (int index); + int open (void); + void pause (void); + void setBufferSize (int aSize); + void setChannelOffset (int anOffset); + void setPort (int aPort); + int setTrace (int aState); + void toggleTrace (void); + void unpause (void); + + static Array<int> threadinitport; + + protected: + int port; // the port to which this object belongs + + static MIDI_Callback_function callbackFunction; + + static int installSysexPrivate (int port, + uchar* anArray, int aSize); + + static int objectCount; // num of similar objects in existence + static int* portObjectCount; // objects connected to particular port + static int* trace; // for verifying input + static std::ostream* tracedisplay; // stream for displaying trace + static int numDevices; // number of input ports + static CircularBuffer<MidiMessage>** midiBuffer; // MIDI storage frm ports + static int channelOffset; // channel offset, either 0 or 1 + // not being used right now. + static int* pauseQ; // for adding items to Buffer or not + static SigTimer midiTimer; // for timing MIDI input + static Array<pthread_t> midiInThread; // for MIDI input thread function + static int* sysexWriteBuffer; // for MIDI sysex write location + static Array<uchar>** sysexBuffers; // for MIDI sysex storage + + private: + void deinitialize (void); + void initialize (void); + + + friend void *interpretMidiInputStreamPrivateALSA(void * x); + +}; + + +#endif /* ALSA */ +#endif /* LINUX */ + +#endif /* _MIDIINPORT_ALSA_H_INCLUDED */ + + + +// md5sum: 260a0accd6b08b638a00904c382293bc - MidiInPort_alsa.h =css= 20030102 diff --git a/src/midiio/include/MidiInPort_alsa05.h b/src/midiio/include/MidiInPort_alsa05.h new file mode 100644 index 0000000..27af569 --- /dev/null +++ b/src/midiio/include/MidiInPort_alsa05.h @@ -0,0 +1,107 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sun May 14 22:05:27 PDT 2000 +// Last Modified: Wed Oct 3 22:28:20 PDT 2001 (frozen for ALSA 0.5) +// Last Modified: Thu Jan 2 18:55:12 PST 2003 (added #ifdef ALSA05) +// Filename: ...sig/maint/code/control/MidiInPort/linux/MidiInPort_alsa05.h +// Web Address: http://sig.sapp.org/include/sig/MidiInPort_alsa05.h +// Syntax: C++ +// +// Description: An interface for MIDI input capabilities of +// linux ALSA sound driver's specific MIDI input methods. +// This class is inherited privately by the MidiInPort class. +// + +#ifndef _MIDIINPORT_ALSA05_H_INCLUDED +#define _MIDIINPORT_ALSA05_H_INCLUDED + +#ifdef LINUX +#ifdef ALSA05 + +#include "MidiMessage.h" +#include "CircularBuffer.h" +#include "Array.h" +#include "Sequencer_alsa05.h" +#include "SigTimer.h" +#include <pthread.h> + +typedef unsigned char uchar; +typedef void (*MIDI_Callback_function)(int arrivalPort); + + +class MidiInPort_alsa05 : public Sequencer_alsa05 { + public: + MidiInPort_alsa05 (void); + MidiInPort_alsa05 (int aPort, int autoOpen = 1); + ~MidiInPort_alsa05 (); + + void clearSysex (int buffer); + void clearSysex (void); + void close (void); + void closeAll (void); + MidiMessage extract (void); + int getBufferSize (void); + int getChannelOffset (void) const; + int getCount (void); + const char* getName (void); + static const char* getName (int i); + static int getNumPorts (void); + int getPort (void); + int getPortStatus (void); + uchar* getSysex (int buffer); + int getSysexSize (int buffer); + int getTrace (void); + void insert (const MidiMessage& aMessage); + int installSysex (uchar* anArray, int aSize); + MidiMessage& message (int index); + int open (void); + void pause (void); + void setBufferSize (int aSize); + void setChannelOffset (int anOffset); + void setPort (int aPort); + int setTrace (int aState); + void toggleTrace (void); + void unpause (void); + + static Array<int> threadinitport; + + protected: + int port; // the port to which this object belongs + + static MIDI_Callback_function callbackFunction; + + static int installSysexPrivate (int port, + uchar* anArray, int aSize); + + static int objectCount; // num of similar objects in existence + static int* portObjectCount; // objects connected to particular port + static int* trace; // for verifying input + static ostream* tracedisplay; // stream for displaying trace + static int numDevices; // number of input ports + static CircularBuffer<MidiMessage>** midiBuffer; // MIDI storage frm ports + static int channelOffset; // channel offset, either 0 or 1 + // not being used right now. + static int* pauseQ; // for adding items to Buffer or not + static SigTimer midiTimer; // for timing MIDI input + static Array<pthread_t> midiInThread; // for MIDI input thread function + static int* sysexWriteBuffer; // for MIDI sysex write location + static Array<uchar>** sysexBuffers; // for MIDI sysex storage + + private: + void deinitialize (void); + void initialize (void); + + + friend void *interpretMidiInputStreamPrivateALSA05(void * x); + +}; + + +#endif /* ALSA05 */ +#endif /* LINUX */ + +#endif /* _MIDIINPORT_ALSA05_H_INCLUDED */ + + + +// md5sum: 7b85b4a658c6f1d45dc1da7752f25cae - MidiInPort_alsa05.h =css= 20030102 diff --git a/src/midiio/include/MidiInPort_linux.h b/src/midiio/include/MidiInPort_linux.h new file mode 100644 index 0000000..589d27a --- /dev/null +++ b/src/midiio/include/MidiInPort_linux.h @@ -0,0 +1,94 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sun May 14 22:30:04 PDT 2000 +// Last Modified: Thu May 18 23:36:07 PDT 2000 (added ifdef LINUX lines) +// Last Modified: Sat Nov 2 20:37:49 PST 2002 (added ifdef ALSA OSS) +// Filename: ...sig/maint/code/control/MidiInPort/MidiInPort_linux.h +// Web Address: http://sig.sapp.org/include/sig/MidiInPort_linux.h +// Syntax: C++ +// +// Description: An interface for MIDI input capabilities of an +// operating-system specific MIDI input method. +// Provides control of all low-level MIDI input +// functionality such that it will work on all +// computers in the same manner. +// + +#ifndef _MIDIINPORT_LINUX_H_INCLUDED +#define _MIDIINPORT_LINUX_H_INCLUDED + +#ifdef LINUX +#if defined(ALSA) && defined(OSS) + +#define MIDI_IN_UNKNOWN_SELECT 0 +#define MIDI_IN_OSS_SELECT 1 +#define MIDI_IN_ALSA_SELECT 2 + +#include "MidiInPort_oss.h" +#include "MidiInPort_alsa.h" +#include "MidiInPort_unsupported.h" +#include "MidiMessage.h" + + +class MidiInPort_linux { + public: + MidiInPort_linux(void); + MidiInPort_linux(int aPort, int autoOpen = 1); + ~MidiInPort_linux(); + + void clearSysex (void); + void clearSysex (int buffer); + void close (void); + void closeAll (void); + MidiMessage extract (void); + int getBufferSize (void); + int getChannelOffset (void) const; + int getCount (void); + const char* getName (void); + static const char* getName (int i); + static int getNumPorts (void); + int getPort (void); + int getPortStatus (void); + uchar* getSysex (int buffer); + int getSysexSize (int buffer); + int getTrace (void); + void insert (const MidiMessage& aMessage); + int installSysex (uchar* anArray, int aSize); + MidiMessage& message (int index); + int open (void); + MidiMessage& operator[] (int index); + void pause (void); + void setBufferSize (int aSize); + void setChannelOffset (int anOffset); + void setAndOpenPort (int aPort); + void setPort (int aPort); + int setTrace (int aState); + void toggleTrace (void); + void unpause (void); + + static int getSelect (void); + static int selectOSS (void); + static int selectALSA (void); + static int selectUnknown (void); + + private: + + static int current; // the type of MIDI out selected + static int alsaQ; // boolean for if ALSA is present + static int ossQ; // boolean for if OSS is present + static int objectCount; // keeps track of static variables + + static MidiInPort_oss *oss_input; + static MidiInPort_alsa *alsa_input; + static MidiInPort_unsupported *unknown_input; + + void determineDrivers (void); +}; + +#endif /* ALSA and OSS def */ +#endif /* LINUX def */ + +#endif /* _MIDIINPORT_LINUX_H_INCLUDED */ + + +// md5sum: cc3608fb63ccf222f018efc89a4275f0 - MidiInPort_linux.h =css= 20030102 diff --git a/src/midiio/include/MidiInPort_oss.h b/src/midiio/include/MidiInPort_oss.h new file mode 100644 index 0000000..ffa5666 --- /dev/null +++ b/src/midiio/include/MidiInPort_oss.h @@ -0,0 +1,105 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Fri Jan 8 08:33:57 PST 1999 +// Last Modified: Fri Jan 8 08:34:01 PST 1999 +// Last Modified: Tue Jun 29 16:18:02 PDT 1999 (added sysex capability) +// Last Modified: Wed May 10 17:10:05 PDT 2000 (name change from _linux to _oss) +// Filename: ...sig/maint/code/control/MidiInPort/linux/MidiInPort_oss.h +// Web Address: http://sig.sapp.org/include/sig/MidiInPort_oss.h +// Syntax: C++ +// +// Description: An interface for MIDI input capabilities of +// linux OSS sound driver's specific MIDI input methods. +// This class is inherited privately by the MidiInPort class. +// + +#ifndef _MIDIINPORT_OSS_H_INCLUDED +#define _MIDIINPORT_OSS_H_INCLUDED + +#ifdef LINUX + +#include "MidiMessage.h" +#include "CircularBuffer.h" +#include "Array.h" +#include "Sequencer_oss.h" +#include "SigTimer.h" +#include <pthread.h> + +typedef unsigned char uchar; +typedef void (*MIDI_Callback_function)(int arrivalPort); + + +class MidiInPort_oss : public Sequencer_oss { + public: + MidiInPort_oss (void); + MidiInPort_oss (int aPort, int autoOpen = 1); + ~MidiInPort_oss (); + + void clearSysex (int buffer); + void clearSysex (void); + void close (void); + void close (int i) { close(); } + void closeAll (void); + MidiMessage extract (void); + int getBufferSize (void); + int getChannelOffset (void) const; + int getCount (void); + const char* getName (void); + static const char* getName (int i); + static int getNumPorts (void); + int getPort (void); + int getPortStatus (void); + uchar* getSysex (int buffer); + int getSysexSize (int buffer); + int getTrace (void); + void insert (const MidiMessage& aMessage); + int installSysex (uchar* anArray, int aSize); + MidiMessage& message (int index); + int open (void); + void pause (void); + void setBufferSize (int aSize); + void setChannelOffset (int anOffset); + void setPort (int aPort); + int setTrace (int aState); + void toggleTrace (void); + void unpause (void); + + protected: + int port; // the port to which this object belongs + + static MIDI_Callback_function callbackFunction; + + static int installSysexPrivate (int port, + uchar* anArray, int aSize); + + static int objectCount; // num of similar objects in existence + static int* portObjectCount; // objects connected to particular port + static int* trace; // for verifying input + static std::ostream* tracedisplay; // stream for displaying trace + static int numDevices; // number of input ports + static CircularBuffer<MidiMessage>** midiBuffer; // MIDI storage frm ports + static int channelOffset; // channel offset, either 0 or 1 + // not being used right now. + static int* pauseQ; // for adding items to Buffer or not + static SigTimer midiTimer; // for timing MIDI input + static pthread_t midiInThread; // for MIDI input thread function + static int* sysexWriteBuffer; // for MIDI sysex write location + static Array<uchar>** sysexBuffers; // for MIDI sysex storage + + private: + void deinitialize (void); + void initialize (void); + + + friend void *interpretMidiInputStreamPrivate(void * x); + +}; + + +#endif /* LINUX */ + +#endif /* _MIDIINPORT_OSS_H_INCLUDED */ + + + +// md5sum: 05331ff5c3806fc753ebebaeffa3c377 - MidiInPort_oss.h =css= 20030102 diff --git a/src/midiio/include/MidiInPort_unsupported.h b/src/midiio/include/MidiInPort_unsupported.h new file mode 100644 index 0000000..1f3bcf0 --- /dev/null +++ b/src/midiio/include/MidiInPort_unsupported.h @@ -0,0 +1,89 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Fri Jan 23 00:04:51 GMT-0800 1998 +// Last Modified: Fri Jan 23 00:04:58 GMT-0800 1998 +// Last Modified: Wed Jun 30 11:42:59 PDT 1999 (added sysex capability) +// Filename: ...sig/code/control/MidiInPort/unsupported/MidiInPort_unsupported.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/MidiInPort_unsupported.h +// Syntax: C++ +// +// Description: An interface for MIDI input capabilities of +// an unknown sound driver's specific MIDI input methods. +// This class is inherited privately by the MidiInPort class. +// This class is used when there is no MIDI input, so +// that MIDI programs can otherwise be compiled and run. +// This file can also serve as a template for creating +// an OS specific class for MIDI input. +// + +#ifndef _MIDIINPUT_UNSUPPORTED_H_INCLUDED +#define _MIDIINPUT_UNSUPPORTED_H_INCLUDED + +#include "MidiMessage.h" +#include "CircularBuffer.h" +#include "Array.h" + +class MidiInPort_unsupported { + public: + MidiInPort_unsupported (void); + MidiInPort_unsupported (int aPort, int autoOpen = 1); + ~MidiInPort_unsupported (); + + void clearSysex (int index) { } + void clearSysex (void) { } + int getSysexSize (int index) { return 0; } + uchar* getSysex (int buffer) { return NULL; } + int installSysex (unsigned char *&, int &) { return 0; } + int getBufferSize (void) { return 0; } + void close (void); + void close (int i) { close(); } + void closeAll (void); + MidiMessage extract (void); + int getChannelOffset (void) const; + int getCount (void); + const char* getName (void); + static const char* getName (int i); + int getNumPorts (void); + int getPort (void); + int getPortStatus (void); + int getTrace (void); + void insert (const MidiMessage& aMessage); + MidiMessage& message (int index); + int open (void); + void pause (void); + void setBufferSize (int aSize); + void setChannelOffset (int anOffset); + void setPort (int aPort); + int setTrace (int aState); + void toggleTrace (void); + void unpause (void); + + protected: + int port; // the port to which this object belongs + int trace; + + static int objectCount; // num of similar objects in existence + static int* portObjectCount; // objects connected to particular port + static int* openQ; // for open/close status of port + static int numDevices; // number of input ports + static CircularBuffer<MidiMessage>* midiBuffer; // MIDI storage from ports + static int channelOffset; // channel offset, either 0 or 1 + // not being used right now. + static int* sysexWriteBuffer; // for MIDI sysex write location + static Array<uchar>** sysexBuffers; // for MIDI sysex storage + + private: + void deinitialize (void); + void initialize (void); + void setPortStatus (int aStatus); + + +}; + + + +#endif /* _MIDIINPUT_UNSUPPORTED_H_INCLUDED */ + + + +// md5sum: ff5492fbd59a47e48e2c0ce06705add1 - MidiInPort_unsupported.h =css= 20030102 diff --git a/src/midiio/include/MidiInPort_visual.h b/src/midiio/include/MidiInPort_visual.h new file mode 100644 index 0000000..398a187 --- /dev/null +++ b/src/midiio/include/MidiInPort_visual.h @@ -0,0 +1,114 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sun Dec 28 15:18:46 GMT-0800 1997 +// Last Modified: Mon Jan 12 20:05:27 GMT-0800 1998 +// Last Modified: Wed Jun 30 11:29:51 PDT 1999 (added sysex capability) +// Filename: ...sig/code/control/MidiInPort/visual/MidiInPort_visual.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/MidiInPort_visual.h +// Syntax: C++ +// +// Description: An interface for MIDI input capabilities of +// Windows 95/NT/98 specific MIDI input methods. +// as defined in winmm.lib. This class is inherited +// privately by the MidiInPort class. +// + +#ifndef _MIDIINPUT_VISUAL_H_INCLUDED +#define _MIDIINPUT_VISUAL_H_INCLUDED + + +#ifdef VISUAL + +#define DEFAULT_INPUT_BUFFER_SIZE (1024) + +#include <windows.h> +#include <mmsystem.h> + +#include "MidiMessage.h" +#include "CircularBuffer.h" +#include "Array.h" + +class MidiInPort_visual { + public: + MidiInPort_visual (void); + MidiInPort_visual (int aPort, int autoOpen = 1); + ~MidiInPort_visual (); + + void clearSysex (void); + void clearSysex (int buffer); + void close (void); + void closeAll (void); + MidiMessage extract (void); + int getBufferSize (void); + int getChannelOffset (void) const; + int getCount (void); + const char* getName (void); + static const char* getName (int i); + static int getNumPorts (void); + int getPort (void); + int getPortStatus (void); + uchar* getSysex (int buffer); + int getSysexSize (int buffer); + int getTrace (void); + void insert (const MidiMessage& aMessage); + int installSysex (uchar* anArray, int aSize); + MidiMessage& message (int index); + int open (void); + void pause (void); + void setBufferSize (int aSize); + void setChannelOffset (int anOffset); + void setPort (int aPort); + int setTrace (int aState); + void toggleTrace (void); + void unpause (void); + + protected: + int port; // the port to which this object belongs + int trace; + + int installSysexPrivate (int port, uchar* anArray, int aSize); + void installSysexStuff (HMIDIIN dev, int port); + void uninstallSysexStuff (HMIDIIN dev, int port); + + static int objectCount; // num of similar objects in existence + static int* portObjectCount; // objects connected to particular port + static int* openQ; // for open/close status of port + static int* inrunningQ; // for running open input port + static int numDevices; // number of input ports + static HMIDIIN* device; // Windoze MIDI-in device structure + static MIDIHDR** sysexDriverBuffer1; // for Windoze driver sysex buffers + static MIDIHDR** sysexDriverBuffer2; // for Windoze driver sysex buffers + static int* sysexDBnumber; // for Windoze driver sysex buffers + static HANDLE* hMutex; // mutual exclusive + static CircularBuffer<MidiMessage>* midiBuffer; // MIDI storage from ports + static int channelOffset; // channel offset from either 0 or 1. + // not being used right now. + static int* sysexWriteBuffer; // for MIDI sysex write location + static Array<uchar>** sysexBuffers;// for MIDI sysex storage + static int* sysexStatus; // tracing multiple MIM_LONGDATA messgs + + private: + void deinitialize (void); + void initialize (void); + void releaseMutex (void); + void setPortStatus (int aStatus); + void waitForMutex (void); + + + friend void CALLBACK midiInputCallback(HMIDIIN hMidiIn, UINT inputStatus, + DWORD instancePtr, DWORD midiMessage, DWORD timestamp); +}; + + +// This is the command which is called by the driver when there is +// MIDI data being received from the MIDI input port: + void CALLBACK midiInputCallback(HMIDIIN hMidiIn, UINT inputStatus, + DWORD instancePtr, DWORD midiMessage, DWORD timestamp); + + +#endif /* VISUAL */ +#endif /* _MIDIINPUT_VISUAL_H_INCLUDED */ + + + +// md5sum: d5aee7a88c4a054b3e2d4d40622fdc42 - MidiInPort_visual.h =css= 20030102 diff --git a/src/midiio/include/MidiInput.h b/src/midiio/include/MidiInput.h new file mode 100644 index 0000000..4425f75 --- /dev/null +++ b/src/midiio/include/MidiInput.h @@ -0,0 +1,53 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: 18 December 1997 +// Last Modified: Sun Jan 25 15:27:02 GMT-0800 1998 +// Last Modified: Thu Apr 20 16:23:24 PDT 2000 (added scale function) +// Filename: ...sig/code/control/MidiInput/MidiInput.h +// Web Address: http://sig.sapp.org/include/sig/MidiInput.h +// Syntax: C++ +// +// Description: A higher-level MIDI input interface than the +// MidiInPort class. Can be used to allow multiple +// objects to share a single MIDI input stream, or +// to fake a MIDI input connection. +// + +#ifndef _MIDIINPUT_H_INCLUDED +#define _MIDIINPUT_H_INCLUDED + + +#include "MidiInPort.h" + + +class MidiInput : public MidiInPort { + public: + MidiInput (void); + MidiInput (int aPort, int autoOpen = 1); + ~MidiInput (); + + int getBufferSize (void); + int getCount (void); + MidiMessage extract (void); + void insert (const MidiMessage& aMessage); + int isOrphan (void) const; + void makeOrphanBuffer (int aSize = 1024); + void removeOrphanBuffer(void); + void setBufferSize (int aSize); + + int scale (int value, int min, int max); + double fscale (int value, double min, double max); + int scale14 (int value, int min, int max); + double fscale14 (int value, double min, double max); + + protected: + CircularBuffer<MidiMessage>* orphanBuffer; + +}; + + +#endif /* _MIDIINPUT_H_INCLUDED */ + + + +// md5sum: 73972cc29d7bcf0fba136b098c0419a0 - MidiInput.h =css= 20030102 diff --git a/src/midiio/include/MidiMessage.h b/src/midiio/include/MidiMessage.h new file mode 100644 index 0000000..e4b59ba --- /dev/null +++ b/src/midiio/include/MidiMessage.h @@ -0,0 +1,78 @@ +// +// Copyright 1997 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: 19 December 1997 +// Last Modified: Fri Jan 23 00:21:24 GMT-0800 1998 +// Last Modified: Sun Sep 20 20:30:53 PDT 1998 +// Last Modified: Mon Oct 15 14:29:12 PDT 2001 (added is_note functions) +// Filename: ...sig/include/sigInfo/MidiMessage.h +// Web Address: http://sig.sapp.org/include/sigInfo/MidiMessage.h +// Syntax: C++ +// +// Description: A structure for handling MIDI input messages. +// This class stores a time stamp plus up to +// four MIDI message bytes. System Exclusive messages +// are stored in a separate array in the MidiInPort +// class, and their storage index is passed to the +// user through a MIDI message for later extraction +// of the full sysex message. +// + +#ifndef _MIDIMESSAGE_H_INCLUDED +#define _MIDIMESSAGE_H_INCLUDED + +#include <iostream> + +typedef unsigned char uchar; +typedef unsigned long ulong; + +class MidiMessage { + public: + ulong time; // timestamp + ulong data; // MIDI command and parameters + + MidiMessage (void); + MidiMessage (int aCommand, int aP1, int aP2, + int aTime = 0); + MidiMessage (const MidiMessage& aMessage); + ~MidiMessage (); + + uchar& command (void); + MidiMessage& operator= (const MidiMessage& aMessage); + uchar& operator[] (int index); + uchar& p0 (void); + uchar& p1 (void); + uchar& p2 (void); + uchar& p3 (void); + int getArgCount (void) const; + int getParameterCount (void) const; + + uchar getCommand (void) const; + uchar getP0 (void) const; + uchar getP1 (void) const; + uchar getP2 (void) const; + uchar getP3 (void) const; + + void setCommand (uchar aCommand); + void setData (uchar aCommand, uchar aP1 = 0, + uchar aP2 = 0, uchar aP3 = 0); + void setP0 (uchar aP0); + void setP1 (uchar aP1); + void setP2 (uchar aP2); + void setP3 (uchar aP3); + + int is_note (void); + int is_note_on (void); + int is_note_off (void); + +}; + + +std::ostream& operator<<(std::ostream& out, MidiMessage& aMessage); + + +#endif /* _MIDIMESSAGE_H_INCLUDED */ + + + +// md5sum: 4738e957fb8a233f6dbaeebda490e6a4 - MidiMessage.h =css= 20030102 diff --git a/src/midiio/include/MidiOutPort.h b/src/midiio/include/MidiOutPort.h new file mode 100644 index 0000000..0287dfd --- /dev/null +++ b/src/midiio/include/MidiOutPort.h @@ -0,0 +1,92 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sun Dec 28 15:04:24 GMT-0800 1997 +// Last Modified: Fri Jan 23 10:56:18 GMT-0800 1998 +// Last Modified: Sat Nov 7 16:15:54 PST 1998 +// Last Modified: Tue May 23 23:08:44 PDT 2000 (oss/alsa selection added) +// Last Modified: Mon Jun 19 10:32:11 PDT 2000 (oss/alsa define fix) +// Filename: ...sig/code/control/MidiOutPort/MidiOutPort.h +// Web Address: http://sig.sapp.org/include/sig/MidiOutPort.h +// Syntax: C++ +// +// Description: Operating-System independent interface for +// basic MIDI output capabilities. Privately +// inherits the operating-system specific class +// for MIDI output. +// + +#ifndef _MIDIOUTPORT_H_INCLUDED +#define _MIDIOUTPORT_H_INCLUDED + + +#ifdef VISUAL + #define MIDIOUTPORT MidiOutPort_visual + #include "MidiOutPort_visual.h" +#elif defined(LINUX) && defined(ALSA) && defined(OSS) + #define MIDIOUTPORT MidiOutPort_linux + #include "MidiOutPort_linux.h" +#elif defined(LINUX) && defined(ALSA) && !defined(OSS) + #define MIDIOUTPORT MidiOutPort_alsa + #include "MidiOutPort_alsa.h" +#elif defined (LINUX) && defined(OSS) && !defined(ALSA) + #define MIDIOUTPORT MidiOutPort_oss + #include "MidiOutPort_oss.h" +#elif defined(LINUX) + #define MIDIOUTPORT MidiOutPort_oss + #include "MidiOutPort_oss.h" +#else + #define MIDIOUTPORT MidiOutPort_unsupported + #include "MidiOutPort_unsupported.h" +#endif + + +class MidiOutPort : protected MIDIOUTPORT { + public: + MidiOutPort (void) : MIDIOUTPORT() {} + MidiOutPort (int aPort, int autoOpen = 1) : + MIDIOUTPORT(aPort, autoOpen) {} + ~MidiOutPort() { } + + void close(void) { MIDIOUTPORT::close(); } + void closeAll(void) { MIDIOUTPORT::closeAll(); } + int getChannelOffset(void) const { + return MIDIOUTPORT::getChannelOffset(); } + const char* getName(void) { return MIDIOUTPORT::getName(); } + static const char* getName(int i) { return MIDIOUTPORT::getName(i); } + static int getNumPorts(void) { return MIDIOUTPORT::getNumPorts(); } + int getPort(void) { return MIDIOUTPORT::getPort(); } + int getPortStatus(void) { + return MIDIOUTPORT::getPortStatus(); } + int getTrace(void) { + return MIDIOUTPORT::getTrace(); } + int open(void) { return MIDIOUTPORT::open(); } + int rawsend(int command, int p1, int p2) { + return MIDIOUTPORT::rawsend(command, p1, p2); } + int rawsend(int command, int p1) { + return MIDIOUTPORT::rawsend(command, p1); } + int rawsend(int command) { + return MIDIOUTPORT::rawsend(command); } + int rawsend(uchar* array, int size) { + return MIDIOUTPORT::rawsend(array, size); } + void setAndOpenPort(int aPort) { setPort(aPort); open(); } +// void setChannelOffset(int aChannel) { +// MIDIOUTPORT::setChannelOffset(aChannel); } + void setPort(int aPort) { MIDIOUTPORT::setPort(aPort); } + int setTrace(int aState) { + return MIDIOUTPORT::setTrace(aState); } + int sysex(uchar* array, int size) { + return MIDIOUTPORT::sysex(array, size); } + void toggleTrace(void) { MIDIOUTPORT::toggleTrace(); } + MidiOutPort& operator=(MidiOutPort& other) { + setPort(other.getPort()); + if (other.getPortStatus()) { open(); } + return *this; } +}; + + + + +#endif /* _MIDIOUTPORT_H_INCLUDED */ + + +// md5sum: 2f7b8aa8ef705eab57179b626ce1d62d - MidiOutPort.h =css= 20030102 diff --git a/src/midiio/include/MidiOutPort_alsa.h b/src/midiio/include/MidiOutPort_alsa.h new file mode 100644 index 0000000..34139a3 --- /dev/null +++ b/src/midiio/include/MidiOutPort_alsa.h @@ -0,0 +1,79 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Wed May 10 16:22:00 PDT 2000 +// Last Modified: Sun May 14 20:43:44 PDT 2000 +// Last Modified: Sat Nov 2 20:39:01 PST 2002 (added ALSA def) +// Filename: ...sig/maint/code/control/MidiOutPort/linux/MidiOutPort_alsa.h +// Web Address: http://sig.sapp.org/include/sig/MidiOutPort_alsa.h +// Syntax: C++ +// +// Description: Operating-System specific interface for +// basic MIDI output capabilities in Linux using +// OSS sound drivers. Privately inherited by the +// MidiOutPort class. +// + +#ifndef _MIDIOUTPORT_ALSA_H_INCLUDED +#define _MIDIOUTPORT_ALSA_H_INCLUDED + +#ifdef LINUX +#ifdef ALSA + +#include "Sequencer_alsa.h" +#include <iostream> + +typedef unsigned char uchar; + + +class MidiOutPort_alsa : public Sequencer_alsa { + public: + MidiOutPort_alsa (void); + MidiOutPort_alsa (int aPort, int autoOpen = 1); + ~MidiOutPort_alsa (); + + void close (void); + void closeAll (void); + int getChannelOffset (void) const; + const char* getName (void); + static const char* getName (int i); + int getPort (void); + static int getNumPorts (void); + int getPortStatus (void); + int getTrace (void); + int rawsend (int command, int p1, int p2); + int rawsend (int command, int p1); + int rawsend (int command); + int rawsend (uchar* array, int size); + int open (void); + void setChannelOffset (int aChannel); + void setPort (int aPort); + int setTrace (int aState); + int sysex (uchar* array, int size); + void toggleTrace (void); + + protected: + int port; // the port to which this object belongs + + static int objectCount; // num of similar objects in existence + static int* portObjectCount; // objects connected to particular port + static int numDevices; // number of output ports + static int* trace; // for printing messages to output + static std::ostream* tracedisplay; // for printing trace messages + + private: + void deinitialize (void); + void initialize (void); + void setPortStatus (int aStatus); + + static int channelOffset; // channel offset, either 0 or 1. + // not being used right now. +}; + + + +#endif /* ALSA */ +#endif /* LINUX */ +#endif /* _MIDIOUTPUT_ALSA_H_INCLUDED */ + + +// md5sum: 5b7648c7b493df7cb0d1fae3bbb8be24 - MidiOutPort_alsa.h =css= 20030102 diff --git a/src/midiio/include/MidiOutPort_linux.h b/src/midiio/include/MidiOutPort_linux.h new file mode 100644 index 0000000..a02dc22 --- /dev/null +++ b/src/midiio/include/MidiOutPort_linux.h @@ -0,0 +1,80 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Wed May 10 16:03:52 PDT 2000 +// Last Modified: Thu May 18 23:37:17 PDT 2000 +// Last Modified: Sat Nov 2 20:40:01 PST 2002 (added ALSA OSS def) +// Filename: ...sig/code/control/MidiOutPort_linux/MidiOutPort_linux.h +// Web Address: http://sig.sapp.org/include/sig/MidiOutPort_linux.h +// Syntax: C++ +// +// Description: Linux MIDI output class which detects which +// type of MIDI drivers are available: either +// ALSA or OSS. +// + +#ifndef _MIDIOUTPORT_LINUX_H_INCLUDED +#define _MIDIOUTPORT_LINUX_H_INCLUDED + +#ifdef LINUX +#if defined(ALSA) && defined(OSS) + +#include "MidiOutPort_oss.h" +#include "MidiOutPort_alsa.h" +#include "MidiOutPort_unsupported.h" + +#define UNKNOWN_MIDI_SELECT 0 /* use dummy MIDI output */ +#define OSS_MIDI_SELECT 1 /* use OSS MIDI output */ +#define ALSA_MIDI_SELECT 2 /* use ALSA MIDI output */ + +class MidiOutPort_linux { + public: + MidiOutPort_linux (void); + MidiOutPort_linux (int aPort, int autoOpen = 1); + ~MidiOutPort_linux (); + + void close (void); + void closeAll (void); + int getChannelOffset (void) const; + const char* getName (void); + static const char* getName (int i); + static int getNumPorts (void); + int getPort (void); + int getPortStatus (void); + int getTrace (void); + int open (void); + int rawsend (int command, int p1, int p2); + int rawsend (int command, int p1); + int rawsend (int command); + int rawsend (uchar* array, int size); + void setAndOpenPort (int aPort); + void setChannelOffset (int aChannel); + void setPort (int aPort); + int setTrace (int aState); + int sysex (uchar* array, int size); + void toggleTrace (void); + + static int getSelect (void); + static int selectOSS (void); + static int selectALSA (void); + static int selectUnknown (void); + + private: + static int current; // the type of MIDI out selected + static int alsaQ; // boolean for if ALSA is present + static int ossQ; // boolean for if OSS is present + + static int objectCount; + static MidiOutPort_oss *oss_output; + static MidiOutPort_alsa *alsa_output; + static MidiOutPort_unsupported *unknown_output; + + void determineDrivers (void); +}; + +#endif /* ALSA and OSS */ +#endif /* LINUX */ + +#endif /* _MIDIOUTPORT_LINUX_H_INCLUDED */ + + +// md5sum: c80f9f47c45a6d4a20b6549743cae9fb - MidiOutPort_linux.h =css= 20030102 diff --git a/src/midiio/include/MidiOutPort_oss.h b/src/midiio/include/MidiOutPort_oss.h new file mode 100644 index 0000000..22cf32d --- /dev/null +++ b/src/midiio/include/MidiOutPort_oss.h @@ -0,0 +1,75 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Fri Dec 18 19:15:00 PST 1998 +// Last Modified: Wed May 10 17:00:11 PDT 2000 (name change from _linux to _oss) +// Filename: ...sig/maint/code/control/MidiOutPort/linux/MidiOutPort_oss.h +// Web Address: http://sig.sapp.org/include/sig/MidiOutPort_oss.h +// Syntax: C++ +// +// Description: Operating-System specific interface for +// basic MIDI output capabilities in Linux using +// OSS sound drivers. Privately inherited by the +// MidiOutPort class. +// + +#ifndef _MIDIOUTPORT_OSS_H_INCLUDED +#define _MIDIOUTPORT_OSS_H_INCLUDED + +#ifdef LINUX + +#include "Sequencer_oss.h" + +typedef unsigned char uchar; + + +class MidiOutPort_oss : public Sequencer_oss { + public: + MidiOutPort_oss (void); + MidiOutPort_oss (int aPort, int autoOpen = 1); + ~MidiOutPort_oss (); + + void close (void); + void closeAll (void); + int getChannelOffset (void) const; + const char* getName (void); + static const char* getName (int i); + int getPort (void); + static int getNumPorts (void); + int getPortStatus (void); + int getTrace (void); + int rawsend (int command, int p1, int p2); + int rawsend (int command, int p1); + int rawsend (int command); + int rawsend (uchar* array, int size); + int open (void); + void setChannelOffset (int aChannel); + void setPort (int aPort); + int setTrace (int aState); + int sysex (uchar* array, int size); + void toggleTrace (void); + + protected: + int port; // the port to which this object belongs + + static int objectCount; // num of similar objects in existence + static int* portObjectCount; // objects connected to particular port + static int numDevices; // number of output ports + static int* trace; // for printing messages to output + static std::ostream* tracedisplay; // for printing trace messages + + private: + void deinitialize (void); + void initialize (void); + void setPortStatus (int aStatus); + + static int channelOffset; // channel offset, either 0 or 1. + // not being used right now. +}; + + + +#endif /* LINUX */ +#endif /* _MIDIOUTPUT_OSS_H_INCLUDED */ + + +// md5sum: f60183e23c49741e93d9b965bbe9a6d8 - MidiOutPort_oss.h =css= 20030102 diff --git a/src/midiio/include/MidiOutPort_unsupported.h b/src/midiio/include/MidiOutPort_unsupported.h new file mode 100644 index 0000000..a5e8c35 --- /dev/null +++ b/src/midiio/include/MidiOutPort_unsupported.h @@ -0,0 +1,71 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Mon Jan 12 21:36:26 GMT-0800 1998 +// Last Modified: Mon Jan 12 21:36:31 GMT-0800 1998 +// Filename: ...sig/code/control/MidiOutPort/unsupported/MidiOutPort_unsupported.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/MidiOutPort_unsupported.h +// Syntax: C++ +// +// Description: Operating-System specific interface for basic MIDI output +// capabilities in an unknown operating system. Privately +// inherited by the MidiOutPort class. Used for compiling +// and running MIDI programs on a computer with no +// MIDI output. +// + +#ifndef _MIDIOUTPUT_UNSUPPORTED_H_INCLUDED +#define _MIDIOUTPUT_UNSUPPORTED_H_INCLUDED + +typedef unsigned char uchar; + +class MidiOutPort_unsupported { + public: + MidiOutPort_unsupported (void); + MidiOutPort_unsupported (int aPort, int autoOpen = 1); + ~MidiOutPort_unsupported (); + + void close (void); + void closeAll (void); + int getChannelOffset (void) const; + const char* getName (void) const; + const char* getName (int i) const; + int getPort (void) const; + int getNumPorts (void) const; + int getPortStatus (void) const; + int getTrace (void) const; + int rawsend (int command, int p1, int p2); + int rawsend (int command, int p1); + int rawsend (int command); + int rawsend (uchar* array, int size); + int open (void); + void setChannelOffset (int aChannel); + void setPort (int aPort); + int setTrace (int aState); + int sysex (uchar* array, int size); + void toggleTrace (void); + + protected: + int port; // the port to which this object belongs + int trace; // for printing out midi messages to standard output + + static int objectCount; // num of similar objects in existence + static int* portObjectCount; // objects connected to particular port + static int* openQ; // for open/close status of port + static int numDevices; // number of output ports + + private: + void deinitialize (void); + void initialize (void); + void setPortStatus (int aStatus); + + static int channelOffset; // channel offset, either 0 or 1 + // not being used right now. +}; + + + +#endif /* _MIDIOUTPUT_UNSUPPORTED_H_INCLUDED */ + + + +// md5sum: e244688a99d220addc7b1c6f6f6a8022 - MidiOutPort_unsupported.h =css= 20030102 diff --git a/src/midiio/include/MidiOutPort_visual.h b/src/midiio/include/MidiOutPort_visual.h new file mode 100644 index 0000000..d6a3984 --- /dev/null +++ b/src/midiio/include/MidiOutPort_visual.h @@ -0,0 +1,75 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sun Dec 28 15:18:46 GMT-0800 1997 +// Last Modified: Mon Jan 12 20:05:27 GMT-0800 1998 +// Filename: ...sig/code/control/MidiOutPort/visual/MidiOutPort_visual.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/MidiOutPort_visual.h +// Syntax: C++ +// +// Description: Operating-System specific interface for +// basic MIDI output capabilities in Windows 95/NT/98 +// using winmm.lib. Privately inherited by the +// MidiOutPort class. +// + +#ifndef _MIDIOUTPUT_VISUAL_H_INCLUDED +#define _MIDIOUTPUT_VISUAL_H_INCLUDED + +#ifdef VISUAL + +typedef unsigned char uchar; + +#include <windows.h> +#include <mmsystem.h> + +class MidiOutPort_visual { + public: + MidiOutPort_visual (void); + MidiOutPort_visual (int aPort, int autoOpen = 1); + ~MidiOutPort_visual (); + + void close (void); + void closeAll (void); + int getChannelOffset (void) const; + const char* getName (void); + static const char* getName (int i); + int getPort (void); + static int getNumPorts (void); + int getPortStatus (void); + int getTrace (void); + int rawsend (int command, int p1, int p2); + int rawsend (int command, int p1); + int rawsend (int command); + int rawsend (uchar* array, int size); + int open (void); + void setChannelOffset (int aChannel); + void setPort (int aPort); + int setTrace (int aState); + int sysex (uchar* array, int size); + void toggleTrace (void); + + protected: + int port; // the port to which this object belongs + int trace; // for printing out Midi messages to standard output + + static int objectCount; // num of similar objects in existence + static int* portObjectCount; // objects connected to particular port + static int* openQ; // for open/close status of port + static int numDevices; // number of output ports + static HMIDIOUT* device; // Windoze midi out device structure + + private: + void deinitialize (void); + void initialize (void); + void setPortStatus (int aStatus); + + static int channelOffset; // channel offset, either 0 or 1. + // not being used right now. +}; + + +#endif /* VISUAL */ +#endif /* _MIDIOUTPUT_VISUAL_H_INCLUDED */ + + +// md5sum: 47799e340effa57676be8a3943cabb70 - MidiOutPort_visual.h =css= 20030102 diff --git a/src/midiio/include/MidiOutput.h b/src/midiio/include/MidiOutput.h new file mode 100644 index 0000000..d424816 --- /dev/null +++ b/src/midiio/include/MidiOutput.h @@ -0,0 +1,140 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: 18 December 1997 +// Last Modified: Mon Jan 26 23:53:05 GMT-0800 1998 +// Last Modified: Sat Jan 30 14:00:29 PST 1999 +// Last Modified: Sun Jul 18 18:52:42 PDT 1999 (added RPN functions) +// Filename: ...sig/maint/code/control/MidiOutput/MidiOutput.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/MidiOutput.h +// Syntax: C++ +// +// Description: The MIDI output interface for MIDI synthesizers/equipment +// which has many convienience functions defined for +// various types of MIDI output. +// + +#ifndef _MIDIOUTPUT_H_INCLUDED +#define _MIDIOUTPUT_H_INCLUDED + +#include "MidiOutPort.h" +#include "FileIO.h" +#include "SigTimer.h" +#include "Array.h" + + +class MidiOutput : public MidiOutPort { + public: + MidiOutput (void); + MidiOutput (int aPort, int autoOpen = 1); + ~MidiOutput (); + + // Basic user MIDI output commands: + int cont (int channel, int controller, int data); + int off (int channel, int keynum, int releaseVelocity); + int pc (int channel, int timbre); + int play (int channel, int keynum, int velocity); + int pw (int channel, int mostByte, int leastByte); + int pw (int channel, int tuningData); + int pw (int channel, double tuningData); + void recordStart (char *filename, int format); + void recordStop (void); + void reset (void); + int send (int command, int p1, int p2); + int send (int command, int p1); + int send (int command); + void silence (int aChannel = -1); + void sustain (int channel, int status); + int sysex (char* data, int length); + int sysex (uchar* data, int length); + + protected: + int outputRecordQ; // boolean for recording + int outputRecordType; // what form to record MIDI data in + int lastFlushTime; // for recording midi data + FileIO outputRecordFile; // file for recording midi data + static SigTimer timer; // for recording midi data + static Array<int>* rpn_lsb_status; // for RPN messages + static Array<int>* rpn_msb_status; // for RPN messages + static int objectCount; // for RPN messages + + void deinitializeRPN (void); + void initializeRPN (void); + void writeOutputAscii (int channel, int p1, int p2); + void writeOutputBinary (int channel, int p1, int p2); + void writeOutputMidifile(int channel, int p1, int p2); + + public: // RPN controller functions + int NRPN (int channel, int nrpn_msb, int nrpn_lsb, + int data_msb, int data_lsb); + int NRPN (int channel, int nrpn_msb, int nrpn_lsb, + int data_msb); + int NRPN (int channel, int nrpn_msb, int nrpn_lsb, + double data); + int NRPN_null (int channel); + int NRPN_attack (int channel, double value); + int NRPN_attack (int channel, int value); + int NRPN_decay (int channel, double value); + int NRPN_decay (int channel, int value); + int NRPN_drumAttack (int drum, double value); + int NRPN_drumAttack (int drum, int value); + int NRPN_drumChorus (int drum, double value); + int NRPN_drumChorus (int drum, int value); + int NRPN_drumDecay (int drum, double value); + int NRPN_drumDecay (int drum, int value); + int NRPN_drumLevel (int drum, double value); + int NRPN_drumLevel (int drum, int value); + int NRPN_drumPan (int drum, double value); + int NRPN_drumPan (int drum, int value); + int NRPN_drumPitch (int drum, double value); + int NRPN_drumPitch (int drum, int value); + int NRPN_drumFilterCutoff (int drum, double value); + int NRPN_drumFilterCutoff (int drum, int value); + int NRPN_drumFilterResonance(int drum, double value); + int NRPN_drumFilterResonance(int drum, int value); + int NRPN_drumReverb (int drum, double value); + int NRPN_drumReverb (int drum, int value); + int NRPN_drumVariation (int drum, double value); + int NRPN_drumVariation (int drum, int value); + int NRPN_filterCutoff (int channel, double value); + int NRPN_filterCutoff (int channel, int value); + int NRPN_release (int channel, double value); + int NRPN_release (int channel, int value); + int NRPN_vibratoDelay (int channel, double value); + int NRPN_vibratoDelay (int channel, int value); + int NRPN_vibratoDepth (int channel, double value); + int NRPN_vibratoDepth (int channel, int value); + int NRPN_vibratoRate (int channel, double value); + int NRPN_vibratoRate (int channel, int value); + + int RPN (int channel, int rpn_msb, int rpn_lsb, + int data_msb, int data_lsb); + int RPN (int channel, int rpn_msb, int rpn_lsb, + int data_msb); + int RPN (int channel, int rpn_msb, int rpn_lsb, + double data); + int RPN_null (void); + int RPN_null (int channel); + int pbRange (int channel, int steps); + int tuneFine (int channel, int cents); + int fineTune (int channel, int cents); + int tuneCoarse (int channel, int steps); + int coarseTune (int channel, int steps); + int tuningProgram (int channel, int program); + int tuningBank (int channel, int bank); + +}; + + +#endif /* _MIDIOUTPUT_H_INCLUDED */ + +// Brief description of MidiOutput public member functions: +// +// send: sends a MIDI command to the MIDI output with up to two parameters +// play: sends a playnote command to the MIDI output +// pc: Patch Change. changes the timbre (instrument) on the given channel +// cont: sends a CONTinuous CONTroller MIDI command +// sysex: sends a system exclusive command to the MIDI output +// + + +// md5sum: 12ee02c32563ae219aaa8c7599de55db - MidiOutput.h =css= 20030102 diff --git a/src/midiio/include/MidiPort.h b/src/midiio/include/MidiPort.h new file mode 100644 index 0000000..834877e --- /dev/null +++ b/src/midiio/include/MidiPort.h @@ -0,0 +1,49 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: 21 December 1997 +// Last Modified: Fri Jan 23 10:21:25 GMT-0800 1998 +// Filename: .../sig/code/control/MidiPort/MidiPort.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/MidiPort.h +// Syntax: C++ +// +// Description: A unified object that handles basic MIDI input and output. +// Derived from the MidiInPort and MidiOutPort classes. +// + +#ifndef _MIDIPORT_H_INCLUDED +#define _MIDIPORT_H_INCLUDED + + +#include "MidiInPort.h" +#include "MidiOutPort.h" + + +class MidiPort : public MidiOutPort, public MidiInPort { + public: + MidiPort (void); + MidiPort (int outputPort, int inputPort); + ~MidiPort (); + + int getChannelInOffset (void) const; + int getChannelOutOffset (void) const; + int getInputPort (void); + int getInputTrace (void); + int getOutputPort (void); + int getOutputTrace (void); + void setChannelOffset (int anOffset); + void setInputPort (int aPort); + int setInputTrace (int aState); + void setOutputPort (int aPort); + int setOutputTrace (int aState); + void toggleInputTrace (void); + void toggleOutputTrace (void); + +}; + + + +#endif /* _MIDIPORT_H_INCLUDED */ + + + +// md5sum: 84d8155528b06c9aa902e8f06649385f - MidiPort.h =css= 20030102 diff --git a/src/midiio/include/Options.h b/src/midiio/include/Options.h new file mode 100644 index 0000000..71754fb --- /dev/null +++ b/src/midiio/include/Options.h @@ -0,0 +1,106 @@ +// +// Copyright 1998-2000 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sun Apr 5 13:07:18 PDT 1998 +// Last Modified: Fri Jan 15 07:24:00 PST 1999 +// Last Modified: Sat Mar 27 18:17:59 PST 1999 +// Last Modified: Thu Apr 13 14:02:52 PDT 2000 (added 2nd define function) +// Last Modified: Fri May 5 17:57:50 PDT 2000 (added --options suppression) +// Filename: ...sig/maint/code/base/Options/Options.h +// Web Address: http://sig.sapp.org/include/sigBase/Options.h +// Documentation: http://sig.sapp.org/doc/classes/Options +// Syntax: C++ +// +// Description: Handles command-line options in a graceful manner. +// + +#ifndef _OPTIONS_H_INCLUDED +#define _OPTIONS_H_INCLUDED + +#include "Array.h" + +class option_list; +class option_register; + + +class Options { + public: + Options (void); + Options (int argc, char** argv); + ~Options (); + + int argc (void) const; + char** argv (void) const; + void define (const char* aDefinition); + void define (const char* aDefinition, + const char* description); + char* getArg (int index); + char* getArgument (int index); + int getArgCount (void); + int getArgumentCount (void); + int getBoolean (const char* optionName); + const char* getCommand (void); + const char* getCommandLine (void); + const char* getString (void); + const char* getDefinition (const char* optionName); + double getDouble (const char* optionName); + char getFlag (void); + float getFloat (const char* optionName); + int getInt (const char* optionName); + int getInteger (const char* optionName); + const char* getString (const char* optionName); + char getType (const char* optionName); + int optionsArg (void); + void print (void); + void process (int error_check = 1, int suppress = 0); + void process (int argc, char** argv, + int error_check = 1, + int suppress = 0); + void reset (void); + void verify (int argc, char** argv, + int error_check = 1, + int suppress = 0); + void verify (int error_check = 1, + int suppress = 0); + void setFlag (char aFlag); + void setModified (const char* optionName, + const char* optionValue); + void setOptions (int argc, char** argv); + + protected: + int options_error_check; // for verify command + int gargc; + char** gargv; + char* commandString; + char optionFlag; + Array<char*> argument; + Array<option_register*> optionRegister; + Array<option_list*> optionList; + int processedQ; + int sortedQ; + int suppressQ; // prevent the --options option + int optionsArgument; // indicates --options present + + int getRegIndex (const char* optionName); + int optionQ (const char* aString, int& argp); + void sortOptionNames (void); + int storeOption (int gargp, int& position, + int& running); + +}; + +#define OPTION_BOOLEAN_TYPE 'b' +#define OPTION_CHAR_TYPE 'c' +#define OPTION_DOUBLE_TYPE 'd' +#define OPTION_FLOAT_TYPE 'f' +#define OPTION_INT_TYPE 'i' +#define OPTION_STRING_TYPE 's' +#define OPTION_UNKNOWN_TYPE 'x' + + + +#endif /* _OPTIONS_H_INCLUDED */ + + + +// md5sum: c59d297a8081cb48f61b534484819f48 - Options.h =css= 20030102 diff --git a/src/midiio/include/Options_private.h b/src/midiio/include/Options_private.h new file mode 100644 index 0000000..8349d55 --- /dev/null +++ b/src/midiio/include/Options_private.h @@ -0,0 +1,73 @@ +// +// Copyright 1998-1999 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sun Apr 5 13:07:18 PDT 1998 +// Last Modified: Sun Jan 10 05:44:48 PST 1999 +// Filename: ...sig/maint/code/base/Options/Options_private.h +// Web Address: http://sig.sapp.org/include/sigBase/Options_private.h +// Syntax: C++ +// +// Description: A private function for use in the Options class. +// + +#ifndef _OPTIONS_PRIVATE_H_INCLUDED +#define _OPTIONS_PRIVATE_H_INCLUDED + + +class option_register { + public: + option_register (void); + option_register (const char* aDefinition, char aType, + const char* aDefaultOption, + const char* aModifiedOption); + ~option_register (); + void clearModified (void); + const char* getDefinition (void); + const char* getDefault (void); + const char* getOption (void); + const char* getModified (void); + int getModifiedQ (void); + char getType (void); + void reset (void); + void setDefault (const char* aString); + void setDefinition (const char* aString); + void setModified (const char* aString); + void setType (char aType); + + protected: + char* definition; + char* defaultOption; + char* modifiedOption; + char type; + +}; + + +///////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// + + +class option_list { + public: + option_list (void); + option_list (const char* optionName, int anIndex); + ~option_list (); + + int getIndex (void); + const char* getName (void); + void setName (const char* aString); + void setIndex (int anIndex); + + protected: + char* name; + int index; + +}; + + + +#endif /* _OPTIONS_PRIVATE_H_INCLUDED */ + + + +// md5sum: b440ad2158e9921d0e31463a8c3e1ae0 - Options_private.h =css= 20030102 diff --git a/src/midiio/include/Sequencer_alsa.h b/src/midiio/include/Sequencer_alsa.h new file mode 100644 index 0000000..3227f5e --- /dev/null +++ b/src/midiio/include/Sequencer_alsa.h @@ -0,0 +1,139 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Thu May 11 21:06:21 PDT 2000 +// Last Modified: Sat Oct 13 14:50:04 PDT 2001 (updated for ALSA 0.9 interface) +// Filename: ...sig/maint/code/control/MidiOutPort/Sequencer_alsa.h +// Web Address: http://sig.sapp.org/include/sig/Sequencer_alsa.h +// Syntax: C++ +// +// Description: Basic MIDI input/output functionality for the +// Linux ALSA midi device /dev/snd/midiXX. This class +// is inherited by the classes MidiInPort_alsa and +// MidiOutPort_alsa. +// +// to get information of status a alsa hardware & software +// cat /proc/asound/version +// cat /proc/asound/devices +// cat /proc/asound/card0/midi0 +// + +#ifndef _SEQUENCER_ALSA_H_INCLUDED +#define _SEQUENCER_ALSA_H_INCLUDED + +#include <iostream> + +#ifdef ALSA + +#include <alsa/asoundlib.h> +#include "Collection.h" + +#define MIDI_EXTERNAL (1) +#define MIDI_INTERNAL (2) + +typedef unsigned char uchar; + + +class Sequencer_alsa { + public: + Sequencer_alsa (int autoOpen = 1); + ~Sequencer_alsa (); + + void close (void); + void closeInput (int index); + void closeOutput (int index); + void displayInputs (std::ostream& out = std::cout, + char* initial = "\t"); + void displayOutputs (std::ostream& out = std::cout, + char* initial = "\t"); + static const char* getInputName (int aDevice); + static const char* getOutputName (int aDevice); + static int getNumInputs (void); + static int getNumOutputs (void); + int is_open (int mode, int index); + int is_open_in (int index); + int is_open_out (int index); + int open (int direction, int index); + int openInput (int index); + int openOutput (int index); + void read (int dev, uchar* buf, int count); + void rebuildInfoDatabase (void); + int write (int aDevice, int aByte); + int write (int aDevice, uchar* bytes, int count); + int write (int aDevice, char* bytes, int count); + int write (int aDevice, int* bytes, int count); + + int getInCardValue (int aDevice) const; + int getOutCardValue (int aDevice) const; + protected: + static int class_count; // number of existing classes using + static int indevcount; // number of MIDI input devices + static int outdevcount; // number of MIDI output devices + static int initialized; // for starting buileinfodatabase + + static Collection<snd_rawmidi_t*> Sequencer_alsa::rawmidi_in; + static Collection<snd_rawmidi_t*> Sequencer_alsa::rawmidi_out; + static Collection<int> Sequencer_alsa::midiincard; + static Collection<int> Sequencer_alsa::midioutcard; + static Collection<int> Sequencer_alsa::midiindevice; + static Collection<int> Sequencer_alsa::midioutdevice; + static Collection<char*> Sequencer_alsa::midiinname; + static Collection<char*> Sequencer_alsa::midioutname; + + private: + static void buildInfoDatabase (void); + static void getPossibleMidiStreams(Collection<int>& cards, + Collection<int>& devices); + int getInDeviceValue (int aDevice) const; + int getInputType (int aDevice) const; + int getOutDeviceValue (int aDevice) const; + int getOutputType (int aDevice) const; + void removeInfoDatabase (void); + + + friend void *interpretMidiInputStreamPrivateALSA(void * x); + +}; + +#else /* ALSA is not defined */ + +typedef unsigned char uchar; + +class Sequencer_alsa { + public: + Sequencer_alsa (int autoOpen = 1) { } + ~Sequencer_alsa () { } + + void close (void) { }; + void displayInputs (std::ostream& out = std::cout, + char* initial = "\t") + { out << initial << "NONE\n"; } + void displayOutputs (std::ostream& out = std::cout, + char* initial = "\t") + { out << initial << "NONE\n"; } + static const char* getInputName (int aDevice) { return ""; } + static const char* getOutputName (int aDevice) { return ""; } + static int getNumInputs (void) { return 0; } + static int getNumOutputs (void) { return 0; } + int is_open (int mode, int index) { return 0; } + int is_open_in (int index) { return 0; } + int is_open_out (int index) { return 0; } + int open (void) { return 0; } + void read (int dev, uchar* buf, int count) { } + void rebuildInfoDatabase (void) { } + int write (int aDevice, int aByte) { return 0; } + int write (int aDevice, uchar* bytes, int count) { return 0; } + int write (int aDevice, char* bytes, int count) { return 0; } + int write (int aDevice, int* bytes, int count) { return 0; } + int getInCardValue (int aDevice) const { return 0; } + int getOutCardValue (int aDevice) const { return 0; } + +}; + + +#endif /* ALSA */ + + +#endif /* _SEQUENCER_ALSA_H_INCLUDED */ + + +// md5sum: 6147020b0646fca8245f653505308949 - Sequencer_alsa.h =css= 20030102 diff --git a/src/midiio/include/Sequencer_oss.h b/src/midiio/include/Sequencer_oss.h new file mode 100644 index 0000000..5f269a7 --- /dev/null +++ b/src/midiio/include/Sequencer_oss.h @@ -0,0 +1,92 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sun Jan 3 21:02:02 PST 1999 +// Last Modified: Sat Jan 30 14:11:18 PST 1999 +// Last Modified: Wed May 10 17:00:11 PDT 2000 (name change from _oss to _oss) +// Filename: ...sig/maint/code/control/MidiOutPort/Sequencer_oss.h +// Web Address: http://sig.sapp.org/include/sig/Sequencer_oss.h +// Syntax: C++ +// +// Description: Basic MIDI input/output functionality for the +// Linux OSS midi device /dev/sequencer. This class +// is inherited by the classes MidiInPort_oss and +// MidiOutPort_oss. +// + +#ifndef _SEQUENCER_OSS_H_INCLUDED +#define _SEQUENCER_OSS_H_INCLUDED + +#include <iostream> + +#define MIDI_EXTERNAL (1) +#define MIDI_INTERNAL (2) + +typedef unsigned char uchar; + + +class Sequencer_oss { + public: + Sequencer_oss (int autoOpen = 1); + ~Sequencer_oss (); + + void close (void); + void displayInputs (std::ostream& out = std::cout, + char* initial = "\t"); + void displayOutputs (std::ostream& out = std::cout, + char* initial = "\t"); + static int getNumInputs (void); + static int getNumOutputs (void); + static const char* getInputName (int aDevice); + static const char* getOutputName (int aDevice); + int is_open (void); + int open (void); + void read (uchar* buf, uchar* dev, int count); + void rawread (uchar* buf, int packetCount); + void rebuildInfoDatabase (void); + int write (int aDevice, int aByte); + int write (int aDevice, uchar* bytes, int count); + int write (int aDevice, char* bytes, int count); + int write (int aDevice, int* bytes, int count); + + protected: + static const char* sequencer; // name of sequencer device + static int sequencer_fd; // sequencer file descriptor + static int class_count; // number of existing classes using + static uchar midi_write_packet[4]; // for writing MIDI bytes out + static uchar midi_read_packet[4]; // for reading MIDI bytes out + static uchar synth_write_message[8]; // for writing to internal seq + static int indevcount; // number of MIDI input devices + static int outdevcount; // number of MIDI output devices + static char** indevnames; // MIDI input device names + static char** outdevnames; // MIDI output device names + static int* indevnum; // total number of MIDI inputs + static int* outdevnum; // total number of MIDI outputs + static int* indevtype; // 1 = External, 2 = Internal + static int* outdevtype; // 1 = External, 2 = Internal + static uchar synth_message_buffer[1024]; // hold bytes for synth dev + static int synth_message_buffer_count; // count of synth buffer + static int synth_message_bytes_expected; // expected count of synth + static int synth_message_curr_device; // for keeping track of dev + static int initialized; // for starting buileinfodatabase + + private: + static void buildInfoDatabase (void); + static int getFd (void); + int getInDeviceValue (int aDevice) const; + int getInputType (int aDevice) const; + int getOutDeviceValue (int aDevice) const; + int getOutputType (int aDevice) const; + void removeInfoDatabase (void); + void setFd (int anFd); + + int writeInternal(int aDevice, int aByte); + int transmitMessageToInternalSynth(void); + int transmitVoiceMessage(void); + int transmitCommonMessage(void); +}; + + +#endif /* _SEQUENCER_OSS_H_INCLUDED */ + + +// md5sum: 1df08cd946c609b9b42aadbc96b7a296 - Sequencer_oss.h =css= 20030102 diff --git a/src/midiio/include/SigTimer.h b/src/midiio/include/SigTimer.h new file mode 100644 index 0000000..e93345c --- /dev/null +++ b/src/midiio/include/SigTimer.h @@ -0,0 +1,104 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Thanks to: Erik Neuenschwander <erikn@leland.stanford.edu> +// for Windows 95 assembly code for Pentium clock cycles. +// Ozgur Izmirli <ozgur@ccrma.stanford.edu> +// for concept of periodic timer. +// Creation Date: Mon Oct 13 11:34:57 GMT-0800 1997 +// Last Modified: Tue Feb 10 21:05:19 GMT-0800 1998 +// Last Modified: Sat Sep 19 15:56:48 PDT 1998 +// Last Modified: Mon Feb 22 04:44:25 PST 1999 +// Last Modified: Sun Nov 28 12:39:39 PST 1999 (added adjustPeriod()) +// Filename: .../sig/code/control/SigTimer/SigTimer.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/SigTimer.h +// Syntax: C++ +// +// Description: This class can only be used on Motorola Pentinum 75 Mhz +// chips or better because the timing information is +// extracted from the clock cycle count from a register +// on the CPU itself. This class will estimate the +// speed of the computer, but it would be better if there +// was a way of finding out the speed from some function. +// This class is used primarily for timing of MIDI input +// and output at a millisecond resolution. +// +// Interesting: http://www.datasilicon.nl/I786/timer_1.htm +// + +#ifndef _SIGTIMER_H_INCLUDED +#define _SIGTIMER_H_INCLUDED + + +#ifdef VISUAL + #include <wtypes.h> + typedef LONGLONG int64bits; +#else + typedef long long int int64bits; + #include <unistd.h> /* for millisleep function */ +#endif + + +class SigTimer { + public: + SigTimer (void); + SigTimer (int aSpeed); + SigTimer (SigTimer& aTimer); + ~SigTimer (); + + void adjustPeriod (double periodDelta); + int expired (void) const; + double getPeriod (void) const; + double getPeriodCount (void) const; + double getTempo (void) const; + int getTicksPerSecond (void) const; + int getTime (void) const; + double getTimeInSeconds (void) const; + int getTimeInTicks (void) const; + void reset (void); + void setPeriod (double aPeriod); + void setTempo (double beatsPerMinute); + void setPeriodCount (double aCount); + void setTicksPerSecond (int aTickRate); + void start (void); + void sync (SigTimer& aTimer); + void update (void); + void update (int periodCount); + + // The following functions are semi-private. They do not have + // anything to do with timing themselves, but are a by-product + // of the timer implementation. They are useful, so they have + // been left public; however, they should be used judiciously. + static int getCpuSpeed (void); + static int measureCpuSpeed (int quantize = 0); + static void setCpuSpeed (int aSpeed); + + // the following function is hardware specific to Intel Pentium + // computers with a processor speed of at least 75 MHz. + // This function is the only non-portable function in this + // class, but everything else is based on it. + static int64bits clockCycles (void); + + protected: + static int64bits globalOffset; + static int cpuSpeed; + + int64bits offset; + int ticksPerSecond; + double period; + + // protected functions + double getFactor (void) const; + +}; + + +// The following function is mostly for Linux: +void millisleep(int milliseconds); +void millisleep(float milliseconds); + + +#endif /* _SIGTIMER_H_INCLUDED */ + + + +// md5sum: 601fa3caae4e3bacc4e6fb87f545c86b - SigTimer.h =css= 20030102 diff --git a/src/midiio/include/Voice.h b/src/midiio/include/Voice.h new file mode 100644 index 0000000..3cddf9f --- /dev/null +++ b/src/midiio/include/Voice.h @@ -0,0 +1,70 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sun Oct 11 18:21:46 PDT 1998 +// Last Modified: Sun Oct 11 18:33:04 PDT 1998 +// Filename: ...sig/maint/code/control/Voice/Voice.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/Voice.h +// Syntax: C++ +// +// Description: The Voice class is a MIDI output class which keeps +// track of the last note played in to it. If the last +// note was not turned off when a new note is played, +// then the old note will be turned off before the +// new note is played. +// + +#ifndef _VOICE_H_INCLUDED +#define _VOICE_H_INCLUDED + +#include "MidiOutput.h" + +class Voice : public MidiOutput { + public: + Voice (int aChannel); + Voice (const Voice& aVoice); + Voice (void); + ~Voice (); + + void cont (int controler, int data); + int getChan (void) const; + int getChannel (void) const; + int getKey (void) const; + int getKeynum (void) const; + int getOffTime (void) const; + int getOnTime (void) const; + int getVel (void) const; + int getVelocity (void) const; + void off (void); + void pc (int aTimbre); + void play (int aChannel, int aKeyno, int aVelocity); + void play (int aKeyno, int aVelocity); + void play (void); + void setChan (int aChannel); + void setChannel (int aChannel); + void setKey (int aKeyno); + void setKeynum (int aKeyno); + void setVel (int aVelocity); + void setVelocity (int aVelocity); + int status (void) const; + void sustain (int aStatus); + + protected: + int chan; // the current channel number + int key; // the current key number + int vel; // the current velocity value + + int onTime; // last note on message sent + int offTime; // last note off message sent + + int oldChan; // last channel played on + int oldKey; // last key to be played + int oldVel; // last velocity of last key + + static SigTimer timer; // for recording on/off times +}; + + +#endif /* _VOICE_H_INCLUDED */ + + +// md5sum: 8a5495ecc10d42be6b1832492e107723 - Voice.h =css= 20030102 diff --git a/src/midiio/include/gminstruments.h b/src/midiio/include/gminstruments.h new file mode 100644 index 0000000..0e567da --- /dev/null +++ b/src/midiio/include/gminstruments.h @@ -0,0 +1,251 @@ +// +// Copyright 1997-2000 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> (from 18Dec1997) +// Creation Date: 26 December 1997 +// Last Modified: Tue Apr 18 11:38:28 PDT 2000 (put CH_X defines here) +// Filename: ...sig/include/sigInfo/gminstruments.h +// Web Address: http://sig.sapp.org/include/sigInfo/gminstruments.h +// Syntax: C +// +// Description: Defines names for instruments as arranged in General MIDI. +// + +#ifndef _GMINSTRUMENTS_H_INCLUDED +#define _GMINSTRUMENTS_H_INCLUDED + +#define CH_1 0 +#define CH_2 1 +#define CH_3 2 +#define CH_4 3 +#define CH_5 4 +#define CH_6 5 +#define CH_7 6 +#define CH_8 7 +#define CH_9 8 +#define CH_10 9 +#define CH_11 10 +#define CH_12 11 +#define CH_13 12 +#define CH_14 13 +#define CH_15 14 +#define CH_16 15 + +#define GM_PIANO(X) (0+(X)) +#define GM_ACOUSTIC_GRAND_PIANO (0) +#define GM_BRIGHT_ACOUSTIC_PIANO (1) +#define GM_ELECTRIC_GRAND_PIANO (1) +#define GM_HONKYTONK_PIANO (2) +#define GM_HONKY_TONK_PIANO (3) +#define GM_ELECTRIC_PIANO_1 (4) +#define GM_ELECTRIC_PIANO_2 (5) +#define GM_HARPSICHORD (6) +#define GM_CLAVI (7) + +#define GM_CHROMATIC(X) (8+(X)) +#define GM_CELESTA (8) +#define GM_GLOCKENSPIEL (9) +#define GM_MUSIC_BOX (10) +#define GM_VIBRAPHONE (11) +#define GM_MARIMBA (12) +#define GM_XYLOPHONE (13) +#define GM_TUBULAR_BELLS (14) +#define GM_DULCIMER (15) + +#define GM_ORGAN(X) (16+(X)) +#define GM_DRAWBAR_ORGAN (16) +#define GM_PERCUSSIVE_ORGAN (17) +#define GM_ROCK_ORGAN (18) +#define GM_CHURCH_ORGAN (19) +#define GM_REED_ORGAN (20) +#define GM_ACCORDION (21) +#define GM_HARMONICA (22) +#define GM_TANGO_ACCORDION (23) + +#define GM_GUITAR(X) (24+(X)) +#define GM_ACOUSTIC_GUITAR_NYLON (24) +#define GM_ACOUSTIC_GUITAR_STEEL (25) +#define GM_ELECTRIC_GUITAR_JAZZ (26) +#define GM_ELECTRIC_GUITAR_CLEAN (27) +#define GM_ELECTRIC_GUITAR_MUTED (28) +#define GM_OVERDRIVEN_GUITAR (29) +#define GM_DISTORTION_GUITAR (30) +#define GM_GUITAR_HARMONICS (31) + +#define GM_BASS(X) (32+(X)) +#define GM_ACOUSTIC_BASS (32) +#define GM_ELECTRIC_BASS_FINGER (33) +#define GM_ELECTRIC_BASS_PICK (34) +#define GM_FRETLESS_BASS (35) +#define GM_SLAP_BASS_1 (36) +#define GM_SLAP_BASS_2 (37) +#define GM_SYNTH_BASS_1 (38) +#define GM_SYNTH_BASS_2 (39) + +#define GM_STRINGS(X) (40+(X)) +#define GM_VIOLIN (40) +#define GM_VIOLA (41) +#define GM_CELLO (42) +#define GM_CONTRABASS (43) +#define GM_TREMOLO_STRINGS (44) +#define GM_PIZZACATO_STRINGS (45) +#define GM_ORCHESTRAL_HARP (46) +#define GM_TIMPANI (47) + +#define GM_ENSEMBLE(X) (48+(X)) +#define GM_STRING_ENSEMBLE_1 (48) +#define GM_STRING_ENSEMBLE_2 (49) +#define GM_SYNTHSTRINGS_1 (50) +#define GM_SYNTHSTRINGS_2 (51) +#define GM_CHOIR_AAHS (52) +#define GM_VOICE_OOHS (53) +#define GM_SYNTH_VOICE (54) +#define GM_ORCHESTRA_HIT (55) + +#define GM_BRASS(X) (56+(X)) +#define GM_TRUMPET (56) +#define GM_TROMBONE (57) +#define GM_TUBA (58) +#define GM_MUTED_TRUMPED (59) +#define GM_FRENCH_HORN (60) +#define GM_BRASS_SECTION (61) +#define GM_SYNTHBRASS_1 (62) +#define GM_SYNTHBRASS_2 (63) + +#define GM_REED(X) (64+(X)) +#define GM_SOPRANO_SAX (64) +#define GM_ALTO_SAX (65) +#define GM_TENOR_SAX (66) +#define GM_BARITONE_SAX (67) +#define GM_OBOE (68) +#define GM_ENGLISH_HORN (69) +#define GM_BASSOON (70) +#define GM_CLARINET (71) + +#define GM_PIPE(X) (72+(X)) +#define GM_PICCOLO (72) +#define GM_FLUTE (73) +#define GM_RECORDER (74) +#define GM_PAN_FLUTE (75) +#define GM_BLOWN_BOTTLE (76) +#define GM_SHAKUHACHI (77) +#define GM_WHISTLE (78) +#define GM_OCARINA (79) + +#define GM_LEAD(X) (80+(X)) +#define GM_LEAD_SQUARE (80) +#define GM_LEAD_SAWTOOTH (81) +#define GM_LEAD_CALLIOPE (82) +#define GM_LEAD_CHIFF (83) +#define GM_LEAD_CHARANG (84) +#define GM_LEAD_VOICE (85) +#define GM_LEAD_FIFTHS (86) +#define GM_LEAD_BASS (87) + +#define GM_PAD(X) (88+(X)) +#define GM_PAD_NEW_AGE (88) +#define GM_PAD_WARM (89) +#define GM_PAD_POLYSYNTH (90) +#define GM_PAD_CHOIR (91) +#define GM_PAD_BOWED (92) +#define GM_PAD_METALLIC (93) +#define GM_PAD_HALO (94) +#define GM_PAD_SWEEP (95) + +#define GM_FX(X) (96+(X)) +#define GM_FX_TRAIN (96) +#define GM_FX_SOUNDTRACK (97) +#define GM_FX_CRYSTAL (98) +#define GM_FX_ATMOSPHERE (99) +#define GM_FX_BRIGHTNESS (100) +#define GM_FX_GOBLINS (101) +#define GM_FX_ECHOES (102) +#define GM_FX_SCI_FI (103) + +#define GM_ETHNIC(X) (104+(X)) +#define GM_SITAR (104) +#define GM_BANJO (105) +#define GM_SHAMISEN (106) +#define GM_KOTO (107) +#define GM_KALIMBA (108) +#define GM_BAGPIPE (109) +#define GM_FIDDLE (110) +#define GM_SHANAI (111) + +#define GM_PERCUSSION(X) (112+(X)) +#define GM_TINKLE_BELL (112) +#define GM_AGOGO (113) +#define GM_STEEL_DRUMS (114) +#define GM_WOODBLOCKS (115) +#define GM_TAIKO_DRUM (116) +#define GM_MELODIC_DRUM (117) +#define GM_SYNTH_DRUM (118) +#define GM_REVERSE_CYMBAL (119) + +#define GM_SOUNDEFFECT(X) (120+(X)) +#define GM_GUITAR_FRET_NOISE (120) +#define GM_BREATH_NOISE (121) +#define GM_SEASHORE (122) +#define GM_BIRD_TWEET (123) +#define GM_TELEPHONE_RING (124) +#define GM_HELICOPTER (125) +#define GM_APPLAUSE (126) +#define GM_GUNSHOT (127) + +// +// Percussion instruments on channel 10 +// + +#define GM_ACOUSTIC_BASS_DRUM (35) +#define GM_BASS_DRUM_1 (36) +#define GM_SIDE_STICK (37) +#define GM_ACOUSTIC_SNARE (38) +#define GM_HAND_CLAP (39) +#define GM_ELECTRIC_SNARE (40) +#define GM_LOW_FLOOR_TOM (41) +#define GM_CLOSED_HI_HAT (42) +#define GM_HIGH_FLOOR_TOM (43) +#define GM_PEDAL_HI_HAT (44) +#define GM_LOW_TOM (45) +#define GM_OPEN_HI_HAT (46) +#define GM_LOW_MID_TOM (47) +#define GM_HIGH_MID_TOM (48) +#define GM_CRASH_CYMBAL_1 (49) +#define GM_HIGH_TOM (50) +#define GM_RIDE_CYMBAL_1 (51) +#define GM_CHINESE_CYMBAL (52) +#define GM_RIDE_BELL (53) +#define GM_TAMBOURINE (54) +#define GM_SPLASH_CYMBAL (55) +#define GM_COWBELL (56) +#define GM_CRASH_CYMBAL_2 (57) +#define GM_VIBRASLAP (58) +#define GM_RIDE_CYMBAL_2 (59) +#define GM_HI_BONGO (60) +#define GM_LOW_BONGO (61) +#define GM_MUTE_HI_CONGA (62) +#define GM_OPEN_HI_CONGA (63) +#define GM_LOW_CONGA (64) +#define GM_HIGH_TIMBALE (65) +#define GM_LOW_TIMBALE (66) +#define GM_HIGH_AGOGO (67) +#define GM_LOW_AGOGO (68) +#define GM_CABASA (69) +#define GM_MARACAS (70) +#define GM_SHORT_WHISTLE (71) +#define GM_LONG_WHISTLE (72) +#define GM_SHORT_GUIRO (73) +#define GM_LONG_GUIRO (74) +#define GM_CLAVES (75) +#define GM_HI_WOOD_BLOCK (76) +#define GM_LOW_WOOD_BLOCK (77) +#define GM_MUTE_CUICA (78) +#define GM_OPEN_CUICA (79) +#define GM_MUTE_TRIANGLE (80) +#define GM_OPEN_TRIANGLE (81) + + +#endif /* _GMINSTRUMENTS_H_INCLUDED */ + + + +// md5sum: 6299d04892a6899533b9164aa9e1a874 - gminstruments.h =css= 20030102 diff --git a/src/midiio/include/midichannels.h b/src/midiio/include/midichannels.h new file mode 100644 index 0000000..4526813 --- /dev/null +++ b/src/midiio/include/midichannels.h @@ -0,0 +1,42 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: 21 December 1997 +// Last Modified: Wed Feb 11 22:49:59 GMT-0800 1998 +// Filename: ...sig/code/control/misc/midichannels.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/midichannels.h +// Syntax: C++ +// +// Description: Offset by 1 MIDI channel names. +// + +#ifndef _MIDICHANNELS_H_INCLUDED +#define _MIDICHANNELS_H_INCLUDED + +/* temporarily changed : + +// channel defines: offset from 0 +#define CH_1 (0x00) +#define CH_2 (0x01) +#define CH_3 (0x02) +#define CH_4 (0x03) +#define CH_5 (0x04) +#define CH_6 (0x05) +#define CH_7 (0x06) +#define CH_8 (0x07) +#define CH_9 (0x08) +#define CH_10 (0x09) +#define CH_11 (0x0a) +#define CH_12 (0x0b) +#define CH_13 (0x0c) +#define CH_14 (0x0d) +#define CH_15 (0x0e) +#define CH_16 (0x0f) + +*/ + +#endif /* _MIDICHANNELS_H_INCLUDED */ + + + + +// md5sum: 5267399f7ff90a6ea3ad2dc132afae3e - midichannels.h =css= 20030102 diff --git a/src/midiio/include/mididefines.h b/src/midiio/include/mididefines.h new file mode 100644 index 0000000..4161c2f --- /dev/null +++ b/src/midiio/include/mididefines.h @@ -0,0 +1,34 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: 21 December 1997 +// Last Modified: Wed Feb 11 22:49:59 GMT-0800 1998 +// Filename: ...sig/code/control/misc/mididefines.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/mididefines.h +// Syntax: C++ +// +// Description: Collection of all of the MIDI convienience defines. +// + +#ifndef _MIDIDEFINES_H_INCLUDED +#define _MIDIDEFINES_H_INCLUDED + + +// include channel defines +#include "midichannels.h" + + +// include note name defines +#include "notenames.h" + + +// include General MIDI instrument names +#include "gminstruments.h" + + + +#endif /* _MIDIDEFINES_H_INCLUDED */ + + + + +// md5sum: 0f081c8e0b386a11e448b6088bfcd489 - mididefines.h =css= 20030102 diff --git a/src/midiio/include/midiiolib.h b/src/midiio/include/midiiolib.h new file mode 100644 index 0000000..17d0430 --- /dev/null +++ b/src/midiio/include/midiiolib.h @@ -0,0 +1,57 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Sat Nov 2 20:20:24 PST 2002 +// Last Modified: Thu Jan 2 18:51:20 PST 2003 (changed name from midio.h) +// Filename: ...sig/code/misc/midiiolib.h +// Web Address: http://sig.sapp.org/include/sig/midiiolib.h +// Syntax: C++ +// +// Description: Includes all of the header files for using the midiio +// Library. +// + +#ifndef _MIDIIOLIB_H_INCLUDED +#define _MIDIIOLIB_H_INCLUDED + +#include "Array.h" +#include "CircularBuffer.h" +#include "Collection.h" +#include "FileIO.h" +#include "gminstruments.h" +#include "midichannels.h" +#include "mididefines.h" +#include "MidiFile.h" +#include "MidiFileWrite.h" +#include "MidiInPort_alsa05.h" +#include "MidiInPort_alsa.h" +#include "MidiInPort.h" +#include "MidiInPort_linux.h" +#include "MidiInPort_oss.h" +#include "MidiInPort_unsupported.h" +#include "MidiInPort_visual.h" +#include "MidiInput.h" +#include "MidiIO.h" +#include "MidiMessage.h" +#include "MidiOutPort_alsa.h" +#include "MidiOutPort.h" +#include "MidiOutPort_linux.h" +#include "MidiOutPort_oss.h" +#include "MidiOutPort_unsupported.h" +#include "MidiOutPort_visual.h" +#include "MidiOutput.h" +#include "MidiPort.h" +#include "notenames.h" +#include "Options.h" +#include "Options_private.h" +#include "Sequencer_alsa.h" +#include "Sequencer_oss.h" +#include "sigConfiguration.h" +#include "SigTimer.h" +#include "Voice.h" + + +#endif /* _MIDIIO_H_INCLUDED */ + + + +// md5sum: b389c20c620865344d827a88a0fb048d - midiiolib.h =css= 20030102 diff --git a/src/midiio/include/notenames.h b/src/midiio/include/notenames.h new file mode 100644 index 0000000..ce9d505 --- /dev/null +++ b/src/midiio/include/notenames.h @@ -0,0 +1,219 @@ +// +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> (from 18Dec1997) +// Creation Date: 26 December 1997 +// Last Modified: 26 December 1997 +// Filename: ...sig/code/control/misc/notenames.h +// Web Address: http://www-ccrma.stanford.edu/~craig/improv/include/notenames.h +// Syntax: C +// +// Description: Defines for pitch names of midi key numbers +// + +#ifndef _NOTENAMES_H_INCLUDED +#define _NOTENAMES_H_INCLUDED + +#define C00 (0) +#define Cs00 (1) +#define Db00 (1) +#define D00 (2) +#define Ds00 (3) +#define Eb00 (3) +#define E00 (4) +#define F00 (5) +#define Fs00 (6) +#define Gb00 (6) +#define G00 (7) +#define Gs00 (8) +#define Ab00 (8) +#define A00 (9) +#define As00 (10) +#define Bb00 (10) +#define B00 (11) + +#define C0 (12) +#define Cs0 (13) +#define Db0 (13) +#define D0 (14) +#define Ds0 (15) +#define Eb0 (15) +#define E0 (16) +#define F0 (17) +#define Fs0 (18) +#define Gb0 (18) +#define G0 (19) +#define Gs0 (20) +#define Ab0 (20) +#define A0 (21) +#define As0 (22) +#define Bb0 (22) + +/* + * Note that the following symbol B0 is used in + * unix in the file /usr/include/termios.h also as + * a symbol, so It is disabled for now in this file. + * termios.h is need in Unix for the KeyboardInput.h file + */ + +// #define B0 (23) + +#define C1 (24) +#define Cs1 (25) +#define Db1 (25) +#define D1 (26) +#define Ds1 (27) +#define Eb1 (27) +#define E1 (28) +#define F1 (29) +#define Fs1 (30) +#define Gb1 (30) +#define G1 (31) +#define Gs1 (32) +#define Ab1 (32) +#define A1 (33) +#define As1 (34) +#define Bb1 (34) +#define B1 (35) + +#define C2 (36) +#define Cs2 (37) +#define Db2 (37) +#define D2 (38) +#define Ds2 (39) +#define Eb2 (39) +#define E2 (40) +#define F2 (41) +#define Fs2 (42) +#define Gb2 (42) +#define G2 (43) +#define Gs2 (44) +#define Ab2 (44) +#define A2 (45) +#define As2 (46) +#define Bb2 (46) +#define B2 (47) + +#define C3 (48) +#define Cs3 (49) +#define Db3 (49) +#define D3 (50) +#define Ds3 (51) +#define Eb3 (51) +#define E3 (52) +#define F3 (53) +#define Fs3 (54) +#define Gb3 (54) +#define G3 (55) +#define Gs3 (56) +#define Ab3 (56) +#define A3 (57) +#define As3 (58) +#define Bb3 (58) +#define B3 (59) + +#define C4 (60) +#define Cs4 (61) +#define Db4 (61) +#define D4 (62) +#define Ds4 (63) +#define Eb4 (63) +#define E4 (64) +#define F4 (65) +#define Fs4 (66) +#define Gb4 (66) +#define G4 (67) +#define Gs4 (68) +#define Ab4 (68) +#define A4 (69) +#define As4 (70) +#define Bb4 (70) +#define B4 (71) + +#define C5 (72) +#define Cs5 (73) +#define Db5 (73) +#define D5 (74) +#define Ds5 (75) +#define Eb5 (75) +#define E5 (76) +#define F5 (77) +#define Fs5 (78) +#define Gb5 (78) +#define G5 (79) +#define Gs5 (80) +#define Ab5 (81) +#define A5 (81) +#define As5 (82) +#define Bb5 (82) +#define B5 (83) + +#define C6 (84) +#define Cs6 (85) +#define Db6 (85) +#define D6 (86) +#define Ds6 (87) +#define Eb6 (87) +#define E6 (88) +#define F6 (89) +#define Fs6 (90) +#define Gb6 (90) +#define G6 (91) +#define Gs6 (92) +#define Ab6 (92) +#define A6 (93) +#define As6 (94) +#define Bb6 (94) +#define B6 (95) + +#define C7 (96) +#define Cs7 (97) +#define Db7 (97) +#define D7 (98) +#define Ds7 (99) +#define Eb7 (99) +#define E7 (100) +#define F7 (101) +#define Fs7 (102) +#define Gb7 (102) +#define G7 (103) +#define Gs7 (104) +#define Ab7 (104) +#define A7 (105) +#define As7 (106) +#define Bb7 (106) +#define B7 (107) + +#define C8 (108) +#define Cs8 (109) +#define Db8 (109) +#define D8 (110) +#define Ds8 (111) +#define Eb8 (111) +#define E8 (112) +#define F8 (113) +#define Fs8 (114) +#define Gb8 (114) +#define G8 (115) +#define Gs8 (116) +#define Ab8 (116) +#define A8 (117) +#define As8 (118) +#define Bb8 (118) +#define B8 (119) + +#define C9 (120) +#define Cs9 (121) +#define Db9 (121) +#define D9 (122) +#define Ds9 (123) +#define Eb9 (123) +#define E9 (124) +#define F9 (125) +#define Fs9 (126) +#define Gb9 (126) +#define G9 (127) + + +#endif /* _NOTENAMES_H_INCLUDED */ + + +// md5sum: c0f727163d32e04212a0ce5c8b6c4a6f - notenames.h =css= 20030102 diff --git a/src/midiio/include/sigConfiguration.h b/src/midiio/include/sigConfiguration.h new file mode 100644 index 0000000..b1e5f17 --- /dev/null +++ b/src/midiio/include/sigConfiguration.h @@ -0,0 +1,100 @@ +// +// Copyright 1997 by Craig Stuart Sapp, All Rights Reserved. +// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu> +// Creation Date: Mon Dec 1 18:16:57 GMT-0800 1997 +// Last Modified: Mon Dec 1 18:16:57 GMT-0800 1997 +// Filename: ...sig/maint/code/misc/sigConfiguration.h +// Web Address: http://sig.sapp.org/include/sig/sigConfiguration.h +// Syntax: C +// +// Description: This file defines flags for different code setups: +// You specify the OS in a compiler flag and this file takes care +// of the rest of the defines for that OS. This file should +// automatically be included in any file which uses any of the +// define flags below. +// +// OS setup defines to use in compiling files: +// +// -DLINUX: Linux running on intel computers +// -DNEXTI: NeXT OS on Intel Hardware +// -DNEXTM: NeXT OS on Motorola Hardware +// -DSUN: Sun SPARCstations +// -DVISUAL: Windows 95/NT using Microsoft Visual C++ 5.0 +// -DHPUX: Hewlett-Packard Unix Workstations. +// -DIRIX: SGI computers with IRIX OS. +// +// +// Various options that can be defined for each OS. These +// defines may be mixed and matched in different OSes: +// +// -DOTHEREND: If the computer is little-endian, then this +// define switches the byte ordering behavior for writing/reading +// soundfiles. Intel computers need this define, most others +// will not.need this define. +// +// -DSHORTRAND: Indicates that the rand() function generates +// numbers between 0 and 0x7fff. The default without this +// option is a range between 0 and 0x7fffffff. +// +// -DINTEL: Indicates that the computer hardware uses an +// intel x86 CPU. Not used for anything right now except to +// define the endian flag (OTHEREND). +// +// -DMOTOROLA: Indicates that the computer hardware uses a +// Motorola 68k CPU. Not used for anything right now. +// +// + +#ifndef _SIGCONFIGURATION_H_INCLUDED +#define _SIGCONFIGURATION_H_INCLUDED + + +#ifdef LINUX + #define INTEL +#endif + + +#ifdef NEXTI + #define INTEL +#endif + + +#ifdef NEXT + #define MOTOROLA +#endif + + +#ifdef VISUAL + #define INTEL +#endif + + +#ifdef SUN + #define SHORTRAND +#endif + + +#ifdef HPUX + #define SHORTRAND +#endif + + +#ifdef IRIX + #define SHORTRAND +#endif + + +// These defines must come after the previous defines: + + +#ifdef INTEL + #define OTHEREND +#endif + + + +#endif /* _SIGCONFIGURATION_H_INCLUDED */ + + + +// md5sum: 32f74a7c264b158b83ff38db1ea885f8 - sigConfiguration.h =css= 20030102 |