#include "tfilepath.h"

#include "tsound.h"

#include "tsound_io.h"

#include "tsop.h"

#include "tthread.h"

#include "texception.h"

#include "tsystem.h"

#include <iostream></iostream>

#include <linux soundcard.h=""></linux>

#include <set></set>

#include <sys time.h=""></sys>

#include <unistd.h></unistd.h>

#include <fcntl.h></fcntl.h>

#include <sys ioctl.h=""></sys>

//using namespace std;

//forward declaration

namespace

{

int openMixer();

int getCurrentRecordSource(int mixer);

bool writeVolume(int volume, int mixer, int indexDev);

bool selectInputDevice(TSoundInputDevice::Source dev);

string parseError(int error);

}

// bisogna interagire con /dev/dsp per il settaggio delle

// caratteristiche della traccia tipo bit, rate, canali e

// per effettuare lettura/scrittura ossia record/play

//

// mentre bisogna interagire con /dev/mixer per modificare

// i valori del volume e per selezionare il dispositivo da

// cui registrare e ascoltare

class SmartWatch

{

	struct timeval m_start_tv;

	TINT32 m_totalus;

	bool m_stopped;

public:

	SmartWatch() : m_totalus(0), m_stopped(true)

	{

		timerclear(&m_start_tv);

	}

	void start()

	{

		m_stopped = false;

		gettimeofday(&m_start_tv, 0);

	}

	void stop()

	{

		m_stopped = true;

		struct timeval tv;

		gettimeofday(&tv, 0);

		m_totalus = (tv.tv_sec - m_start_tv.tv_sec) * 1000000 + (tv.tv_usec - m_start_tv.tv_usec);

	}

	double getTotalTime()

	{

		if (!m_stopped) //questa e' una porcata!

		{

			stop();

			m_stopped = false;

		}

		return m_totalus / 1000.;

	}

	void addDelay(double ms)

	{

		m_start_tv.tv_usec += (long)(ms * 1000.);

	}

};

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

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

//					CLASSI PER IL PLAYBACK

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

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

class TSoundOutputDeviceImp

{

private:

	static int m_count;

public:

	int m_dev;

	bool m_stopped;

	bool m_isPlaying;

	bool m_looped;

	TSoundTrackFormat m_currentFormat;

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

	static std::multimap<tuint32, tsoundtrackformat=""> m_supportFormats;</tuint32,>

	typedef pair<tsoundtrackp, bool=""> WaitPair;</tsoundtrackp,>

	vector<waitpair> m_waitingTracks;</waitpair>

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

	TThread::Executor m_executor;

	TThread::Mutex m_mutex;

	TSoundOutputDeviceImp()

		: m_dev(-1), m_stopped(false), m_isPlaying(false), m_looped(false), m_supportedRate()

	{

		/*

  if (m_count != 0)

    throw TException("unable to create second instance of TSoundOutputDeviceImp");

*/

		++m_count;

		checkSupportedFormat();

	};

	~TSoundOutputDeviceImp() { --m_count; };

	bool doOpenDevice();

	bool doCloseDevice();

	bool verifyRate();

	void insertAllRate();

	void checkSupportedFormat();

	bool isSupportFormat(const TSoundTrackFormat &fmt);

	void setFormat(const TSoundTrackFormat &fmt);

};

int TSoundOutputDeviceImp::m_count = 0;

std::multimap<tuint32, tsoundtrackformat=""> TSoundOutputDeviceImp::m_supportFormats;</tuint32,>

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

bool TSoundOutputDeviceImp::doOpenDevice()

