#include "tsound.h"

#ifndef TNZCORE_LIGHT

#include "tthread.h"

#endif

#include "tsop.h"

#include <set></set>

#include "tsystem.h"

//=========================================================

//forward declarations

class TSoundOutputDeviceImp;

class TSoundInputDeviceImp;

//=========================================================

namespace

{

void CALLBACK recordCB(

	HWAVEIN hwi,

	UINT uMsg,

	DWORD dwInstance,

	DWORD dwParam1,

	DWORD dwParam2);

bool setRecordLine(TSoundInputDevice::Source typeInput);

MMRESULT getLineInfo(

	HMIXEROBJ hMixer,

	DWORD dwComponentType,

	MIXERLINE &mxl);

MMRESULT getLineControl(

	MIXERCONTROL &mxc,

	HMIXEROBJ hMixer,

	DWORD dwLineID,

	DWORD dwControlType);

MMRESULT setControlDetails(

	HMIXEROBJ hMixer,

	DWORD dwSelectControlID,

	DWORD dwMultipleItems,

	MIXERCONTROLDETAILS_UNSIGNED *mxcdSelectValue);

MMRESULT getControlDetails(

	HMIXEROBJ hMixer,

	DWORD dwSelectControlID,

	DWORD dwMultipleItems,

	MIXERCONTROLDETAILS_UNSIGNED *mxcdSelectValue);

MMRESULT isaFormatSupported(

	int sampleRate, int channelCount, int bitPerSample, bool input);

DWORD WINAPI MyWaveOutCallbackThread(LPVOID lpParameter);

void getAmplitude(int &litude, const TSoundTrackP st, TINT32 sample);

}

//==============================================================================

//     Class to send the message that a playback is completed

//==============================================================================

#ifndef TNZCORE_LIGHT

class EndPlayMsg : public TThread::Message

{

public:

	EndPlayMsg(TSoundOutputDeviceListener *notifier)

	{

		m_listener = notifier;

	}

	TThread::Message *clone() const

	{

		return new EndPlayMsg(*this);

	}

	void onDeliver()

	{

		m_listener->onPlayCompleted();

	}

private:

	TSoundOutputDeviceListener *m_listener;

};

#endif

int makeDWORD(const short lo, const short hi)

{

	int dw = hi << 16;

	dw |= lo;

	return dw;

}

//==============================================================================

class WavehdrQueue;

class TSoundOutputDeviceImp

{

public:

	HWAVEOUT m_wout;

	WavehdrQueue *m_whdrQueue;

	TSoundTrackFormat m_currentFormat;

	std::set<int> m_supportedRate;</int>

	TThread::Mutex m_mutex;

	bool m_stopped;

	bool m_isPlaying;

	bool m_looped;

	bool m_scrubbing;

	std::set<tsoundoutputdevicelistener *=""> m_listeners;</tsoundoutputdevicelistener>

	DWORD m_notifyThreadId;

	HANDLE m_closeDevice;

	TSoundOutputDeviceImp();

	~TSoundOutputDeviceImp();

	bool doOpenDevice(const TSoundTrackFormat &format);

	bool doPlay(WAVEHDR *whdr, const TSoundTrackFormat format);

	bool doCloseDevice();

	bool verifyRate();

	void insertAllRate();

};

//==============================================================================

class WavehdrQueue

{

public:

	WavehdrQueue(TSoundOutputDeviceImp *devImp, int slotCount)

		: m_devImp(devImp), m_items(), m_queuedItems(), m_slotCount(slotCount), m_mutex(), m_lastOffset(0)

	{

	}

	~WavehdrQueue() {}

	void put(TSoundTrackP &subTrack);

	WAVEHDR *get();

	bool popFront(int count);

	void pushBack(WAVEHDR *whdr, TSoundTrackP st);

	int size();

	void clear();

	bool isAllQueuedItemsPlayed();

private:

	std::list<std::pair<wavehdr *,="" tsoundtrackp="">> m_items;</std::pair<wavehdr>

	std::list<wavehdr *=""> m_queuedItems;</wavehdr>

	TThread::Mutex m_mutex;

	int m_slotCount;

	int m_lastOffset;

