Initial Contribution

author: The Android Open Source Project <initial-contribution@android.com> 2008-10-21 07:00:00 -0700
committer: The Android Open Source Project <initial-contribution@android.com> 2008-10-21 07:00:00 -0700
commit: e442bb7cd6a085b33a4dd52c0e20a157ada7feb1 (patch)
tree: eef3202d79b3cbef0ee4f83b4b1f56922cb8d2ac /arm-wt-22k/host_src
download: android_external_sonivox-e442bb7cd6a085b33a4dd52c0e20a157ada7feb1.tar.gz
android_external_sonivox-e442bb7cd6a085b33a4dd52c0e20a157ada7feb1.tar.bz2
android_external_sonivox-e442bb7cd6a085b33a4dd52c0e20a157ada7feb1.zip
17 files changed, 4705 insertions, 0 deletions
diff --git a/arm-wt-22k/host_src/arm-wt-22k.mak b/arm-wt-22k/host_src/arm-wt-22k.mak
new file mode 100644
index 0000000..222d174
--- /dev/null
+++ b/arm-wt-22k/host_src/arm-wt-22k.mak
@@ -0,0 +1,25 @@
+#
+# Auto-generated sample makefile
+#
+# This makefile is intended for use with GNU make.
+# Set the paths to the tools (CC, AR, LD, etc.)
+#
+
+vpath %.c host_src
+
+CC = C:\Program Files\GNUARM\bin\arm-elf-gcc.exe
+AS = C:\Program Files\GNUARM\bin\arm-elf-as.exe
+LD = C:\Program Files\GNUARM\bin\arm-elf-gcc.exe
+AR = C:\Program Files\GNUARM\bin\arm-elf-ar.exe
+
+%.o: %.c
+	$(CC) -c -O2 -o $@ -I host_src -D UNIFIED_DEBUG_MESSAGES -D EAS_WT_SYNTH -D _IMELODY_PARSER -D _RTTTL_PARSER -D _OTA_PARSER -D _XMF_PARSER -D _WAVE_PARSER -D _REVERB_ENABLED -D _CHORUS_ENABLED -D MMAPI_SUPPORT -D JET_INTERFACE $<
+
+%.o: %.s
+	$(AS) -o $@ -EL -mcpu=arm946e-s -mfpu=softfpa -I lib_src --defsym CHECK_STACK=0 --defsym REVERB=0 --defsym CHORUS=0 --defsym STEREO_OUTPUT=1 --defsym SAMPLE_RATE_22050=1 --defsym SAMPLES_8_BIT=1 --defsym FILTER_ENABLED=1 $<
+
+OBJS = eas_main.o eas_report.o eas_wave.o eas_hostmm.o eas_config.o
+
+arm-wt-22k: $(OBJS)
+	$(LD) -o $@ $(OBJS) libarm-wt-22k.a -lm
+
diff --git a/arm-wt-22k/host_src/eas.h b/arm-wt-22k/host_src/eas.h
new file mode 100644
index 0000000..949e66e
--- /dev/null
+++ b/arm-wt-22k/host_src/eas.h
@@ -0,0 +1,1063 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas.h
+ *
+ * Contents and purpose:
+ * The public interface header for the EAS synthesizer.
+ *
+ * This header only contains declarations that are specific
+ * to this implementation.  
+ *
+ * DO NOT MODIFY THIS FILE!
+ *			
+ * Copyright Sonic Network Inc. 2005, 2006
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 852 $
+ *   $Date: 2007-09-04 11:43:49 -0700 (Tue, 04 Sep 2007) $
+ *----------------------------------------------------------------------------
+*/
+
+#ifndef _EAS_H
+#define _EAS_H
+
+#include "eas_types.h"
+
+/* for C++ linkage */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* library version macro */
+#define MAKE_LIB_VERSION(a,b,c,d) (((((((EAS_U32) a <<8) | (EAS_U32) b) << 8) | (EAS_U32) c) << 8) | (EAS_U32) d)
+#define LIB_VERSION MAKE_LIB_VERSION(3, 6, 10, 14)
+
+typedef struct
+{
+	EAS_U32		libVersion;
+	EAS_BOOL	checkedVersion;
+	EAS_I32		maxVoices;
+	EAS_I32		numChannels;
+	EAS_I32		sampleRate;
+	EAS_I32		mixBufferSize;
+	EAS_BOOL	filterEnabled;
+	EAS_U32		buildTimeStamp;
+	EAS_CHAR 	*buildGUID;
+} S_EAS_LIB_CONFIG;
+
+/* enumerated effects module numbers for configuration */
+typedef enum
+{
+	EAS_MODULE_ENHANCER = 0,
+	EAS_MODULE_COMPRESSOR,
+	EAS_MODULE_REVERB,
+	EAS_MODULE_CHORUS,
+	EAS_MODULE_WIDENER,
+	EAS_MODULE_GRAPHIC_EQ,
+	EAS_MODULE_WOW,
+	EAS_MODULE_MAXIMIZER,
+	EAS_MODULE_TONECONTROLEQ,
+	NUM_EFFECTS_MODULES
+} E_FX_MODULES;
+
+/* enumerated optional module numbers for configuration */
+typedef enum
+{
+	EAS_MODULE_MMAPI_TONE_CONTROL = 0,
+	EAS_MODULE_METRICS
+} E_OPT_MODULES;
+#define NUM_OPTIONAL_MODULES	2
+
+/* enumerated audio decoders for configuration */
+typedef enum
+{
+	EAS_DECODER_PCM = 0,
+	EAS_DECODER_SMAF_ADPCM,
+	EAS_DECODER_IMA_ADPCM,
+	EAS_DECODER_7BIT_SMAF_ADPCM,
+	EAS_DECODER_NOT_SUPPORTED
+} E_DECODER_MODULES;
+#define NUM_DECODER_MODULES		4
+
+/* defines for EAS_PEOpenStream flags parameter */
+#define PCM_FLAGS_STEREO		0x00000100	/* stream is stereo */
+#define PCM_FLAGS_8_BIT			0x00000001	/* 8-bit format */
+#define PCM_FLAGS_UNSIGNED		0x00000010	/* unsigned format */
+#define PCM_FLAGS_STREAMING		0x80000000	/* streaming mode */
+
+/* maximum volume setting */
+#define EAS_MAX_VOLUME			100
+
+/*----------------------------------------------------------------------------
+ * EAS_Init()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Initialize the synthesizer library
+ *
+ * Inputs:
+ *  polyphony		- number of voices to play (dynamic memory model only)
+ *	ppLibData		- pointer to data handle variable for this instance
+ *
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_Init (EAS_DATA_HANDLE *ppEASData);
+
+/*----------------------------------------------------------------------------
+ * EAS_Config()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Returns a pointer to a structure containing the configuration options
+ * in this library build.
+ *
+ * Inputs:
+ *
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC const S_EAS_LIB_CONFIG *EAS_Config (void);
+
+/*----------------------------------------------------------------------------
+ * EAS_Shutdown()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Shuts down the library. Deallocates any memory associated with the
+ * synthesizer (dynamic memory model only)
+ *
+ * Inputs:
+ *	pEASData		- handle to data for this instance
+ *
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_Shutdown (EAS_DATA_HANDLE pEASData);
+
+/*----------------------------------------------------------------------------
+ * EAS_Render()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Parse the Midi data and render PCM audio data.
+ *
+ * Inputs:
+ *  pEASData        - buffer for internal EAS data
+ *	pOut			- output buffer pointer
+ *	nNumRequested	- requested num samples to generate
+ *	pnNumGenerated	- actual number of samples generated
+ *
+ * Outputs:
+ *	EAS_SUCCESS if PCM data was successfully rendered
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_Render (EAS_DATA_HANDLE pEASData, EAS_PCM *pOut, EAS_I32 numRequested, EAS_I32 *pNumGenerated);
+
+/*----------------------------------------------------------------------------
+ * EAS_SetRepeat()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Set the selected stream to repeat.
+ *
+ * Inputs:
+ *	pEASData		- handle to data for this instance
+ *	streamHandle	- handle to stream
+ *	repeatCount		- repeat count (0 = no repeat, -1 = repeat forever)
+ *		
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ * Notes:
+ *	0 = no repeat
+ *	1 = repeat once, i.e. play through twice
+ *  -1 = repeat forever
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetRepeat (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 repeatCount);
+
+/*----------------------------------------------------------------------------
+ * EAS_GetRepeat()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Gets the current repeat count for the selected stream.
+ *
+ * Inputs:
+ *	pEASData		- handle to data for this instance
+ *	streamHandle	- handle to stream
+ *	pRrepeatCount	- pointer to variable to hold repeat count
+ *		
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ * Notes:
+ *	0 = no repeat
+ *	1 = repeat once, i.e. play through twice
+ *  -1 = repeat forever
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_GetRepeat (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 *pRepeatCount);
+
+/*----------------------------------------------------------------------------
+ * EAS_SetPlaybackRate()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Set the playback rate.
+ *
+ * Inputs:
+ *	pEASData		- handle to data for this instance
+ *	streamHandle	- handle to stream
+ *	rate			- rate (28-bit fractional amount)
+ *		
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetPlaybackRate (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_U32 rate);
+#define MAX_PLAYBACK_RATE	(EAS_U32)(1L << 29)
+#define MIN_PLAYBACK_RATE	(EAS_U32)(1L << 27)
+
+/*----------------------------------------------------------------------------
+ * EAS_SetTransposition)
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Sets the key tranposition for the synthesizer. Transposes all
+ * melodic instruments by the specified amount. Range is limited
+ * to +/-12 semitones.
+ *
+ * Inputs:
+ *	pEASData		- handle to data for this instance
+ *	streamHandle	- handle to stream
+ *	transposition	- +/-12 semitones
+ *		
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetTransposition (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 transposition);
+#define MAX_TRANSPOSE		12
+
+/*----------------------------------------------------------------------------
+ * EAS_SetSynthPolyphony()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Set the polyphony of the synthesizer. Value must be >= 1 and <= the
+ * maximum number of voices. This function will pin the polyphony
+ * at those limits
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * synthNum			- synthesizer number (0 = onboard, 1 = DSP)
+ * polyphonyCount	- the desired polyphony count
+ *		
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetSynthPolyphony (EAS_DATA_HANDLE pEASData, EAS_I32 synthNum, EAS_I32 polyphonyCount);
+
+/*----------------------------------------------------------------------------
+ * EAS_GetSynthPolyphony()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Returns the current polyphony setting of the synthesizer
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * synthNum			- synthesizer number (0 = onboard, 1 = DSP)
+ * pPolyphonyCount	- pointer to variable to receive polyphony count
+ *		
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_GetSynthPolyphony (EAS_DATA_HANDLE pEASData, EAS_I32 synthNum, EAS_I32 *pPolyphonyCount);
+
+/*----------------------------------------------------------------------------
+ * EAS_SetPolyphony()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Set the polyphony of the stream. Value must be >= 1 and <= the
+ * maximum number of voices. This function will pin the polyphony
+ * at those limits
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- handle returned by EAS_OpenFile
+ * polyphonyCount	- the desired polyphony count
+ *		
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetPolyphony (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 polyphonyCount);
+
+/*----------------------------------------------------------------------------
+ * EAS_GetPolyphony()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Returns the current polyphony setting of the stream
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- handle returned by EAS_OpenFile
+ * pPolyphonyCount	- pointer to variable to receive polyphony count
+ *		
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_GetPolyphony (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 *pPolyphonyCount);
+
+/*----------------------------------------------------------------------------
+ * EAS_SetPriority()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Set the priority of the stream. Determines which stream's voices
+ * are stolen when there are insufficient voices for all notes.
+ * Value must be in the range of 1-255, lower values are higher
+ * priority. The default priority is 50.
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- handle returned by EAS_OpenFile
+ * polyphonyCount	- the desired polyphony count
+ *		
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetPriority (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 priority);
+
+/*----------------------------------------------------------------------------
+ * EAS_GetPriority()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Returns the current priority setting of the stream
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- handle returned by EAS_OpenFile
+ * pPriority		- pointer to variable to receive priority
+ *		
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_GetPriority (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 *pPriority);
+
+/*----------------------------------------------------------------------------
+ * EAS_SetVolume()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Set the master volume for the mixer. The default volume setting is
+ * 90 (-10 dB). The volume range is 0 to 100 in 1dB increments.
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * volume			- the desired master volume
+ *		
+ * Outputs:
+ *
+ *
+ * Side Effects:
+ * overrides any previously set master volume from sysex
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetVolume (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 volume);
+
+/*----------------------------------------------------------------------------
+ * EAS_GetVolume()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Returns the master volume for the mixer in 1dB increments.
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * volume			- the desired master volume
+ *		
+ * Outputs:
+ *
+ *
+ * Side Effects:
+ * overrides any previously set master volume from sysex
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_I32 EAS_GetVolume (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle);
+
+/*----------------------------------------------------------------------------
+ * EAS_SetMaxLoad()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Sets the maximum workload the parsers will do in a single call to
+ * EAS_Render. The units are currently arbitrary, but should correlate
+ * well to the actual CPU cycles consumed. The primary effect is to
+ * reduce the occasional peaks in CPU cycles consumed when parsing
+ * dense parts of a MIDI score. Setting maxWorkLoad to zero disables
+ * the workload limiting function.
+ *
+ * Inputs:
+ *	pEASData		- handle to data for this instance
+ *	maxLoad			- the desired maximum workload
+ *		
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetMaxLoad (EAS_DATA_HANDLE pEASData, EAS_I32 maxLoad);
+
+/*----------------------------------------------------------------------------
+ * EAS_SetMaxPCMStreams()
+ *----------------------------------------------------------------------------
+ * Sets the maximum number of PCM streams allowed in parsers that
+ * use PCM streaming.
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- handle returned by EAS_OpenFile
+ * maxNumStreams	- maximum number of PCM streams
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetMaxPCMStreams (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 maxNumStreams);
+
+/*----------------------------------------------------------------------------
+ * EAS_OpenFile()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Opens a file for audio playback.
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * locator			- pointer to filename or other locating information
+ * pStreamHandle	- pointer to stream handle variable
+ * memfailvar		- pointer to var to set to indicate memory access failure
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_OpenFile (EAS_DATA_HANDLE pEASData, EAS_FILE_LOCATOR locator, EAS_HANDLE *pStreamHandle, int **memfailvar);
+
+#ifdef MMAPI_SUPPORT
+/*----------------------------------------------------------------------------
+ * EAS_MMAPIToneControl()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Opens a ToneControl file for audio playback.
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * locator			- pointer to filename or other locating information
+ * pStreamHandle	- pointer to stream handle variable
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_MMAPIToneControl (EAS_DATA_HANDLE pEASData, EAS_FILE_LOCATOR locator, EAS_HANDLE *pStreamHandle);
+
+/*----------------------------------------------------------------------------
+ * EAS_GetWaveFmtChunk
+ *----------------------------------------------------------------------------
+ * Helper function to retrieve WAVE file fmt chunk for MMAPI
+ *----------------------------------------------------------------------------
+ * pEASData			- pointer to EAS persistent data object
+ * streamHandle		- stream handle
+ * pFmtChunk		- pointer to pointer to FMT chunk data
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_GetWaveFmtChunk (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_VOID_PTR *ppFmtChunk);
+#endif
+
+/*----------------------------------------------------------------------------
+ * EAS_GetFileType
+ *----------------------------------------------------------------------------
+ * Returns the file type (see eas_types.h for enumerations)
+ *----------------------------------------------------------------------------
+ * pEASData			- pointer to EAS persistent data object
+ * streamHandle		- stream handle
+ * pFileType		- pointer to variable to receive file type
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_GetFileType (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 *pFileType);
+
+/*----------------------------------------------------------------------------
+ * EAS_ParseMetaData()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * 
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- file or stream handle
+ * playLength		- pointer to variable to store the play length (in msecs)
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *					- resets the parser to the start of the file
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_ParseMetaData (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 *pPlayLength);
+
+/*----------------------------------------------------------------------------
+ * EAS_Prepare()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Prepares the synthesizer to play the file or stream. Parses the first
+ * frame of data from the file and arms the synthesizer.
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- file or stream handle
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_Prepare (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle);
+
+/*----------------------------------------------------------------------------
+ * EAS_State()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Returns the state of an audio file or stream. 
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- file or stream handle
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_State (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_STATE *pState);
+
+/*----------------------------------------------------------------------------
+ * EAS_RegisterMetaDataCallback()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Registers a metadata callback function for parsed metadata. To
+ * de-register the callback, call this function again with parameter
+ * cbFunc set to NULL.
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- file or stream handle
+ * cbFunc			- pointer to host callback function
+ * metaDataBuffer	- pointer to metadata buffer
+ * metaDataBufSize	- maximum size of the metadata buffer
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_RegisterMetaDataCallback (
+	EAS_DATA_HANDLE pEASData, 
+	EAS_HANDLE streamHandle, 
+	EAS_METADATA_CBFUNC cbFunc, 
+	char *metaDataBuffer, 
+	EAS_I32 metaDataBufSize, 
+	EAS_VOID_PTR pUserData);
+
+/*----------------------------------------------------------------------------
+ * EAS_GetNoteCount ()
+ *----------------------------------------------------------------------------
+ * Returns the total number of notes played in this stream
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- file or stream handle
+ * pNoteCount		- pointer to variable to receive note count
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_GetNoteCount (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *pNoteCount);
+
+/*----------------------------------------------------------------------------
+ * EAS_CloseFile()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Closes an audio file or stream. Playback should have either paused or
+ * completed (EAS_State returns EAS_PAUSED or EAS_STOPPED).
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- file or stream handle
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_CloseFile (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle);
+
+/*----------------------------------------------------------------------------
+ * EAS_OpenMIDIStream()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Opens a raw MIDI stream allowing the host to route MIDI cable data directly to the synthesizer
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * pStreamHandle	- pointer to variable to hold file or stream handle
+ * streamHandle		- open stream or NULL for new synthesizer instance
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_OpenMIDIStream (EAS_DATA_HANDLE pEASData, EAS_HANDLE *pStreamHandle, EAS_HANDLE streamHandle);
+
+/*----------------------------------------------------------------------------
+ * EAS_WriteMIDIStream()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Send data to the MIDI stream device
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- stream handle
+ * pBuffer			- pointer to buffer
+ * count			- number of bytes to write
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_WriteMIDIStream(EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_U8 *pBuffer, EAS_I32 count);
+
+/*----------------------------------------------------------------------------
+ * EAS_CloseMIDIStream()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Closes a raw MIDI stream
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- stream handle
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_CloseMIDIStream (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle);
+
+/*----------------------------------------------------------------------------
+ * EAS_Locate()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Locate into the file associated with the handle.
+ *
+ * Inputs:
+ * pEASData 		- pointer to overall EAS data structure
+ * streamHandle		- file handle
+ * milliseconds		- playback offset from start of file in milliseconds
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ * the actual offset will be quantized to the closest update period, typically
+ * a resolution of 5.9ms. Notes that are started prior to this time will not
+ * sound. Any notes currently playing will be shut off.
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_Locate (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 milliseconds, EAS_BOOL offset);
+
+/*----------------------------------------------------------------------------
+ * EAS_GetRenderTime()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Returns the current playback offset 
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ *		
+ * Outputs:
+ * Gets the render time clock in msecs.
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_GetRenderTime (EAS_DATA_HANDLE pEASData, EAS_I32 *pTime);
+
+/*----------------------------------------------------------------------------
+ * EAS_GetLocation()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Returns the current playback offset 
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- file handle
+ *		
+ * Outputs:
+ * The offset in milliseconds from the start of the current sequence, quantized
+ * to the nearest update period. Actual resolution is typically 5.9 ms.
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_GetLocation (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_I32 *pTime);
+
+/*----------------------------------------------------------------------------
+ * EAS_Pause()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Pauses the playback of the data associated with this handle. The audio
+ * is gracefully ramped down to prevent clicks and pops. It may take several
+ * buffers of audio before the audio is muted.
+ *
+ * Inputs:
+ * psEASData		- pointer to overall EAS data structure
+ * streamHandle		- file or stream handle
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_Pause (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle);
+
+/*----------------------------------------------------------------------------
+ * EAS_Resume()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Resumes the playback of the data associated with this handle. The audio
+ * is gracefully ramped up to prevent clicks and pops.
+ *
+ * Inputs:
+ * psEASData		- pointer to overall EAS data structure
+ * streamHandle		- file or stream handle
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_Resume (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle);
+
+/*----------------------------------------------------------------------------
+ * EAS_GetParameter()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Set the parameter of a module. See E_MODULES for a list of modules
+ * and the header files of the modules for a list of parameters.
+ *
+ * Inputs:
+ * psEASData		- pointer to overall EAS data structure
+ * module			- enumerated module number
+ * param			- enumerated parameter number
+ * pValue			- pointer to variable to receive parameter value
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_GetParameter (EAS_DATA_HANDLE pEASData, EAS_I32 module, EAS_I32 param, EAS_I32 *pValue);
+
+/*----------------------------------------------------------------------------
+ * EAS_SetParameter()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Set the parameter of a module. See E_MODULES for a list of modules
+ * and the header files of the modules for a list of parameters.
+ *
+ * Inputs:
+ * psEASData		- pointer to overall EAS data structure
+ * handle			- file or stream handle
+ * module			- enumerated module number
+ * param			- enumerated parameter number
+ * value			- new parameter value
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetParameter (EAS_DATA_HANDLE pEASData, EAS_I32 module, EAS_I32 param, EAS_I32 value);
+
+#ifdef _METRICS_ENABLED	
+/*----------------------------------------------------------------------------
+ * EAS_MetricsReport()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Displays the current metrics through the EAS_Report interface.
+ *
+ * Inputs:
+ * pEASData				- instance data handle
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_MetricsReport (EAS_DATA_HANDLE pEASData);
+
+/*----------------------------------------------------------------------------
+ * EAS_MetricsReset()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Displays the current metrics through the EAS_Report interface.
+ *
+ * Inputs:
+ * pEASData				- instance data handle
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_MetricsReset (EAS_DATA_HANDLE pEASData);
+#endif
+
+/*----------------------------------------------------------------------------
+ * EAS_SetSoundLibrary()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Sets the location of the sound library.
+ *
+ * Inputs:
+ * pEASData				- instance data handle
+ * streamHandle			- file or stream handle
+ * pSoundLib			- pointer to sound library
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetSoundLibrary (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_SNDLIB_HANDLE pSndLib);
+
+/*----------------------------------------------------------------------------
+ * EAS_SetHeaderSearchFlag()
+ *----------------------------------------------------------------------------
+ * By default, when EAS_OpenFile is called, the parsers check the
+ * first few bytes of the file looking for a specific header. Some
+ * mobile devices may add a header to the start of a file, which
+ * will prevent the parser from recognizing the file. If the
+ * searchFlag is set to EAS_TRUE, the parser will search the entire
+ * file looking for the header. This may enable EAS to recognize
+ * some files that it would ordinarily reject. The negative is that
+ * it make take slightly longer to process the EAS_OpenFile request.
+ *
+ * Inputs:
+ * pEASData				- instance data handle
+ * searchFlag			- search flag (EAS_TRUE or EAS_FALSE)
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetHeaderSearchFlag (EAS_DATA_HANDLE pEASData, EAS_BOOL searchFlag);
+
+/*----------------------------------------------------------------------------
+ * EAS_SetPlayMode()
+ *----------------------------------------------------------------------------
+ * Some file formats support special play modes, such as iMode partial
+ * play mode. This call can be used to change the play mode. The
+ * default play mode (usually straight playback) is always zero.
+ *
+ * Inputs:
+ * pEASData				- instance data handle
+ * handle				- file or stream handle
+ * playMode				- play mode (see eas_types.h for enumerations)
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetPlayMode (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 playMode);
+
+#ifdef DLS_SYNTHESIZER
+/*----------------------------------------------------------------------------
+ * EAS_LoadDLSCollection()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Downloads a DLS collection
+ *
+ * Inputs:
+ * pEASData				- instance data handle
+ * streamHandle			- file or stream handle
+ * locator				- file locator
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ * May overlay instruments in the GM sound set
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_LoadDLSCollection (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_FILE_LOCATOR locator);
+#endif
+
+/*----------------------------------------------------------------------------
+ * EAS_SetFrameBuffer()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Sets the frame buffer pointer passed to the IPC communications functions
+ *
+ * Inputs:
+ * pEASData				- instance data handle
+ * locator				- file locator
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ * May overlay instruments in the GM sound set
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_SetFrameBuffer (EAS_DATA_HANDLE pEASData, EAS_FRAME_BUFFER_HANDLE pFrameBuffer);
+
+#ifdef EXTERNAL_AUDIO
+/*----------------------------------------------------------------------------
+ * EAS_RegExtAudioCallback()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Registers callback functions for audio events.
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- file or stream handle
+ * cbProgChgFunc	- pointer to host callback function for program change
+ * cbEventFunc		- pointer to host callback functio for note events
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_RegExtAudioCallback (EAS_DATA_HANDLE pEASData,
+	EAS_HANDLE streamHandle,
+	EAS_VOID_PTR pInstData,
+	EAS_EXT_PRG_CHG_FUNC cbProgChgFunc,
+	EAS_EXT_EVENT_FUNC cbEventFunc);
+
+/*----------------------------------------------------------------------------
+ * EAS_GetMIDIControllers()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Returns the current state of MIDI controllers on the requested channel.
+ *
+ * Inputs:
+ * pEASData			- pointer to overall EAS data structure
+ * streamHandle		- file or stream handle
+ * pControl			- pointer to structure to receive data
+ *		
+ * Outputs:
+ * 
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT EAS_GetMIDIControllers (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_U8 channel, S_MIDI_CONTROLLERS *pControl);
+#endif
+
+/*----------------------------------------------------------------------------
+ * EAS_SearchFile
+ *----------------------------------------------------------------------------
+ * Search file for specific sequence starting at current file
+ * position. Returns offset to start of sequence.
+ *
+ * Inputs:
+ * pEASData			- pointer to EAS persistent data object
+ * fileHandle		- file handle
+ * searchString		- pointer to search sequence
+ * len				- length of search sequence
+ * pOffset			- pointer to variable to store offset to sequence
+ *
+ * Returns EAS_EOF if end-of-file is reached
+ *----------------------------------------------------------------------------
+*/
+EAS_RESULT EAS_SearchFile (EAS_DATA_HANDLE pEASData, EAS_FILE_HANDLE fileHandle, const EAS_U8 *searchString, EAS_I32 len, EAS_I32 *pOffset);
+
+#ifdef __cplusplus
+} /* end extern "C" */
+#endif
+
+#endif /* #ifndef _EAS_H */
diff --git a/arm-wt-22k/host_src/eas_build.h b/arm-wt-22k/host_src/eas_build.h
new file mode 100644
index 0000000..4ff15cc
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_build.h
@@ -0,0 +1,36 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * host_src\eas_build.h
+ *
+ * Contents and purpose:
+ * This file contains the build configuration for this
+ * build. The buildGUIDStr is a GUID created during
+ * the build process and is guaranteed to be unique
+ * for each build.
+ *
+ * Copyright Sonic Network Inc. 2006
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * This file was autogenerated by buildid.exe
+ *----------------------------------------------------------------------------
+*/
+
+#ifndef _GUID_1feda229b9a845e996f473c0a80e7220_
+#define _GUID_1feda229b9a845e996f473c0a80e7220_
+
+#define _BUILD_VERSION_ "1feda229-b9a8-45e9-96f4-73c0a80e7220"
+#define _BUILD_TIME_ 0x4743badd
+
+#endif /* _GUID_1feda229b9a845e996f473c0a80e7220_ */
diff --git a/arm-wt-22k/host_src/eas_chorus.h b/arm-wt-22k/host_src/eas_chorus.h
new file mode 100644
index 0000000..0e9057f
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_chorus.h
@@ -0,0 +1,53 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas_chorus.h
+ *
+ * Contents and purpose:
+ * Contains parameter enumerations for the Chorus effect
+ *
+ *
+ * Copyright Sonic Network Inc. 2006
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 309 $
+ *   $Date: 2006-09-12 18:52:45 -0700 (Tue, 12 Sep 2006) $
+ *----------------------------------------------------------------------------
+*/
+
+#ifndef EAS_CHORUS_H
+#define EAS_CHORUS_H
+
+/* enumerated parameter settings for Chorus effect */
+typedef enum
+{
+	EAS_PARAM_CHORUS_BYPASS,
+	EAS_PARAM_CHORUS_PRESET,
+	EAS_PARAM_CHORUS_RATE,
+	EAS_PARAM_CHORUS_DEPTH,
+	EAS_PARAM_CHORUS_LEVEL
+} E_CHORUS_PARAMS;
+
+typedef enum
+{
+	EAS_PARAM_CHORUS_PRESET1,
+	EAS_PARAM_CHORUS_PRESET2,
+	EAS_PARAM_CHORUS_PRESET3,
+	EAS_PARAM_CHORUS_PRESET4
+} E_CHORUS_PRESETS;
+
+
+#endif
+\ No newline at end of file
diff --git a/arm-wt-22k/host_src/eas_config.c b/arm-wt-22k/host_src/eas_config.c
new file mode 100644
index 0000000..c45fbb7
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_config.c
@@ -0,0 +1,619 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas_config.c
+ *
+ * Contents and purpose:
+ * This file contains the Configuration Module interface (CM). The CM
+ * is a module compiled external to the library that sets the configuration
+ * for this build. It allows the library to find optional components and
+ * links to static memory allocations (when used in a static configuration).
+ *
+ * DO NOT MODIFY THIS FILE!
+ *
+ * NOTE: This module is not intended to be modified by the customer. It
+ * needs to be included in the build process with the correct configuration
+ * defines (see the library documentation for information on how to configure
+ * the library).
+ *			
+ * Copyright Sonic Network Inc. 2004-2006
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 796 $
+ *   $Date: 2007-08-01 00:15:25 -0700 (Wed, 01 Aug 2007) $
+ *----------------------------------------------------------------------------
+*/
+
+#include "eas.h"
+#include "eas_config.h"
+
+
+#ifdef _MFI_PARSER
+/*----------------------------------------------------------------------------
+ * Vendor/Device ID for MFi Extensions
+ *
+ * Define the preprocessor symbols to establish the vendor ID and
+ * device ID for the MFi PCM/ADPCM extensions. 
+ *----------------------------------------------------------------------------
+*/
+const EAS_U8 eas_MFIVendorIDMSB = (MFI_VENDOR_ID >> 8) & 0xff;
+const EAS_U8 eas_MFIVendorIDLSB = MFI_VENDOR_ID & 0xff;
+const EAS_U8 eas_MFIDeviceID = MFI_DEVICE_ID;
+#endif
+
+/*----------------------------------------------------------------------------
+ *
+ * parserModules
+ *
+ * This structure is used by the EAS library to locate file parsing
+ * modules. 
+ *----------------------------------------------------------------------------
+*/
+
+/* define the external file parsers */
+extern EAS_VOID_PTR EAS_SMF_Parser;
+
+#ifdef _XMF_PARSER
+extern EAS_VOID_PTR EAS_XMF_Parser;
+#endif
+
+#ifdef _SMAF_PARSER
+extern EAS_VOID_PTR EAS_SMAF_Parser;
+#endif
+
+#ifdef _WAVE_PARSER
+extern EAS_VOID_PTR EAS_Wave_Parser;
+#endif
+
+#ifdef _OTA_PARSER
+extern EAS_VOID_PTR EAS_OTA_Parser;
+#endif
+
+#ifdef _IMELODY_PARSER
+extern EAS_VOID_PTR EAS_iMelody_Parser;
+#endif
+
+#ifdef _RTTTL_PARSER
+extern EAS_VOID_PTR EAS_RTTTL_Parser;
+#endif
+
+#if defined (_CMX_PARSER) || defined(_MFI_PARSER)
+extern EAS_VOID_PTR EAS_CMF_Parser;
+#endif
+
+/* initalize pointers to parser interfaces */
+/*lint -e{605} not pretty, but it works */
+EAS_VOID_PTR const parserModules[] = 
+{
+	&EAS_SMF_Parser,
+		
+#ifdef _XMF_PARSER
+	&EAS_XMF_Parser,
+#endif
+
+#ifdef _WAVE_PARSER
+	&EAS_Wave_Parser,
+#endif
+
+#ifdef _SMAF_PARSER
+	&EAS_SMAF_Parser,
+#endif
+
+#ifdef _OTA_PARSER
+	&EAS_OTA_Parser,
+#endif
+
+#ifdef _IMELODY_PARSER
+	&EAS_iMelody_Parser,
+#endif
+
+#ifdef _RTTTL_PARSER
+	&EAS_RTTTL_Parser,
+#endif
+
+#if defined (_CMX_PARSER) || defined(_MFI_PARSER)
+	&EAS_CMF_Parser
+#endif
+};
+#define NUM_PARSER_MODULES (sizeof(parserModules) / sizeof(EAS_VOID_PTR))
+
+/*----------------------------------------------------------------------------
+ * Data Modules
+ *----------------------------------------------------------------------------
+*/
+
+#ifdef _STATIC_MEMORY
+extern EAS_VOID_PTR eas_SMFData;
+extern EAS_VOID_PTR eas_Data;
+extern EAS_VOID_PTR eas_MixBuffer;
+extern EAS_VOID_PTR eas_Synth;
+extern EAS_VOID_PTR eas_MIDI;
+extern EAS_VOID_PTR eas_PCMData;
+extern EAS_VOID_PTR eas_MIDIData;
+
+#ifdef _XMF_PARSER
+extern EAS_VOID_PTR eas_XMFData;
+#endif
+
+#ifdef _SMAF_PARSER
+extern EAS_VOID_PTR eas_SMAFData;
+#endif
+
+#ifdef _OTA_PARSER
+extern EAS_VOID_PTR eas_OTAData;
+#endif
+
+#ifdef _IMELODY_PARSER
+extern EAS_VOID_PTR eas_iMelodyData;
+#endif
+
+#ifdef _RTTTL_PARSER
+extern EAS_VOID_PTR eas_RTTTLData;
+#endif
+
+#ifdef _WAVE_PARSER
+extern EAS_VOID_PTR eas_WaveData;
+#endif
+
+#if defined (_CMX_PARSER) || defined(_MFI_PARSER)
+extern EAS_VOID_PTR eas_CMFData;
+#endif
+#endif
+
+/*----------------------------------------------------------------------------
+ *
+ * Effects Modules
+ *
+ * These declarations are used by the EAS library to locate  
+ * effects modules. 
+ *----------------------------------------------------------------------------
+*/
+
+#ifdef _ENHANCER_ENABLED
+extern EAS_VOID_PTR					EAS_Enhancer;
+#define EAS_ENHANCER_INTERFACE		&EAS_Enhancer
+#ifdef _STATIC_MEMORY
+extern EAS_VOID_PTR					eas_EnhancerData;
+#define EAS_ENHANCER_DATA			&eas_EnhancerData
+#else
+#define EAS_ENHANCER_DATA			NULL
+#endif
+#else
+#define EAS_ENHANCER_INTERFACE		NULL
+#define EAS_ENHANCER_DATA			NULL
+#endif
+
+#ifdef _COMPRESSOR_ENABLED
+extern EAS_VOID_PTR	 				EAS_Compressor;
+#define EAS_COMPRESSOR_INTERFACE	&EAS_Compressor
+#ifdef _STATIC_MEMORY
+extern EAS_VOID_PTR					eas_CompressorData;
+#define EAS_COMPRESSOR_DATA			&eas_CompressorData
+#else
+#define EAS_COMPRESSOR_DATA			NULL
+#endif
+#else
+#define EAS_COMPRESSOR_INTERFACE	NULL
+#define EAS_COMPRESSOR_DATA			NULL
+#endif
+
+#ifdef _MAXIMIZER_ENABLED
+extern EAS_VOID_PTR	 				EAS_Maximizer;
+#define EAS_MAXIMIZER_INTERFACE		&EAS_Maximizer
+#ifdef _STATIC_MEMORY
+extern EAS_VOID_PTR					eas_MaximizerData;
+#define EAS_MAXIMIZER_DATA			&eas_MaximizerData
+#else
+#define EAS_MAXIMIZER_DATA			NULL
+#endif
+#else
+#define EAS_MAXIMIZER_INTERFACE	NULL
+#define EAS_MAXIMIZER_DATA			NULL
+#endif
+
+
+#ifdef _REVERB_ENABLED
+extern EAS_VOID_PTR	 				EAS_Reverb;
+#define EAS_REVERB_INTERFACE		&EAS_Reverb
+#ifdef _STATIC_MEMORY
+extern EAS_VOID_PTR					eas_ReverbData;
+#define EAS_REVERB_DATA				&eas_ReverbData
+#else
+#define EAS_REVERB_DATA				NULL
+#endif
+#else
+#define EAS_REVERB_INTERFACE		NULL
+#define EAS_REVERB_DATA				NULL
+#endif
+
+#ifdef _CHORUS_ENABLED
+extern EAS_VOID_PTR	 				EAS_Chorus;
+#define EAS_CHORUS_INTERFACE		&EAS_Chorus
+#ifdef _STATIC_MEMORY
+extern EAS_VOID_PTR					eas_ChorusData;
+#define EAS_CHORUS_DATA				&eas_ChorusData
+#else
+#define EAS_CHORUS_DATA				NULL
+#endif
+#else
+#define EAS_CHORUS_INTERFACE		NULL
+#define EAS_CHORUS_DATA				NULL
+#endif
+
+#ifdef _WIDENER_ENABLED
+extern EAS_VOID_PTR	 				EAS_Widener;
+#define EAS_WIDENER_INTERFACE		&EAS_Widener
+#ifdef _STATIC_MEMORY
+extern EAS_VOID_PTR					eas_WidenerData;
+#define EAS_WIDENER_DATA			&eas_WidenerData
+#else
+#define EAS_WIDENER_DATA			NULL
+#endif
+#else
+#define EAS_WIDENER_INTERFACE		NULL
+#define EAS_WIDENER_DATA			NULL
+#endif
+
+#ifdef _GRAPHIC_EQ_ENABLED
+extern EAS_VOID_PTR	 				EAS_GraphicEQ;
+#define EAS_GRAPHIC_EQ_INTERFACE	&EAS_GraphicEQ
+#ifdef _STATIC_MEMORY
+extern EAS_VOID_PTR					eas_GraphicEQData;
+#define EAS_GRAPHIC_EQ_DATA			&eas_GraphicEQData
+#else
+#define EAS_GRAPHIC_EQ_DATA			NULL
+#endif
+#else
+#define EAS_GRAPHIC_EQ_INTERFACE	NULL
+#define EAS_GRAPHIC_EQ_DATA			NULL
+#endif
+
+#ifdef _WOW_ENABLED
+extern EAS_VOID_PTR	 				EAS_Wow;
+#define EAS_WOW_INTERFACE			&EAS_Wow
+#ifdef _STATIC_MEMORY
+#error "WOW module requires dynamic memory model"
+#else
+#define EAS_WOW_DATA				NULL
+#endif
+#else
+#define EAS_WOW_INTERFACE			NULL
+#define EAS_WOW_DATA				NULL
+#endif
+
+#ifdef _TONECONTROLEQ_ENABLED
+extern EAS_VOID_PTR					EAS_ToneControlEQ;
+#define EAS_TONECONTROLEQ_INTERFACE	&EAS_ToneControlEQ
+#ifdef _STATIC_MEMORY
+extern EAS_VOID_PTR					eas_ToneControlEQData;
+#define EAS_TONECONTROLEQ_DATA		&eas_ToneControlEQData
+#else
+#define EAS_TONECONTROLEQ_DATA		NULL
+#endif
+#else
+#define EAS_TONECONTROLEQ_INTERFACE	NULL
+#define EAS_TONECONTROLEQ_DATA		NULL
+#endif
+
+/*lint -e{605} not pretty, but it works */
+EAS_VOID_PTR const effectsModules[] = 
+{
+	EAS_ENHANCER_INTERFACE,
+	EAS_COMPRESSOR_INTERFACE,
+	EAS_REVERB_INTERFACE,
+	EAS_CHORUS_INTERFACE,
+	EAS_WIDENER_INTERFACE,
+	EAS_GRAPHIC_EQ_INTERFACE,
+	EAS_WOW_INTERFACE,
+	EAS_MAXIMIZER_INTERFACE,
+	EAS_TONECONTROLEQ_INTERFACE
+};
+
+EAS_VOID_PTR const effectsData[] =
+{
+	EAS_ENHANCER_DATA,
+	EAS_COMPRESSOR_DATA,
+	EAS_REVERB_DATA,
+	EAS_CHORUS_DATA,
+	EAS_WIDENER_DATA,
+	EAS_GRAPHIC_EQ_DATA,
+	EAS_WOW_DATA,
+	EAS_MAXIMIZER_DATA,
+	EAS_TONECONTROLEQ_DATA
+};
+
+/*----------------------------------------------------------------------------
+ *
+ * Optional Modules
+ *
+ * These declarations are used by the EAS library to locate  
+ * effects modules. 
+ *----------------------------------------------------------------------------
+*/
+
+#ifdef _METRICS_ENABLED
+extern EAS_VOID_PTR					EAS_Metrics;
+#define EAS_METRICS_INTERFACE		&EAS_Metrics
+#ifdef _STATIC_MEMORY
+extern EAS_VOID_PTR					eas_MetricsData;
+#define EAS_METRICS_DATA			&eas_MetricsData
+#else
+#define EAS_METRICS_DATA			NULL
+#endif
+#else
+#define EAS_METRICS_INTERFACE		NULL
+#define EAS_METRICS_DATA			NULL
+#endif
+
+#ifdef MMAPI_SUPPORT
+extern EAS_VOID_PTR					EAS_TC_Parser;
+#define EAS_TONE_CONTROL_PARSER		&EAS_TC_Parser
+#ifdef _STATIC_MEMORY
+extern EAS_VOID_PTR					eas_TCData;
+#define EAS_TONE_CONTROL_DATA		&eas_TCData
+#else
+#define EAS_TONE_CONTROL_DATA		NULL
+#endif
+#else
+#define EAS_TONE_CONTROL_PARSER		NULL
+#define EAS_TONE_CONTROL_DATA		NULL
+#endif
+
+/*lint -e{605} not pretty, but it works */
+EAS_VOID_PTR const optionalModules[] = 
+{
+	EAS_TONE_CONTROL_PARSER,
+	EAS_METRICS_INTERFACE
+};
+
+EAS_VOID_PTR const optionalData[] =
+{
+	EAS_TONE_CONTROL_DATA,
+	EAS_METRICS_DATA
+};
+
+/*----------------------------------------------------------------------------
+ * EAS_CMStaticMemoryModel()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function returns true if EAS has been configured for 
+ * a static memory model. There are some limitations in the
+ * static memory model, see the documentation for more
+ * information.
+ *
+ * Outputs:
+ *  returns EAS_TRUE if a module is found
+ *----------------------------------------------------------------------------
+*/
+EAS_BOOL EAS_CMStaticMemoryModel (void)
+{
+#ifdef _STATIC_MEMORY
+	return EAS_TRUE;
+#else
+	return EAS_FALSE;
+#endif
+}
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumModules()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to optional modules. 
+ *
+ * Inputs:
+ *  module			- module number
+ *
+ * Outputs:
+ *  returns a pointer to the module function table or NULL if no module
+ *----------------------------------------------------------------------------
+*/
+EAS_VOID_PTR EAS_CMEnumModules (EAS_INT module)
+{
+
+	if (module >= (EAS_INT) NUM_PARSER_MODULES)
+		return NULL;
+	return parserModules[module];
+}
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumData()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to static memory allocations. 
+ *
+ * Inputs:
+ *  dataModule			- enumerated module number
+ *
+ * Outputs:
+ * Returns handle to data or NULL if not found
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, dataModule) used only when _STATIC_MEMORY is defined */
+EAS_VOID_PTR EAS_CMEnumData (EAS_INT dataModule)
+{
+
+#ifdef _STATIC_MEMORY
+	switch (dataModule)
+	{
+
+	/* main instance data for synthesizer */
+	case EAS_CM_EAS_DATA:
+		return &eas_Data;
+
+	/* mix buffer for mix engine */
+	case EAS_CM_MIX_BUFFER:
+		/*lint -e{545} lint doesn't like this because it sees the underlying type */
+		return &eas_MixBuffer;
+
+	/* instance data for synth */
+	case EAS_CM_SYNTH_DATA:
+		return &eas_Synth;
+
+	/* instance data for MIDI parser */
+	case EAS_CM_MIDI_DATA:
+		return &eas_MIDI;
+	
+	/* instance data for SMF parser */
+	case EAS_CM_SMF_DATA:
+		return &eas_SMFData;
+
+#ifdef _XMF_PARSER
+	/* instance data for XMF parser */
+	case EAS_CM_XMF_DATA:
+		return &eas_XMFData;
+#endif		
+
+#ifdef _SMAF_PARSER
+	/* instance data for SMAF parser */
+	case EAS_CM_SMAF_DATA:
+		return &eas_SMAFData;
+#endif		
+
+	/* instance data for the PCM engine */
+	case EAS_CM_PCM_DATA:
+		/*lint -e{545} lint doesn't like this because it sees the underlying type */
+		return &eas_PCMData;
+
+	case EAS_CM_MIDI_STREAM_DATA:
+		return &eas_MIDIData;
+
+#ifdef _OTA_PARSER
+	/* instance data for OTA parser */
+	case EAS_CM_OTA_DATA:
+		return &eas_OTAData;
+#endif		
+		
+#ifdef _IMELODY_PARSER
+	/* instance data for iMelody parser */
+	case EAS_CM_IMELODY_DATA:
+		return &eas_iMelodyData;
+#endif		
+
+#ifdef _RTTTL_PARSER
+	/* instance data for RTTTL parser */
+	case EAS_CM_RTTTL_DATA:
+		return &eas_RTTTLData;
+#endif		
+
+#ifdef _WAVE_PARSER
+	/* instance data for WAVE parser */
+	case EAS_CM_WAVE_DATA:
+		return &eas_WaveData;
+#endif		
+
+#if defined (_CMX_PARSER) || defined(_MFI_PARSER)
+	/* instance data for CMF parser */
+	case EAS_CM_CMF_DATA:
+		return &eas_CMFData;
+#endif
+
+	default:
+		return NULL;
+	}
+
+#else
+	return NULL;
+#endif
+}
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumFXModules()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to optional effects modules. 
+ *
+ * Inputs:
+ *  module			- enumerated module number
+ *  pModule			- pointer to module interface
+ *
+ * Outputs:
+ *  Returns pointer to function table or NULL if not found
+ *----------------------------------------------------------------------------
+*/
+EAS_VOID_PTR EAS_CMEnumFXModules (EAS_INT module)
+{
+
+	if (module >= NUM_EFFECTS_MODULES)
+		return NULL;
+	return effectsModules[module];
+}
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumFXData()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to static memory allocations. 
+ *
+ * Inputs:
+ *  dataModule			- enumerated module number
+ *  pData				- pointer to handle variable
+ *
+ * Outputs:
+ * Returns handle to data or NULL if not found
+ *----------------------------------------------------------------------------
+*/
+EAS_VOID_PTR EAS_CMEnumFXData (EAS_INT dataModule)
+{
+
+	if (dataModule >= NUM_EFFECTS_MODULES)
+		return NULL;
+	return effectsData[dataModule];
+}
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumOptModules()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to optional modules. 
+ *
+ * Inputs:
+ *  module			- enumerated module number
+ *
+ * Outputs:
+ *  returns pointer to function table or NULL if no module
+ *----------------------------------------------------------------------------
+*/
+EAS_VOID_PTR EAS_CMEnumOptModules (EAS_INT module)
+{
+
+	/* sanity check */
+	if (module >= NUM_OPTIONAL_MODULES)
+		return EAS_FALSE;
+	return optionalModules[module];
+}
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumOptData()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to static memory allocations. 
+ *
+ * Inputs:
+ *  dataModule			- enumerated module number
+ *
+ * Outputs:
+ * Returns handle to data or NULL if not found
+ *----------------------------------------------------------------------------
+*/
+EAS_VOID_PTR EAS_CMEnumOptData (EAS_INT dataModule)
+{
+
+	if (dataModule >= NUM_OPTIONAL_MODULES)
+		return NULL;
+	return optionalData[dataModule];
+}
+
+
diff --git a/arm-wt-22k/host_src/eas_config.h b/arm-wt-22k/host_src/eas_config.h
new file mode 100644
index 0000000..d16be4a
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_config.h
@@ -0,0 +1,191 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas_config.h
+ *
+ * Contents and purpose:
+ * This header declares the Configuration Module interface (CM). The CM
+ * is a module compiled external to the library that sets the configuration
+ * for this build. It allows the library to find optional components and
+ * links to static memory allocations (when used in a static configuration).
+ *
+ * NOTE: This module is not intended to be modified by the customer. It
+ * needs to be included in the build process with the correct configuration
+ * defines (see the library documentation for information on how to configure
+ * the library).
+ *
+ * DO NOT MODIFY THIS FILE!
+ *
+ * Copyright 2005 Sonic Network Inc.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 82 $
+ *   $Date: 2006-07-10 11:45:19 -0700 (Mon, 10 Jul 2006) $
+ *----------------------------------------------------------------------------
+*/
+
+// sentinel
+#ifndef _EAS_CONFIG_H
+#define _EAS_CONFIG_H
+
+#include "eas_types.h"
+
+/* list of enumerators for optional modules */
+typedef enum {
+	EAS_CM_FILE_PARSERS	= 1
+} E_CM_ENUM_MODULES;
+
+/* list of enumerators for module and memory pointers */
+typedef enum {
+	EAS_CM_EAS_DATA = 1,
+	EAS_CM_MIX_BUFFER,
+	EAS_CM_SYNTH_DATA,
+	EAS_CM_MIDI_DATA,
+	EAS_CM_SMF_DATA,
+	EAS_CM_XMF_DATA,
+	EAS_CM_SMAF_DATA,
+	EAS_CM_PCM_DATA,
+	EAS_CM_MIDI_STREAM_DATA,
+	EAS_CM_METRICS_DATA,
+	EAS_CM_OTA_DATA,
+	EAS_CM_IMELODY_DATA,
+	EAS_CM_RTTTL_DATA,
+	EAS_CM_WAVE_DATA,
+	EAS_CM_CMF_DATA
+} E_CM_DATA_MODULES;
+
+typedef struct
+{
+	int maxSMFStreams;
+	void *pSMFData;
+	void *pSMFStream;
+} S_EAS_SMF_PTRS;
+
+typedef struct
+{
+	int maxSMAFStreams;
+	void *pSMAFData;
+	void *pSMAFStream;
+} S_EAS_SMAF_PTRS;
+
+/*----------------------------------------------------------------------------
+ * EAS_CMStaticMemoryModel()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function returns true if EAS has been configured for 
+ * a static memory model. There are some limitations in the
+ * static memory model, see the documentation for more
+ * information.
+ *
+ * Outputs:
+ *  returns EAS_TRUE if a module is found
+ *----------------------------------------------------------------------------
+*/
+EAS_BOOL EAS_CMStaticMemoryModel (void);
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumModules()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to optional modules. 
+ *
+ * Inputs:
+ *  module			- module number
+ *
+ * Outputs:
+ *  returns a pointer to the module function table or NULL if no module
+ *----------------------------------------------------------------------------
+*/
+EAS_VOID_PTR EAS_CMEnumModules (EAS_INT module);
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumData()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to static memory allocations. 
+ *
+ * Inputs:
+ *  dataModule			- enumerated module number
+ *
+ * Outputs:
+ * Returns handle to data or NULL if not found
+ *----------------------------------------------------------------------------
+*/
+EAS_VOID_PTR EAS_CMEnumData (EAS_INT dataModule);
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumFXModules()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to optional effects modules. 
+ *
+ * Inputs:
+ *  module			- enumerated module number
+ *  pModule			- pointer to module interface
+ *
+ * Outputs:
+ *  Returns pointer to function table or NULL if not found
+ *----------------------------------------------------------------------------
+*/
+EAS_VOID_PTR EAS_CMEnumFXModules (EAS_INT module);
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumFXData()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to static memory allocations. 
+ *
+ * Inputs:
+ *  dataModule			- enumerated module number
+ *  pData				- pointer to handle variable
+ *
+ * Outputs:
+ * Returns handle to data or NULL if not found
+ *----------------------------------------------------------------------------
+*/
+EAS_VOID_PTR EAS_CMEnumFXData (EAS_INT dataModule);
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumOptModules()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to optional modules. 
+ *
+ * Inputs:
+ *  module			- enumerated module number
+ *
+ * Outputs:
+ *  returns pointer to function table or NULL if no module
+ *----------------------------------------------------------------------------
+*/
+EAS_VOID_PTR EAS_CMEnumOptModules (EAS_INT module);
+
+/*----------------------------------------------------------------------------
+ * EAS_CMEnumOptData()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * This function is used to find pointers to static memory allocations. 
+ *
+ * Inputs:
+ *  dataModule			- enumerated module number
+ *
+ * Outputs:
+ * Returns handle to data or NULL if not found
+ *----------------------------------------------------------------------------
+*/
+EAS_VOID_PTR EAS_CMEnumOptData (EAS_INT dataModule);
+
+#endif /* end _EAS_CONFIG_H */
diff --git a/arm-wt-22k/host_src/eas_debugmsgs.h b/arm-wt-22k/host_src/eas_debugmsgs.h
new file mode 100644
index 0000000..25913bd
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_debugmsgs.h
@@ -0,0 +1,87 @@
+/* Auto-generated from source file: eas_chorusdata.c */
+/* Auto-generated from source file: eas_xmfdata.c */
+/* Auto-generated from source file: eas_mdls.c */
+{ 0x19299ed4, 0x00000022, "eas_mdls.c[2561]: #Instruments: %u\n" },
+{ 0x19299ed4, 0x00000023, "eas_mdls.c[2562]: #Regions: %u\n" },
+{ 0x19299ed4, 0x00000024, "eas_mdls.c[2563]: #Articulations: %u\n" },
+{ 0x19299ed4, 0x00000025, "eas_mdls.c[2564]: #Waves: %u\n" },
+{ 0x19299ed4, 0x00000026, "eas_mdls.c[2569]: Locale: %lu:%lu:%lu\n" },
+{ 0x19299ed4, 0x00000027, "eas_mdls.c[2576]: \tRegion: %u\n" },
+{ 0x19299ed4, 0x00000028, "eas_mdls.c[2578]: \t\tm_nGain: %d\n" },
+{ 0x19299ed4, 0x00000029, "eas_mdls.c[2579]: \t\trangeLow:rangeHigh %u:%u\n" },
+{ 0x19299ed4, 0x0000002a, "eas_mdls.c[2580]: \t\tm_nKeyGroupAndFlags: %04x\n" },
+{ 0x19299ed4, 0x0000002b, "eas_mdls.c[2581]: \t\tm_nLoopStart: %u\n" },
+{ 0x19299ed4, 0x0000002c, "eas_mdls.c[2582]: \t\tm_nLoopEnd: %u\n" },
+{ 0x19299ed4, 0x0000002d, "eas_mdls.c[2583]: \t\tm_nNetTuningInCents: %d\n" },
+{ 0x19299ed4, 0x0000002e, "eas_mdls.c[2584]: \t\tArt Index: %u\n" },
+{ 0x19299ed4, 0x0000002f, "eas_mdls.c[2585]: \t\tWave Index: %u\n" },
+{ 0x19299ed4, 0x00000030, "eas_mdls.c[2597]: Articulation: %u\n" },
+{ 0x19299ed4, 0x00000031, "eas_mdls.c[2599]: \t\tm_nEG2toFilterDepth: %d\n" },
+{ 0x19299ed4, 0x00000032, "eas_mdls.c[2600]: \t\tm_nEG2toPitchDepth: %d\n" },
+{ 0x19299ed4, 0x00000033, "eas_mdls.c[2601]: \t\tm_nFilterCutoffFrequency: %d\n" },
+{ 0x19299ed4, 0x00000034, "eas_mdls.c[2602]: \t\tm_nFilterResonance: %u\n" },
+{ 0x19299ed4, 0x00000035, "eas_mdls.c[2603]: \t\tm_nLFOAmplitudeDepth: %d\n" },
+{ 0x19299ed4, 0x00000036, "eas_mdls.c[2604]: \t\tm_nLFODelayTime: %d\n" },
+{ 0x19299ed4, 0x00000037, "eas_mdls.c[2605]: \t\tm_nLFOFrequency: %d\n" },
+{ 0x19299ed4, 0x00000038, "eas_mdls.c[2606]: \t\tm_nLFOPitchDepth: %d\n" },
+{ 0x19299ed4, 0x00000039, "eas_mdls.c[2607]: \t\tm_nPan: %d\n" },
+{ 0x19299ed4, 0x0000003a, "eas_mdls.c[2610]: \t\tm_nAttack: %d\n" },
+{ 0x19299ed4, 0x0000003b, "eas_mdls.c[2611]: \t\tm_nDecay: %d\n" },
+{ 0x19299ed4, 0x0000003c, "eas_mdls.c[2612]: \t\tm_nSustain: %d\n" },
+{ 0x19299ed4, 0x0000003d, "eas_mdls.c[2613]: \t\tm_nRelease: %d\n" },
+{ 0x19299ed4, 0x0000003e, "eas_mdls.c[2616]: \t\tm_nAttack: %d\n" },
+{ 0x19299ed4, 0x0000003f, "eas_mdls.c[2617]: \t\tm_nDecay: %d\n" },
+{ 0x19299ed4, 0x00000040, "eas_mdls.c[2618]: \t\tm_nSustain: %d\n" },
+{ 0x19299ed4, 0x00000041, "eas_mdls.c[2619]: \t\tm_nRelease: %d\n" },
+{ 0x19299ed4, 0x00000042, "eas_mdls.c[2626]: Wave Index: %d\n" },
+{ 0x19299ed4, 0x00000043, "eas_mdls.c[2627]: \tSize %u\n" },
+{ 0x19299ed4, 0x00000044, "eas_mdls.c[2628]: \tPointer %08lx\n" },
+/* Auto-generated from source file: eas_mididata.c */
+/* Auto-generated from source file: eas_pan.c */
+/* Auto-generated from source file: eas_wavefiledata.c */
+/* Auto-generated from source file: eas_reverbdata.c */
+/* Auto-generated from source file: eas_imelodydata.c */
+/* Auto-generated from source file: eas_ota.c */
+/* Auto-generated from source file: eas_mixbuf.c */
+/* Auto-generated from source file: eas_tcdata.c */
+/* Auto-generated from source file: jet.c */
+/* Auto-generated from source file: eas_rtttl.c */
+/* Auto-generated from source file: eas_reverb.c */
+/* Auto-generated from source file: eas_pcmdata.c */
+/* Auto-generated from source file: eas_chorus.c */
+/* Auto-generated from source file: eas_math.c */
+/* Auto-generated from source file: eas_xmf.c */
+/* Auto-generated from source file: eas_smfdata.c */
+/* Auto-generated from source file: eas_imelody.c */
+/* Auto-generated from source file: eas_dlssynth.c */
+/* Auto-generated from source file: eas_public.c */
+/* Auto-generated from source file: eas_rtttldata.c */
+/* Auto-generated from source file: eas_voicemgt.c */
+/* Auto-generated from source file: eas_tonecontrol.c */
+/* Auto-generated from source file: eas_wtengine.c */
+/* Auto-generated from source file: eas_imaadpcm.c */
+{ 0x2380b977, 0x00000006, "eas_imaadpcm.c[305]: IMADecoderLocate: Time=%d, samples=%d\n" },
+{ 0x2380b977, 0x00000007, "eas_imaadpcm.c[328]: IMADecoderLocate: Looped sample, numBlocks=%d, samplesPerLoop=%d, samplesInLastBlock=%d, samples=%d\n" },
+{ 0x2380b977, 0x00000008, "eas_imaadpcm.c[335]: IMADecoderLocate: Byte location in audio = %d\n" },
+{ 0x2380b977, 0x00000009, "eas_imaadpcm.c[345]: IMADecoderLocate: bytesLeft = %d\n" },
+/* Auto-generated from source file: eas_flog.c */
+/* Auto-generated from source file: eas_midi.c */
+/* Auto-generated from source file: eas_otadata.c */
+/* Auto-generated from source file: eas_ima_tables.c */
+/* Auto-generated from source file: eas_data.c */
+/* Auto-generated from source file: eas_pcm.c */
+/* Auto-generated from source file: eas_mixer.c */
+/* Auto-generated from source file: eas_wavefile.c */
+/* Auto-generated from source file: eas_wtsynth.c */
+/* Auto-generated from source file: eas_smf.c */
+/* Auto-generated from source file: eas_wave.c */
+/* Auto-generated from source file: eas_hostmm.c */
+{ 0x1a54b6e8, 0x00000001, "eas_hostmm.c[586]: Vibrate state: %d\n" },
+{ 0x1a54b6e8, 0x00000002, "eas_hostmm.c[601]: LED state: %d\n" },
+{ 0x1a54b6e8, 0x00000003, "eas_hostmm.c[616]: Backlight state: %d\n" },
+{ 0x1a54b6e8, 0x00000004, "eas_hostmm.c[162]: HWMemCpy: bad amount: %d\n" },
+{ 0x1a54b6e8, 0x00000005, "eas_hostmm.c[179]: HWMemSet: bad amount: %d\n" },
+{ 0x1a54b6e8, 0x00000006, "eas_hostmm.c[196]: HWMemCmp: bad amount: %d\n" },
+/* Auto-generated from source file: eas_config.c */
+/* Auto-generated from source file: eas_main.c */
+{ 0xe624f4d9, 0x00000005, "eas_main.c[106]: Play length: %d.%03d (secs)\n" },
diff --git a/arm-wt-22k/host_src/eas_host.h b/arm-wt-22k/host_src/eas_host.h
new file mode 100644
index 0000000..270e68c
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_host.h
@@ -0,0 +1,87 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas_host.h
+ *
+ * Contents and purpose:
+ * This header defines the host wrapper functions for stdio, stdlib, etc.
+ * The host application must provide an abstraction layer for these functions
+ * to support certain features, such as SMAF and SMF-1 conversion.
+ *
+ * DO NOT MODIFY THIS FILE!
+ *
+ * Copyright 2005 Sonic Network Inc.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 82 $
+ *   $Date: 2006-07-10 11:45:19 -0700 (Mon, 10 Jul 2006) $
+ *----------------------------------------------------------------------------
+*/
+
+// sentinel
+#ifndef _EAS_HOST_H
+#define _EAS_HOST_H
+
+#include "eas_types.h"
+
+/* for C++ linkage */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* initialization and shutdown routines */
+extern EAS_RESULT EAS_HWInit(EAS_HW_DATA_HANDLE *hwInstData);
+extern EAS_RESULT EAS_HWShutdown(EAS_HW_DATA_HANDLE hwInstData);
+
+/* threading */
+extern void* EAS_HWRegisterSignalHandler();
+extern EAS_RESULT EAS_HWUnRegisterSignalHandler(void *cookie);
+
+/* memory functions */
+extern void *EAS_HWMemSet(void *s, int c, EAS_I32 n);
+extern void *EAS_HWMemCpy(void *s1, const void *s2, EAS_I32 n);
+extern EAS_I32 EAS_HWMemCmp(const void *s1, const void *s2, EAS_I32 n);
+
+/* memory allocation */
+extern void *EAS_HWMalloc(EAS_HW_DATA_HANDLE hwInstData, EAS_I32 size);
+extern void EAS_HWFree(EAS_HW_DATA_HANDLE hwInstData, void *p);
+
+/* file I/O */
+extern EAS_RESULT EAS_HWOpenFile(EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_LOCATOR locator, EAS_FILE_HANDLE *pFile, EAS_FILE_MODE mode);
+extern EAS_RESULT EAS_HWReadFile(EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *pBuffer, EAS_I32 n, EAS_I32 *pBytesRead);
+extern EAS_RESULT EAS_HWGetByte(EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p);
+extern EAS_RESULT EAS_HWGetWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst);
+extern EAS_RESULT EAS_HWGetDWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst);
+extern EAS_RESULT EAS_HWFilePos (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pPosition);
+extern EAS_RESULT EAS_HWFileSeek (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position);
+extern EAS_RESULT EAS_HWFileSeekOfs (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position);
+extern EAS_RESULT EAS_HWFileLength (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pLength);
+extern EAS_RESULT EAS_HWDupHandle (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_FILE_HANDLE* pFile);
+extern EAS_RESULT EAS_HWCloseFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file);
+
+/* vibrate, LED, and backlight functions */
+extern EAS_RESULT EAS_HWVibrate(EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state);
+extern EAS_RESULT EAS_HWLED(EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state);
+extern EAS_RESULT EAS_HWBackLight(EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state);
+
+#ifdef __cplusplus
+} /* end extern "C" */
+#endif
+
+
+/* host yield function */
+extern EAS_BOOL EAS_HWYield(EAS_HW_DATA_HANDLE hwInstData);
+#endif /* end _EAS_HOST_H */
diff --git a/arm-wt-22k/host_src/eas_hostmm.c b/arm-wt-22k/host_src/eas_hostmm.c
new file mode 100644
index 0000000..bb9356e
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_hostmm.c
@@ -0,0 +1,737 @@
+/*----------------------------------------------------------------------------
+ *
+ * File:
+ * eas_hostmm.c
+ *
+ * Contents and purpose:
+ * This file contains the host wrapper functions for stdio, stdlib, etc.
+ * This is a sample version that maps the requested files to an
+ * allocated memory block and uses in-memory pointers to replace
+ * file system calls. The file locator (EAS_FILE_LOCATOR) handle passed
+ * HWOpenFile is the same one that is passed to EAS_OpenFile. If your
+ * system stores data in fixed locations (such as flash) instead of
+ * using a file system, you can use the locator handle to point to
+ * your memory. You will need a way of knowing the length of the
+ * data stored at that location in order to respond correctly in the
+ * HW_FileLength function.
+ * 
+ * Modify this file to suit the needs of your particular system.
+ *
+ * EAS_MAX_FILE_HANDLES sets the maximum number of MIDI streams within
+ * a MIDI type 1 file that can be played. 
+ *
+ * EAS_HW_FILE is a structure to support the file I/O functions. It
+ * comprises the base memory pointer, the file read pointer, and
+ * the dup flag, which when sets, indicates that the file handle has
+ * been duplicated. If your system uses in-memory resources, you
+ * can eliminate the duplicate handle logic, and simply copy the 
+ * base memory pointer and file read pointer to the duplicate handle.
+ *
+ * Copyright 2005 Sonic Network Inc.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 795 $
+ *   $Date: 2007-08-01 00:14:45 -0700 (Wed, 01 Aug 2007) $
+ *----------------------------------------------------------------------------
+*/
+
+#ifdef _lint
+#include "lint_stdlib.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <sys/mman.h>
+#include <errno.h>
+#include <signal.h>
+#define LOG_TAG "Sonivox"
+#include <utils/Log.h>
+#include <media/MediaPlayerInterface.h>
+#endif
+
+#include "eas_host.h"
+
+/* Only for debugging LED, vibrate, and backlight functions */
+#include "eas_report.h"
+
+/* this module requires dynamic memory support */
+#ifdef _STATIC_MEMORY
+#error "eas_hostmm.c requires the dynamic memory model!\n"
+#endif
+
+#ifndef EAS_MAX_FILE_HANDLES
+#define EAS_MAX_FILE_HANDLES    32
+#endif
+
+/*
+ * this structure and the related function are here
+ * to support the ability to create duplicate handles
+ * and buffering it in memory. If your system uses
+ * in-memory resources, you can eliminate the calls
+ * to malloc and free, the dup flag, and simply track
+ * the file size and read position.
+ */
+typedef struct eas_hw_file_tag
+{
+    EAS_I32 fileSize;
+    EAS_I32 filePos;
+    EAS_BOOL dup;
+    EAS_U8 *buffer;
+    EAS_I32 length;
+    EAS_I32 offset;
+    void *oldsigbushandler;
+    struct mediasigbushandler sigbushandler;
+    int memfailed;
+} EAS_HW_FILE;
+
+typedef struct eas_hw_inst_data_tag
+{
+    EAS_HW_FILE files[EAS_MAX_FILE_HANDLES];
+} EAS_HW_INST_DATA;
+
+pthread_key_t EAS_sigbuskey;
+
+/*----------------------------------------------------------------------------
+ * EAS_HWInit
+ *
+ * Initialize host wrapper interface
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_RESULT EAS_HWInit (EAS_HW_DATA_HANDLE *pHWInstData)
+{
+
+    /* need to track file opens for duplicate handles */
+    *pHWInstData = malloc(sizeof(EAS_HW_INST_DATA));
+    if (!(*pHWInstData))
+        return EAS_ERROR_MALLOC_FAILED;
+
+    EAS_HWMemSet(*pHWInstData, 0, sizeof(EAS_HW_INST_DATA));
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ * EAS_HWShutdown
+ *
+ * Shut down host wrapper interface
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_RESULT EAS_HWShutdown (EAS_HW_DATA_HANDLE hwInstData)
+{
+
+    free(hwInstData);
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWMalloc
+ *
+ * Allocates dynamic memory
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+void *EAS_HWMalloc (EAS_HW_DATA_HANDLE hwInstData, EAS_I32 size)
+{
+    /* Since this whole library loves signed sizes, let's not let
+     * negative or 0 values through */
+    if (size <= 0)
+      return NULL;
+    return malloc((size_t) size);
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWFree
+ *
+ * Frees dynamic memory
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+void EAS_HWFree (EAS_HW_DATA_HANDLE hwInstData, void *p)
+{
+    free(p);
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWMemCpy
+ *
+ * Copy memory wrapper
+ *
+ *----------------------------------------------------------------------------
+*/
+void *EAS_HWMemCpy (void *dest, const void *src, EAS_I32 amount) 
+{
+    if (amount < 0)  {
+      EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000004 , amount);
+      exit(255);
+    }
+    return memcpy(dest, src, (size_t) amount);
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWMemSet
+ *
+ * Set memory wrapper
+ *
+ *----------------------------------------------------------------------------
+*/
+void *EAS_HWMemSet (void *dest, int val, EAS_I32 amount) 
+{
+    if (amount < 0)  {
+      EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000005 , amount);
+      exit(255);
+    }
+    return memset(dest, val, (size_t) amount);
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWMemCmp
+ *
+ * Compare memory wrapper
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_I32 EAS_HWMemCmp (const void *s1, const void *s2, EAS_I32 amount) 
+{
+    if (amount < 0) {
+      EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000006 , amount);
+      exit(255);
+    }
+    return (EAS_I32) memcmp(s1, s2, (size_t) amount);
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWOpenFile
+ *
+ * Open a file for read or write
+ *
+ *----------------------------------------------------------------------------
+*/
+int * EAS_HWGetMemFailVar(EAS_FILE_HANDLE pFile)
+{
+    EAS_HW_FILE *file = pFile;
+    return &file->memfailed;
+}
+
+EAS_RESULT EAS_HWOpenFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_LOCATOR locator, EAS_FILE_HANDLE *pFile, EAS_FILE_MODE mode)
+{
+    EAS_HW_FILE *file;
+    int fd;
+    int i, temp;
+
+    /* set return value to NULL */
+    *pFile = NULL;
+
+    /* only support read mode at this time */
+    if (mode != EAS_FILE_READ)
+        return EAS_ERROR_INVALID_FILE_MODE;
+
+    /* find an empty entry in the file table */
+    file = hwInstData->files;
+    for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
+    {
+        /* is this slot being used? */
+        if (file->buffer == NULL)
+        {
+            if (locator->path) {
+                /* open the file */
+                if ((fd = open(locator->path, O_RDONLY)) < 0) {
+                    return EAS_ERROR_FILE_OPEN_FAILED;
+                }
+            } else {
+                /* else file is already open */
+                fd = dup(locator->fd);
+            }
+
+            /* determine the file size */
+            if (locator->length == 0) {
+                if (lseek(fd, 0, SEEK_END) < 0)
+                    return EAS_ERROR_FILE_LENGTH;
+                if ((file->fileSize = lseek(fd, 0, SEEK_CUR)) == -1L)
+                    return EAS_ERROR_FILE_LENGTH;
+            }
+
+            // file size was passed in
+            else {
+                file->fileSize = (EAS_I32) locator->length;
+            }
+
+            // round offset down to page size
+            long pagesize = sysconf(_SC_PAGE_SIZE);
+            long mapoffset = locator->offset & ~(pagesize - 1);
+            long mapoffsetdelta = locator->offset - mapoffset;
+
+            void * bar = mmap(0, file->fileSize + mapoffsetdelta, PROT_READ, MAP_PRIVATE, fd, mapoffset);
+            if (bar == MAP_FAILED) {
+                    LOGE("error mapping file %d (%ld/%ld): %s\n", fd, mapoffset,
+                            file->fileSize + mapoffsetdelta, strerror(errno));
+                    close(fd);
+                    return EAS_FAILURE;
+            }
+            file->buffer = bar;
+            file->length = file->fileSize + mapoffsetdelta;
+            file->offset = mapoffsetdelta;
+            close(fd);
+
+            /* initialize some values */
+            file->filePos = 0;
+            file->dup = EAS_FALSE;
+            file->memfailed = 0;
+            file->sigbushandler.handlesigbus = NULL;
+            file->sigbushandler.sigbusvar = &file->memfailed;
+            file->sigbushandler.base = file->buffer;
+            file->sigbushandler.len = file->length;
+            file->oldsigbushandler = pthread_getspecific(EAS_sigbuskey);
+            pthread_setspecific(EAS_sigbuskey, &file->sigbushandler);
+
+            *pFile = file;
+            return EAS_SUCCESS;
+        }
+        file++;
+    }
+
+    /* too many open files */
+    return EAS_ERROR_MAX_FILES_OPEN;
+}
+
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWReadFile
+ *
+ * Read data from a file
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_RESULT EAS_HWReadFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *pBuffer, EAS_I32 n, EAS_I32 *pBytesRead)
+{
+    EAS_I32 count;
+
+    /* make sure we have a valid handle */
+    if (file->buffer == NULL)
+        return EAS_ERROR_INVALID_HANDLE;
+
+    if (n < 0)
+      return EAS_EOF;
+
+    /* calculate the bytes to read */
+    count = file->fileSize - file->filePos;
+    if (n < count)
+        count = n;
+    if (count < 0)
+      return EAS_EOF;
+
+    /* copy the data to the requested location, and advance the pointer */
+    if (count)
+        EAS_HWMemCpy(pBuffer, &file->buffer[file->filePos + file->offset], count);
+    if (*file->sigbushandler.sigbusvar)
+        count = 0;
+    file->filePos += count;
+    *pBytesRead = count;
+
+    /* were n bytes read? */
+    if (count!= n)
+        return EAS_EOF;
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWGetByte
+ *
+ * Read a byte from a file
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_RESULT EAS_HWGetByte (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p)
+{
+
+    /* make sure we have a valid handle */
+    if (file->buffer == NULL)
+        return EAS_ERROR_INVALID_HANDLE;
+
+    /* check for end of file */
+    if (file->filePos >= file->fileSize)
+    {
+        *((EAS_U8*) p) = 0;
+        return EAS_EOF;
+    }
+
+    /* get a character from the buffer */
+    *((EAS_U8*) p) = file->buffer[file->filePos++ + file->offset];
+    if (*file->sigbushandler.sigbusvar)
+    {
+        return EAS_EOF;
+    }
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWGetWord
+ *
+ * Returns the current location in the file 
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_RESULT EAS_HWGetWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)
+{
+    EAS_RESULT result;
+    EAS_U8 c1, c2;
+
+    /* read 2 bytes from the file */
+    if ((result = EAS_HWGetByte(hwInstData, file, &c1)) != EAS_SUCCESS)
+        return result;
+    if ((result = EAS_HWGetByte(hwInstData, file, &c2)) != EAS_SUCCESS)
+        return result;
+
+    /* order them as requested */
+    if (msbFirst)
+        *((EAS_U16*) p) = ((EAS_U16) c1 << 8) | c2;
+    else
+        *((EAS_U16*) p) = ((EAS_U16) c2 << 8) | c1;
+
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWGetDWord
+ *
+ * Returns the current location in the file 
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_RESULT EAS_HWGetDWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)
+{
+    EAS_RESULT result;
+    EAS_U8 c1, c2,c3,c4;
+
+    /* read 4 bytes from the file */
+    if ((result = EAS_HWGetByte(hwInstData, file, &c1)) != EAS_SUCCESS)
+        return result;
+    if ((result = EAS_HWGetByte(hwInstData, file, &c2)) != EAS_SUCCESS)
+        return result;
+    if ((result = EAS_HWGetByte(hwInstData, file, &c3)) != EAS_SUCCESS)
+        return result;
+    if ((result = EAS_HWGetByte(hwInstData, file, &c4)) != EAS_SUCCESS)
+        return result;
+
+    /* order them as requested */
+    if (msbFirst)
+        *((EAS_U32*) p) = ((EAS_U32) c1 << 24) | ((EAS_U32) c2 << 16) | ((EAS_U32) c3 << 8) | c4;
+    else
+        *((EAS_U32*) p)= ((EAS_U32) c4 << 24) | ((EAS_U32) c3 << 16) | ((EAS_U32) c2 << 8) | c1;
+
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWFilePos
+ *
+ * Returns the current location in the file 
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_RESULT EAS_HWFilePos (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pPosition)
+{
+
+    /* make sure we have a valid handle */
+    if (file->buffer == NULL)
+        return EAS_ERROR_INVALID_HANDLE;
+
+    *pPosition = file->filePos;
+    return EAS_SUCCESS;
+} /* end EAS_HWFilePos */
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWFileSeek
+ *
+ * Seek to a specific location in the file
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_RESULT EAS_HWFileSeek (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
+{
+
+    /* make sure we have a valid handle */
+    if (file->buffer == NULL)
+        return EAS_ERROR_INVALID_HANDLE;
+
+    /* validate new position */	
+    if ((position < 0) || (position > file->fileSize))
+        return EAS_ERROR_FILE_SEEK;
+
+    /* save new position */
+    file->filePos = position;
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWFileSeekOfs
+ *
+ * Seek forward or back relative to the current position
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_RESULT EAS_HWFileSeekOfs (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
+{
+
+    /* make sure we have a valid handle */
+    if (file->buffer == NULL)
+        return EAS_ERROR_INVALID_HANDLE;
+
+    /* determine the file position */	
+    position += file->filePos;
+    if ((position < 0) || (position > file->fileSize))
+        return EAS_ERROR_FILE_SEEK;
+
+    /* save new position */
+    file->filePos = position;
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWFileLength
+ *
+ * Return the file length
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_RESULT EAS_HWFileLength (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pLength)
+{
+
+    /* make sure we have a valid handle */
+    if (file->buffer == NULL)
+        return EAS_ERROR_INVALID_HANDLE;
+
+    *pLength = file->fileSize;
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWDupHandle
+ *
+ * Duplicate a file handle
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_RESULT EAS_HWDupHandle (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_FILE_HANDLE *pDupFile)
+{
+    EAS_HW_FILE *dupFile;
+    int i;
+
+    /* make sure we have a valid handle */
+    if (file->buffer == NULL)
+        return EAS_ERROR_INVALID_HANDLE;
+
+    /* find an empty entry in the file table */
+    dupFile = hwInstData->files;
+    for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
+    {
+        /* is this slot being used? */
+        if (dupFile->buffer == NULL)
+        {
+
+            /* copy info from the handle to be duplicated */
+            dupFile->filePos = file->filePos;
+            dupFile->fileSize = file->fileSize;
+            dupFile->buffer = file->buffer;
+            dupFile->length = file->length;
+            dupFile->offset = file->offset;
+            dupFile->sigbushandler = file->sigbushandler;
+            dupFile->oldsigbushandler = file->oldsigbushandler;
+
+            /* set the duplicate handle flag */
+            dupFile->dup = file->dup = EAS_TRUE;
+
+            *pDupFile = dupFile;
+            return EAS_SUCCESS;
+        }
+        dupFile++;
+    }
+
+    /* too many open files */
+    return EAS_ERROR_MAX_FILES_OPEN;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWClose
+ *
+ * Wrapper for fclose function
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_RESULT EAS_HWCloseFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file1)
+{
+    EAS_HW_FILE *file2,*dupFile;
+    int i;
+
+
+    /* make sure we have a valid handle */
+    if (file1->buffer == NULL)
+        return EAS_ERROR_INVALID_HANDLE;
+
+    /* check for duplicate handle */
+    if (file1->dup)
+    {
+        dupFile = NULL;
+        file2 = hwInstData->files;
+        for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
+        {
+            /* check for duplicate */
+            if ((file1 != file2) && (file2->buffer == file1->buffer))
+            {
+                /* is there more than one duplicate? */
+                if (dupFile != NULL)
+                {
+                    /* clear this entry and return */
+                    file1->buffer = NULL;
+                    return EAS_SUCCESS;
+                }
+
+                /* this is the first duplicate found */
+                else
+                    dupFile = file2;
+            }
+            file2++;
+        }
+
+        /* there is only one duplicate, clear the dup flag */
+        if (dupFile)
+            dupFile->dup = EAS_FALSE;
+        else
+            /* if we get here, there's a serious problem */
+            return EAS_ERROR_HANDLE_INTEGRITY;
+
+        /* clear this entry and return */
+        file1->buffer = NULL;
+        return EAS_SUCCESS;
+    }
+
+    /* no duplicates -free the buffer */
+    int e = munmap(file1->buffer, file1->length);
+    if (e != 0) {
+        LOGE("error unmapping %p/%ld: %s\n", file1->buffer, file1->length, strerror(errno));
+    }
+    pthread_setspecific(EAS_sigbuskey, file1->oldsigbushandler);
+
+    /* clear this entry and return */
+    file1->buffer = NULL;
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWVibrate
+ *
+ * Turn on/off vibrate function
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_RESULT EAS_HWVibrate (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
+{
+    EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000001 , state);
+    return EAS_SUCCESS;
+} /* end EAS_HWVibrate */
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWLED
+ *
+ * Turn on/off LED
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_RESULT EAS_HWLED (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
+{
+    EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000002 , state);
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWBackLight
+ *
+ * Turn on/off backlight
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_RESULT EAS_HWBackLight (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
+{
+    EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000003 , state);
+    return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWYield
+ *
+ * This function is called periodically by the EAS library to give the
+ * host an opportunity to allow other tasks to run. There are two ways to
+ * use this call:
+ *
+ * If you have a multi-tasking OS, you can call the yield function in the
+ * OS to allow other tasks to run. In this case, return EAS_FALSE to tell
+ * the EAS library to continue processing when control returns from this
+ * function.
+ *
+ * If tasks run in a single thread by sequential function calls (sometimes
+ * call a "commutator loop"), return EAS_TRUE to cause the EAS Library to
+ * return to the caller. Be sure to check the number of bytes rendered
+ * before passing the audio buffer to the codec - it may not be filled.
+ * The next call to EAS_Render will continue processing until the buffer
+ * has been filled.
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) hwInstData available for customer use */
+EAS_BOOL EAS_HWYield (EAS_HW_DATA_HANDLE hwInstData)
+{
+    /* put your code here */
+    return EAS_FALSE;
+}
+
diff --git a/arm-wt-22k/host_src/eas_main.c b/arm-wt-22k/host_src/eas_main.c
new file mode 100644
index 0000000..b71f543
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_main.c
@@ -0,0 +1,464 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas_main.c
+ *
+ * Contents and purpose:
+ * The entry point and high-level functions for the EAS Synthesizer test
+ * harness.
+ *			
+ * Copyright Sonic Network Inc. 2004
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 775 $
+ *   $Date: 2007-07-20 10:11:11 -0700 (Fri, 20 Jul 2007) $
+ *----------------------------------------------------------------------------
+*/
+
+#ifdef _lint
+#include "lint_stdlib.h"
+#else
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#endif
+
+#include "eas.h"
+#include "eas_wave.h"
+#include "eas_report.h"
+
+/* determines how many EAS buffers to fill a host buffer */
+#define NUM_BUFFERS			8
+
+/* default file to play if no filename is specified on the command line */
+static const char defaultTestFile[] = "test.mid";
+
+EAS_I32 polyphony;
+
+/* prototypes for helper functions */
+static void StrCopy(char *dest, const char *src, EAS_I32 size);
+static EAS_BOOL ChangeFileExt(char *str, const char *ext, EAS_I32 size);
+static EAS_RESULT PlayFile (EAS_DATA_HANDLE easData, const char* filename, const char* outputFile, const S_EAS_LIB_CONFIG *pLibConfig, void *buffer, EAS_I32 bufferSize);
+static EAS_BOOL EASLibraryCheck (const S_EAS_LIB_CONFIG *pLibConfig);
+
+/* main is defined after playfile to avoid the need for two passes through lint */
+
+/*----------------------------------------------------------------------------
+ * PlayFile()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * This function plays the file requested by filename
+ * 
+ * Inputs: 
+ *			
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+
+static EAS_RESULT PlayFile (EAS_DATA_HANDLE easData, const char* filename, const char* outputFile, const S_EAS_LIB_CONFIG *pLibConfig, void *buffer, EAS_I32 bufferSize)
+{
+	EAS_HANDLE handle;
+	EAS_RESULT result, reportResult;
+	EAS_I32 count;
+	EAS_STATE state;
+	EAS_I32 playTime;
+	char waveFilename[256];
+	WAVE_FILE *wFile;
+	EAS_INT i;
+	EAS_PCM *p;
+	EAS_FILE file;
+
+	/* determine the name of the output file */
+	wFile = NULL;
+	if (outputFile == NULL)
+	{
+		StrCopy(waveFilename, filename, sizeof(waveFilename));
+		if (!ChangeFileExt(waveFilename, "wav", sizeof(waveFilename)))
+		{
+			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error in output filename %s\n", waveFilename); */ }
+			return EAS_FAILURE;
+		}
+		outputFile = waveFilename;
+	}
+
+	/* call EAS library to open file */
+	file.path = filename;
+	file.fd = 0;
+	if ((reportResult = EAS_OpenFile(easData, &file, &handle, NULL)) != EAS_SUCCESS)
+	{
+		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_OpenFile returned %ld\n", reportResult); */ }
+		return reportResult;
+	}
+
+	/* prepare to play the file */
+	if ((result = EAS_Prepare(easData, handle)) != EAS_SUCCESS)
+	{
+		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_Prepare returned %ld\n", result); */ }
+		reportResult = result;
+	}
+
+	/* get play length */
+	if ((result = EAS_ParseMetaData(easData, handle, &playTime)) != EAS_SUCCESS)
+	{
+		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_ParseMetaData returned %ld\n", result); */ }
+		return result;
+	}
+	EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0xe624f4d9, 0x00000005 , playTime / 1000, playTime % 1000);
+
+	if (reportResult == EAS_SUCCESS)
+	{
+		/* create the output file */
+		wFile = WaveFileCreate(outputFile, pLibConfig->numChannels, pLibConfig->sampleRate, sizeof(EAS_PCM) * 8);
+		if (!wFile)
+		{
+			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Unable to create output file %s\n", waveFilename); */ }
+			reportResult = EAS_FAILURE;
+		}
+	}
+
+	/* rendering loop */
+	while (reportResult == EAS_SUCCESS)
+	{
+
+		/* we may render several buffers here to fill one host buffer */
+		for (i = 0, p = buffer; i < NUM_BUFFERS; i++, p+= pLibConfig->mixBufferSize * pLibConfig->numChannels)
+		{
+			
+			/* get the current time */
+			if ((result = EAS_GetLocation(easData, handle, &playTime)) != EAS_SUCCESS)
+			{
+				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_GetLocation returned %d\n",result); */ }
+				if (reportResult == EAS_SUCCESS)
+					reportResult = result;
+				break;
+			}
+			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Parser time: %d.%03d\n", playTime / 1000, playTime % 1000); */ }
+
+			/* render a buffer of audio */
+			if ((result = EAS_Render(easData, p, pLibConfig->mixBufferSize, &count)) != EAS_SUCCESS)
+			{
+				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_Render returned %d\n",result); */ }
+				if (reportResult == EAS_SUCCESS)
+					reportResult = result;
+			}
+		}
+
+		if (result == EAS_SUCCESS)
+		{
+			/* write it to the wave file */
+			if (WaveFileWrite(wFile, buffer, bufferSize) != bufferSize)
+			{
+				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "WaveFileWrite failed\n"); */ }
+				reportResult = EAS_FAILURE;
+			}
+		}
+
+		if (reportResult == EAS_SUCCESS)
+		{
+			/* check stream state */
+			if ((result = EAS_State(easData, handle, &state)) != EAS_SUCCESS)
+			{
+				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_State returned %d\n", result); */ }
+				reportResult = result;
+			}
+
+			/* is playback complete */
+			if ((state == EAS_STATE_STOPPED) || (state == EAS_STATE_ERROR))
+				break;
+		}
+	}
+
+	/* close the output file */
+	if (wFile)
+	{
+		if (!WaveFileClose(wFile))
+		{
+			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error closing wave file %s\n", waveFilename); */ }
+			if (reportResult == EAS_SUCCESS)
+				result = EAS_FAILURE;
+		}
+	}
+	
+	/* close the input file */
+	if ((result = EAS_CloseFile(easData,handle)) != EAS_SUCCESS)
+	{
+		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_Close returned %ld\n", result); */ }
+		if (reportResult == EAS_SUCCESS)
+			result = EAS_FAILURE;
+	}
+
+	return reportResult;
+} /* end PlayFile */
+
+/*----------------------------------------------------------------------------
+ * main()
+ *----------------------------------------------------------------------------
+ * Purpose: The entry point for the EAS sample application
+ * 
+ * Inputs: 
+ *			
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+int main( int argc, char **argv )
+{
+	EAS_DATA_HANDLE easData;
+	const S_EAS_LIB_CONFIG *pLibConfig;
+	void *buffer;
+	EAS_RESULT result, playResult;
+	EAS_I32 bufferSize;
+	int i;
+	int temp;
+	FILE *debugFile;
+	char *outputFile = NULL;
+
+	/* set the error reporting level */
+	EAS_SetDebugLevel(_EAS_SEVERITY_INFO);
+	debugFile = NULL;
+
+	/* process command-line arguments */
+	for (i = 1; i < argc; i++)
+	{
+		/* check for switch */
+		if (argv[i][0] == '-')
+		{
+			switch (argv[i][1])
+			{
+			case 'd':
+				temp = argv[i][2];
+				if ((temp >= '0') || (temp <= '9'))
+					EAS_SetDebugLevel(temp);
+				else
+					{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Invalid debug level %d\n", temp); */ }
+				break;
+			case 'f':
+				if ((debugFile = fopen(&argv[i][2],"w")) == NULL)
+					{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Unable to create debug file %s\n", &argv[i][2]); */ }
+				else
+					EAS_SetDebugFile(debugFile, EAS_TRUE);
+				break;
+			case 'o':
+				outputFile = &argv[i][2];
+				break;
+			case 'p':
+				polyphony = atoi(&argv[i][2]);
+				if (polyphony < 1)
+					polyphony = 1;
+				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "Polyphony set to %d\n", polyphony); */ }
+				break;
+			default:
+				break;
+			}
+			continue;
+		}
+	}
+
+	/* assume success */
+	playResult = EAS_SUCCESS;
+
+	/* get the library configuration */
+	pLibConfig = EAS_Config();
+	if (!EASLibraryCheck(pLibConfig))
+		return -1;
+	if (polyphony > pLibConfig->maxVoices)
+		polyphony = pLibConfig->maxVoices;
+
+	/* calculate buffer size */
+	bufferSize = pLibConfig->mixBufferSize * pLibConfig->numChannels * (EAS_I32)sizeof(EAS_PCM) * NUM_BUFFERS;
+
+	/* allocate output buffer memory */
+	buffer = malloc((EAS_U32)bufferSize);
+	if (!buffer)
+	{
+		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Error allocating memory for audio buffer\n"); */ }
+		return EAS_FAILURE;
+	}
+
+	/* initialize the EAS library */
+	polyphony = pLibConfig->maxVoices;
+	if ((result = EAS_Init(&easData)) != EAS_SUCCESS)
+	{
+		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "EAS_Init returned %ld - aborting!\n", result); */ }
+		free(buffer);
+		return result;
+	}
+
+	/*
+	 * Some debugging environments don't allow for passed parameters.
+	 * In this case, just play the default MIDI file "test.mid"
+	 */
+	if (argc < 2)
+	{
+		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "Playing '%s'\n", defaultTestFile); */ }
+		if ((playResult = PlayFile(easData, defaultTestFile, NULL, pLibConfig, buffer, bufferSize)) != EAS_SUCCESS)
+		{
+			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %d playing file %s\n", playResult, defaultTestFile); */ }
+		}
+	}
+	/* iterate through the list of files to be played */
+	else
+	{
+		for (i = 1; i < argc; i++)
+		{
+			/* check for switch */
+			if (argv[i][0] != '-')
+			{
+
+				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "Playing '%s'\n", argv[i]); */ }
+				if ((playResult = PlayFile(easData, argv[i], outputFile, pLibConfig, buffer, bufferSize)) != EAS_SUCCESS)
+				{
+					{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %d playing file %s\n", playResult, argv[i]); */ }
+					break;
+				}
+			}
+		}
+	}
+
+	/* shutdown the EAS library */
+	if ((result = EAS_Shutdown(easData)) != EAS_SUCCESS)
+	{
+		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "EAS_Shutdown returned %ld\n", result); */ }
+	}
+
+	/* free the output buffer */
+	free(buffer);
+
+	/* close the debug file */
+	if (debugFile)
+		fclose(debugFile);
+
+	/* play errors take precedence over shutdown errors */
+	if (playResult != EAS_SUCCESS)
+		return playResult;
+	return result;
+} /* end main */
+
+/*----------------------------------------------------------------------------
+ * StrCopy()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Safe string copy
+ * 
+ * Inputs: 
+ *			
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+static void StrCopy(char *dest, const char *src, EAS_I32 size)
+{
+	int len;
+
+	strncpy(dest, src, (size_t) size-1);
+	len = (int) strlen(src);
+	if (len < size)
+		dest[len] = 0;
+} /* end StrCopy */
+
+/*----------------------------------------------------------------------------
+ * ChangeFileExt()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Changes the file extension of a filename
+ * 
+ * Inputs: 
+ *			
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+static EAS_BOOL ChangeFileExt(char *str, const char *ext, EAS_I32 size)
+{
+	char *p;
+
+	/* find the extension, if any */
+	p = strrchr(str,'.');
+	if (!p)
+	{
+		if ((EAS_I32)(strlen(str) + 5) > size)
+			return EAS_FALSE;
+		strcat(str,".");
+		strcat(str,ext);
+		return EAS_TRUE;
+	}
+
+	/* make sure there's room for the extension */
+	p++;
+	*p = 0;
+	if ((EAS_I32)(strlen(str) + 4) > size)
+		return EAS_FALSE;
+	strcat(str,ext);
+	return EAS_TRUE;
+} /* end ChangeFileExt */
+
+/*----------------------------------------------------------------------------
+ * EASLibraryCheck()
+ *----------------------------------------------------------------------------
+ * Purpose: 
+ * Displays the library version and checks it against the header
+ * file used to build this code.
+ *
+ * Inputs:
+ * pLibConfig		- library configuration retrieved from the library
+ *		
+ * Outputs:
+ * returns EAS_TRUE if matched
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+static EAS_BOOL EASLibraryCheck (const S_EAS_LIB_CONFIG *pLibConfig)
+{
+
+	/* display the library version */
+	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "EAS Library Version %d.%d.%d.%d\n",
+		pLibConfig->libVersion >> 24,
+		(pLibConfig->libVersion >> 16) & 0x0f,
+		(pLibConfig->libVersion >> 8) & 0x0f,
+		pLibConfig->libVersion & 0x0f); */ }
+
+	/* display some info about the library build */
+	if (pLibConfig->checkedVersion)
+		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tChecked library\n"); */ }
+	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tMaximum polyphony: %d\n", pLibConfig->maxVoices); */ }
+	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tNumber of channels: %d\n", pLibConfig->numChannels); */ }
+	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tSample rate: %d\n", pLibConfig->sampleRate); */ }
+	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tMix buffer size: %d\n", pLibConfig->mixBufferSize); */ }
+	if (pLibConfig->filterEnabled)
+		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tFilter enabled\n"); */ }
+#ifndef _WIN32_WCE
+	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tLibrary Build Timestamp: %s", ctime((time_t*)&pLibConfig->buildTimeStamp)); */ }
+#endif
+	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tLibrary Build ID: %s\n", pLibConfig->buildGUID); */ }
+		
+	/* check it against the header file used to build this code */
+	/*lint -e{778} constant expression used for display purposes may evaluate to zero */
+	if (LIB_VERSION != pLibConfig->libVersion)
+	{
+		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Library version does not match header files. EAS Header Version %d.%d.%d.%d\n", 
+			LIB_VERSION >> 24,
+			(LIB_VERSION >> 16) & 0x0f,
+			(LIB_VERSION >> 8) & 0x0f,
+			LIB_VERSION & 0x0f); */ }
+		return EAS_FALSE;
+	}
+	return EAS_TRUE;
+} /* end EASLibraryCheck */
+
diff --git a/arm-wt-22k/host_src/eas_report.c b/arm-wt-22k/host_src/eas_report.c
new file mode 100644
index 0000000..d4dd22c
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_report.c
@@ -0,0 +1,264 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas_report.c
+ *
+ * Contents and purpose:
+ * This file contains the debug message handling routines for the EAS library.
+ * These routines should be modified as needed for your system.
+ *
+ * Copyright 2005 Sonic Network Inc.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *	 $Revision: 659 $
+ *	 $Date: 2007-04-24 13:36:35 -0700 (Tue, 24 Apr 2007) $
+ *----------------------------------------------------------------------------
+*/
+
+#ifdef _lint
+#include "lint_stdlib.h"
+#else
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#endif
+
+#include "eas_report.h"
+
+static int severityLevel = 9999;
+
+/* debug file */
+static FILE *debugFile = NULL;
+int flush = 0;
+
+#ifndef _NO_DEBUG_PREPROCESSOR
+
+/* structure should have an #include for each error message header file */
+S_DEBUG_MESSAGES debugMessages[] =
+{
+#ifndef UNIFIED_DEBUG_MESSAGES
+#include "eas_config_msgs.h"
+
+
+#include "eas_host_msgs.h"
+#include "eas_hostmm_msgs.h"
+#include "eas_math_msgs.h"
+#include "eas_midi_msgs.h"
+#include "eas_mixer_msgs.h"
+#include "eas_pcm_msgs.h"
+#include "eas_public_msgs.h"
+#include "eas_smf_msgs.h"
+#include "eas_wave_msgs.h"
+#include "eas_voicemgt_msgs.h"
+
+#ifdef _FM_SYNTH
+#include "eas_fmsynth_msgs.h"
+#include "eas_fmengine_msgs.h"
+#endif
+
+#ifdef _WT_SYNTH
+#include "eas_wtsynth_msgs.h"
+#include "eas_wtengine_msgs.h"
+#endif
+
+#ifdef _ARM_TEST_MAIN
+#include "arm_main_msgs.h"
+#endif
+
+#ifdef _EAS_MAIN
+#include "eas_main_msgs.h"
+#endif
+
+#ifdef _EAS_MAIN_IPC
+#include "eas_main_ipc_msgs.h"
+#endif
+
+#ifdef _METRICS_ENABLED
+#include "eas_perf_msgs.h"
+#endif
+
+#ifdef _COMPRESSOR_ENABLED
+#include "eas_compressor_msgs.h"
+#endif
+
+#ifdef _ENHANCER_ENABLED
+#include "eas_enhancer_msgs.h"
+#endif
+
+#ifdef _WOW_ENABLED
+#include "eas_wow_msgs.h"
+#endif
+
+#ifdef _SMAF_PARSER
+#include "eas_smaf_msgs.h"
+#endif
+
+#ifdef _OTA_PARSER
+#include "eas_ota_msgs.h"
+#endif
+
+#ifdef _IMELODY_PARSER
+#include "eas_imelody_msgs.h"
+#endif
+
+#ifdef _WAVE_PARSER
+#include "eas_wavefile_msgs.h"
+#endif
+
+#if defined(_CMX_PARSER) || defined(_MFI_PARSER)
+#include "eas_cmf_msgs.h"
+#endif
+
+#if defined(_CMX_PARSER) || defined(_MFI_PARSER) || defined(_WAVE_PARSER)
+#include "eas_imaadpcm_msgs.h"
+#endif
+
+#else
+#include "eas_debugmsgs.h"
+#endif
+
+/* denotes end of error messages */
+{ 0,0,0 }
+};
+
+/*----------------------------------------------------------------------------
+ * EAS_ReportEx()
+ *
+ * This is the error message handler. The default handler outputs error
+ * messages to stdout. Modify this as needed for your system.
+ *----------------------------------------------------------------------------
+*/
+void EAS_ReportEx (int severity, unsigned long hashCode, int serialNum, ...)
+{
+	va_list vargs;
+	int i;
+
+	/* check severity level */
+	if (severity > severityLevel)
+		return;
+
+	/* find the error message and output to stdout */
+	/*lint -e{661} we check for NULL pointer - no fence post error here */
+	for (i = 0; debugMessages[i].m_pDebugMsg; i++)
+	{
+		if ((debugMessages[i].m_nHashCode == hashCode) &&
+		(debugMessages[i].m_nSerialNum == serialNum))
+		{
+			/*lint -e{826} <allow variable args> */
+			va_start(vargs, serialNum);
+			if (debugFile)
+			{
+				vfprintf(debugFile, debugMessages[i].m_pDebugMsg, vargs);
+				if (flush)
+					fflush(debugFile);
+			}
+			else
+			{
+				vprintf(debugMessages[i].m_pDebugMsg, vargs);
+			}
+			va_end(vargs);
+			return;
+		}
+	}
+	printf("Unrecognized error: Severity=%d; HashCode=%lu; SerialNum=%d\n", severity, hashCode, serialNum);
+} /* end EAS_ReportEx */
+
+#else
+/*----------------------------------------------------------------------------
+ * EAS_Report()
+ *
+ * This is the error message handler. The default handler outputs error
+ * messages to stdout. Modify this as needed for your system.
+ *----------------------------------------------------------------------------
+*/
+void EAS_Report (int severity, const char *fmt, ...)
+{
+	va_list vargs;
+
+	/* check severity level */
+	if (severity > severityLevel)
+		return;
+
+	/*lint -e{826} <allow variable args> */
+	va_start(vargs, fmt);
+	if (debugFile)
+	{
+		vfprintf(debugFile, fmt, vargs);
+		if (flush)
+			fflush(debugFile);
+	}
+	else
+	{
+		vprintf(fmt, vargs);
+	}
+	va_end(vargs);
+} /* end EAS_Report */
+
+/*----------------------------------------------------------------------------
+ * EAS_ReportX()
+ *
+ * This is the error message handler. The default handler outputs error
+ * messages to stdout. Modify this as needed for your system.
+ *----------------------------------------------------------------------------
+*/
+void EAS_ReportX (int severity, const char *fmt, ...)
+{
+	va_list vargs;
+	
+	/* check severity level */
+	if (severity > severityLevel)
+		return;
+
+	/*lint -e{826} <allow variable args> */
+	va_start(vargs, fmt);
+	if (debugFile)
+	{
+		vfprintf(debugFile, fmt, vargs);
+		if (flush)
+			fflush(debugFile);
+	}
+	else
+	{
+		vprintf(fmt, vargs);
+	}
+	va_end(vargs);
+} /* end EAS_ReportX */
+#endif
+
+/*----------------------------------------------------------------------------
+ * EAS_SetDebugLevel()
+ *
+ * Sets the level for debug message output
+ *----------------------------------------------------------------------------
+*/
+
+void EAS_SetDebugLevel (int severity)
+{
+	severityLevel = severity;
+} /* end EAS_SetDebugLevel */
+
+/*----------------------------------------------------------------------------
+ * EAS_SetDebugFile()
+ *
+ * Redirect debugger output to the specified file.
+ *----------------------------------------------------------------------------
+*/
+void EAS_SetDebugFile (void *file, int flushAfterWrite)
+{
+	debugFile = (FILE*) file;
+	flush = flushAfterWrite;
+} /* end EAS_SetDebugFile */
+
diff --git a/arm-wt-22k/host_src/eas_report.h b/arm-wt-22k/host_src/eas_report.h
new file mode 100644
index 0000000..9d7c8e8
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_report.h
@@ -0,0 +1,77 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas_report.h
+ *
+ * Contents and purpose:
+ * This file contains the debug message handling routines for the EAS library.
+ * These routines should be modified as needed for your system.
+ *
+ * DO NOT MODIFY THIS FILE!
+ *
+ * Copyright 2005 Sonic Network Inc.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 82 $
+ *   $Date: 2006-07-10 11:45:19 -0700 (Mon, 10 Jul 2006) $
+ *----------------------------------------------------------------------------
+*/
+
+/* sentinel */
+#ifndef _EAS_REPORT_H
+#define _EAS_REPORT_H
+
+#define _EAS_SEVERITY_NOFILTER 0
+#define _EAS_SEVERITY_FATAL 1
+#define _EAS_SEVERITY_ERROR 2
+#define _EAS_SEVERITY_WARNING 3
+#define _EAS_SEVERITY_INFO 4
+#define _EAS_SEVERITY_DETAIL 5
+
+/* for C++ linkage */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _NO_DEBUG_PREPROCESSOR
+
+/* structure for included debug message header files */
+typedef struct
+{
+	unsigned long m_nHashCode;
+	int m_nSerialNum;
+	char *m_pDebugMsg;
+} S_DEBUG_MESSAGES;
+
+/* debug message handling prototypes */
+extern void EAS_ReportEx (int severity, unsigned long hashCode, int serialNum, ...);
+
+#else
+
+/* these prototypes are used if the debug preprocessor is not used */
+extern void EAS_Report (int severity, const char* fmt, ...);
+extern void EAS_ReportX (int severity, const char* fmt, ...);
+
+#endif
+
+extern void EAS_SetDebugLevel (int severity);
+extern void EAS_SetDebugFile (void *file, int flushAfterWrite);
+
+#ifdef __cplusplus
+} /* end extern "C" */
+#endif
+
+#endif
diff --git a/arm-wt-22k/host_src/eas_reverb.h b/arm-wt-22k/host_src/eas_reverb.h
new file mode 100644
index 0000000..a2535fb
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_reverb.h
@@ -0,0 +1,54 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas_reverb.h
+ *
+ * Contents and purpose:
+ * Contains parameter enumerations for the Reverb effect
+ *
+ *
+ * Copyright Sonic Network Inc. 2006
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 300 $
+ *   $Date: 2006-09-11 17:37:20 -0700 (Mon, 11 Sep 2006) $
+ *----------------------------------------------------------------------------
+*/
+
+#ifndef _EAS_REVERB_H
+#define _EAS_REVERB_H
+									
+
+/* enumerated parameter settings for Reverb effect */
+typedef enum
+{
+	EAS_PARAM_REVERB_BYPASS,
+	EAS_PARAM_REVERB_PRESET,
+	EAS_PARAM_REVERB_WET,
+	EAS_PARAM_REVERB_DRY
+} E_REVERB_PARAMS;
+
+
+typedef enum
+{
+	EAS_PARAM_REVERB_LARGE_HALL,
+	EAS_PARAM_REVERB_HALL,
+	EAS_PARAM_REVERB_CHAMBER,
+	EAS_PARAM_REVERB_ROOM,
+} E_REVERB_PRESETS;
+
+
+#endif /* _REVERB_H */
diff --git a/arm-wt-22k/host_src/eas_types.h b/arm-wt-22k/host_src/eas_types.h
new file mode 100644
index 0000000..5ba1e4e
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_types.h
@@ -0,0 +1,273 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas_types.h
+ *
+ * Contents and purpose:
+ * The public interface header for the EAS synthesizer.
+ *
+ * This header only contains declarations that are specific
+ * to this implementation.  
+ *			
+ * DO NOT MODIFY THIS FILE!
+ *
+ * Copyright Sonic Network Inc. 2004
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 726 $
+ *   $Date: 2007-06-14 23:10:46 -0700 (Thu, 14 Jun 2007) $
+ *----------------------------------------------------------------------------
+*/
+
+#ifndef _EAS_TYPES_H
+#define _EAS_TYPES_H
+
+/* EAS_RESULT return codes */
+typedef long EAS_RESULT;
+#define EAS_SUCCESS							0
+#define EAS_FAILURE							-1
+#define EAS_ERROR_INVALID_MODULE			-2
+#define EAS_ERROR_MALLOC_FAILED				-3
+#define EAS_ERROR_FILE_POS					-4
+#define EAS_ERROR_INVALID_FILE_MODE			-5
+#define EAS_ERROR_FILE_SEEK					-6
+#define EAS_ERROR_FILE_LENGTH				-7
+#define EAS_ERROR_NOT_IMPLEMENTED			-8
+#define EAS_ERROR_CLOSE_FAILED				-9
+#define EAS_ERROR_FILE_OPEN_FAILED			-10
+#define EAS_ERROR_INVALID_HANDLE			-11
+#define EAS_ERROR_NO_MIX_BUFFER				-12
+#define EAS_ERROR_PARAMETER_RANGE			-13
+#define EAS_ERROR_MAX_FILES_OPEN			-14
+#define EAS_ERROR_UNRECOGNIZED_FORMAT		-15
+#define EAS_BUFFER_SIZE_MISMATCH			-16
+#define EAS_ERROR_FILE_FORMAT				-17
+#define EAS_ERROR_SMF_NOT_INITIALIZED		-18
+#define EAS_ERROR_LOCATE_BEYOND_END			-19
+#define EAS_ERROR_INVALID_PCM_TYPE			-20
+#define EAS_ERROR_MAX_PCM_STREAMS			-21
+#define EAS_ERROR_NO_VOICE_ALLOCATED		-22
+#define EAS_ERROR_INVALID_CHANNEL			-23
+#define EAS_ERROR_ALREADY_STOPPED			-24
+#define EAS_ERROR_FILE_READ_FAILED			-25
+#define EAS_ERROR_HANDLE_INTEGRITY			-26
+#define EAS_ERROR_MAX_STREAMS_OPEN			-27
+#define EAS_ERROR_INVALID_PARAMETER			-28
+#define EAS_ERROR_FEATURE_NOT_AVAILABLE		-29
+#define EAS_ERROR_SOUND_LIBRARY				-30
+#define EAS_ERROR_NOT_VALID_IN_THIS_STATE	-31
+#define EAS_ERROR_NO_VIRTUAL_SYNTHESIZER	-32
+#define EAS_ERROR_FILE_ALREADY_OPEN			-33
+#define EAS_ERROR_FILE_ALREADY_CLOSED		-34
+#define EAS_ERROR_INCOMPATIBLE_VERSION		-35
+#define EAS_ERROR_QUEUE_IS_FULL				-36
+#define EAS_ERROR_QUEUE_IS_EMPTY			-37
+#define EAS_ERROR_FEATURE_ALREADY_ACTIVE	-38
+
+/* special return codes */
+#define EAS_EOF								3
+#define EAS_STREAM_BUFFERING				4
+#define EAS_BUFFER_FULL						5
+
+/* EAS_STATE return codes */
+typedef long EAS_STATE;
+typedef enum
+{
+	EAS_STATE_READY = 0,
+	EAS_STATE_PLAY,
+	EAS_STATE_STOPPING,
+	EAS_STATE_PAUSING,
+	EAS_STATE_STOPPED,
+	EAS_STATE_PAUSED,
+	EAS_STATE_OPEN,
+	EAS_STATE_ERROR,
+	EAS_STATE_EMPTY
+} E_EAS_STATE;
+
+/* constants */
+#ifndef EAS_CONST
+#define EAS_CONST const
+#endif
+
+/* definition for public interface functions */
+#ifndef EAS_PUBLIC
+#define EAS_PUBLIC
+#endif
+
+/* boolean values */
+typedef unsigned EAS_BOOL;
+typedef unsigned char EAS_BOOL8;
+
+#define EAS_FALSE	0
+#define EAS_TRUE	1
+
+/* scalar variable definitions */
+typedef unsigned char EAS_U8;
+typedef signed char EAS_I8;
+typedef char EAS_CHAR;
+
+typedef unsigned short EAS_U16;
+typedef short EAS_I16;
+
+typedef unsigned long EAS_U32;
+typedef long EAS_I32;
+
+typedef unsigned EAS_UINT;
+typedef int EAS_INT;
+typedef long EAS_LONG;
+
+/* audio output type */
+typedef short EAS_PCM;
+
+/* file open modes */
+typedef EAS_I32 EAS_FILE_MODE;
+#define EAS_FILE_READ	1
+#define EAS_FILE_WRITE	2
+
+/* file locator e.g. filename or memory pointer */
+typedef struct s_eas_file_tag {
+    const char* path;
+    int         fd;
+    long long   offset;
+    long long   length;
+} EAS_FILE, *EAS_FILE_LOCATOR;
+
+/* handle to stream */
+typedef struct s_eas_stream_tag *EAS_HANDLE;
+
+/* handle to file */
+typedef struct eas_hw_file_tag *EAS_FILE_HANDLE;
+	
+/* handle for synthesizer data */
+typedef struct s_eas_data_tag *EAS_DATA_HANDLE;
+
+/* handle to persistent data for host wrapper interface */
+typedef struct eas_hw_inst_data_tag *EAS_HW_DATA_HANDLE;
+
+/* handle to sound library */
+typedef struct s_eas_sndlib_tag *EAS_SNDLIB_HANDLE;
+typedef struct s_eas_dls_tag *EAS_DLSLIB_HANDLE;
+
+/* pointer to frame buffer - used in split architecture only */
+typedef struct s_eas_frame_buffer_tag *EAS_FRAME_BUFFER_HANDLE;
+
+/* untyped pointer for instance data */
+typedef void *EAS_VOID_PTR;
+
+/* inline functions */
+#ifndef EAS_INLINE
+#if defined (__XCC__)
+#define EAS_INLINE __inline__
+#elif defined (__GNUC__)
+#define EAS_INLINE inline static
+#else
+#define EAS_INLINE __inline
+#endif
+#endif
+
+/* define NULL value */
+#ifndef NULL
+#define NULL 0
+#endif
+
+/* metadata types for metadata return codes */
+typedef enum
+{
+	EAS_METADATA_UNKNOWN = 0,
+	EAS_METADATA_TITLE,
+	EAS_METADATA_AUTHOR,
+	EAS_METADATA_COPYRIGHT,
+	EAS_METADATA_LYRIC,
+	EAS_METADATA_TEXT
+} E_EAS_METADATA_TYPE;
+
+/* metadata callback function */
+typedef void (*EAS_METADATA_CBFUNC) (E_EAS_METADATA_TYPE metaDataType, char *metaDataBuf, EAS_VOID_PTR pUserData);
+
+/* file types for metadata return codes */
+typedef enum
+{
+	EAS_FILE_UNKNOWN = 0,
+	EAS_FILE_SMF0,
+	EAS_FILE_SMF1,
+	EAS_FILE_SMAF_UNKNOWN,
+	EAS_FILE_SMAF_MA2,
+	EAS_FILE_SMAF_MA3,
+	EAS_FILE_SMAF_MA5,
+	EAS_FILE_CMX,
+	EAS_FILE_MFI,
+	EAS_FILE_OTA,
+	EAS_FILE_IMELODY,
+	EAS_FILE_RTTTL,
+	EAS_FILE_XMF0,
+	EAS_FILE_XMF1,
+	EAS_FILE_WAVE_PCM,
+	EAS_FILE_WAVE_IMA_ADPCM,
+	EAS_FILE_MMAPI_TONE_CONTROL
+} E_EAS_FILE_TYPE;
+
+/* enumeration for synthesizers */
+typedef enum
+{
+	EAS_MCU_SYNTH = 0,
+	EAS_DSP_SYNTH
+} E_SYNTHESIZER;
+
+/* external audio callback program change */
+typedef struct s_ext_audio_prg_chg_tag
+{
+	EAS_U16 	bank;
+	EAS_U8		program;	
+	EAS_U8		channel;
+} S_EXT_AUDIO_PRG_CHG;
+
+/* external audio callback event */
+typedef struct s_ext_audio_event_tag
+{
+	EAS_U8		channel;
+	EAS_U8		note;
+	EAS_U8		velocity;
+	EAS_BOOL8	noteOn;
+} S_EXT_AUDIO_EVENT;
+
+typedef struct s_midi_controllers_tag
+{
+	EAS_U8		modWheel;			/* CC1 */
+	EAS_U8		volume;				/* CC7 */
+	EAS_U8		pan;				/* CC10 */
+	EAS_U8		expression;			/* CC11 */
+	EAS_U8		channelPressure;	/* MIDI channel pressure */
+
+#ifdef	_REVERB
+	EAS_U8		reverbSend;			/* CC91 */
+#endif
+
+#ifdef	_CHORUS
+	EAS_U8		chorusSend;			/* CC93 */
+#endif
+} S_MIDI_CONTROLLERS;
+
+/* iMode play modes enumeration for EAS_SetPlayMode */
+typedef enum
+{
+	IMODE_PLAY_ALL = 0,
+	IMODE_PLAY_PARTIAL
+} E_I_MODE_PLAY_MODE;
+
+typedef EAS_BOOL (*EAS_EXT_PRG_CHG_FUNC) (EAS_VOID_PTR pInstData, S_EXT_AUDIO_PRG_CHG *pPrgChg);
+typedef EAS_BOOL (*EAS_EXT_EVENT_FUNC) (EAS_VOID_PTR pInstData, S_EXT_AUDIO_EVENT *pEvent);
+
+#endif /* #ifndef _EAS_TYPES_H */
diff --git a/arm-wt-22k/host_src/eas_wave.c b/arm-wt-22k/host_src/eas_wave.c
new file mode 100644
index 0000000..02fed6e
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_wave.c
@@ -0,0 +1,423 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas_wave.c
+ *
+ * Contents and purpose:
+ * This module contains .WAV file functions for the EAS synthesizer
+ * test harness.  
+ *			
+ * Copyright Sonic Network Inc. 2005
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 658 $
+ *   $Date: 2007-04-24 13:35:49 -0700 (Tue, 24 Apr 2007) $
+ *----------------------------------------------------------------------------
+*/
+
+/* lint complaints about most C library headers, so we use our own during lint step */
+#ifdef _lint
+#include "lint_stdlib.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#endif
+
+#include "eas_wave.h"
+
+/* .WAV file format tags */
+const EAS_U32 riffTag = 0x46464952;
+const EAS_U32 waveTag = 0x45564157;
+const EAS_U32 fmtTag = 0x20746d66;
+const EAS_U32 dataTag = 0x61746164;
+
+#ifdef _BIG_ENDIAN
+/*----------------------------------------------------------------------------
+ * FlipDWord()
+ *----------------------------------------------------------------------------
+ * Purpose: Endian flip a DWORD for big-endian processors
+ * 
+ * Inputs: 
+ *			
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+static void FlipDWord (EAS_U32 *pValue)
+{
+	EAS_U8 *p;
+	EAS_U32 temp;
+
+	p = (EAS_U8*) pValue;
+	temp = (((((p[3] << 8) | p[2]) << 8) | p[1]) << 8) | p[0];
+	*pValue = temp;
+}
+
+/*----------------------------------------------------------------------------
+ * FlipWord()
+ *----------------------------------------------------------------------------
+ * Purpose: Endian flip a WORD for big-endian processors
+ * 
+ * Inputs: 
+ *			
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+static void FlipWord (EAS_U16 *pValue)
+{
+	EAS_U8 *p;
+	EAS_U16 temp;
+
+	p = (EAS_U8*) pValue;
+	temp = (p[1] << 8) | p[0];
+	*pValue = temp;
+}
+
+/*----------------------------------------------------------------------------
+ * FlipWaveHeader()
+ *----------------------------------------------------------------------------
+ * Purpose: Endian flip the wave header for big-endian processors
+ * 
+ * Inputs: 
+ *			
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+static void FlipWaveHeader (WAVE_HEADER *p)
+{
+
+	FlipDWord(&p->nRiffTag);
+	FlipDWord(&p->nRiffSize);
+	FlipDWord(&p->nWaveTag);
+	FlipDWord(&p->nFmtTag);
+	FlipDWord(&p->nFmtSize);
+	FlipDWord(&p->nDataTag);
+	FlipDWord(&p->nDataSize);
+	FlipWord(&p->fc.wFormatTag);
+	FlipWord(&p->fc.nChannels);
+	FlipDWord(&p->fc.nSamplesPerSec);
+	FlipDWord(&p->fc.nAvgBytesPerSec);
+	FlipWord(&p->fc.nBlockAlign);
+	FlipWord(&p->fc.wBitsPerSample);
+	
+}
+#endif
+
+/*----------------------------------------------------------------------------
+ * WaveFileCreate()
+ *----------------------------------------------------------------------------
+ * Purpose: Opens a wave file for writing and writes the header
+ * 
+ * Inputs: 
+ *			
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+
+WAVE_FILE *WaveFileCreate (const char *filename, EAS_I32 nChannels, EAS_I32 nSamplesPerSec, EAS_I32 wBitsPerSample)
+{
+	WAVE_FILE *wFile;
+
+	/* allocate memory */
+	wFile = malloc(sizeof(WAVE_FILE));
+	if (!wFile)
+		return NULL;
+	wFile->write = EAS_TRUE;
+
+	/* create the file */
+	wFile->file = fopen(filename,"wb");
+	if (!wFile->file)
+	{
+		free(wFile);
+		return NULL;
+	}
+
+	/* initialize PCM format .WAV file header */
+	wFile->wh.nRiffTag = riffTag;
+	wFile->wh.nRiffSize = sizeof(WAVE_HEADER) - 8;
+	wFile->wh.nWaveTag = waveTag;
+	wFile->wh.nFmtTag = fmtTag;
+	wFile->wh.nFmtSize = sizeof(FMT_CHUNK);
+
+	/* initalize 'fmt' chunk */
+	wFile->wh.fc.wFormatTag = 1;
+	wFile->wh.fc.nChannels = (EAS_U16) nChannels;
+	wFile->wh.fc.nSamplesPerSec = (EAS_U32) nSamplesPerSec;
+	wFile->wh.fc.wBitsPerSample = (EAS_U16) wBitsPerSample;
+	wFile->wh.fc.nBlockAlign = (EAS_U16) (nChannels * (EAS_U16) (wBitsPerSample / 8));
+	wFile->wh.fc.nAvgBytesPerSec = wFile->wh.fc.nBlockAlign * (EAS_U32) nSamplesPerSec;
+
+	/* initialize 'data' chunk */
+	wFile->wh.nDataTag = dataTag;
+	wFile->wh.nDataSize = 0;
+
+#ifdef _BIG_ENDIAN
+	FlipWaveHeader(&wFile->wh);
+#endif
+
+	/* write the header */
+	if (fwrite(&wFile->wh, sizeof(WAVE_HEADER), 1, wFile->file) != 1)
+	{
+		fclose(wFile->file);
+		free(wFile);
+		return NULL;
+	}
+
+#ifdef _BIG_ENDIAN
+	FlipWaveHeader(&wFile->wh);
+#endif
+
+	/* return the file handle */
+	return wFile;
+} /* end WaveFileCreate */
+
+/*----------------------------------------------------------------------------
+ * WaveFileWrite()
+ *----------------------------------------------------------------------------
+ * Purpose: Writes data to the wave file
+ * 
+ * Inputs: 
+ *			
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_I32 WaveFileWrite (WAVE_FILE *wFile, void *buffer, EAS_I32 n)
+{
+	EAS_I32 count;
+
+	/* make sure we have an open file */
+	if (wFile == NULL)
+	{
+		return 0;
+	}
+
+#ifdef _BIG_ENDIAN
+	{
+		EAS_I32 i;
+		EAS_U16 *p;
+		p = buffer;
+		i = n >> 1;
+		while (i--)
+			FlipWord(p++);
+	}
+#endif	
+	
+	/* write the data */
+	count = (EAS_I32) fwrite(buffer, 1, (size_t) n, wFile->file);
+
+	/* add the number of bytes written */
+	wFile->wh.nRiffSize += (EAS_U32) count;
+	wFile->wh.nDataSize += (EAS_U32) count;
+
+	/* return the count of bytes written */
+	return count;
+} /* end WriteWaveHeader */
+
+/*----------------------------------------------------------------------------
+ * WaveFileClose()
+ *----------------------------------------------------------------------------
+ * Purpose: Opens a wave file for writing and writes the header
+ * 
+ * Inputs: 
+ *			
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+
+EAS_BOOL WaveFileClose (WAVE_FILE *wFile)
+{
+	EAS_I32 count = 1;
+
+	/* return to beginning of file and write the header */
+	if (wFile->write)
+	{
+		if (fseek(wFile->file, 0L, SEEK_SET) == 0)
+		{
+			
+#ifdef _BIG_ENDIAN
+			FlipWaveHeader(&wFile->wh);
+#endif
+			count = (EAS_I32) fwrite(&wFile->wh, sizeof(WAVE_HEADER), 1, wFile->file);
+#ifdef _BIG_ENDIAN
+			FlipWaveHeader(&wFile->wh);
+#endif
+		}
+	}
+	
+	/* close the file */
+	if (fclose(wFile->file) != 0)
+		count = 0;
+
+	/* free the memory */
+	free(wFile);
+
+	/* return the file handle */
+	return (count == 1 ? EAS_TRUE : EAS_FALSE);
+} /* end WaveFileClose */
+
+#ifdef _WAVE_FILE_READ
+#ifdef _BIG_ENDIAN
+#error "WaveFileOpen not currently supported on big-endian processors"
+#endif
+/*----------------------------------------------------------------------------
+ * WaveFileOpen()
+ *----------------------------------------------------------------------------
+ * Purpose: Opens a wave file for reading and reads the header
+ * 
+ * Inputs: 
+ *			
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+
+WAVE_FILE *WaveFileOpen (const char *filename)
+{
+	WAVE_FILE *wFile;
+	struct
+	{
+		EAS_U32 tag;
+		EAS_U32 size;
+	} chunk;
+	EAS_U32 tag;
+	EAS_I32 startChunkPos;
+	EAS_INT state;
+	EAS_BOOL done;
+
+	/* allocate memory */
+	wFile = malloc(sizeof(WAVE_FILE));
+	if (!wFile)
+		return NULL;
+
+	/* open the file */
+	wFile->write = EAS_FALSE;
+	wFile->file = fopen(filename,"rb");
+	if (!wFile->file)
+	{
+		free(wFile);
+		return NULL;
+	}
+
+	/* make lint happy */
+	chunk.tag = chunk.size = 0;
+	startChunkPos = 0;
+
+	/* read the RIFF tag and file size */
+	state = 0;
+	done = EAS_FALSE;
+	while (!done)
+	{
+
+		switch(state)
+		{
+			/* read the RIFF tag */
+			case 0:
+				if (fread(&chunk, sizeof(chunk), 1, wFile->file) != 1)
+					done = EAS_TRUE;
+				else
+				{
+					if (chunk.tag != riffTag)
+						done = EAS_TRUE;
+					else
+						state++;
+				}
+				break;
+
+			/* read the WAVE tag */
+			case 1:
+				if (fread(&tag, sizeof(tag), 1, wFile->file) != 1)
+					done = EAS_TRUE;
+				else
+				{
+					if (tag != waveTag)
+						done = EAS_TRUE;
+					else
+						state++;
+				}
+				break;
+
+			/* looking for fmt chunk */
+			case 2:
+				if (fread(&chunk, sizeof(chunk), 1, wFile->file) != 1)
+					done = EAS_TRUE;
+				else
+				{
+					startChunkPos = ftell(wFile->file);
+						
+					/* not fmt tag, skip it */
+					if (chunk.tag != fmtTag)
+						fseek(wFile->file, startChunkPos + (EAS_I32) chunk.size, SEEK_SET);
+					else
+						state++;
+				}
+				break;
+
+			/* read fmt chunk */
+			case 3:
+				if (fread(&wFile->wh.fc, sizeof(FMT_CHUNK), 1, wFile->file) != 1)
+					done = EAS_TRUE;
+				else
+				{
+					fseek(wFile->file, startChunkPos + (EAS_I32) chunk.size, SEEK_SET);
+					state++;				
+				}
+				break;
+				
+			/* looking for data chunk */
+			case 4:
+				if (fread(&chunk, sizeof(chunk), 1, wFile->file) != 1)
+					done = EAS_TRUE;
+				else
+				{
+					startChunkPos = ftell(wFile->file);
+						
+					/* not data tag, skip it */
+					if (chunk.tag != dataTag)
+						fseek(wFile->file, startChunkPos + (EAS_I32) chunk.size, SEEK_SET);
+					else
+					{
+						wFile->dataSize = chunk.size;
+						state++;
+						done = EAS_TRUE;
+					}
+				}
+				break;
+				
+			default:
+				done = EAS_TRUE;
+				break;
+		}
+	}
+
+	/* if not final state, an error occurred */
+	if (state != 5)
+	{
+		fclose(wFile->file);
+		free(wFile);
+		return NULL;
+	}
+
+	/* return the file handle */
+	return wFile;
+} /* end WaveFileOpen */
+#endif
+
+
+
diff --git a/arm-wt-22k/host_src/eas_wave.h b/arm-wt-22k/host_src/eas_wave.h
new file mode 100644
index 0000000..ca388f5
--- /dev/null
+++ b/arm-wt-22k/host_src/eas_wave.h
@@ -0,0 +1,74 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * eas_wave.h
+ *
+ * Contents and purpose:
+ * Writes output to a .WAV file
+ *			
+ * DO NOT MODIFY THIS FILE!
+ *
+ * Copyright Sonic Network Inc. 2005
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 82 $
+ *   $Date: 2006-07-10 11:45:19 -0700 (Mon, 10 Jul 2006) $
+ *----------------------------------------------------------------------------
+*/
+
+#include "eas_types.h"
+
+/* sentinel */
+#ifndef _EAS_WAVE_H
+#define _EAS_WAVE_H
+
+/* .WAV file format chunk */
+typedef struct {
+	EAS_U16 wFormatTag;
+	EAS_U16 nChannels;
+	EAS_U32 nSamplesPerSec;
+	EAS_U32 nAvgBytesPerSec;
+	EAS_U16 nBlockAlign;
+	EAS_U16 wBitsPerSample;
+} FMT_CHUNK;
+
+/* .WAV file header */
+typedef struct {
+	EAS_U32 nRiffTag;
+	EAS_U32 nRiffSize;
+	EAS_U32 nWaveTag;
+	EAS_U32 nFmtTag;
+	EAS_U32 nFmtSize;
+	FMT_CHUNK fc;
+	EAS_U32 nDataTag;
+	EAS_U32 nDataSize;
+} WAVE_HEADER;
+
+typedef struct {
+	WAVE_HEADER wh;
+	FILE *file;
+	EAS_BOOL write;
+	EAS_U32 dataSize;
+} WAVE_FILE;
+
+WAVE_FILE *WaveFileCreate (const char *filename, EAS_I32 nChannels, EAS_I32 nSamplesPerSec, EAS_I32 wBitsPerSample);
+EAS_I32 WaveFileWrite (WAVE_FILE *wFile, void *buffer, EAS_I32 n);
+EAS_BOOL WaveFileClose (WAVE_FILE *wFile);
+WAVE_FILE *WaveFileOpen (const char *filename);
+
+#endif /* end #ifndef _EAS_WAVE_H */
+
+
+
diff --git a/arm-wt-22k/host_src/jet.h b/arm-wt-22k/host_src/jet.h
new file mode 100644
index 0000000..8e7f984
--- /dev/null
+++ b/arm-wt-22k/host_src/jet.h
@@ -0,0 +1,178 @@
+/*----------------------------------------------------------------------------
+ *
+ * File: 
+ * jet.h
+ *
+ * Contents and purpose:
+ * Public interface for JET sound engine
+ *
+ * Copyright (c) 2006 Sonic Network Inc.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *----------------------------------------------------------------------------
+ * Revision Control:
+ *   $Revision: 554 $
+ *   $Date: 2007-02-02 11:06:10 -0800 (Fri, 02 Feb 2007) $
+ *----------------------------------------------------------------------------
+*/
+
+#ifndef _JET_H
+#define _JET_H
+
+#include "eas_types.h"
+#include "eas.h"
+
+/* opaque handle types for JET interface */
+typedef struct s_jet_data_tag *JET_DATA_HANDLE;
+
+typedef struct s_jet_config_tag
+{
+	EAS_U8		appEventRangeLow;
+	EAS_U8		appEventRangeHigh;
+} S_JET_CONFIG;
+
+typedef struct s_jet_status_tag
+{
+	EAS_INT 	currentUserID;
+	EAS_INT 	segmentRepeatCount;
+	EAS_INT 	numQueuedSegments;
+	EAS_BOOL 	paused;
+} S_JET_STATUS;
+
+typedef struct s_jet_event_tag
+{
+	EAS_U8		segment;
+	EAS_U8		channel;
+	EAS_U8		track;
+	EAS_U8		controller;
+	EAS_U8		value;
+} S_JET_EVENT;
+
+/*----------------------------------------------------------------------------
+ * JET_Init()
+ *----------------------------------------------------------------------------
+ * Initializes the JET library, allocates memory, etc. Call
+ * JET_Shutdown to de-allocate memory. Pass NULL for pConfig
+ * to use defaults. If passing config data, configSize should be
+ * sizeof(S_JET_CONFIG). This allows for future expansion of the
+ * config structure while maintaining compatibility.
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT JET_Init (EAS_DATA_HANDLE easHandle, const S_JET_CONFIG *pConfig, EAS_INT configSize);
+
+/*----------------------------------------------------------------------------
+ * JET_Shutdown()
+ *----------------------------------------------------------------------------
+ * Frees any memory used by the JET library
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT JET_Shutdown (EAS_DATA_HANDLE easHandle);
+
+/*----------------------------------------------------------------------------
+ * JET_OpenFile()
+ *----------------------------------------------------------------------------
+ * Opens a JET content file for playback
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT JET_OpenFile (EAS_DATA_HANDLE easHandle, EAS_FILE_LOCATOR locator);
+
+/*----------------------------------------------------------------------------
+ * JET_GetAppData()
+ *----------------------------------------------------------------------------
+ * Returns location and size of application data in the JET file
+ *----------------------------------------------------------------------------
+*/
+EAS_RESULT JET_GetAppData (EAS_DATA_HANDLE easHandle, EAS_I32 *pAppDataOffset, EAS_I32 *pAppDataSize);
+
+/*----------------------------------------------------------------------------
+ * JET_CloseFile()
+ *----------------------------------------------------------------------------
+ * Closes a JET content file and releases associated resources
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT JET_CloseFile (EAS_DATA_HANDLE easHandle);
+
+/*----------------------------------------------------------------------------
+ * JET_Status()
+ *----------------------------------------------------------------------------
+ * Returns current status
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT JET_Status (EAS_DATA_HANDLE easHandle, S_JET_STATUS *pStatus);
+
+/*----------------------------------------------------------------------------
+ * JET_GetEvent()
+ *----------------------------------------------------------------------------
+ * Checks for application events
+ *----------------------------------------------------------------------------
+*/
+EAS_BOOL JET_GetEvent (EAS_DATA_HANDLE easHandle, EAS_U32 *pEventRaw, S_JET_EVENT *pEvent);
+
+/*----------------------------------------------------------------------------
+ * JET_ParseEvent()
+ *----------------------------------------------------------------------------
+ * Returns current status
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC void JET_ParseEvent (EAS_U32 event, S_JET_EVENT *pEvent);
+
+/*----------------------------------------------------------------------------
+ * JET_QueueSegment()
+ *----------------------------------------------------------------------------
+ * Queue a segment for playback
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT JET_QueueSegment (EAS_DATA_HANDLE easHandle, EAS_INT segmentNum, EAS_INT libNum, EAS_INT repeatCount, EAS_INT transpose, EAS_U32 muteFlags, EAS_U8 userID);
+
+/*----------------------------------------------------------------------------
+ * JET_Play()
+ *----------------------------------------------------------------------------
+ * Starts playback of the file
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT JET_Play (EAS_DATA_HANDLE easHandle);
+
+/*----------------------------------------------------------------------------
+ * JET_Pause()
+ *----------------------------------------------------------------------------
+ * Pauses playback of the file
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT JET_Pause (EAS_DATA_HANDLE easHandle);
+
+/*----------------------------------------------------------------------------
+ * JET_SetMuteFlags()
+ *----------------------------------------------------------------------------
+ * Change the state of the mute flags
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT JET_SetMuteFlags (EAS_DATA_HANDLE easHandle, EAS_U32 muteFlags, EAS_BOOL sync);
+
+/*----------------------------------------------------------------------------
+ * JET_SetMuteFlag()
+ *----------------------------------------------------------------------------
+ * Change the state of a single mute flag
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT JET_SetMuteFlag (EAS_DATA_HANDLE easHandle, EAS_INT trackNum, EAS_BOOL muteFlag, EAS_BOOL sync);
+
+/*----------------------------------------------------------------------------
+ * JET_TriggerClip()
+ *----------------------------------------------------------------------------
+ * Unmute a track and then mute it when it is complete
+ *----------------------------------------------------------------------------
+*/
+EAS_PUBLIC EAS_RESULT JET_TriggerClip (EAS_DATA_HANDLE easHandle, EAS_INT clipID);
+
+#endif
+
author	The Android Open Source Project <initial-contribution@android.com>	2008-10-21 07:00:00 -0700
committer	The Android Open Source Project <initial-contribution@android.com>	2008-10-21 07:00:00 -0700
commit	e442bb7cd6a085b33a4dd52c0e20a157ada7feb1 (patch)
tree	eef3202d79b3cbef0ee4f83b4b1f56922cb8d2ac /arm-wt-22k/host_src
download	android_external_sonivox-e442bb7cd6a085b33a4dd52c0e20a157ada7feb1.tar.gz android_external_sonivox-e442bb7cd6a085b33a4dd52c0e20a157ada7feb1.tar.bz2 android_external_sonivox-e442bb7cd6a085b33a4dd52c0e20a157ada7feb1.zip