arm-wt-22k/lib_src/jet.c

/*----------------------------------------------------------------------------
 *
 * File: 
 * jet.c
 *
 * Contents and purpose:
 * Implementation 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: 563 $
 *   $Date: 2007-02-13 20:26:23 -0800 (Tue, 13 Feb 2007) $
 *----------------------------------------------------------------------------
*/

//#define LOG_NDEBUG 0
#define LOG_TAG "JET_C"

//#define DEBUG_JET

#include "eas_data.h"
#include "eas_smf.h"
#include "jet_data.h"
#include "eas_host.h"
#include "eas_report.h"


/* default configuration */
static const S_JET_CONFIG jetDefaultConfig = 
{
	JET_EVENT_APP_LOW,
	JET_EVENT_APP_HIGH
};

/* function prototypes */
extern EAS_RESULT EAS_IntSetStrmParam (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_INT param, EAS_I32 value);
extern EAS_RESULT EAS_OpenJETStream (EAS_DATA_HANDLE pEASData, EAS_FILE_HANDLE fileHandle, EAS_I32 offset, EAS_HANDLE *ppStream);
extern EAS_RESULT DLSParser (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE fileHandle, EAS_I32 offset, EAS_DLSLIB_HANDLE *ppDLS);

/*----------------------------------------------------------------------------
 * JET_ParseEvent()
 *----------------------------------------------------------------------------
 * Returns current status
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC void JET_ParseEvent (EAS_U32 event, S_JET_EVENT *pEvent)
{
	pEvent->segment = (EAS_U8) ((event & JET_EVENT_SEG_MASK) >> JET_EVENT_SEG_SHIFT);
	pEvent->track = (EAS_U8) ((event & JET_EVENT_TRACK_MASK) >> JET_EVENT_TRACK_SHIFT);
	pEvent->channel = (EAS_U8) ((event & JET_EVENT_CHAN_MASK) >> JET_EVENT_CHAN_SHIFT);
	pEvent->controller = (EAS_U8) ((event & JET_EVENT_CTRL_MASK) >> JET_EVENT_CTRL_SHIFT);
	pEvent->value = (EAS_U8) (event & JET_EVENT_VAL_MASK);
}

#ifdef DEBUG_JET
/*----------------------------------------------------------------------------
 * JET_DumpEvent
 *----------------------------------------------------------------------------
 * Advances queue read/write index
 *----------------------------------------------------------------------------
*/
static void JET_DumpEvent (const char *procName, EAS_U32 event)
{
	S_JET_EVENT sEvent;
	JET_ParseEvent(event, &sEvent);
	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "%s: SegID=%d, TrkID=%d, channel=%d, ctrl=%d, val=%d\n",
		procName, sEvent.segment, sEvent.track, sEvent.channel, sEvent.controller, sEvent.value); */ }
}
#endif

/*----------------------------------------------------------------------------
 * JET_IncQueueIndex
 *----------------------------------------------------------------------------
 * Advances queue read/write index
 *----------------------------------------------------------------------------
*/
EAS_INLINE EAS_U8 JET_IncQueueIndex (EAS_U8 index, EAS_U8 queueSize)
{
	if (++index == queueSize)
		index = 0;
	return index;
}

/*----------------------------------------------------------------------------
 * JET_WriteQueue
 *----------------------------------------------------------------------------
 * Save event to queue
 *----------------------------------------------------------------------------
*/
EAS_INLINE void JET_WriteQueue (EAS_U32 *pEventQueue, EAS_U8 *pWriteIndex, EAS_U8 readIndex, EAS_U8 queueSize, EAS_U32 event)
{
	EAS_U8 temp;

	/* check for queue overflow */
	temp = JET_IncQueueIndex(*pWriteIndex, queueSize);
	if (temp == readIndex)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "JET_Event: Event queue overflow --- event ignored!\n"); */ }
		return;
	}

	/* save in queue and advance write index */
	pEventQueue[*pWriteIndex] = event;
	*pWriteIndex = temp;
}

/*----------------------------------------------------------------------------
 * JET_ReadQueue
 *----------------------------------------------------------------------------
 * Read event to queue
 *----------------------------------------------------------------------------
*/
EAS_INLINE EAS_BOOL JET_ReadQueue (EAS_U32 *pEventQueue, EAS_U8 *pReadIndex, EAS_U8 writeIndex, EAS_U8 queueSize, EAS_U32 *pEvent)
{

	/* check for empty queue */
	if (*pReadIndex == writeIndex)
		return EAS_FALSE;

	/* save in queue and advance write index */
	*pEvent = pEventQueue[*pReadIndex];
	*pReadIndex = JET_IncQueueIndex(*pReadIndex, queueSize);
	return EAS_TRUE;
}

