#include "tfilepath.h"
#include "tsound.h"
#include "tsound_io.h"
#include "tsop.h"
#include "tthread.h"
#include "texception.h"
#include "tsystem.h"
#include <iostream>
#include <linux/soundcard.h>
#include <set>
#include <sys/time.h>

#include <unistd.h>

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

// 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;
  static std::multimap<TUINT32, TSoundTrackFormat> m_supportFormats;

  typedef pair<TSoundTrackP, bool> WaitPair;
  vector<WaitPair> m_waitingTracks;
  std::set<TSoundOutputDeviceListener *> m_listeners;
  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;
//----------------------------------------------------------------------------

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<<std::endl;
  // 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" <<std::endl;

  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;

  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 << " " <<bits<<"
                      // "<<test_channel<<std::endl;
                      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;
  pair<std::multimap<TUINT32, TSoundTrackFormat>::iterator,
       std::multimap<TUINT32, TSoundTrackFormat>::iterator>
      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")  << " "
          // << 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"<<std::endl;
            // 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"<<std::endl;
    } 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;

          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;
          int bigSkip     = 0;
          if (delta > maxDelay)  // underrun
          {
            // std::cout << "out of sync -> audio troppo lento"<<std::endl;
            // 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;
            bigSkip = bytesToSkip;
          } else {  // sto fra minDelay e maxDelay
            bytesToSkip = 0;
          }

          bytesToSkip = tmin(bytesLeft, bytesToSkip);
          bigSkip -= bytesToSkip;
          bytesLeft -= bytesToSkip;
          done += bytesToSkip;

          bytesToWrite = tmin(bytesLeft, fragmentsFree_bytes);

          if (bytesToWrite % info.fragsize !=
              0) {  // cerco di gestire il write di un frammento non intero
            auxbuffersize =
                ((bytesToWrite / info.fragsize) + 1) * info.fragsize;
          }

          if (bigSkip)
            while (!m_devImp->m_waitingTracks.empty()) {
              TSoundTrackP st = m_devImp->m_waitingTracks[0].first;
              int count       = st->getSampleCount() * sampleSize;
              if (bigSkip >= count) {
                m_devImp->m_waitingTracks.erase(
                    m_devImp->m_waitingTracks.begin());
                bigSkip -= count;
              } else
                break;
            }

          preWrittenBytes = 0;
          if (auxbuffersize == 0) {
            if (bytesToSkip != 0) {
              // costruisco traccia su cui fare il crossfade
              // utilizzo il contenuto della traccia di crossfade
              dst = m_sndtrack->extract(done / sampleSize,
                                        (done + bytesToWrite) / sampleSize);
              TSoundTrackP st = TSop::crossFade(0.2, src, dst);
              char *buffer    = (char *)st->getRawData();
              written         = write(m_devImp->m_dev, buffer, bytesToWrite);
            } else
              written = write(m_devImp->m_dev, buf + done, bytesToWrite);
            src       = m_sndtrack->extract((done + bytesToWrite) / sampleSize,
                                      (done + bytesToWrite) / sampleSize);
          } else {  // auxbuffersize != 0 sse il numero di bytes residui nella
                    // traccia e' inferiore alla dimensione del frammento
            char *auxbuf = new char[auxbuffersize];
            TSoundTrackP newSrc;
            dst = TSoundTrack::create(m_sndtrack->getFormat(),
                                      auxbuffersize / sampleSize);
            memcpy(auxbuf, buf + done, bytesToWrite);
            dst->copy(m_sndtrack->extract(done / sampleSize,
                                          (done + bytesToWrite) / sampleSize),
                      0);
            preWrittenBytes = auxbuffersize - bytesToWrite;
            if (m_devImp->m_looped) {
              memcpy(auxbuf + bytesToWrite, buf, preWrittenBytes);
              dst->copy(m_sndtrack->extract(0, preWrittenBytes / sampleSize),
                        bytesToWrite / sampleSize);
              newSrc = m_sndtrack->extract(preWrittenBytes / sampleSize,
                                           preWrittenBytes / sampleSize);
            } else {
              newSrc = TSoundTrack::create(m_sndtrack->getFormat(), 1);
              static int added = 0;
              // se non c'e' alcuna altra traccia o e di diverso format
              // riempo il frammento con del silenzio
              if (m_devImp->m_waitingTracks.empty() ||
                  (m_sndtrack->getFormat() !=
                   m_devImp->m_waitingTracks[0].first->getFormat())) {
                int val = m_sndtrack->isSampleSigned() ? 0 : 127;
                memset(auxbuf + bytesToWrite, val,
                       preWrittenBytes);  // ci metto silenzio
              } else
                while (true)  // ci sono altre tracce accodate
                {
                  TSoundTrackP st = m_devImp->m_waitingTracks[0].first;
                  int sampleBytes = st->getSampleCount() * st->getSampleSize();
                  if (sampleBytes >= preWrittenBytes - added) {
                    // La traccia ha abbastanza campioni per riempire il
                    // frammento
                    // quindi la sostituisco alla corrente del runnable e
                    // continuo
                    buf = (char *)st->getRawData();
                    memcpy(auxbuf + bytesToWrite, buf, preWrittenBytes - added);
                    m_sndtrack         = st;
                    m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
                    m_devImp->m_waitingTracks.erase(
                        m_devImp->m_waitingTracks.begin());
                    changeSnd = true;
                    dst->copy(m_sndtrack->extract(
                                  0, (preWrittenBytes - added) / sampleSize),
                              bytesToWrite / sampleSize + added);
                    newSrc = m_sndtrack->extract(
                        (preWrittenBytes - added) / sampleSize,
                        (preWrittenBytes - added) / sampleSize);
                    break;
                  } else {  // occhio al loop
                    // La traccia successiva e' piu corta del frammento da
                    // riempire quindi
                    // ce la metto tutta e se non ha il flag di loop settato
                    // cerco di aggiungere
                    // i byte della successiva
                    memcpy(auxbuf + bytesToWrite, st->getRawData(),
                           sampleBytes);
                    dst->copy(st->extract(0, st->getSampleCount() - 1),
                              bytesToWrite / sampleSize);
                    added += st->getSampleCount();
                    if (m_devImp->m_waitingTracks[0]
                            .second)  // e' quella che deve essere in loop
                    {
                      buf                = (char *)st->getRawData();
                      m_sndtrack         = st;
                      m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
                      preWrittenBytes    = 0;
                      bytesLeft          = 0;
                      m_devImp->m_waitingTracks.erase(
                          m_devImp->m_waitingTracks.begin());
                      changeSnd = true;
                      break;
                    }

                    // la elimino e vedo se esiste la successiva altrimenti
                    // metto campioni "zero"
                    m_devImp->m_waitingTracks.erase(
                        m_devImp->m_waitingTracks.begin());
                    if (!m_devImp->m_waitingTracks.empty()) {
                      st = m_devImp->m_waitingTracks[0].first;
                      std::cout
                          << " Traccia con meno campioni cerco la successiva"
                          << std::endl;
                    } else {
                      int val = m_sndtrack->isSampleSigned() ? 0 : 127;
                      memset(
                          auxbuf + bytesToWrite, val,
                          preWrittenBytes - sampleBytes);  // ci metto silenzio
                      std::cout << "OPS ..... silence" << std::endl;
                      break;
                    }
                  }
                }  // end while(true)
            }
            // qui andrebbe fatto un cross-fade se c'erano da skippare campioni
            // => bytesToSkip != 0
            if (bytesToSkip != 0) {
              TSoundTrackP st = TSop::crossFade(0.2, src, dst);
              char *buffer    = (char *)st->getRawData();
              written         = write(m_devImp->m_dev, buffer, bytesToWrite);
            } else
              written     = write(m_devImp->m_dev, auxbuf, auxbuffersize);
            src           = newSrc;
            auxbuffersize = 0;
            delete[] auxbuf;
          }
          if (written == -1) break;
          if (written != bytesToWrite + preWrittenBytes) break;
          bytesLeft -= written;
          done += written;
        }  // chiudo il while((bytesLeft > 0))
        done    = preWrittenBytes;
        written = 0;
        bytesLeft =
            m_sndtrack->getSampleCount() * m_sndtrack->getSampleSize() - done;
        m_stopWatch->start();
        if (done > 0) {
          m_stopWatch->addDelay(((done / m_sndtrack->getSampleSize()) * 1000) /
                                double(m_sndtrack->getSampleRate()));
        }
      } while (m_devImp->m_looped || changeSnd);

      if (m_devImp->m_waitingTracks.empty()) {
        // std::cout<<"OPS ..... non accodato"<<std::endl;
        break;
      }

      // std::cout<<"OPS ..... accodato"<<std::endl;
      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"<<std::endl;
    } 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;
  }
}

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

