void FileStreamerThread::processQuit(volatile Request *request)
{
	NOT_NULL(request);

	ExitChain::quit();
	Gate *gate = request->gate;
	delete request;
	gate->open();
}
void FileStreamerThread::processRead(volatile Request *request)
{
	NOT_NULL(request);

	// shortcut to the file
	OsFile *osFile = request->osFile;

	// seek to the requested offset
	osFile->seek(request->offset);

	// read the data
	if (request->bytesToBeRead > cms_maxReadSize)
	{
		// only read up to FileStreamerThread::cms_maxReadSize, then resubmit smaller request
		const int amountRead = osFile->read(request->buffer, cms_maxReadSize);

		request->offset += amountRead;
		request->bytesRead += amountRead;
		request->bytesToBeRead -= amountRead;
		request->buffer = reinterpret_cast<byte *>(request->buffer) + amountRead;

		// if we read less than we could have, we're done
		if (amountRead < cms_maxReadSize)
		{
			// store final number of bytes read in storage accessible to main thread
			*request->returnValue = static_cast<int>(request->bytesRead);

			Gate *gate = request->gate;
			delete request;

			//set event so other main thread continues
			gate->open();
		}
		else
		{
			// resubmit request (put it on the head so we get it back first)
			if (request->priority == AbstractFile::PriorityAudioVideo)
			{
				ms_queueCriticalSection.enter();
					if (ms_firstAudioVideoRequest)
					{
						request->next = ms_firstAudioVideoRequest;
						ms_firstAudioVideoRequest = request;
					}
					else
					{
						ms_firstAudioVideoRequest = request;
						ms_lastAudioVideoRequest = request;
					}
				ms_queueCriticalSection.leave();
			}
			else
				if (request->priority == AbstractFile::PriorityData)
				{
					ms_queueCriticalSection.enter();
						if (ms_firstDataRequest)
						{
							request->next = ms_firstDataRequest;
							ms_firstDataRequest = request;
						}
						else
						{
							ms_firstDataRequest = request;
							ms_lastDataRequest = request;
						}
					ms_queueCriticalSection.leave();
				}
				else
					if (request->priority == AbstractFile::PriorityLow)
					{
						ms_queueCriticalSection.enter();
							if (ms_firstLowRequest)
							{
								request->next = ms_firstLowRequest;
								ms_firstLowRequest = request;
							}
							else
							{
								ms_firstLowRequest = request;
								ms_lastLowRequest = request;
							}
						ms_queueCriticalSection.leave();
					}
					else
						DEBUG_FATAL(true, ("FileStreamerThread::processRead request has unknown priority type"));

			// signal the file thread that a new request is waiting
			ms_eventsPending.signal();
		}
	}
	else
	{
		// fulfill entire read request
		const int amountRead = osFile->read(request->buffer, request->bytesToBeRead);

		request->bytesRead += amountRead;
		request->bytesToBeRead -= amountRead;

		// store final number of bytes read in storage accessible to main thread
		*request->returnValue = static_cast<int>(request->bytesRead);

		Gate *gate = request->gate;
		delete request;
		gate->open();
	}
}