/*----------------------------------------------------------------------------
 * JET_NextSegment
 *----------------------------------------------------------------------------
 * Advances segment number
 *----------------------------------------------------------------------------
*/
EAS_INLINE EAS_INT JET_NextSegment (EAS_INT seg_num)
{
	if (++seg_num == SEG_QUEUE_DEPTH)
		seg_num = 0;
	return seg_num;
}

/*----------------------------------------------------------------------------
 * JET_PrepareSegment()
 *----------------------------------------------------------------------------
 * Prepare a segment for playback
 *----------------------------------------------------------------------------
*/
static EAS_RESULT JET_PrepareSegment (EAS_DATA_HANDLE easHandle, EAS_I32 queueNum)
{
	EAS_RESULT result;
	S_JET_SEGMENT *p;

	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "JET_PrepareSegment: %d\n", queueNum); */ }

	p = &easHandle->jetHandle->segQueue[queueNum];
	result = EAS_Prepare(easHandle, p->streamHandle);
	if (result != EAS_SUCCESS)
		return result;

	/* pause segment - must be triggered by play or end of previous segment */
	result = EAS_Pause(easHandle, p->streamHandle);
	if (result != EAS_SUCCESS)
		return result;
	p->state = JET_STATE_READY;

	/* set calback data */
	result = EAS_IntSetStrmParam(easHandle, p->streamHandle, PARSER_DATA_JET_CB, queueNum);
	if (result != EAS_SUCCESS)
		return result;
	
	/* set DLS collection */
	if (p->libNum >= 0)
	{
		result = EAS_IntSetStrmParam(easHandle, p->streamHandle, 
			PARSER_DATA_DLS_COLLECTION, (EAS_I32) easHandle->jetHandle->libHandles[p->libNum]);
		if (result != EAS_SUCCESS)
			return result;
	}

	/* set transposition */
	if (p->transpose)
	{
		result = EAS_SetTransposition(easHandle, p->streamHandle, p->transpose);
		if (result != EAS_SUCCESS)
			return result;
	}

	return result;
}

/*----------------------------------------------------------------------------
 * JET_StartPlayback()
 *----------------------------------------------------------------------------
 * Start segment playback
 *----------------------------------------------------------------------------
*/
static EAS_RESULT JET_StartPlayback (EAS_DATA_HANDLE easHandle, EAS_I32 queueNum)
{
	EAS_RESULT result = EAS_SUCCESS;
	S_JET_SEGMENT *pSeg;
	
	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "JET_StartPlayback %d\n", queueNum); */ }

	/* if next segment is queued, start playback */					
	pSeg = &easHandle->jetHandle->segQueue[queueNum];
	if (pSeg->streamHandle != NULL)
	{
		result = EAS_Resume(easHandle, pSeg->streamHandle);
		easHandle->jetHandle->segQueue[queueNum].state = JET_STATE_PLAYING;

		/* set mute flags */
		if ((result == EAS_SUCCESS) && (pSeg->muteFlags != 0))
			result = EAS_IntSetStrmParam(easHandle, pSeg->streamHandle, PARSER_DATA_MUTE_FLAGS, (EAS_I32) pSeg->muteFlags);
	}
	return result;
}

/*----------------------------------------------------------------------------
 * JET_CloseSegment
 *----------------------------------------------------------------------------
 * Closes stream associated with a segment
 *----------------------------------------------------------------------------
*/
EAS_INLINE EAS_INT JET_CloseSegment (EAS_DATA_HANDLE easHandle, EAS_INT queueNum)
{
	EAS_RESULT result;

	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "JET_CloseSegment %d\n", queueNum); */ }
	
	/* close the segment */
	result = EAS_CloseFile(easHandle, easHandle->jetHandle->segQueue[queueNum].streamHandle);
	if (result != EAS_SUCCESS)
		return result;

	easHandle->jetHandle->segQueue[queueNum].streamHandle = NULL;
	easHandle->jetHandle->segQueue[queueNum].state = JET_STATE_CLOSED;
	easHandle->jetHandle->numQueuedSegments--;
	return result;
}