TSoundOutputDevice::TSoundOutputDevice() : m_imp(new TSoundOutputDeviceImp) {
  if (m_imp->doOpenDevice()) {
    m_imp->insertAllRate();
    try {
      if (!m_imp->verifyRate())
        throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
                                    "No default samplerate are supported");
    } catch (TSoundDeviceException &e) {
      throw TSoundDeviceException(e.getType(), e.getMessage());
    }
    m_imp->doCloseDevice();
  }
}

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

TSoundOutputDevice::~TSoundOutputDevice() { close(); }

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

bool TSoundOutputDevice::installed() {
  bool ret = false;
  int dev  = ::open("/dev/dsp", O_WRONLY, 0);
  if (dev >= 0) {
    ret = true;
    ::close(dev);
  }
  return ret;
}

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

bool TSoundOutputDevice::open(const TSoundTrackP &st) {
  m_imp->m_currentFormat = st->getFormat();
  try {
    m_imp->doOpenDevice();
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }
  return true;
}

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

bool TSoundOutputDevice::close() {
  stop();
  if (m_imp->m_dev != -1) {
    bool closed = m_imp->doCloseDevice();
    if (!closed)
      throw TSoundDeviceException(
          TSoundDeviceException::UnableCloseDevice,
          "Error during the closing of the output device");
  }
  return true;
}

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

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;

  TThread::ScopedLock 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");

  TSoundTrackFormat format = st->getFormat();
  if (!m_imp->isSupportFormat(format)) {
    throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
                                "Unsupported format for playback");
  }

  if (m_imp->m_isPlaying) {
    assert(s1 >= s0);
    TSoundTrackP subTrack = st->extract(s0, s1);
    m_imp->m_waitingTracks.push_back(std::make_pair(subTrack, loop));
    // std::cout<<"Sono in pushback"<<std::endl;
    return;
  }

  if ((m_imp->m_dev == -1)) try {
      if (m_imp->doOpenDevice()) m_imp->setFormat(format);
    } catch (TSoundDeviceException &e) {
      m_imp->doCloseDevice();
      throw TSoundDeviceException(e.getType(), e.getMessage());
    }

  m_imp->m_isPlaying = true;
  m_imp->m_stopped   = false;
  m_imp->m_looped    = loop;
  // m_imp->m_currentFormat = st->getFormat();

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

  m_imp->m_executor.addTask(new TPlayTask(m_imp, subTrack));
}
//------------------------------------------------------------------------------