{

	if (m_dev >= 0)

		return true;

	TThread::ScopedLock sl(m_mutex);

	m_dev = open("/dev/dsp", O_WRONLY, 0);

	if (m_dev < 0) {

		string errMsg = strerror(errno);

		throw TSoundDeviceException(

			TSoundDeviceException::UnableOpenDevice, errMsg + " /dev/dsp"

			/*"Unable to open device /dev/dsp; check permissions"*/);

	}

	//le chiamate a questa ioctl sono state commentate perche' pag 36 doc OSS

	//"this ioctl stop the device immadiately	and returns it to a state where it

	//can accept new parameters. It Should not be called after opening the device

	//as it may cause unwanted side effect in his situation. require to abort play

	//or secord.Generally recommended to open and close device after using the RESET"

	//ioctl(m_dev, SNDCTL_DSP_RESET,0);

	// N.B. e' bene che la dimensione sia piccola cosi' l'attesa, in seguito

	// alla richiesta di stop,

	// e' minore in questo caso vogliamo 32 frammenti ognuno di 256 byte

	// Se non chiamata questa ioctl il device la calcola per conto suo

	// ma alcune volte la dimensione dei frammenti potrebbe essere eccessiva e

	// creare dei click e dei silenzi in attesi ad esempio nel playback dentro

	// zcomp, quindi e' meglio settarla. 32 rappresenta il numero di frammenti

	// di solito e' documentato che 2 siano sufficienti ma potrebbero essere pochi

	// soprattutto se si interagisce con altre console

	//int fraginfo = ( 32<<16)|8;

	int fraginfo = 0xffffffff;

	if (ioctl(m_dev, SNDCTL_DSP_SETFRAGMENT, &fraginfo) == -1)

		perror("SETFRAGMENT");

	//if(fraginfo != ((32<<16)|8))

	//std::cout << std::hex << fraginfo<

	//exit(0);

	audio_buf_info info;

	if (ioctl(m_dev, SNDCTL_DSP_GETOSPACE, &info) == -1)

		perror("GETOSPACE");

	//std::cout << info.fragments << " frammenti " << " da " << info.fragsize << "  = " << info.fragsize*info.fragments << " bytes" <

	return true;

}

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

bool TSoundOutputDeviceImp::doCloseDevice()

{

	if (m_dev < 0)

		return true;

	TThread::ScopedLock sl(m_mutex);

	ioctl(m_dev, SNDCTL_DSP_POST, 0);

	ioctl(m_dev, SNDCTL_DSP_RESET, 0);

	int tmpDev = m_dev;

	bool not_closed = (close(m_dev) < 0);

	if (not_closed) {

		while (true) {

			m_dev = tmpDev;

			perror("non chiude il device :");

			not_closed = (close(m_dev) < 0);

			if (!not_closed)

				break;

		}

		//return false;

	}

	ioctl(m_dev, SNDCTL_DSP_RESET, 0);

	m_dev = -1;

	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(); ++it) {

		int sampleRate = *it;

		if (ioctl(m_dev, SNDCTL_DSP_SPEED, &sampleRate) == -1)

			throw TSoundDeviceException(

				TSoundDeviceException::UnablePrepare,

				"Failed setting the specified sample rate  aaaa");

		if (sampleRate != *it)

			m_supportedRate.erase(*it);

	}

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

		return false;

	return true;

}

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

void TSoundOutputDeviceImp::checkSupportedFormat()