/*----------------------------------------------------------------------------
 * JetParseInfoChunk()
 *----------------------------------------------------------------------------
 * Parses the JET info chunk
 *----------------------------------------------------------------------------
*/
static EAS_RESULT JetParseInfoChunk (EAS_DATA_HANDLE easHandle, EAS_I32 pos, EAS_I32 chunkSize)
{
	EAS_RESULT result;
	EAS_U32 infoType;
	EAS_U32 temp;

	/* offset to data */
	result = EAS_HWFileSeek(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle, pos);
	if (result != EAS_SUCCESS)
		return result;

	/* read the entire chunk */
	result = EAS_SUCCESS;
	while ((result == EAS_SUCCESS) && (chunkSize > 0))
	{
		
		/* get info infoType */
		result = EAS_HWGetDWord(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle, &infoType, EAS_TRUE);
		if (result != EAS_SUCCESS)
			break;

		/* get info field */
		result = EAS_HWGetDWord(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle, &temp, EAS_FALSE);
		if (result == EAS_SUCCESS)

		switch (infoType)
		{
			case INFO_NUM_SMF_CHUNKS:
				easHandle->jetHandle->numSegments = (EAS_U8) temp;
				break;
				
			case INFO_NUM_DLS_CHUNKS:
				easHandle->jetHandle->numLibraries = (EAS_U8) temp;
				break;

			case INFO_JET_VERSION:
				/* check major version number */
				if ((temp & 0xff000000) != (JET_VERSION & 0xff000000))
					return EAS_ERROR_INCOMPATIBLE_VERSION;
				break;

			default:
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Ignoring unrecognized JET info type 0x%08x", infoType); */ }
				break;
		}

		chunkSize -= 8;
	}

	/* allocate pointers for chunks to follow */
	
	return result;
}