void TSoundOutputDevice::stop() {
  TThread::ScopedLock sl(m_imp->m_mutex);
  if (!m_imp->m_isPlaying) return;
  m_imp->m_executor.cancel();
  ioctl(m_imp->m_dev, SNDCTL_DSP_POST, 0);
  m_imp->m_isPlaying = false;
  m_imp->m_stopped   = true;
  m_imp->m_looped    = false;
  m_imp->m_waitingTracks.clear();
}

//------------------------------------------------------------------------------
double TSoundOutputDevice::getVolume() {
  int mixer;
  if ((mixer = openMixer()) < 0)
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Can't open the mixer device");

  int devmask;
  if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &devmask) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Error in ioctl with mixer device");
  }

  int recmask;
  if (ioctl(mixer, SOUND_MIXER_READ_RECMASK, &recmask) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Error in ioctl with mixer device");
  }

  int stereo;
  if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &stereo) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Error in ioctl with mixer device");
  }

  int outmask = devmask | ~recmask;

  int index;
  if (outmask & (1 << SOUND_MIXER_ALTPCM))
    index = SOUND_MIXER_ALTPCM;
  else if (outmask & (1 << SOUND_MIXER_PCM))
    index = SOUND_MIXER_PCM;

  int level;
  if (ioctl(mixer, MIXER_READ(index), &level) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
                                "Error to read the volume");
  }
  if ((1 << index) & stereo) {
    int left  = level & 0xff;
    int right = ((level & 0xff00) >> 8);
    ::close(mixer);
    return (left + right) / 20.0;
  } else {
    ::close(mixer);
    return (level & 0xff) / 10.0;
  }
}

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