{

	if (!m_supportFormats.empty())

		return;

	int test_formats[] = {

		AFMT_U8,

		AFMT_S8,

		AFMT_S16_LE,

		AFMT_S16_BE,

		/* // servono per supportare traccie a 24 e 32 bit ma non compaiono in 

   // nessun file linux/soundcard.h in distribuzione sulle macchine che abbiamo

   // il che fa pensare che non sono supportati ancora

   AFMT_S32_LE,  

   AFMT_S32_BE,  

*/

		0};

	int test_channels[] = {

		1,

		2,

		0};

	TUINT32 test_sample_rates[] = {

		8000,

		11025,

		16000,

		22050,

		32000,

		44100,

		48000,

		0};

	// Open the device nonblocking, so the open call returns immediately.

	if (m_dev)

		if ((m_dev = open("/dev/dsp", O_WRONLY | O_NONBLOCK)) == -1) {

			/*

      m_dev = -1;

      string errMsg = strerror(errno);

      throw TSoundDeviceException(

				  TSoundDeviceException::UnableOpenDevice, errMsg + " /dev/dsp\n: impossible check supported formats");

      */

			return;

		}

	int mask;

	// Querying hardware supported formats.

	if (ioctl(m_dev, SNDCTL_DSP_GETFMTS, &mask) == -1) {

		/*

	  throw TSoundDeviceException(

			TSoundDeviceException::UnsupportedFormat,

			"Getting supported formats failed.");

    */

		return;

	} else {

		for (int i = 0; test_formats[i] != 0; i++) {

			// Test all the formats in test_formats which are supported by the hardware.

			if (mask & test_formats[i]) {

				// Test the format only if it is supported by the hardware.

				// Note: We also could test formats that are not supported by the hardware.

				//       In some cases there exist OSS software converter, so that some formats

				//       work but are not reported by the above SNDCTL_DSP_GETFMTS.

				int fmt = test_formats[i];

				// Try to set the format...

				if (ioctl(m_dev, SNDCTL_DSP_SETFMT, &fmt) == -1)

					continue; //gli altri formati potrebbero essere supportati

				else {

					// and always check the variable after doing an ioctl!

					if (fmt == test_formats[i]) {

						// Test the supported channel numbers for this format.

						// Note: If you need a channel that is not tested here, simply add it to

						//       the definition of the array test_channels in this file.

						for (int j = 0; test_channels[j] != 0; j++) {

							int test_channel = test_channels[j];

							// Try to set the channel number.

							if (ioctl(m_dev, SNDCTL_DSP_CHANNELS, &test_channel) == -1)

								continue; //altri canali potrebbero essere supportati

							else {

								if (test_channel == test_channels[j]) {

									// Last step: Test the supported sample rates for the current channel number

									//            and format.

									// Note: If you need a sample rate that is not tested here, simply add it to

									//       the definition of the array test_sample_rates in this file.

									for (int k = 0; test_sample_rates[k] != 0; k++) {

										TUINT32 test_rate = test_sample_rates[k];

										if (ioctl(m_dev, SNDCTL_DSP_SPEED, &test_rate) == -1)

											continue; //altri rates ppotrebbero essere supportati

										else {

											bool sign = true;

											int bits;

											if (fmt == AFMT_U8 || fmt == AFMT_S8) {

												bits = 8;

												if (fmt == AFMT_U8)

													sign = false;

											} else if (fmt == AFMT_S16_LE || fmt == AFMT_S16_BE)

												bits = 16;

											/*// vedi commento alla variabile test_formats

                      else if(fmt == AFMT_S32_LE || fmt == AFMT_S32_BE)

                        bits = 24;

                      */

											// Add it to the format in the input property.

											//std::cout << test_rate << " " <

											m_supportFormats.insert(std::make_pair(test_rate, TSoundTrackFormat(test_rate, bits, test_channel, sign)));

										}

									}

								} // loop over the test_sample_rates

							}	 // channel set correctly ?

						}		  // ioctl for sample rate worked ?

					}			  // loop over the test_channels

				}				  // channel set correctly ?

			}					  // ioctl for channel worked ?

			// After testing all configurations for one format, the device is closed and reopened.

			// This is necessary to configure it to another format in a secure way.

			if (close(m_dev) == -1) {

				/*

        throw TSoundDeviceException(

				  TSoundDeviceException::UnableCloseDevice,

				  "Problem to close the output device checking formats");

        */

				continue;

			} else if ((m_dev = open("/dev/dsp", O_WRONLY | O_NONBLOCK)) == -1) {

				/*

        m_dev = -1;

        string errMsg = strerror(errno);

        throw TSoundDeviceException(

				    TSoundDeviceException::UnableOpenDevice, errMsg + " /dev/dsp\n: impossible check supported formats");

        */

				return;

			}

		} // format set correctly ?

	}	 // loop over the test_formats

	// Close the device to make it forget the last format configurations.

	if (close(m_dev) == -1) {

		/*

    throw TSoundDeviceException(

			TSoundDeviceException::UnableCloseDevice,

			"Problem to close the output device checking formats");

    */

		return;

	} else

		m_dev = -1;

	//std::cout << "FINITO " << m_supportFormats.size()<< std::endl;

}

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