/*----------------------------------------------------------------------------
 * JET_OpenFile()
 *----------------------------------------------------------------------------
 * Opens a JET content file for playback
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT JET_OpenFile (EAS_DATA_HANDLE easHandle, EAS_FILE_LOCATOR locator)
{
	EAS_RESULT result;
	EAS_U32 chunkType;
	EAS_I32 pos;
	EAS_I32 chunkSize;
	EAS_INT smfChunkNum;
	EAS_INT dlsChunkNum;
	EAS_I32 dataSize = 0; /* make lint happy */

	/* make sure that we don't have an open file */
	if (easHandle->jetHandle->jetFileHandle != NULL)
		return EAS_ERROR_FILE_ALREADY_OPEN;

	/* open the media file */
	result = EAS_HWOpenFile(easHandle->hwInstData, locator, &easHandle->jetHandle->jetFileHandle, EAS_FILE_READ);
	if (result != EAS_SUCCESS)
		return result;

	/* check header */
	result = EAS_HWGetDWord(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle, &chunkType, EAS_TRUE);
	if (result == EAS_SUCCESS)
	{
		if (chunkType != JET_HEADER_TAG)
		{
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "File is not JET format\n"); */ }
			result = EAS_ERROR_UNRECOGNIZED_FORMAT;
		}
	}
	/* get the file data size */
	if (result == EAS_SUCCESS)
		result = EAS_HWGetDWord(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle, &dataSize, EAS_FALSE);

	/* parse through the file to find contents */
	smfChunkNum = dlsChunkNum = 0;
	pos = chunkSize = 8;
	while ((result == EAS_SUCCESS) && (pos < dataSize))
	{

		/* offset to chunk data */
		result = EAS_HWFileSeek(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle, pos);
		if (result != EAS_SUCCESS)
			break;
			
		/* get chunk size and type */
		result = EAS_HWGetDWord(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle, &chunkType, EAS_TRUE);
		if (result != EAS_SUCCESS)
			break;

		result = EAS_HWGetDWord(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle, &chunkSize, EAS_FALSE);
		if (result != EAS_SUCCESS)
			break;
		pos += 8;

		switch (chunkType)
		{
			case JET_INFO_CHUNK:
				result = JetParseInfoChunk(easHandle, pos, chunkSize);
				break;
				
			case JET_SMF_CHUNK:
				if (smfChunkNum < easHandle->jetHandle->numSegments)
					easHandle->jetHandle->segmentOffsets[smfChunkNum++] = pos;
				else
					{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Ignoring extraneous SMF chunk"); */ }
				break;

			case JET_DLS_CHUNK:
				if (dlsChunkNum < easHandle->jetHandle->numLibraries)
					result = DLSParser(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle, pos, &easHandle->jetHandle->libHandles[dlsChunkNum++]);
				else
					{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Ignoring extraneous DLS chunk"); */ }
				break;

			case JET_APP_DATA_CHUNK:
				easHandle->jetHandle->appDataOffset = pos;
				easHandle->jetHandle->appDataSize = chunkSize;
				break;

			case INFO_JET_COPYRIGHT:
				break;

			default:
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Ignoring unrecognized JET chunk type 0x%08x", chunkType); */ }
				break;
		}

		/* offset to next chunk */
		pos += chunkSize;
	}

	/* close file if something went wrong */
	if (result != EAS_SUCCESS)
		EAS_HWCloseFile(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle);

	return result;
}

/*----------------------------------------------------------------------------
 * 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)
{

	/* check for app chunk */
	if (easHandle->jetHandle->appDataSize == 0)
	{
		*pAppDataOffset = *pAppDataSize = 0;
		return EAS_FAILURE;
	}

	/* return app data */
	*pAppDataOffset = easHandle->jetHandle->appDataOffset;
	*pAppDataSize = easHandle->jetHandle->appDataSize;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * JET_CloseFile()
 *----------------------------------------------------------------------------
 * Closes a JET content file and releases associated resources
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT JET_CloseFile (EAS_DATA_HANDLE easHandle)
{
	EAS_INT index;
	EAS_RESULT result = EAS_SUCCESS;

	/* close open streams */
	for (index = 0; index < SEG_QUEUE_DEPTH; index++)
	{
		if (easHandle->jetHandle->segQueue[index].streamHandle != NULL)
		{
			result = JET_CloseSegment(easHandle, index);
			if (result != EAS_SUCCESS)
				break;
		}
	}

	/* close the main file handle */
	if ((result == EAS_SUCCESS) && (easHandle->jetHandle->jetFileHandle != NULL))
	{
		result = EAS_HWCloseFile(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle);
		if (result == EAS_SUCCESS)
			easHandle->jetHandle->jetFileHandle = NULL;
	}
	return result;
}
	
/*----------------------------------------------------------------------------
 * JET_Init()
 *----------------------------------------------------------------------------
 * Initializes the JET library, allocates memory, etc. Call
 * JET_Shutdown to de-allocate memory.
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT JET_Init (EAS_DATA_HANDLE easHandle, const S_JET_CONFIG *pConfig, EAS_INT configSize)
{
	S_JET_DATA *pJet;
	EAS_U8 flags = 0;

	/* sanity check */
	if (easHandle == NULL)
		return EAS_ERROR_HANDLE_INTEGRITY;
	if (easHandle->jetHandle != NULL)
		return EAS_ERROR_FEATURE_ALREADY_ACTIVE;
	if (pConfig == NULL)
		pConfig = &jetDefaultConfig;

	/* allocate the JET data object */
	pJet = EAS_HWMalloc(easHandle->hwInstData, sizeof(S_JET_DATA));
	if (pJet == NULL)
		return EAS_ERROR_MALLOC_FAILED;

	/* initialize JET data structure */
	EAS_HWMemSet(pJet, 0, sizeof(S_JET_DATA));
	easHandle->jetHandle = pJet;
	pJet->flags = flags;

	/* copy config data */
	if (configSize > (EAS_INT) sizeof(S_JET_CONFIG))
		configSize = sizeof(S_JET_CONFIG);
	EAS_HWMemCpy(&pJet->config, pConfig, configSize);
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * JET_Shutdown()
 *----------------------------------------------------------------------------
 * Frees any memory used by the JET library
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT JET_Shutdown (EAS_DATA_HANDLE easHandle)
{
	EAS_RESULT result;

	/* close any open files */
	result = JET_CloseFile(easHandle);

	/* free allocated data */
	EAS_HWFree(easHandle->hwInstData, easHandle->jetHandle);
	easHandle->jetHandle = NULL;
	return result;
}

/*----------------------------------------------------------------------------
 * JET_Status()
 *----------------------------------------------------------------------------
 * Returns current status
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT JET_Status (EAS_DATA_HANDLE easHandle, S_JET_STATUS *pStatus)
{
	S_JET_SEGMENT *pSeg;

	pSeg = &easHandle->jetHandle->segQueue[easHandle->jetHandle->playSegment];
	if (pSeg->streamHandle != NULL)
	{
		pStatus->currentUserID = pSeg->userID;
		pStatus->segmentRepeatCount = pSeg->repeatCount;
	}
	else
	{
		pStatus->currentUserID = -1;
		pStatus->segmentRepeatCount = 0;
	}

	pStatus->paused = !(easHandle->jetHandle->flags & JET_FLAGS_PLAYING);
	pStatus->numQueuedSegments = easHandle->jetHandle->numQueuedSegments;
	pStatus->currentPlayingSegment = easHandle->jetHandle->playSegment;
	pStatus->currentQueuedSegment = easHandle->jetHandle->queueSegment;
	if (pSeg->streamHandle != NULL)
	{
		EAS_RESULT result;
		EAS_I32 location ;
		if ((result = EAS_GetLocation(easHandle, pSeg->streamHandle, &location)) == EAS_SUCCESS)
			if(location != 0)
			{
				pStatus->location = location;
			}
	}
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * JET_GetEvent()
 *----------------------------------------------------------------------------
 * Checks for application events
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_BOOL JET_GetEvent (EAS_DATA_HANDLE easHandle, EAS_U32 *pEventRaw, S_JET_EVENT *pEvent)
{
	EAS_U32 jetEvent;
	EAS_BOOL gotEvent;
	
	/* process event queue */
	gotEvent = JET_ReadQueue(easHandle->jetHandle->appEventQueue,
		&easHandle->jetHandle->appEventQueueRead, 
		easHandle->jetHandle->appEventQueueWrite,
		APP_EVENT_QUEUE_SIZE, &jetEvent);

	if (gotEvent)
	{
		if (pEventRaw != NULL)
			*pEventRaw = jetEvent;
		
		if (pEvent != NULL)
			JET_ParseEvent(jetEvent, pEvent);
	}

	return gotEvent;
}