bool TSoundOutputDevice::setVolume(double volume) {
  int mixer;
  if ((mixer = openMixer()) < 0)
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Can't open the mixer device");

  int devmask;
  if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &devmask) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Error in ioctl with mixer device");
  }

  int recmask;
  if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &recmask) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Error in ioctl with mixer device");
  }

  int stereo;
  if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &stereo) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Error in ioctl with mixer device");
  }

  int outmask = devmask | ~recmask;

  if (outmask & (1 << SOUND_MIXER_ALTPCM)) {
    int vol, index = SOUND_MIXER_ALTPCM;
    if ((1 << index) & stereo) {
      volume *= 10.0;
      vol = (int)volume + ((int)(volume * 256.0));
    } else
      vol = (int)(volume * 10.0);

    if (!writeVolume(vol, mixer, index)) {
      ::close(mixer);
      throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
                                  "Can't write the volume");
    }

    // metto anche l'altro ad un livello di sensibilita' adeguata
    if (outmask & (1 << SOUND_MIXER_PCM)) {
      int vol, index = SOUND_MIXER_PCM;
      double volDefault = 6.7;
      if ((1 << index) & stereo) {
        volDefault *= 10.0;
        vol = (int)volDefault + ((int)(volDefault * 256.0));
      } else
        vol = (int)(volDefault * 10.0);

      if (!writeVolume(vol, mixer, index)) {
        ::close(mixer);
        throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
                                    "Can't write the volume");
      }
    }
  } else if (outmask & (1 << SOUND_MIXER_PCM)) {
    int vol, index = SOUND_MIXER_PCM;
    if ((1 << index) & stereo) {
      volume *= 10.0;
      vol = (int)volume + ((int)(volume * 256.0));
    } else
      vol = (int)(volume * 10.0);

    if (!writeVolume(vol, mixer, index)) {
      ::close(mixer);
      throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                  "Can't write the volume");
    }
  }

  ::close(mixer);
  return true;
}

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

bool TSoundOutputDevice::isPlaying() const {
  TThread::ScopedLock sl(m_imp->m_mutex);
  return m_imp->m_isPlaying;
}

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

bool TSoundOutputDevice::isLooping() {
  TThread::ScopedLock sl(m_imp->m_mutex);
  return m_imp->m_looped;
}

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

void TSoundOutputDevice::setLooping(bool loop) {
  TThread::ScopedLock sl(m_imp->m_mutex);
  m_imp->m_looped = loop;
}

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

bool TSoundOutputDevice::supportsVolume() {
  int mixer;
  if ((mixer = openMixer()) < 0)
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Can't open the mixer device");

  int devmask;
  if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &devmask) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Error in ioctl with mixer device");
  }

  int recmask;
  if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &recmask) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Error in ioctl with mixer device");
  }

  int stereo;
  if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &stereo) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Error in ioctl with mixer device");
  }

  int outmask = devmask | ~recmask;

  if ((outmask & (1 << SOUND_MIXER_ALTPCM)) ||
      (outmask & (1 << SOUND_MIXER_PCM))) {
    ::close(mixer);
    return true;
  }

  return false;
}

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

TSoundTrackFormat TSoundOutputDevice::getPreferredFormat(TUINT32 sampleRate,
                                                         int channelCount,
                                                         int bitPerSample) {
  TSoundTrackFormat fmt;
  if (bitPerSample == 8)
    fmt = TSoundTrackFormat(sampleRate, channelCount, bitPerSample, false);
  else
    fmt = TSoundTrackFormat(sampleRate, channelCount, bitPerSample);
  if (m_imp->isSupportFormat(fmt)) return fmt;

  int bps, ch, status;

  bps = bitPerSample;
  ch  = channelCount;

  if (m_imp->m_dev == -1) m_imp->doOpenDevice();

  if (bitPerSample <= 8) {
    bitPerSample       = AFMT_U8;
    fmt.m_signedSample = false;
  } else if ((bitPerSample > 8 && bitPerSample < 16) || bitPerSample >= 16) {
    bitPerSample       = AFMT_S16_NE;
    fmt.m_signedSample = true;
  }

  status = ioctl(m_imp->m_dev, SNDCTL_DSP_SETFMT, &bitPerSample);
  if (status == -1) {
    perror("CHE palle ");
    throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
                                "Failed setting the specified number of bits");
  }
  fmt.m_bitPerSample = bitPerSample;

  status = ioctl(m_imp->m_dev, SNDCTL_DSP_CHANNELS, &channelCount);
  if (status == -1)
    throw TSoundDeviceException(
        TSoundDeviceException::UnablePrepare,
        "Failed setting the specified number of channel");
  fmt.m_channelCount = channelCount;

  if (m_imp->m_supportedRate.find((int)sampleRate) ==
      m_imp->m_supportedRate.end()) {
    std::set<int>::iterator it =
        m_imp->m_supportedRate.lower_bound((int)sampleRate);
    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())
        sampleRate = *(m_imp->m_supportedRate.rbegin());
      else
        throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
                                    "There isn't a supported rate");
    } else
      sampleRate = *it;
  }

  if (ioctl(m_imp->m_dev, SNDCTL_DSP_SPEED, &sampleRate) == -1)
    throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
                                "Failed setting the specified sample rate");
  fmt.m_sampleRate = sampleRate;

  if (ch != channelCount || bps != bitPerSample) {
    m_imp->doCloseDevice();
  }

  return fmt;
}