	TSoundOutputDeviceImp *m_devImp;

	TSoundTrackP m_lastTrack;

};

//==============================================================================

WAVEHDR *prepareWaveHeader(HWAVEOUT wout, const TSoundTrackP &subTrack, ULONG &count)

{

	WAVEHDR *whdr = new WAVEHDR;

	memset(whdr, 0, sizeof(WAVEHDR));

	whdr->dwBufferLength = subTrack->getSampleSize() * subTrack->getSampleCount();

	whdr->lpData = new char[whdr->dwBufferLength];

	whdr->dwFlags = 0;

	whdr->dwUser = count;

	memcpy(whdr->lpData, subTrack->getRawData(), whdr->dwBufferLength);

	MMRESULT ret = waveOutPrepareHeader(wout, whdr, sizeof(WAVEHDR));

	if (ret != MMSYSERR_NOERROR) {

		delete[] whdr->lpData;

		delete whdr;

		return 0;

	}

	++count;

	return whdr;

}

//==============================================================================

void WavehdrQueue::put(TSoundTrackP &subTrack)

{

	assert(subTrack->getRawData());

	static ULONG count = 1;

	//codice messo per tab: facendo il play al rilascio del mouse e su piu'

	//colonne in cui le traccie potrebbe avere diversi formati siccome qui in

	//alcune situazioni si fa subito waveOutWrite c'e' bisogno di controllare

	//se il formato con cui e' stato aperto in precedenza il device e' uguale

	//a quello della traccia

	if (m_devImp->m_wout && m_devImp->m_currentFormat != subTrack->getFormat()) {

		m_devImp->doCloseDevice();

		TSystem::sleep(300);

		m_devImp->doOpenDevice(subTrack->getFormat());

	}

	TThread::MutexLocker sl(&m_mutex);

	if (!m_devImp->m_scrubbing) {

		WAVEHDR *whdr2 = 0;

		//traccia

		whdr2 = prepareWaveHeader(m_devImp->m_wout, subTrack, count);

		getAmplitude(m_lastOffset, subTrack, subTrack->getSampleCount() - 1L);

		MMRESULT ret = MMSYSERR_NOERROR;

		if (whdr2 && whdr2->dwFlags & WHDR_PREPARED) {

			ret = waveOutWrite(m_devImp->m_wout, whdr2, sizeof(WAVEHDR));

			if (ret == MMSYSERR_NOERROR) {

				pushBack(whdr2, subTrack);

				getAmplitude(m_lastOffset, subTrack, subTrack->getSampleCount() - 1L);

				TThread::MutexLocker sl(&m_devImp->m_mutex);

				m_devImp->m_isPlaying = true;

				m_devImp->m_stopped = false;

			}

		}

		return;

	}

	if (m_queuedItems.size() == 0) {

		WAVEHDR *whdr1 = 0;

		WAVEHDR *whdr2 = 0;

		WAVEHDR *whdr3 = 0;

		MMRESULT ret;

		TSoundTrackP riseTrack, decayTrack;

		int sampleSize = subTrack->getSampleSize();

		//cresce

		riseTrack = TSop::fadeIn(subTrack, 0.9);

		whdr1 = prepareWaveHeader(m_devImp->m_wout, riseTrack, count);

		//traccia

		whdr2 = prepareWaveHeader(m_devImp->m_wout, subTrack, count);

		getAmplitude(m_lastOffset, subTrack, subTrack->getSampleCount() - 1L);

		//decresce

		decayTrack = 0;

		if (m_lastOffset) {

			decayTrack = TSop::fadeOut(subTrack, 0.9);

			whdr3 = prepareWaveHeader(m_devImp->m_wout, decayTrack, count);

		}

		if (whdr1 && (whdr1->dwFlags & WHDR_PREPARED)) {

			ret = waveOutWrite(m_devImp->m_wout, whdr1, sizeof(WAVEHDR));

			if (ret == MMSYSERR_NOERROR) {

				pushBack(whdr1, riseTrack);

				getAmplitude(m_lastOffset, riseTrack, riseTrack->getSampleCount() - 1L);

			}

		}

		if (whdr2 && (whdr2->dwFlags & WHDR_PREPARED)) {

			ret = waveOutWrite(m_devImp->m_wout, whdr2, sizeof(WAVEHDR));

			if (ret == MMSYSERR_NOERROR) {

				pushBack(whdr2, subTrack);

				getAmplitude(m_lastOffset, subTrack, subTrack->getSampleCount() - 1L);

				TThread::MutexLocker sl(&m_devImp->m_mutex);

				m_devImp->m_isPlaying = true;

				m_devImp->m_stopped = false;

			}

		}

		if (whdr3 && (whdr3->dwFlags & WHDR_PREPARED)) {

			ret = waveOutWrite(m_devImp->m_wout, whdr3, sizeof(WAVEHDR));

			if (ret == MMSYSERR_NOERROR) {

				pushBack(whdr3, decayTrack);

				if (decayTrack->isSampleSigned())

					m_lastOffset = 0;

				else

					m_lastOffset = 127;

			}

		}

		return;

	}

	if (m_queuedItems.size() < 10) {

		WAVEHDR *whdr1 = 0;

		WAVEHDR *whdr2 = 0;

		WAVEHDR *whdr = new WAVEHDR;

		memset(whdr, 0, sizeof(WAVEHDR));

		whdr->dwBufferLength = subTrack->getSampleSize() * subTrack->getSampleCount();

		whdr->lpData = new char[whdr->dwBufferLength];

		whdr->dwFlags = 0;

		memcpy(whdr->lpData, subTrack->getRawData(), whdr->dwBufferLength);

		int sampleSize = subTrack->getSampleSize();

		TSoundTrackP riseTrack = 0;

		if (m_lastOffset) ///devo fare ilcross fade

		{

			int offset;

			getAmplitude(offset, subTrack, 0L);

			offset = m_lastOffset - offset;

			if (offset) {

				TSoundTrackP st = TSop::crossFade(m_lastTrack, subTrack, 0.3);

				memcpy(whdr->lpData, st->getRawData(), st->getSampleCount() * sampleSize);

			}

		} else // e' zero ma ne metto uno che cresce faccio il fadeIn

		{

			riseTrack = TSop::fadeIn(subTrack, 0.3);

			whdr1 = prepareWaveHeader(m_devImp->m_wout, riseTrack, count);

		}

		whdr->dwUser = count;

		++count;

		MMRESULT ret = waveOutPrepareHeader(m_devImp->m_wout, whdr, sizeof(WAVEHDR));

		if (ret != MMSYSERR_NOERROR) {

			delete[] whdr->lpData;

			delete whdr;

			return;

		}

		getAmplitude(m_lastOffset, subTrack, subTrack->getSampleCount() - 1L);

		TSoundTrackP decayTrack = 0;

		if (m_queuedItems.size() <= 7) {

			if (m_lastOffset) //devo fare il fadeOut

			{

				decayTrack = TSop::fadeOut(subTrack, 0.3);

				whdr2 = prepareWaveHeader(m_devImp->m_wout, decayTrack, count);

			}

		}

		if (whdr1 && whdr1->dwFlags & WHDR_PREPARED) {

			ret = waveOutWrite(m_devImp->m_wout, whdr1, sizeof(WAVEHDR));

			if (ret == MMSYSERR_NOERROR) {

				pushBack(whdr1, riseTrack);

				getAmplitude(m_lastOffset, riseTrack, riseTrack->getSampleCount() - 1L);

			}

		}

		if (whdr && whdr->dwFlags & WHDR_PREPARED) {

			ret = waveOutWrite(m_devImp->m_wout, whdr, sizeof(WAVEHDR));

			if (ret == MMSYSERR_NOERROR) {

				pushBack(whdr, subTrack);

				getAmplitude(m_lastOffset, subTrack, subTrack->getSampleCount() - 1L);

				{

					TThread::MutexLocker sl(&m_devImp->m_mutex);

					m_devImp->m_isPlaying = true;

					m_devImp->m_stopped = false;

				}

			}

		}

		if (whdr2 && whdr2->dwFlags & WHDR_PREPARED) {

			ret = waveOutWrite(m_devImp->m_wout, whdr2, sizeof(WAVEHDR));

			if (ret == MMSYSERR_NOERROR) {

				pushBack(whdr2, decayTrack);

				if (decayTrack->isSampleSigned())

					m_lastOffset = 0;

				else

					m_lastOffset = 127;

			}

		}

		return;

	}

	if ((int)m_items.size() == m_slotCount) {

		WAVEHDR *item = m_items.front().first;

		MMRESULT ret = waveOutUnprepareHeader(

			m_devImp->m_wout, item, sizeof(WAVEHDR));

		if (ret == MMSYSERR_NOERROR) {

			delete[] item->lpData;

			delete item;

		}

		m_items.pop_front();

		if (m_queuedItems.size() != 0) {

			WAVEHDR *item = m_items.front().first;

			int sampleSize = m_items.front().second->getSampleSize();

			int offset;

			getAmplitude(offset, m_items.front().second, 0L);

			offset = m_lastOffset - offset;

			if (offset) {

				TSoundTrackP st = TSop::crossFade(

					m_lastTrack, m_items.front().second, 0.3);

				memcpy(item->lpData, st->getRawData(), st->getSampleCount() * sampleSize);

			}

		}

	}

	WAVEHDR *whdr = prepareWaveHeader(m_devImp->m_wout, subTrack, count);

	assert(whdr && whdr->dwFlags & WHDR_PREPARED);

	m_items.push_back(std::make_pair(whdr, subTrack));

	assert((int)m_items.size() <= m_slotCount);

}