/*----------------------------------------------------------------------------
 * 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)
{
	EAS_FILE_HANDLE fileHandle;
	EAS_RESULT result;
	S_JET_SEGMENT *p;

	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "JET_QueueSegment segNum=%d, queue=%d\n", segmentNum, easHandle->jetHandle->queueSegment); */ }

	/* make sure it's a valid segment */
	if (segmentNum >= easHandle->jetHandle->numSegments)
		return EAS_ERROR_PARAMETER_RANGE;

	/* make sure it's a valid DLS */
	if (libNum >= easHandle->jetHandle->numLibraries)
		return EAS_ERROR_PARAMETER_RANGE;

	/* check to see if queue is full */
	p = &easHandle->jetHandle->segQueue[easHandle->jetHandle->queueSegment];
	if (p->streamHandle != NULL)
		return EAS_ERROR_QUEUE_IS_FULL;		

	/* initialize data */
	p->userID = userID;
	p->repeatCount = (EAS_I16) repeatCount;
	p->transpose = (EAS_I8) transpose;
	p->libNum = (EAS_I8) libNum;
	p->muteFlags = muteFlags;
	p->state = JET_STATE_CLOSED;

	/* open the file */
	result = EAS_OpenJETStream(easHandle, easHandle->jetHandle->jetFileHandle, easHandle->jetHandle->segmentOffsets[segmentNum], &p->streamHandle);
	if (result != EAS_SUCCESS)
		return result;
	p->state = JET_STATE_OPEN;

	/* if less than SEG_QUEUE_DEPTH segments queued up, prepare file for playback */
	if (++easHandle->jetHandle->numQueuedSegments < SEG_QUEUE_DEPTH)
	{
		result = JET_PrepareSegment(easHandle, easHandle->jetHandle->queueSegment);
		if (result != EAS_SUCCESS)
			return result;
	}
	
	/* create duplicate file handle */
	result = EAS_HWDupHandle(easHandle->hwInstData, easHandle->jetHandle->jetFileHandle, &fileHandle);
	if (result != EAS_SUCCESS)
		return result;

	easHandle->jetHandle->jetFileHandle = fileHandle;
	easHandle->jetHandle->queueSegment = (EAS_U8) JET_NextSegment(easHandle->jetHandle->queueSegment);
	return result;
}