//------------------------------------------------------------------------------
TSoundTrackFormat TSoundOutputDevice::getPreferredFormat(
    const TSoundTrackFormat &format) {
  try {
    return getPreferredFormat(format.m_sampleRate, format.m_channelCount,
                              format.m_bitPerSample);
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }
}

//======================================================================
//======================================================================
//					CLASSI PER IL RECORD
//======================================================================
//======================================================================

class TSoundInputDeviceImp {
public:
  int m_dev;
  bool m_stopped;
  bool m_isRecording;
  TSoundTrackFormat m_currentFormat;
  TSoundTrackP m_st;
  std::set<int> m_supportedRate;

  TINT32 m_recordedSampleCount;
  vector<char *> m_recordedBlocks;
  vector<int> m_samplePerBlocks;
  bool m_oneShotRecording;

  TThread::Executor m_executor;

  TSoundInputDeviceImp()
      : m_dev(-1)
      , m_stopped(false)
      , m_isRecording(false)
      , m_st(0)
      , m_supportedRate()
      , m_recordedBlocks()
      , m_samplePerBlocks()
      , m_oneShotRecording(false) {}

  ~TSoundInputDeviceImp() {}

  bool doOpenDevice(const TSoundTrackFormat &format,
                    TSoundInputDevice::Source devType);
  bool doCloseDevice();
  void insertAllRate();
  bool verifyRate();
};

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

bool TSoundInputDeviceImp::doOpenDevice(const TSoundTrackFormat &format,
                                        TSoundInputDevice::Source devType) {
  m_dev = open("/dev/dsp", O_RDONLY);
  if (m_dev < 0)
    throw TSoundDeviceException(TSoundDeviceException::UnableOpenDevice,
                                "Cannot open the dsp device");

  // ioctl(m_dev, SNDCTL_DSP_RESET,0);

  return true;
}

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

bool TSoundInputDeviceImp::doCloseDevice() {
  if (close(m_dev) < 0)
    throw TSoundDeviceException(TSoundDeviceException::UnableCloseDevice,
                                "Cannot close the dsp device");
  m_dev = -1;
  return true;
}

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

void TSoundInputDeviceImp::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 TSoundInputDeviceImp::verifyRate() {
  std::set<int>::iterator it;

  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");
    if (sampleRate != *it) m_supportedRate.erase(*it);
  }
  if (m_supportedRate.end() == m_supportedRate.begin()) return false;

  return true;
}
//==============================================================================

class TRecordTask : public TThread::Runnable {
public:
  TSoundInputDeviceImp *m_devImp;

  TRecordTask(TSoundInputDeviceImp *devImp) : Runnable(), m_devImp(devImp){};

  ~TRecordTask(){};

  void run();
};

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

void TRecordTask::run() {
  // N.B. e' bene che la dimensione sia piccola cosi' l'attesa perche' termini
  // e' minore in questo caso vogliamo 16 frammenti ognuno di 4096 byte
  int fraginfo = (16 << 16) | 12;
  if (ioctl(m_devImp->m_dev, SNDCTL_DSP_SETFRAGMENT, &fraginfo) == -1)
    perror("SETFRAGMENT");

  int fragsize = 0;
  if (ioctl(m_devImp->m_dev, SNDCTL_DSP_GETBLKSIZE, &fragsize) == -1)
    perror("GETFRAGMENT");
  TINT32 byteRecordedSample = 0;

  if (m_devImp->m_oneShotRecording) {
    TINT32 byteToSample =
        m_devImp->m_st->getSampleSize() * m_devImp->m_st->getSampleCount();
    char *buf = (char *)m_devImp->m_st->getRawData();

    while ((byteRecordedSample < byteToSample) && m_devImp->m_isRecording) {
      int sample;
      if (fragsize > (byteToSample - byteRecordedSample))
        sample = byteToSample - byteRecordedSample;
      else
        sample  = fragsize;
      int nread = read(m_devImp->m_dev, buf + byteRecordedSample, sample);
      if (nread == -1) break;
      if (nread != sample) break;

      byteRecordedSample += nread;
    }
  } else {
    int bytePerSample = m_devImp->m_currentFormat.m_bitPerSample >> 3;
    switch (bytePerSample) {
    case 3:
      bytePerSample++;
      break;
    default:
      break;
    }
    bytePerSample *= m_devImp->m_currentFormat.m_channelCount;

    while (m_devImp->m_isRecording) {
      char *dataBuffer = new char[fragsize];
      m_devImp->m_recordedBlocks.push_back(dataBuffer);
      m_devImp->m_samplePerBlocks.push_back(fragsize);

      int nread = read(m_devImp->m_dev, dataBuffer, fragsize);
      if (nread == -1) break;
      if (nread != fragsize) break;

      m_devImp->m_recordedSampleCount += (fragsize / bytePerSample);
    }
  }
  ioctl(m_devImp->m_dev, SNDCTL_DSP_RESET, 0);
}

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