bool TSoundOutputDeviceImp::isSupportFormat(const TSoundTrackFormat &fmt)

{

	try {

		if (m_supportFormats.empty())

			checkSupportedFormat();

	} catch (TSoundDeviceException &e) {

		return false;

	}

	std::multimap<tuint32, tsoundtrackformat="">::iterator it;</tuint32,>

	pair<std::multimap<tuint32, tsoundtrackformat="">::iterator, std::multimap<tuint32, tsoundtrackformat="">::iterator> findRange;</tuint32,></std::multimap<tuint32,>

	findRange = m_supportFormats.equal_range(fmt.m_sampleRate);

	it = findRange.first;

	for (; it != findRange.second; ++it) {

		assert(it->first == fmt.m_sampleRate);

		if (it->second == fmt) {

			return true;

		}

	}

	return false;

}

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

void TSoundOutputDeviceImp::setFormat(const TSoundTrackFormat &fmt)

{

	int bps, ch, status;

	TUINT32 sampleRate;

	ch = fmt.m_channelCount;

	sampleRate = fmt.m_sampleRate;

	if (m_dev == -1)

		if (!doOpenDevice())

			return;

	if (fmt.m_bitPerSample == 8) {

		if (fmt.m_signedSample)

			bps = AFMT_S8;

		else

			bps = AFMT_U8;

	} else if (fmt.m_bitPerSample == 16) {

		bps = AFMT_S16_NE;

	}

	int bitPerSample = bps;

	status = ioctl(m_dev, SNDCTL_DSP_SETFMT, &bps);

	if (status == -1) {

		throw TSoundDeviceException(

			TSoundDeviceException::UnablePrepare,

			"Failed setting the specified number of bits");

	}

	status = ioctl(m_dev, SNDCTL_DSP_CHANNELS, &ch);

	if (status == -1)

		throw TSoundDeviceException(

			TSoundDeviceException::UnablePrepare,

			"Failed setting the specified number of channel");

	if (ioctl(m_dev, SNDCTL_DSP_SPEED, &sampleRate) == -1)

		throw TSoundDeviceException(

			TSoundDeviceException::UnablePrepare,

			"Failed setting the specified sample rate");

	if (ch != fmt.m_channelCount || bps != bitPerSample || sampleRate != fmt.m_sampleRate) {

		doCloseDevice();

		m_currentFormat = TSoundTrackFormat();

		return;

	}

	m_currentFormat = fmt;

}

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

class TPlayTask : public TThread::Runnable

{

	SmartWatch *m_stopWatch;

public:

	TSoundOutputDeviceImp *m_devImp;

	TSoundTrackP m_sndtrack;

	static int m_skipBytes;

	TPlayTask(TSoundOutputDeviceImp *devImp, const TSoundTrackP &st);

	~TPlayTask() { delete m_stopWatch; }

	void run();

	void run2();

};

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

TPlayTask::TPlayTask(TSoundOutputDeviceImp *devImp, const TSoundTrackP &st)

	: Runnable(), m_stopWatch(new SmartWatch), m_devImp(devImp), m_sndtrack(st)

{

	if (st->getFormat() != m_devImp->m_currentFormat)

		if (m_devImp->doCloseDevice())

			m_devImp->setFormat(st->getFormat());

	m_stopWatch->start();

};

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

void TPlayTask::run()