/*----------------------------------------------------------------------------
 * JET_Play()
 *----------------------------------------------------------------------------
 * Starts playback of the file
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT JET_Play (EAS_DATA_HANDLE easHandle)
{
	EAS_RESULT result;
	EAS_INT index;
	EAS_INT count = 0;

	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "JET_Play\n"); */ }

	/* sanity check */
	if (easHandle->jetHandle->flags & JET_FLAGS_PLAYING)
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;

	/* resume all paused streams */
	for (index = 0; index < SEG_QUEUE_DEPTH; index++)
	{
		if (((index == easHandle->jetHandle->playSegment) && (easHandle->jetHandle->segQueue[index].state == JET_STATE_READY)) ||
			(easHandle->jetHandle->segQueue[index].state == JET_STATE_PAUSED))
		{
			result = JET_StartPlayback(easHandle, index);
			if (result != EAS_SUCCESS)
				return result;
			count++;
		}
	}

	/* if no streams are playing, return error */
	if (!count)
		return EAS_ERROR_QUEUE_IS_EMPTY;

	easHandle->jetHandle->flags |= JET_FLAGS_PLAYING;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * JET_Pause()
 *----------------------------------------------------------------------------
 * Pauses playback of the file
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT JET_Pause (EAS_DATA_HANDLE easHandle)
{
	EAS_RESULT result;
	EAS_INT index;
	EAS_INT count = 0;

	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "JET_Pause\n"); */ }
	
	/* sanity check */
	if ((easHandle->jetHandle->flags & JET_FLAGS_PLAYING) == 0)
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	
	/* pause all playing streams */
	for (index = 0; index < SEG_QUEUE_DEPTH; index++)
	{
		if (easHandle->jetHandle->segQueue[index].state == JET_STATE_PLAYING)
		{
			result = EAS_Pause(easHandle, easHandle->jetHandle->segQueue[easHandle->jetHandle->playSegment].streamHandle);
			if (result != EAS_SUCCESS)
				return result;
			easHandle->jetHandle->segQueue[easHandle->jetHandle->playSegment].state = JET_STATE_PAUSED;
			count++;
		}
	}

	/* if no streams are paused, return error */
	if (!count)
		return EAS_ERROR_QUEUE_IS_EMPTY;

	easHandle->jetHandle->flags &= ~JET_FLAGS_PLAYING;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * 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)
{
	S_JET_SEGMENT *pSeg;

	/* get pointer to current segment */
	pSeg = &easHandle->jetHandle->segQueue[easHandle->jetHandle->playSegment];

	/* unsynchronized mute, set flags and return */
	if (!sync)
	{
		if (pSeg->streamHandle == NULL)
			return EAS_ERROR_QUEUE_IS_EMPTY;
		pSeg->muteFlags = muteFlags;
		return EAS_IntSetStrmParam(easHandle, pSeg->streamHandle, PARSER_DATA_MUTE_FLAGS, (EAS_I32) muteFlags);
	}


	/* check for valid stream state */
	if (pSeg->state == JET_STATE_CLOSED)
		return EAS_ERROR_QUEUE_IS_EMPTY;

	/* save mute flags */
	pSeg->muteFlags = muteFlags;

	/* if repeating segment, set mute update flag */
	if (sync)
		pSeg->flags |= JET_SEG_FLAG_MUTE_UPDATE;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * 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)
{
	S_JET_SEGMENT *pSeg;
	EAS_U32 trackMuteFlag;


	/* setup flag */
	if ((trackNum < 0) || (trackNum > 31))
		return EAS_ERROR_PARAMETER_RANGE;
	trackMuteFlag = (1 << trackNum);

	/* get pointer to current segment */
	pSeg = &easHandle->jetHandle->segQueue[easHandle->jetHandle->playSegment];

	/* unsynchronized mute, set flags and return */
	if (!sync)
	{
		if (pSeg->streamHandle == NULL)
			return EAS_ERROR_QUEUE_IS_EMPTY;
		if (muteFlag)
			pSeg->muteFlags |= trackMuteFlag;
		else
			pSeg->muteFlags &= ~trackMuteFlag;
		return EAS_IntSetStrmParam(easHandle, pSeg->streamHandle, PARSER_DATA_MUTE_FLAGS, (EAS_I32) pSeg->muteFlags);
	}


	/* check for valid stream state */
	if (pSeg->state == JET_STATE_CLOSED)
		return EAS_ERROR_QUEUE_IS_EMPTY;

	/* save mute flags and set mute update flag */
	if (muteFlag)
		pSeg->muteFlags |= trackMuteFlag;
	else
		pSeg->muteFlags &= ~trackMuteFlag;
	pSeg->flags |= JET_SEG_FLAG_MUTE_UPDATE;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * JET_TriggerClip()
 *----------------------------------------------------------------------------
 * Unmute a track and then mute it when it is complete. If a clip
 * is already playing, change mute event to a trigger event. The
 * JET_Event function will not mute the clip, but will allow it
 * to continue playing through the next clip.
 *
 * NOTE: We use bit 7 to indicate an entry in the queue. For a
 * small queue, it is cheaper in both memory and CPU cycles to
 * scan the entire queue for non-zero events than keep enqueue
 * and dequeue indices.
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT JET_TriggerClip (EAS_DATA_HANDLE easHandle, EAS_INT clipID)
{
	EAS_INT i;
	EAS_INT index = -1;

	/* check for valid clipID */
	if ((clipID < 0) || (clipID > 63))
		return EAS_ERROR_PARAMETER_RANGE;

	/* set active flag */
	clipID |= JET_CLIP_ACTIVE_FLAG;

	/* Reverse the search so that we get the first empty element */
	for (i = JET_MUTE_QUEUE_SIZE-1; i >= 0 ; i--)
	{
		if (easHandle->jetHandle->muteQueue[i] == clipID)
		{
			index = i;
			break;
		}
		if (easHandle->jetHandle->muteQueue[i] == 0)
			index = i;
	}
	if (index < 0)
		return EAS_ERROR_QUEUE_IS_FULL;

	easHandle->jetHandle->muteQueue[index] = (EAS_U8) clipID | JET_CLIP_TRIGGER_FLAG;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * JET_Process()
 *----------------------------------------------------------------------------
 * Called during EAS_Render to process stream states
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT JET_Process (EAS_DATA_HANDLE easHandle)
{
	S_JET_SEGMENT *pSeg;
	EAS_STATE state;
	EAS_INT index;
	EAS_INT playIndex;
	EAS_RESULT result = EAS_SUCCESS;
	EAS_BOOL endOfLoop = EAS_FALSE;
	EAS_BOOL startNextSegment = EAS_FALSE;
	EAS_BOOL prepareNextSegment = EAS_FALSE;
	EAS_U32 jetEvent;

	/* process event queue */
	while (JET_ReadQueue(easHandle->jetHandle->jetEventQueue,
		&easHandle->jetHandle->jetEventQueueRead, 
		easHandle->jetHandle->jetEventQueueWrite,
		JET_EVENT_QUEUE_SIZE, &jetEvent))
	{
		S_JET_EVENT event;
#ifdef DEBUG_JET		
		JET_DumpEvent("JET_Process", jetEvent);
#endif
		JET_ParseEvent(jetEvent, &event);

		/* check for end of loop */
		if ((event.controller == JET_EVENT_MARKER) &&
				(event.value == JET_MARKER_LOOP_END) && 
				(easHandle->jetHandle->segQueue[easHandle->jetHandle->playSegment].streamHandle != NULL))
			endOfLoop = EAS_TRUE;
	}

	/* check state of all streams */
	index = playIndex = easHandle->jetHandle->playSegment;
	for (;;)
	{
		pSeg = &easHandle->jetHandle->segQueue[index];
		if (pSeg->state != JET_STATE_CLOSED)
		{

			/* get playback state */		
			result = EAS_State(easHandle, pSeg->streamHandle, &state);
			if (result != EAS_SUCCESS)
				return result;

			/* process state */
			switch (pSeg->state)
			{
				/* take action if this segment is stopping */
				case JET_STATE_PLAYING:
					if (endOfLoop || (state == EAS_STATE_STOPPING) || (state == EAS_STATE_STOPPED))
					{
						/* handle repeats */
						if (pSeg->repeatCount != 0)
						{
							{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "JET_Render repeating segment %d\n", index); */ }
							result = EAS_Locate(easHandle, pSeg->streamHandle, 0, EAS_FALSE);
							if (result != EAS_SUCCESS)
								return result;
							if (pSeg->repeatCount > 0)
								pSeg->repeatCount--;

							/* update mute flags if necessary */
							if (pSeg->flags & JET_SEG_FLAG_MUTE_UPDATE)
							{
								result = EAS_IntSetStrmParam(easHandle, pSeg->streamHandle, PARSER_DATA_MUTE_FLAGS, (EAS_I32) pSeg->muteFlags);
								if (result != EAS_SUCCESS)
									return result;
								pSeg->flags &= ~JET_SEG_FLAG_MUTE_UPDATE;
							}
							
						}
						/* no repeat, start next segment */
						else
						{
							{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "JET_Render stopping queue %d\n", index); */ }
							startNextSegment = EAS_TRUE;
							pSeg->state = JET_STATE_STOPPING;
							easHandle->jetHandle->playSegment = (EAS_U8) JET_NextSegment(index);
						}
					}
					break;

				/* if playback has stopped, close the segment */
				case JET_STATE_STOPPING:
					if (state == EAS_STATE_STOPPED)
					{
						result = JET_CloseSegment(easHandle, index);
						if (result != EAS_SUCCESS)
							return result;
					}
					break;

				case JET_STATE_READY:
					if (startNextSegment)
					{
						result = JET_StartPlayback(easHandle, index);
						if (result != EAS_SUCCESS)
							return result;
						startNextSegment = EAS_FALSE;
						prepareNextSegment = EAS_TRUE;
					}
					break;

				case JET_STATE_OPEN:
					if (prepareNextSegment)
					{
						result = JET_PrepareSegment(easHandle, index);
						if (result != EAS_SUCCESS)
							return result;
						prepareNextSegment = EAS_FALSE;
					}
					break;

				case JET_STATE_PAUSED:
					break;
					
				default:
					{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "JET_Render: Unexpected segment state %d\n", pSeg->state); */ }
					break;
			}
		}
		
		/* increment index */
		index = JET_NextSegment(index);
		if (index == playIndex)
			break;
	}

	/* if out of segments, clear playing flag */
	if (easHandle->jetHandle->numQueuedSegments == 0)
		easHandle->jetHandle->flags &= ~JET_FLAGS_PLAYING;

	return result;
}