TSoundInputDevice::TSoundInputDevice() : m_imp(new TSoundInputDeviceImp) {
  m_imp->m_dev = open("/dev/dsp", O_RDONLY);
  if (m_imp->m_dev < 0)
    throw TSoundDeviceException(TSoundDeviceException::UnableOpenDevice,
                                "Cannot open the dsp device");

  m_imp->insertAllRate();
  try {
    if (!m_imp->verifyRate())
      throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
                                  "No default samplerate are supported");
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }
  m_imp->doCloseDevice();
}

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

TSoundInputDevice::~TSoundInputDevice() {
  if (m_imp->m_dev != -1) m_imp->doCloseDevice();
  delete m_imp;
}

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

bool TSoundInputDevice::installed() {
  bool ret = false;
  int dev  = ::open("/dev/dsp", O_RDONLY);
  if (dev >= 0) {
    ret = true;
    ::close(dev);
  }
  return ret;
}

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

void TSoundInputDevice::record(const TSoundTrackFormat &format,
                               TSoundInputDevice::Source type) {
  m_imp->m_recordedBlocks.clear();
  m_imp->m_samplePerBlocks.clear();

  // registra creando una nuova traccia
  m_imp->m_oneShotRecording = false;
  try {
    if (m_imp->m_dev == -1) m_imp->doOpenDevice(format, type);

    if (!selectInputDevice(type))
      throw TSoundDeviceException(
          TSoundDeviceException::UnableSetDevice,
          "Input device is not supported for recording");

    TSoundTrackFormat fmt = getPreferredFormat(format);
    if (fmt != format)
      throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
                                  "Unsupported format");
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }

  try {
    if (getVolume() == 0.0) {
      double volume = 5.0;
      setVolume(volume);
    }
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }

  m_imp->m_currentFormat       = format;
  m_imp->m_isRecording         = true;
  m_imp->m_stopped             = false;
  m_imp->m_recordedSampleCount = 0;

  // far partire il thread
  /*TRecordThread *recordThread = new TRecordThread(m_imp);
if (!recordThread)
throw TSoundDeviceException(
TSoundDeviceException::UnablePrepare,
"Problemi per creare il thread");
recordThread->start();*/
  m_imp->m_executor.addTask(new TRecordTask(m_imp));
}

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

void TSoundInputDevice::record(const TSoundTrackP &st,
                               TSoundInputDevice::Source type) {
  m_imp->m_recordedBlocks.clear();
  m_imp->m_samplePerBlocks.clear();

  try {
    if (m_imp->m_dev == -1) m_imp->doOpenDevice(st->getFormat(), type);

    if (!selectInputDevice(type))
      throw TSoundDeviceException(
          TSoundDeviceException::UnableSetDevice,
          "Input device is not supported for recording");

    TSoundTrackFormat fmt = getPreferredFormat(st->getFormat());
    if (fmt != st->getFormat())
      throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
                                  "Unsupported format");

    if (getVolume() == 0.0) {
      double volume = 5.0;
      setVolume(volume);
    }
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }

  // Sovrascive un'intera o parte di traccia gia' esistente
  m_imp->m_oneShotRecording    = true;
  m_imp->m_currentFormat       = st->getFormat();
  m_imp->m_isRecording         = true;
  m_imp->m_stopped             = false;
  m_imp->m_recordedSampleCount = 0;
  m_imp->m_st                  = st;

  m_imp->m_recordedBlocks.push_back((char *)st->getRawData());

  // far partire il thread
  /*TRecordThread *recordThread = new TRecordThread(m_imp);
if (!recordThread)
throw TSoundDeviceException(
TSoundDeviceException::UnablePrepare,
"Problemi per creare il thread");
recordThread->start();*/
  m_imp->m_executor.addTask(new TRecordTask(m_imp));
}

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

