#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=""></tuint32,>

    TSoundOutputDeviceImp::m_supportFormats;

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

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,>

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

      findRange;

  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")  << " "</mindelay?"overrun":delta>

          // << delta<< std::endl;

          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();