/*----------------------------------------------------------------------------
 * JET_Event()
 *----------------------------------------------------------------------------
 * Called from MIDI parser when data of interest is received
 *----------------------------------------------------------------------------
*/
void JET_Event (EAS_DATA_HANDLE easHandle, EAS_U32 segTrack, EAS_U8 channel, EAS_U8 controller, EAS_U8 value)
{
	EAS_U32 event;

	if (easHandle->jetHandle == NULL)
		return;

	/* handle triggers */
	if (controller == JET_EVENT_TRIGGER_CLIP)
	{
		S_JET_SEGMENT *pSeg;
		EAS_INT i;
		EAS_U32 muteFlag;

		for (i = 0; i < JET_MUTE_QUEUE_SIZE; i++)
		{
			/* search for event in queue */
			if ((easHandle->jetHandle->muteQueue[i] & JET_CLIP_ID_MASK) == (value & JET_CLIP_ID_MASK))
			{
				/* get segment pointer and mute flag */
				pSeg = &easHandle->jetHandle->segQueue[segTrack >> JET_EVENT_SEG_SHIFT];
				muteFlag = 1 << ((segTrack & JET_EVENT_TRACK_MASK) >> JET_EVENT_TRACK_SHIFT);
				
				/* un-mute the track */
				if ((easHandle->jetHandle->muteQueue[i] & JET_CLIP_TRIGGER_FLAG) && ((value & 0x40) > 0))
				{
					pSeg->muteFlags &= ~muteFlag;
					easHandle->jetHandle->muteQueue[i] &= ~JET_CLIP_TRIGGER_FLAG;
				}

				/* mute the track */
				else
				{
					EAS_U32 beforeMute ;
					beforeMute = pSeg->muteFlags ;
					pSeg->muteFlags |= muteFlag;
					if (beforeMute != pSeg->muteFlags)
						easHandle->jetHandle->muteQueue[i] = 0;
				}
				EAS_IntSetStrmParam(easHandle, pSeg->streamHandle, PARSER_DATA_MUTE_FLAGS, (EAS_I32) pSeg->muteFlags);
				return;
			}
		}
		return;
	}
		
	/* generic event stuff */
	event = (channel << JET_EVENT_CHAN_SHIFT) | (controller << JET_EVENT_CTRL_SHIFT) | value;

	/* write to app queue, translate queue index to segment number */
	if ((controller >= easHandle->jetHandle->config.appEventRangeLow) && (controller <= easHandle->jetHandle->config.appEventRangeHigh))
	{

		event |= easHandle->jetHandle->segQueue[(segTrack & JET_EVENT_SEG_MASK) >> JET_EVENT_SEG_SHIFT].userID << JET_EVENT_SEG_SHIFT;
#ifdef DEBUG_JET		
		JET_DumpEvent("JET_Event[app]", event);
#endif
		JET_WriteQueue(easHandle->jetHandle->appEventQueue,
			&easHandle->jetHandle->appEventQueueWrite, 
			easHandle->jetHandle->appEventQueueRead, 
			APP_EVENT_QUEUE_SIZE,
			event);
	}

	/* write to JET queue */
	else if ((controller >= JET_EVENT_LOW) && (controller <= JET_EVENT_HIGH))
	{
		event |= segTrack;
#ifdef DEBUG_JET		
		JET_DumpEvent("JET_Event[jet]", event);
#endif
		JET_WriteQueue(easHandle->jetHandle->jetEventQueue,
			&easHandle->jetHandle->jetEventQueueWrite, 
			easHandle->jetHandle->jetEventQueueRead, 
			JET_EVENT_QUEUE_SIZE,
			event);
	}
}