{

	int bytesLeft = m_sndtrack->getSampleCount() * m_sndtrack->getSampleSize();

	char *buf = (char *)m_sndtrack->getRawData();

	int done = 0;

	int written = 0;

	TINT32 sampleSize = (TINT32)m_sndtrack->getSampleSize();

	const double msToBytes = sampleSize * m_sndtrack->getSampleRate() / 1000.;

	TThread::milestone();

	double startupDelay = m_stopWatch->getTotalTime();

	//std::cout << "ritardo iniziale " << startupDelay << std::endl;

	int miss = 0;

	m_stopWatch->start(); //e' meglio ignorare il ritardo iniziale

	if (done > 0) {

		m_stopWatch->addDelay(((done / sampleSize) * 1000) / double(m_sndtrack->getSampleRate()));

	}

	int auxbuffersize = 0;

	int preWrittenBytes = 0;

	int bytesToSkipNext;

	TSoundTrackP src = TSoundTrack::create(m_sndtrack->getFormat(), 1);

	TSoundTrackP dst = src;

	TSoundTrackP newSrc = src;

	try {

		do //gia' tracce accodate

		{

			bool changeSnd = false;

			do //c'e' il flag loop settato

			{

				while ((bytesLeft > 0)) {

					TThread::milestone();

					changeSnd = false;

					audio_buf_info info;

					TINT32 bytesToWrite = 0;

					TINT32 bytesToWriteNext = 0;

					double samplesDone = done / (double)sampleSize;

					double trackTime = (samplesDone * 1000.) / m_sndtrack->getSampleRate();

					double curTime = m_stopWatch->getTotalTime();

					double delta = curTime - trackTime;

					/* 

					 delta

									 == 0 sync

									 <	 0 audio piu' veloce del tempo di playback  --> simuliamo un ritardo con un continue;

									 >  0 audio piu' lento del playback -> skip una porzione di audio

				 */

					const double minDelay = -10;

					const double maxDelay = 0;

					//if (delta>maxDelay)

					//std::cout << "buffer underrun:" << delta << std::endl;

					//std::cout << "buffer " << (delta<mindelay?"overrun":delta>maxDelay?"underrun":"sync")  << " " << delta<< std::endl;</mindelay?"overrun":delta>

					if (delta < minDelay) //overrun

					{

						//std::cout << "out of sync -> audio troppo veloce" << std::endl;

						continue;

					}

					if (ioctl(m_devImp->m_dev, SNDCTL_DSP_GETOSPACE, &info) == -1) {

						miss++;

						break;

					}

					int fragmentsFree_bytes = info.fragsize * info.fragments;

					if (fragmentsFree_bytes == 0) {

						//std::cout << "no bytes left on device" << std::endl;

						continue;

					}

					int bytesToSkip = 0;

					bytesToSkipNext = 0;

					if (delta > maxDelay) //underrun

					{

						//std::cout << "out of sync -> audio troppo lento"<

						//skip di una porzione... delta in ms

						bytesToSkip = tceil(delta * msToBytes); //numero di bytes da skippare

						//lo arrotondo al sample size

						bytesToSkip += sampleSize - (bytesToSkip % sampleSize);

						//std::cout << "bytes skippati "<< bytesToSkip << std::endl;

					} else { //sto fra minDelay e maxDelay

						bytesToSkip = 0;

					}

					bytesToSkipNext = bytesToSkip;

					bytesToSkip = tmin(bytesLeft, bytesToSkip);

					bytesToSkipNext -= bytesToSkip; //se !=0 => la corrente traccia non basta per avere il sync

					bytesLeft -= bytesToSkip;

					done += bytesToSkip;

					bytesToWrite = tmin(bytesLeft, fragmentsFree_bytes);

					bytesToWriteNext = fragmentsFree_bytes - bytesToWrite;

					assert(bytesToWrite >= 0);

					assert(bytesToWriteNext >= 0);

					if (bytesToWrite % info.fragsize != 0) { //cerco di gestire il write di un frammento non intero

						auxbuffersize = ((bytesToWrite / info.fragsize) + 1) * info.fragsize;

					} else

						auxbuffersize = 0;

					//--------------write

					if (bytesToSkipNext == 0) //la corrente traccia basta per lo skip

					{

						std::cout << " QUI 0 " << std::endl;

						dst = m_sndtrack->extract(done / sampleSize, (done + bytesToWrite) / sampleSize);

						if (bytesToSkip != 0) {

							//costruisco traccia su cui fare il crossfade

							//utilizzo il contenuto della traccia di crossfade

							dst = TSop::crossFade(0.2, src, dst);

						}

						char *auxbuf = new char[fragmentsFree_bytes];

						memcpy(auxbuf, (char *)dst->getRawData(), bytesToWrite);

						if (bytesToWriteNext != 0) {

							int offset = bytesToWrite;

							if (m_devImp->m_looped) {

								offset += bytesToWriteNext;

								preWrittenBytes = bytesToWriteNext;

								memcpy(auxbuf + offset, buf, preWrittenBytes);

								newSrc = m_sndtrack->extract(preWrittenBytes / sampleSize, preWrittenBytes / sampleSize);

								std::cout << " QUI 1" << std::endl;

							} else {

								while (!m_devImp->m_waitingTracks.empty()) {

									TSoundTrackP st = m_devImp->m_waitingTracks[0].first;

									int count = st->getSampleCount() * sampleSize;

									if (bytesToWriteNext >= count) {

										char *buffer = (char *)st->getRawData();

										memcpy(auxbuf + offset, buffer, count);

										bytesToWriteNext -= count;

										offset += count;

										std::cout << " QUI 2" << std::endl;

										if (m_devImp->m_waitingTracks[0].second) {

											m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;

											m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());

											newSrc = m_sndtrack->extract(count / sampleSize, count / sampleSize);

											m_sndtrack = st;

											preWrittenBytes = 0;

											std::cout << " QUI 3" << std::endl;

											break;

										}

										m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());

										newSrc = m_sndtrack->extract(count / sampleSize, count / sampleSize);

									} else {

										m_sndtrack = st;

										m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;

										preWrittenBytes = bytesToWriteNext;

										buf = (char *)m_sndtrack->getRawData();

										memcpy(auxbuf + offset, buf, bytesToWriteNext);

										m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());

										newSrc = m_sndtrack->extract((bytesToWriteNext) / sampleSize, (bytesToWriteNext) / sampleSize);

										std::cout << " QUI 4" << std::endl;

										break;

									}

								} //end while

							}

							if (fragmentsFree_bytes > offset) {

								std::cout << " QUI 5" << std::endl;

								int val = m_sndtrack->isSampleSigned() ? 0 : 127;

								memset(auxbuf + offset, val, fragmentsFree_bytes - offset); // ci metto silenzio

								newSrc = TSoundTrack::create(m_sndtrack->getFormat(), 1);

							}

						}

						written = write(m_devImp->m_dev, auxbuf, fragmentsFree_bytes);

						delete[] auxbuf;

					} else //devo skippare anche parte di una delle seguenti

					{

						std::cout << " QUI 6a" << std::endl;

						assert(bytesToWriteNext > 0);

						assert(bytesToWriteNext == fragmentsFree_bytes - bytesToWrite);

						assert(bytesToWrite == 0);

						assert(bytesToSkip != 0);

						char *auxbuf = new char[fragmentsFree_bytes];

						//memcpy(auxbuf, buf+done, bytesToWrite);

						//TSoundTrackP subCross = m_sndtrack->extract((done+bytesToWrite)/sampleSize, (done+bytesToWrite)/sampleSize);

						//togli quelle da skippare

						int backupSkipNext = bytesToSkipNext;

						while (!m_devImp->m_waitingTracks.empty()) {

							TSoundTrackP st = m_devImp->m_waitingTracks[0].first;

							int count = st->getSampleCount() * sampleSize;

							if (bytesToSkipNext >= count) {

								std::cout << " QUI 6b" << std::endl;

								m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());

								bytesToSkipNext -= count;

							} else {

								std::cout << " QUI 7" << std::endl;

								m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());

								m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;

								m_sndtrack = st;

								buf = (char *)st->getRawData();

								break;

							}

						}

						//scrivi byteWriteNext fai crossfade e cerca quella successiva

						//con cui riempire

						TINT32 displacement = 0; //deve essere in munero di campioni non bytes

						dst = TSoundTrack::create(m_sndtrack->getFormat(), (fragmentsFree_bytes - bytesToWrite) / sampleSize);

						int count = m_sndtrack->getSampleCount() * sampleSize;

						if (count >= bytesToSkipNext + bytesToWriteNext) //la traccia trovata e' suff sia per skippare che per scrivere

						{

							preWrittenBytes = bytesToSkipNext + bytesToWriteNext;

							dst = m_sndtrack->extract(bytesToSkipNext / sampleSize, preWrittenBytes / sampleSize);

							newSrc = m_sndtrack->extract(preWrittenBytes / sampleSize, preWrittenBytes / sampleSize);

						} else //non e' suff per scrivere

						{

							dst->copy(m_sndtrack->extract(bytesToSkipNext / sampleSize, m_sndtrack->getSampleCount() - 1), 0);

							displacement = m_sndtrack->getSampleCount() - bytesToSkipNext / sampleSize;

							bytesToWriteNext -= displacement * sampleSize;

							while (!m_devImp->m_waitingTracks.empty()) {

								TSoundTrackP st = m_devImp->m_waitingTracks[0].first;

								int count = st->getSampleCount() * sampleSize;

								if (bytesToWriteNext >= count) {

									std::cout << " QUI 8" << std::endl;

									dst->copy(st, displacement);

									bytesToWriteNext -= count;

									displacement += count;

									if (m_devImp->m_waitingTracks[0].second) {

										std::cout << " QUI 9" << std::endl;

										m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;

										m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());

										newSrc = m_sndtrack->extract(count / sampleSize, count / sampleSize);

										m_sndtrack = st;

										break;

									}

									m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());

									newSrc = m_sndtrack->extract(count / sampleSize, count / sampleSize);

								} else {

									std::cout << " QUI 10" << std::endl;

									dst->copy(st->extract(0L, bytesToWriteNext / sampleSize), displacement);

									m_sndtrack = st;

									m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;

									preWrittenBytes = bytesToWriteNext;

									done = preWrittenBytes;

									bytesLeft = m_sndtrack->getSampleCount() * sampleSize - done;

									buf = (char *)m_sndtrack->getRawData();

									m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());

									newSrc = m_sndtrack->extract(preWrittenBytes / sampleSize, preWrittenBytes / sampleSize);

									break;

								}

							}

							bytesToSkipNext = backupSkipNext;

						}

						TSoundTrackP st = TSop::crossFade(0.2, src, dst);

						memcpy(auxbuf + bytesToWrite, (char *)st->getRawData(), fragmentsFree_bytes - bytesToWrite);

						//devo ricercare quella giusta che non deve essere skippata

						//ma sostitutita come traccia corrente

						//devo fare un cross fade

						written = write(m_devImp->m_dev, auxbuf, fragmentsFree_bytes);

						delete[] auxbuf;

					}

					//----------- end write

					src = newSrc;

					if (written == -1)

						break;

					std::cout << written << " " << (bytesToWrite + preWrittenBytes) << std::endl;

					if (written != bytesToWrite + preWrittenBytes)

						break;

					std::cout << " update done 2" << std::endl;

					bytesLeft -= written;

					done += written;

				} //chiudo il while((bytesLeft > 0))

				std::cout << " QUI 11" << std::endl;

				done = preWrittenBytes + bytesToSkipNext;

				written = 0;

				bytesLeft = m_sndtrack->getSampleCount() * sampleSize - done;

				m_stopWatch->start();

				if (done > 0) {

					m_stopWatch->addDelay(((done / m_sndtrack->getSampleSize()) * 1000) / double(m_sndtrack->getSampleRate()));

				}

				preWrittenBytes = 0;

			} while (m_devImp->m_looped || changeSnd);

			if (m_devImp->m_waitingTracks.empty())

				break;

			m_sndtrack = m_devImp->m_waitingTracks[0].first;

			m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;

			m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());

			bytesLeft = m_sndtrack->getSampleCount() * m_sndtrack->getSampleSize();

			buf = (char *)m_sndtrack->getRawData();

			done = 0;

			written = 0;

			m_stopWatch->start(); //ignoro il ritardo iniziale

			if (done > 0) {

				m_stopWatch->addDelay(((done / m_sndtrack->getSampleSize()) * 1000) / double(m_sndtrack->getSampleRate()));

			}

		} while (true); //ci sono gia' tracce accodate

		if (!m_devImp->m_waitingTracks.empty()) {

			m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;

			m_devImp->m_executor.addTask(new TPlayTask(m_devImp, m_devImp->m_waitingTracks[0].first));

			m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());

			//std::cout<<"OPS ..... erase 4"<

		} else if (m_devImp->m_dev != -1) {

			if (ioctl(m_devImp->m_dev, SNDCTL_DSP_SYNC) == -1) {

				std::cout << "unable to sync! " << std::endl;

				throw TException("unable to sync!");

			}

			m_devImp->m_isPlaying = false;

			m_devImp->m_stopped = true;

			m_devImp->m_looped = false;

			//std::cout << "miss = " << miss << std::endl;

		}

	} catch (TThread::Interrupt &e) {

		std::cout << "Play interrupted " << e.getMessage() << std::endl;

		m_devImp->m_isPlaying = false;

		m_devImp->m_stopped = true;

		m_devImp->m_looped = false;

	} catch (TException &e) {

		std::cout << "esco dal play " << e.getMessage() << std::endl;

		m_devImp->m_isPlaying = false;

		m_devImp->m_stopped = true;

		m_devImp->m_looped = false;

	}

}

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