//----------------------------------------------------------------------------

// restituisce il piu' vecchio WAVEHDR il cui stato e' prepared && !done

WAVEHDR *WavehdrQueue::get()

{

	TThread::MutexLocker sl(&m_mutex);

	if (m_items.size() == 0)

		return 0;

	WAVEHDR *whdr = m_items.front().first;

	assert(whdr->dwFlags & WHDR_PREPARED);

	pushBack(whdr, m_items.front().second);

	getAmplitude(

		m_lastOffset, m_items.front().second, m_items.front().second->getSampleCount() - 1L);

	m_items.pop_front();

	return whdr;

}

//-----------------------------------------------------------------------------

// rimuove dalla coda il piu' vecchio WAVEHDR il cui stato e' done

bool WavehdrQueue::popFront(int count)

{

	TThread::MutexLocker sl(&m_mutex);

	//assert(m_queuedItems.size() > 0);

	if (m_queuedItems.size() <= 0)

		return false;

	WAVEHDR *whdr = m_queuedItems.front();

	// controllo introdotto pr via che su win2k si perde alcune

	// notifiche di WHDR_DONE

	while ((DWORD)count > whdr->dwUser) {

		MMRESULT ret = waveOutUnprepareHeader(

			m_devImp->m_wout, whdr, sizeof(WAVEHDR));

		if (ret == MMSYSERR_NOERROR) {

			m_queuedItems.pop_front();

			delete[] whdr->lpData;

			delete whdr;

			whdr = m_queuedItems.front();

		}

	}

	assert(whdr->dwFlags & WHDR_DONE);

	m_queuedItems.pop_front();

	delete[] whdr->lpData;

	delete whdr;

	return true;

}