TSoundTrackP TSoundInputDevice::stop() {
  TSoundTrackP st;

  if (!m_imp->m_isRecording) return st;

  m_imp->m_isRecording = false;

  // mettere istruzioni per fermare il rec
  ioctl(m_imp->m_dev, SNDCTL_DSP_SYNC, 0);
  try {
    m_imp->doCloseDevice();
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }

  // attendo 1/5 di secondo
  usleep(200000);
  if (m_imp->m_oneShotRecording)
    st = m_imp->m_st;
  else {
    st = TSoundTrack::create(m_imp->m_currentFormat,
                             m_imp->m_recordedSampleCount);
    TINT32 bytesCopied = 0;

    for (int i = 0; i < (int)m_imp->m_recordedBlocks.size(); ++i) {
      memcpy((void *)(st->getRawData() + bytesCopied),
             m_imp->m_recordedBlocks[i], m_imp->m_samplePerBlocks[i]);
      delete[] m_imp->m_recordedBlocks[i];

      bytesCopied += m_imp->m_samplePerBlocks[i];
    }
    m_imp->m_samplePerBlocks.clear();
  }

  return st;
}

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

double TSoundInputDevice::getVolume() {
  int mixer;
  if ((mixer = openMixer()) < 0)
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Can't have the mixer");

  int index;
  if ((index = getCurrentRecordSource(mixer)) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Can't obtain information by mixer");
  }

  int stereo;
  if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &stereo) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Can't obtain information by mixer");
  }

  int level;
  if (ioctl(mixer, MIXER_READ(index), &level) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
                                "Can't read the volume value");
  }

  if ((1 << index) & stereo) {
    int left  = level & 0xff;
    int right = ((level & 0xff00) >> 8);
    ::close(mixer);
    return (left + right) / 20.0;
  } else {
    ::close(mixer);
    return (level & 0xff) / 10.0;
  }
}

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

bool TSoundInputDevice::setVolume(double volume) {
  int mixer;
  if ((mixer = openMixer()) < 0)
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Can't have the mixer");

  int caps;
  if (ioctl(mixer, SOUND_MIXER_READ_CAPS, &caps) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Can't obtain information by mixer");
  }

  if (!(caps & SOUND_CAP_EXCL_INPUT)) {
    int rec;
    if (ioctl(mixer, SOUND_MIXER_READ_RECMASK, &rec) == -1) {
      ::close(mixer);
      throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                  "Can't obtain information by mixer");
    }
    int i;
    int nosound = 0;
    for (i = 0; i < 32; ++i)
      if (rec & (1 << i))
        if (!writeVolume(nosound, mixer, i)) {
          ::close(mixer);
          throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
                                      "Can't set the volume value");
        }
  }

  int index;
  if ((index = getCurrentRecordSource(mixer)) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Can't obtain information by mixer");
  }

  int stereo;
  if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &stereo) == -1) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Can't obtain information by mixer");
  }

  int vol;
  if ((1 << index) & stereo) {
    volume *= 10.0;
    vol = (int)volume + ((int)(volume * 256.0));
  } else
    vol = (int)(volume * 10.0);

  if (!writeVolume(vol, mixer, index)) {
    ::close(mixer);
    throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
                                "Can't write the volume value");
  }
  ::close(mixer);
  return true;
}

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

bool TSoundInputDevice::isRecording() { return m_imp->m_isRecording; }

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

TSoundTrackFormat TSoundInputDevice::getPreferredFormat(TUINT32 sampleRate,
                                                        int channelCount,
                                                        int bitPerSample) {
  TSoundTrackFormat fmt;
  int status;

  if (bitPerSample <= 8) {
    bitPerSample       = AFMT_U8;
    fmt.m_signedSample = false;
  } else if ((bitPerSample > 8 && bitPerSample < 16) || bitPerSample >= 16) {
    bitPerSample       = AFMT_S16_NE;
    fmt.m_signedSample = true;
  }

  status = ioctl(m_imp->m_dev, SNDCTL_DSP_SETFMT, &bitPerSample);
  if (status == -1)
    throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
                                "Failed setting the specified number of bits");
  fmt.m_bitPerSample = bitPerSample;

  status = ioctl(m_imp->m_dev, SNDCTL_DSP_CHANNELS, &channelCount);
  if (status == -1)
    throw TSoundDeviceException(
        TSoundDeviceException::UnablePrepare,
        "Failed setting the specified number of channel");
  fmt.m_channelCount = channelCount;

  if (m_imp->m_supportedRate.find((int)sampleRate) ==
      m_imp->m_supportedRate.end()) {
    std::set<int>::iterator it =
        m_imp->m_supportedRate.lower_bound((int)sampleRate);
    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())
        sampleRate = *(m_imp->m_supportedRate.rbegin());
      else
        throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
                                    "There isn't a supported rate");
    } else
      sampleRate = *it;
  }

  if (ioctl(m_imp->m_dev, SNDCTL_DSP_SPEED, &sampleRate) == -1)
    throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
                                "Failed setting the specified sample rate");
  fmt.m_sampleRate = sampleRate;

  return fmt;
}

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