/*----------------------------------------------------------------------------
 * JET_Clear_Queue()
 *----------------------------------------------------------------------------
 * Clears the queue and stops play without a complete shutdown
 *----------------------------------------------------------------------------
*/
EAS_RESULT JET_Clear_Queue(EAS_DATA_HANDLE easHandle)
{	
	EAS_INT index;
	EAS_RESULT result = EAS_SUCCESS;

	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "JET_Clear_Queue\n"); */ }
		
	/* pause all playing streams */
	for (index = 0; index < SEG_QUEUE_DEPTH; index++)
	{
		if (easHandle->jetHandle->segQueue[index].state == JET_STATE_PLAYING)
		{
			result = EAS_Pause(easHandle, easHandle->jetHandle->segQueue[index].streamHandle);
			if (result != EAS_SUCCESS)
				return result;
				
			easHandle->jetHandle->segQueue[index].state = JET_STATE_PAUSED;
		}		
	}
	
	/* close all streams */
	for (index = 0; index < SEG_QUEUE_DEPTH; index++)
	{
		if (easHandle->jetHandle->segQueue[index].streamHandle != NULL)
		{
			result = JET_CloseSegment(easHandle, index);
			if (result != EAS_SUCCESS)
				return result;
		}
	}
    
    /* clear all clips */
    for (index = 0; index < JET_MUTE_QUEUE_SIZE ; index++)
    {
        easHandle->jetHandle->muteQueue[index] = 0;
    }
	
	easHandle->jetHandle->flags &= ~JET_FLAGS_PLAYING;
	easHandle->jetHandle->playSegment = easHandle->jetHandle->queueSegment = 0;
	return result;
}