//-----------------------------------------------------------------------------

void WavehdrQueue::pushBack(WAVEHDR *whdr, TSoundTrackP st)

{

	TThread::MutexLocker sl(&m_mutex);

	m_queuedItems.push_back(whdr);

	m_lastTrack = st;

}

//-----------------------------------------------------------------------------

int WavehdrQueue::size()

{

	TThread::MutexLocker sl(&m_mutex);

	int size = m_queuedItems.size();

	return size;

}

//-----------------------------------------------------------------------------

void WavehdrQueue::clear()

{

	TThread::MutexLocker sl(&m_mutex);

	m_items.clear();

	m_lastTrack = TSoundTrackP();

	std::list<wavehdr *="">::iterator it;</wavehdr>

	for (it = m_queuedItems.begin(); it != m_queuedItems.end(); it++) {

		WAVEHDR *wvhdr = *it;

		delete[] wvhdr->lpData;

		delete wvhdr;

	}

	m_queuedItems.clear();

}

//-----------------------------------------------------------------------------

bool WavehdrQueue::isAllQueuedItemsPlayed()

{

	std::list<wavehdr *="">::iterator it;</wavehdr>

	bool finished = true;

	for (it = m_queuedItems.begin(); it != m_queuedItems.end(); it++) {

		WAVEHDR *wvhdr = *it;

		finished = finished && (wvhdr->dwFlags & WHDR_DONE);

	}

	return finished;

}

