Start adding Loris files

1 files changed, 361 insertions, 0 deletions

diff --git a/src/loris/AiffData.h b/src/loris/AiffData.h
new file mode 100644
index 0000000..fb07ed2
--- /dev/null
+++ b/src/loris/AiffData.h
@@ -0,0 +1,361 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * AiffData.h
+ *
+ * Declarations of import and export functions.
+ *
+ * Kelly Fitz, 17 Sept 2003 
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "Marker.h"
+
+#include <string>
+#include <vector>
+
+//	in case configure wasn't run (no config.h), 
+//	pick some (hopefully-) reasonable values for
+//	these things and hope for the best...
+#if ! defined( SIZEOF_SHORT )
+#define SIZEOF_SHORT 2
+#endif
+
+#if ! defined( SIZEOF_INT )
+#define SIZEOF_INT 4
+#endif
+
+#if ! defined( SIZEOF_LONG )
+#define SIZEOF_LONG 4	// not for DEC Alpha!
+#endif
+
+
+#if SIZEOF_SHORT == 2
+typedef short 			Int_16;
+typedef unsigned short 	Uint_16;
+#elif SIZEOF_INT == 2
+typedef int 			Int_16;
+typedef unsigned int 	Uint_16;
+#else
+#error "cannot find an appropriate type for 16-bit integers"
+#endif
+
+#if SIZEOF_INT == 4
+typedef int 			Int_32;
+typedef unsigned int 	Uint_32;
+#elif SIZEOF_LONG == 4
+typedef long 			Int_32;
+typedef unsigned long 	Uint_32;
+#else
+#error "cannot find an appropriate type for 32-bit integers"
+#endif
+
+
+//	begin namespace
+namespace Loris {
+
+//	-- chunk types --
+enum 
+{ 
+	ContainerId = 0x464f524d,				// 'FORM' 
+	AiffType = 0x41494646,					// 'AIFF' 
+	CommonId = 0x434f4d4d,					// 'COMM'
+	ApplicationSpecificId = 0x4150504c,		// 'APPL'
+	SosEnvelopesId = 0x534f5365,			// 'SOSe'
+	SoundDataId = 0x53534e44,				// 'SSND'
+	InstrumentId = 0x494e5354,				// 'INST'
+	MarkerId = 0x4d41524b					// 'MARK'
+};
+
+typedef Uint_32 ID;
+typedef char Byte;
+
+struct CkHeader 
+{
+	ID id;
+	Uint_32 size;
+	
+	//	providing this default constructor
+	//	gives clients a way to determine whether
+	//	a chunk has been read and assigned:
+	CkHeader( void ) : id(0), size(0) {}
+};
+
+struct ContainerCk
+{
+	CkHeader header;
+	ID formType;
+};
+
+struct CommonCk
+{
+	CkHeader header;
+	Int_16 channels;			// number of channels 
+	Int_32 sampleFrames;		// channel independent sample frames 
+	Int_16 bitsPerSample;		// number of bits per sample 
+	double srate;				// sampling rate (stored in IEEE 10 byte format)
+};
+
+struct SoundDataCk
+{
+	CkHeader header;	
+	Uint_32 offset;				
+	Uint_32 blockSize;	
+	
+	//	sample frames follow
+	std::vector< Byte > sampleBytes;
+};
+
+struct MarkerCk 
+{ 
+	CkHeader header;	
+	Uint_16  numMarkers; 
+	
+	struct Marker
+	{ 
+		Uint_16  markerID; 
+		Uint_32	 position;	 		// position in uncompressed samples
+		std::string markerName; 
+	}; 
+	
+	std::vector< MarkerCk::Marker > markers;
+}; 
+
+struct InstrumentCk
+{
+	CkHeader header;	
+	Byte	baseNote;		/* all notes are MIDI note numbers */ 
+	Byte	detune;			/* cents off, only -50 to +50 are significant */ 
+	Byte	lowNote; 
+	Byte	highNote; 
+	Byte	lowVelocity;	/* 1 to 127 */ 
+	Byte	highVelocity;	/* 1 to 127 */ 
+	Int_16	gain;			/* in dB, 0 is normal */ 
+
+	struct Loop 
+	{ 
+		Int_16	playMode;	/* 0 - no loop, 1 - forward looping, 2 - backward looping */ 
+		Uint_16 beginLoop;	/* this is a reference to a markerID, so you always 
+	تتتتتتتتتتتتتتتتتتتتتتتتتتتتتتتت have to work with MARK and INST together!! */ 
+		Uint_16 endLoop; 
+	}; 
+
+	Loop sustainLoop;
+	Loop releaseLoop; 
+}; 
+
+
+struct SosEnvelopesCk
+{
+	CkHeader header;	
+	Int_32	signature;		// For SOS, should be 'SOSe'
+	Int_32	enhanced;		// 0 for sine-only, 1 for bandwidth-enhanced
+	Int_32	validPartials;	// Number of partials with data in them; the file must
+							// be padded out to the next higher 2**n partials;
+							// this number is doubled for enhanced files
+	
+	//	skip validPartials * sizeof(Int_32) bytes of junk here
+	Int_32	resolution;		// frame duration in microseconds 
+	Int_32	quasiHarmonic;	// how many of the partials are quasiharmonic
+	//	skip 
+	//		(4*LargestLabel + 8 - validPartials - 2) * sizeof(Int_32) 
+	//	bytes of junk here	
+
+/*				
+	//	this stuff is unbelievably nasty!						
+	
+#define initPhaseLth ( 4*LargestLabel + 8 )
+	Int_32	initPhase[initPhaseLth]; // obsolete initial phase array; is VARIABLE LENGTH array 
+							// this is big enough for a max of 512 enhanced partials plus values below
+//	Int_32	resolution;		// frame duration in microseconds 
+	#define SOSresolution( es )   initPhase[ spcEI.enhanced \
+											? 2 * spcEI.numPartials : spcEI.numPartials]	
+							// follows the initPhase[] array
+	
+							
+//	Int_32	quasiHarmonic;	// how many of the partials are quasiharmonic
+	#define SOSquasiHarmonic( es )  initPhase[ spcEI.enhanced \
+											? 2 * spcEI.numPartials + 1 : spcEI.numPartials + 1]	
+							// follows the initPhase[] array
+*/							
+};
+
+// ---------------------------------------------------------------------------
+//	readChunkHeader
+// ---------------------------------------------------------------------------
+//	Read the id and chunk size from the current file position.
+//	Let exceptions propogate.
+//
+std::istream &  
+readChunkHeader( std::istream & s, CkHeader & h );
+
+
+// ---------------------------------------------------------------------------
+//	readApplicationSpecifcData
+// ---------------------------------------------------------------------------
+//	Read the data in the ApplicationSpecific chunk, assume the stream is 
+//	correctly positioned, and that the chunk header has already been read.
+//
+//  Look for data specific to SPC files. Any other kind of Application 
+//	Specific data is ignored.
+//
+std::istream & 
+readApplicationSpecifcData( std::istream & s, SosEnvelopesCk & ck, unsigned long chunkSize );
+
+
+// ---------------------------------------------------------------------------
+//	readCommonData
+// ---------------------------------------------------------------------------
+//	Read the data in the Common chunk, assume the stream is correctly
+//	positioned, and that the chunk header has already been read.
+//
+std::istream & 
+readCommonData( std::istream & s, CommonCk & ck, unsigned long chunkSize );
+
+// ---------------------------------------------------------------------------
+//	readContainer
+// ---------------------------------------------------------------------------
+//
+std::istream & 
+readContainer( std::istream & s, ContainerCk & ck, unsigned long chunkSize );
+
+// ---------------------------------------------------------------------------
+//	readInstrumentData
+// ---------------------------------------------------------------------------
+//
+std::istream & 
+readInstrumentData( std::istream & s, InstrumentCk & ck, unsigned long chunkSize );
+
+// ---------------------------------------------------------------------------
+//	readMarkerData
+// ---------------------------------------------------------------------------
+//
+std::istream & 
+readMarkerData( std::istream & s, MarkerCk & ck, unsigned long chunkSize );
+
+// ---------------------------------------------------------------------------
+//	readSampleData
+// ---------------------------------------------------------------------------
+//	Read the data in the Sound Data chunk, assume the stream is correctly
+//	positioned, and that the chunk header has already been read.
+//
+std::istream & 
+readSampleData( std::istream & s, SoundDataCk & ck, unsigned long chunkSize );
+
+// ---------------------------------------------------------------------------
+//	configureCommonCk
+// ---------------------------------------------------------------------------
+void 
+configureCommonCk( CommonCk & ck, unsigned long nFrames, unsigned int nChans,
+				   unsigned int bps, double srate  );
+				   
+// ---------------------------------------------------------------------------
+//	configureContainer
+// ---------------------------------------------------------------------------
+//	dataSize is the combined size of all other chunks in file. Configure 
+//	them first, then add their sizes (with headers!).
+//
+void 
+configureContainer( ContainerCk & ck, unsigned long dataSize );
+
+// ---------------------------------------------------------------------------
+//	configureInstrumentCk
+// ---------------------------------------------------------------------------
+void 
+configureInstrumentCk( InstrumentCk & ck, double midiNoteNum );
+
+// ---------------------------------------------------------------------------
+//	configureMarkerCk
+// ---------------------------------------------------------------------------
+void 
+configureMarkerCk( MarkerCk & ck, const std::vector< Marker > & markers, 
+				   double srate  );
+
+// ---------------------------------------------------------------------------
+//	configureSoundDataCk
+// ---------------------------------------------------------------------------
+//
+void 
+configureSoundDataCk( SoundDataCk & ck, const std::vector< double > & samples, 
+					  unsigned int bps  );
+
+// ---------------------------------------------------------------------------
+//	writeCommon
+// ---------------------------------------------------------------------------
+//
+std::ostream &
+writeCommonData( std::ostream & s, const CommonCk & ck );
+
+// ---------------------------------------------------------------------------
+//	writeContainer
+// ---------------------------------------------------------------------------
+//
+std::ostream &
+writeContainer( std::ostream & s, const ContainerCk & ck );
+
+// ---------------------------------------------------------------------------
+//	writeInstrumentData
+// ---------------------------------------------------------------------------
+std::ostream &
+writeInstrumentData( std::ostream & s, const InstrumentCk & ck );
+
+// ---------------------------------------------------------------------------
+//	writeMarkerData
+// ---------------------------------------------------------------------------
+std::ostream &
+writeMarkerData( std::ostream & s, const MarkerCk & ck );
+
+// ---------------------------------------------------------------------------
+//	writeSampleData
+// ---------------------------------------------------------------------------
+//
+std::ostream & 
+writeSampleData( std::ostream & s, const SoundDataCk & ck );
+
+// ---------------------------------------------------------------------------
+//	convertBytesToSamples
+// ---------------------------------------------------------------------------
+//	Convert sample bytes to double precision floating point samples 
+//	(-1.0, 1.0). The samples vector is resized to fit exactly as many
+//	samples as are represented in the bytes vector, and any prior
+//	contents are overwritten.
+//
+void
+convertBytesToSamples( const std::vector< Byte > & bytes, 
+					   std::vector< double > & samples, unsigned int bps );
+
+// ---------------------------------------------------------------------------
+//	convertSamplesToBytes
+// ---------------------------------------------------------------------------
+//	Convert floating point samples (-1.0, 1.0) to bytes. 
+//	The bytes vector is resized to fit exactly as many
+//	samples as are stored in the samples vector, and any prior
+//	contents are overwritten.
+//
+void
+convertSamplesToBytes( const std::vector< double > & samples, 
+					   std::vector< Byte > & bytes, unsigned int bps );
+					   
+} // end of namespace