void TPlayTask::run2()

{

	int bytesLeft = m_sndtrack->getSampleCount() * m_sndtrack->getSampleSize();

	char *buf = (char *)m_sndtrack->getRawData();

	int done = 0;

	int written = 0;

	TINT32 sampleSize = (TINT32)m_sndtrack->getSampleSize();

	const double msToBytes = sampleSize * m_sndtrack->getSampleRate() / 1000.;

	TThread::milestone();

	double startupDelay = m_stopWatch->getTotalTime();

	//std::cout << "ritardo iniziale " << startupDelay << std::endl;

	int miss = 0;

	m_stopWatch->start(); //e' meglio ignorare il ritardo iniziale

	if (done > 0) {

		m_stopWatch->addDelay(((done / sampleSize) * 1000) / double(m_sndtrack->getSampleRate()));

	}

	int auxbuffersize = 0;

	int preWrittenBytes = 0;

	TSoundTrackP src = TSoundTrack::create(m_sndtrack->getFormat(), 1);

	TSoundTrackP dst = src;

	try {

		do //gia' tracce accodate

		{

			bool changeSnd = false;

			do //c'e' il flag loop settato

			{

				while ((bytesLeft > 0)) {

					changeSnd = false;

					TThread::milestone();

					audio_buf_info info;

					TINT32 bytesToWrite;

					double samplesDone = done / (double)sampleSize;

					double trackTime = (samplesDone * 1000.) / m_sndtrack->getSampleRate();

					double curTime = m_stopWatch->getTotalTime();

					double delta = curTime - trackTime;

					/* 

					 delta

									 == 0 sync

									 <	 0 audio piu' veloce del tempo di playback  --> simuliamo un ritardo con un continue;

									 >  0 audio piu' lento del playback -> skip una porzione di audio

				 */

					const double minDelay = -10;

					const double maxDelay = 0;

					//if (delta>maxDelay)

					//std::cout << "buffer underrun:" << delta << std::endl;

					//std::cout << "buffer " << (delta<mindelay?"overrun":delta>maxDelay?"underrun":"sync")  << " " << delta<< std::endl;</mindelay?"overrun":delta>

					if (delta < minDelay) //overrun

					{

						//std::cout << "out of sync -> audio troppo veloce" << std::endl;

						continue;

					}

					if (ioctl(m_devImp->m_dev, SNDCTL_DSP_GETOSPACE, &info) == -1) {

						miss++;

						break;