//==============================================================================

TSoundOutputDeviceImp::TSoundOutputDeviceImp()

	: m_stopped(true), m_isPlaying(false), m_looped(false), m_scrubbing(false), m_wout(0)

{

	m_whdrQueue = new WavehdrQueue(this, 4);

	insertAllRate();

	if (!verifyRate())

		throw TSoundDeviceException(

			TSoundDeviceException::FailedInit,

			"Unable to verify supported rates");

	m_closeDevice = CreateEvent(

		NULL,  // no security attributes

		FALSE, // auto-reset event

		FALSE, // initial state is not signaled

		NULL); // object not named

}

//----------------------------------------------------------------------------

TSoundOutputDeviceImp::~TSoundOutputDeviceImp()

{

	delete m_whdrQueue;

}

//----------------------------------------------------------------------------

bool TSoundOutputDeviceImp::doOpenDevice(const TSoundTrackFormat &format)

{

	WAVEFORMATEX wf;

	wf.wFormatTag = WAVE_FORMAT_PCM;

	wf.nChannels = format.m_channelCount;

	wf.nSamplesPerSec = format.m_sampleRate;

	wf.wBitsPerSample = format.m_bitPerSample;

	wf.nBlockAlign = (wf.nChannels * wf.wBitsPerSample) >> 3;

	wf.nAvgBytesPerSec = wf.nSamplesPerSec * wf.nBlockAlign;

	wf.cbSize = 0;

	TThread::MutexLocker sl(&m_mutex);

	CloseHandle(CreateThread(NULL, 0, MyWaveOutCallbackThread, (LPVOID) this, 0, &m_notifyThreadId));

	MMRESULT ret;

	if ((ret = waveOutOpen(&m_wout, WAVE_MAPPER,

						   &wf, (DWORD)m_notifyThreadId, (DWORD) this, CALLBACK_THREAD)) != MMSYSERR_NOERROR) {

		while (!PostThreadMessage(m_notifyThreadId, WM_QUIT, 0, 0))

			;

	}

	if (ret != MMSYSERR_NOERROR)

		return false;

	if (ret != MMSYSERR_NOERROR)

		return false;

	m_currentFormat = format;

	return (ret == MMSYSERR_NOERROR);

}

//----------------------------------------------------------------------------

bool TSoundOutputDeviceImp::doPlay(WAVEHDR *whdr, const TSoundTrackFormat format)

{

	TThread::MutexLocker sl(&m_mutex);

	if (!m_wout || (m_wout && m_currentFormat != format))

		doOpenDevice(format);

	MMRESULT ret;

	ret = waveOutWrite(m_wout, whdr, sizeof(WAVEHDR));

	if (ret != MMSYSERR_NOERROR)

		return false;

	m_stopped = false;

	m_isPlaying = true;

	return true;

}

//----------------------------------------------------------------------------

bool TSoundOutputDeviceImp::doCloseDevice()

{

	TThread::MutexLocker sl(&m_mutex);

	if (m_wout) {

		MMRESULT ret = waveOutReset(m_wout);

		if (ret != MMSYSERR_NOERROR)

			return false;

		ret = waveOutClose(m_wout);

		if (ret != MMSYSERR_NOERROR)

			return false;

		m_wout = 0;

		m_stopped = true;

		m_isPlaying = false;

		m_looped = false;

	}

	PostThreadMessage(m_notifyThreadId, WM_QUIT, 0, 0);

	return true;

}

//----------------------------------------------------------------------------

void TSoundOutputDeviceImp::insertAllRate()

{

	m_supportedRate.insert(8000);

	m_supportedRate.insert(11025);

	m_supportedRate.insert(16000);

	m_supportedRate.insert(22050);

	m_supportedRate.insert(32000);

	m_supportedRate.insert(44100);

	m_supportedRate.insert(48000);

}