TSoundTrackFormat TSoundInputDevice::getPreferredFormat(
    const TSoundTrackFormat &format) {
  try {
    return getPreferredFormat(format.m_sampleRate, format.m_channelCount,
                              format.m_bitPerSample);
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }
}

//******************************************************************************
//******************************************************************************
//						funzioni per l'interazione con la
//libreria
// OSS
//******************************************************************************
//******************************************************************************
namespace {
string parseError(int error) {
  switch (error) {
  case EBADF:
    return string("Bad file descriptor");
  case EFAULT:
    return string("Pointer to/from buffer data is invalid");
  case EINTR:
    return string("Signal interrupt the signal");
  case EINVAL:
    return string("Request/arg isn't valid for this device");
  case EIO:
    return string("Some phisical I/O error has occurred");
  case ENOTTY:
    return string(
        "Fieldes isn't associated with a device that accepts control");
  case ENXIO:
    return string(
        "Request/arg  valid, but the requested cannot be performed on this "
        "subdevice");
  default:
    return string("Unknown error");
    break;
  }
}

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

TSoundInputDevice::Source stringToSource(string dev) {
  if (dev == "mic")
    return TSoundInputDevice::Mic;
  else if (dev == "line")
    return TSoundInputDevice::LineIn;
  else if (dev == "cd")
    return TSoundInputDevice::CdAudio;
  else
    return TSoundInputDevice::DigitalIn;
}

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

string sourceToString(TSoundInputDevice::Source dev) {
  switch (dev) {
  case TSoundInputDevice::Mic:
    return string("mic");
  case TSoundInputDevice::LineIn:
    return string("line");
  case TSoundInputDevice::DigitalIn:
    return string("digital");
  default:
    return string("cd");
  }
}

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

int openMixer() {
  int mixer = open("/dev/mixer", O_RDWR);
  if (mixer == -1) return false;
  return mixer;
}
//------------------------------------------------------------------------------

int getCurrentRecordSource(int mixer) {
  int recsrc;
  if (ioctl(mixer, SOUND_MIXER_READ_RECSRC, &recsrc) == -1) return -1;
  int index = -1;
  for (index = 0; index < 32; ++index)
    if (recsrc & 1 << index) break;
  return index;
}
//------------------------------------------------------------------------------

bool writeVolume(int volume, int mixer, int indexDev) {
  if (ioctl(mixer, MIXER_WRITE(indexDev), &volume) == -1) return false;
  return true;
}

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

bool controlEnableRecord(int mixer) {
  int recmask;
  if (ioctl(mixer, SOUND_MIXER_READ_RECMASK, &recmask) == -1) {
    perror("Read recmask");
    return false;
  }
  if (recmask & (1 << SOUND_MIXER_IGAIN)) {
    int volume;
    if (ioctl(mixer, MIXER_READ(SOUND_MIXER_IGAIN), &volume) == -1)
      return false;

    int app = (volume & 0xff);
    if (app <= 30) {
      volume = 80 | 80 << 8;
      if (!writeVolume(volume, mixer, SOUND_MIXER_IGAIN)) return false;
    }
  }
  return true;
}

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

int isInputDeviceSupported(TSoundInputDevice::Source dev, int &mixer) {
  int recmask;
  if (ioctl(mixer, SOUND_MIXER_READ_RECMASK, &recmask) == -1) {
    perror("Read recmask");
    return -1;
  }

  int i;
  string devS              = sourceToString(dev);
  const char *deviceName[] = SOUND_DEVICE_NAMES;
  for (i = 0; i < 32; ++i) {
    if (!(recmask & 1 << i)) continue;
    if (strcmp(devS.c_str(), deviceName[i]) == 0) return i;
  }
  return -1;
}

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

bool selectInputDevice(TSoundInputDevice::Source dev) {
  int mixer;
  if ((mixer = openMixer()) < 0) {
    close(mixer);
    return false;  // throw TException("Can't open the mixer device");
  }
  int index = isInputDeviceSupported(dev, mixer);
  if (index == -1) return false;
  int recsrc;
  if (ioctl(mixer, SOUND_MIXER_READ_RECSRC, &recsrc) == -1) {
    perror("Read recsrc");
    close(mixer);
    return false;
  }
  if (!(recsrc & 1 << index)) {
    recsrc = 1 << index;
    if (ioctl(mixer, SOUND_MIXER_WRITE_RECSRC, &recsrc) == -1) {
      perror("Write recsrc");
      ::close(mixer);
      return false;
    }
  }

  if (!controlEnableRecord(mixer)) {
    close(mixer);
    return false;  // throw TException("Can't enable recording");
  }
  ::close(mixer);
  return true;
}
}