//----------------------------------------------------------------------------

bool TSoundOutputDeviceImp::verifyRate()

{

	std::set<int>::iterator it;</int>

	for (it = m_supportedRate.begin();

		 it != m_supportedRate.end();) {

		MMRESULT ret;

		WAVEFORMATEX wf;

		wf.wFormatTag = WAVE_FORMAT_PCM;

		wf.nChannels = 1;

		wf.nSamplesPerSec = *it;

		wf.wBitsPerSample = 8;

		wf.nBlockAlign = (wf.nChannels * wf.wBitsPerSample) >> 3;

		wf.nAvgBytesPerSec = wf.nSamplesPerSec * wf.nBlockAlign;

		wf.cbSize = 0;

		ret = waveOutOpen(NULL, WAVE_MAPPER, &wf, NULL, NULL, WAVE_FORMAT_QUERY);

		if (ret == MMSYSERR_NOERROR) {

			++it;

			continue;

		}

		if (ret == WAVERR_BADFORMAT)

			it = m_supportedRate.erase(it);

		else

			return false;

	}

	if (m_supportedRate.end() == m_supportedRate.begin())

		return false;

	return true;

}

//==============================================================================

TSoundOutputDevice::TSoundOutputDevice() : m_imp(new TSoundOutputDeviceImp())

{

}

//------------------------------------------------------------------------------

TSoundOutputDevice::~TSoundOutputDevice()

{

	close();

	WaitForSingleObject(m_imp->m_closeDevice, INFINITE);

	CloseHandle(m_imp->m_closeDevice);

}

//------------------------------------------------------------------------------

namespace

{

DWORD WINAPI MyWaveOutCallbackThread(LPVOID lpParameter)

{

	TSoundOutputDeviceImp *devImp = (TSoundOutputDeviceImp *)lpParameter;

	if (!devImp)

		return 0;

	MSG msg;

	BOOL bRet;

	while (bRet = GetMessage(&msg, NULL, 0, 0)) {

		if (bRet == -1) {

			// si e' verificato un errore

			break;

		}

		switch (msg.message) {

		case MM_WOM_DONE: {

			WAVEHDR *pWaveHdr = ((WAVEHDR *)msg.lParam);

			{

				TThread::MutexLocker sl(&devImp->m_mutex);

				if (devImp->m_looped) {

					devImp->doPlay(pWaveHdr, devImp->m_currentFormat);

					continue;

				}

			}

			WAVEHDR *whdr = 0;

			if (devImp->m_whdrQueue->popFront(pWaveHdr->dwUser)) {

				whdr = devImp->m_whdrQueue->get();

				if (whdr)

					devImp->doPlay(whdr, devImp->m_currentFormat);

				WaitForSingleObject(devImp->m_closeDevice, INFINITE);

				CloseHandle(devImp->m_closeDevice);

				MMRESULT ret = waveOutUnprepareHeader(

					devImp->m_wout, pWaveHdr, sizeof(WAVEHDR));

				if (ret == MMSYSERR_NOERROR) {

					delete pWaveHdr->lpData;

					delete pWaveHdr;

				}

			}

			if (!whdr && devImp->m_whdrQueue->size() == 0) {

				std::set<tsoundoutputdevicelistener *="">::iterator it = devImp->m_listeners.begin();</tsoundoutputdevicelistener>

				for (; it != devImp->m_listeners.end(); ++it) {

#ifndef TNZCORE_LIGHT

					EndPlayMsg *event = new EndPlayMsg(*it);

					event->send();

#else

					assert(false);

#endif

				}

				devImp->doCloseDevice();

			}

			continue;

		}

		case MM_WOM_CLOSE:

			break;

		default:

			continue;

		}

	}

	SetEvent(devImp->m_closeDevice);

	return 0;

}

void getAmplitude(int &litude, const TSoundTrackP st, TINT32 sample)

{

	TSoundTrackP snd = st;

	amplitude = 0;

	int k = 0;

	for (k = 0; k < snd->getChannelCount(); ++k)

		amplitude += (int)snd->getPressure(sample, k);

	amplitude /= k;

}

}

//------------------------------------------------------------------------------

bool TSoundOutputDevice::installed()

{

	int ndev = waveOutGetNumDevs();

	if (ndev <= 0)

		return false;

	return true;

}

//------------------------------------------------------------------------------

bool TSoundOutputDevice::open(const TSoundTrackP &st)

{

	return m_imp->doOpenDevice(st->getFormat());

}

//------------------------------------------------------------------------------

void TSoundOutputDevice::attach(TSoundOutputDeviceListener *listener)

{

	m_imp->m_listeners.insert(listener);

}

//------------------------------------------------------------------------------

void TSoundOutputDevice::detach(TSoundOutputDeviceListener *listener)

{

	m_imp->m_listeners.erase(listener);

}

//------------------------------------------------------------------------------

void TSoundOutputDevice::play(

	const TSoundTrackP &st, TINT32 s0, TINT32 s1, bool loop, bool scrubbing)

{

	assert((scrubbing && !loop) || !scrubbing);

	if (!st->getSampleCount())

		return;

	TSoundTrackFormat format;

	TSoundTrackP subTrack;

	{

		TThread::MutexLocker sl(&m_imp->m_mutex);

		if (m_imp->m_looped)

			throw TSoundDeviceException(

				TSoundDeviceException::Busy,

				"Unable to queue another playback when the sound player is looping");

		format = st->getFormat();

		try {

			TSoundTrackFormat fmt = getPreferredFormat(format);

			if (fmt != format) {

				throw TSoundDeviceException(

					TSoundDeviceException::UnsupportedFormat,

					"Unsupported Format");

			}

		} catch (TSoundDeviceException &e) {

			throw TSoundDeviceException(

				TSoundDeviceException::UnsupportedFormat,

				e.getMessage());

		}

		assert(s1 >= s0);

		subTrack = st->extract(s0, s1);

		m_imp->m_looped = loop;

		m_imp->m_scrubbing = scrubbing;

	}

	if (!m_imp->m_wout)

		m_imp->doOpenDevice(format);

	m_imp->m_whdrQueue->put(subTrack);

}

//------------------------------------------------------------------------------

void TSoundOutputDevice::stop()

{

	if ((m_imp->m_wout) && m_imp->m_isPlaying) {

		MMRESULT ret = waveOutReset(m_imp->m_wout);

		if (ret != MMSYSERR_NOERROR)

			return;

		TThread::MutexLocker sl(&m_imp->m_mutex);

		m_imp->m_looped = false;

		m_imp->m_stopped = true;

		m_imp->m_isPlaying = false;

		m_imp->m_whdrQueue->clear();

	}

}

//------------------------------------------------------------------------------

bool TSoundOutputDevice::close()

{

	return m_imp->doCloseDevice();

}

//------------------------------------------------------------------------------

bool TSoundOutputDevice::isPlaying() const

{

	return m_imp->m_isPlaying;

}

//------------------------------------------------------------------------------

bool TSoundOutputDevice::isAllQueuedItemsPlayed()

{

	return m_imp->m_whdrQueue->isAllQueuedItemsPlayed();

}

//------------------------------------------------------------------------------

bool TSoundOutputDevice::isLooping()

{

	TThread::MutexLocker sl(&m_imp->m_mutex);

	return m_imp->m_looped;

}

//------------------------------------------------------------------------------

void TSoundOutputDevice::setLooping(bool loop)

{

	TThread::MutexLocker sl(&m_imp->m_mutex);

	m_imp->m_looped = loop;

}

//------------------------------------------------------------------------------

TSoundTrackFormat TSoundOutputDevice::getPreferredFormat(

	TUINT32 sampleRate, int channelCount, int bitPerSample)

{

	TSoundTrackFormat fmt;

	//avvvicinarsi al sample rate => dovrebbe esser OK avendo selezionato i piu' vicini

	std::set<int>::iterator it = m_imp->m_supportedRate.lower_bound(sampleRate);</int>

	if (it == m_imp->m_supportedRate.end()) {

		it = std::max_element(m_imp->m_supportedRate.begin(),

							  m_imp->m_supportedRate.end());

		if (it != m_imp->m_supportedRate.end())