#include "tsound.h"

#ifndef TNZCORE_LIGHT

#include "tthread.h"

#endif

#include "tsop.h"

#include <set></set>

#include "tsystem.h"

#include <mmsystem.h></mmsystem.h>

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

// forward declarations

class TSoundOutputDeviceImp;

class TSoundInputDeviceImp;

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

namespace {

void CALLBACK recordCB(HWAVEIN hwi, UINT uMsg, DWORD dwInstance, DWORD dwParam1,

                       DWORD dwParam2);

bool setRecordLine(TSoundInputDevice::Source typeInput);

MMRESULT getLineInfo(HMIXEROBJ hMixer, DWORD dwComponentType, MIXERLINE &mxl);

MMRESULT getLineControl(MIXERCONTROL &mxc, HMIXEROBJ hMixer, DWORD dwLineID,

                        DWORD dwControlType);

MMRESULT setControlDetails(HMIXEROBJ hMixer, DWORD dwSelectControlID,

                           DWORD dwMultipleItems,

                           MIXERCONTROLDETAILS_UNSIGNED *mxcdSelectValue);

MMRESULT getControlDetails(HMIXEROBJ hMixer, DWORD dwSelectControlID,

                           DWORD dwMultipleItems,

                           MIXERCONTROLDETAILS_UNSIGNED *mxcdSelectValue);

MMRESULT isaFormatSupported(int sampleRate, int channelCount, int bitPerSample,

                            bool input);

DWORD WINAPI MyWaveOutCallbackThread(LPVOID lpParameter);

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

}

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

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

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

#ifndef TNZCORE_LIGHT

class EndPlayMsg : public TThread::Message {

public:

  EndPlayMsg(TSoundOutputDeviceListener *notifier) { m_listener = notifier; }

  TThread::Message *clone() const override { return new EndPlayMsg(*this); }

  void onDeliver() override { m_listener->onPlayCompleted(); }

private:

  TSoundOutputDeviceListener *m_listener;

};

#endif

int makeDWORD(const short lo, const short hi) {

  int dw = hi << 16;

  dw |= lo;

  return dw;

}

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

class WavehdrQueue;

class TSoundOutputDeviceImp {

public:

  HWAVEOUT m_wout;

  WavehdrQueue *m_whdrQueue;

  TSoundTrackFormat m_currentFormat;

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

  TThread::Mutex m_mutex;

  bool m_stopped;

  bool m_isPlaying;

  bool m_looped;

  bool m_scrubbing;

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

  DWORD m_notifyThreadId;

  HANDLE m_closeDevice;

  TSoundOutputDeviceImp();

  ~TSoundOutputDeviceImp();

  bool doOpenDevice(const TSoundTrackFormat &format);

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

  bool doCloseDevice();

  bool verifyRate();

  void insertAllRate();

};

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

class WavehdrQueue {

public:

  WavehdrQueue(TSoundOutputDeviceImp *devImp, int slotCount)

      : m_devImp(devImp)

      , m_items()

      , m_queuedItems()

      , m_slotCount(slotCount)

      , m_mutex()

      , m_lastOffset(0) {}

  ~WavehdrQueue() {}

  void put(TSoundTrackP &subTrack);

  WAVEHDR *get();

  bool popFront(int count);

  void pushBack(WAVEHDR *whdr, TSoundTrackP st);

  int size();

  void clear();

  bool isAllQueuedItemsPlayed();

private:

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

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

  TThread::Mutex m_mutex;

  int m_slotCount;

  int m_lastOffset;

  TSoundOutputDeviceImp *m_devImp;

  TSoundTrackP m_lastTrack;

};

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

WAVEHDR *prepareWaveHeader(HWAVEOUT wout, const TSoundTrackP &subTrack,

                           ULONG &count) {

  WAVEHDR *whdr = new WAVEHDR;

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

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

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

  whdr->dwFlags        = 0;

  whdr->dwUser         = count;

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

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

  if (ret != MMSYSERR_NOERROR) {

    delete[] whdr->lpData;

    delete whdr;

    return 0;

  }

  ++count;

  return whdr;

}

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

void WavehdrQueue::put(TSoundTrackP &subTrack) {

  assert(subTrack->getRawData());

  static ULONG count = 1;

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

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

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

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

  // a quello della traccia

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

    m_devImp->doCloseDevice();

    TSystem::sleep(300);

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

  }

  TThread::MutexLocker sl(&m_mutex);

  if (!m_devImp->m_scrubbing) {

    WAVEHDR *whdr2 = 0;

    // traccia

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

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

    MMRESULT ret = MMSYSERR_NOERROR;

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

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

      if (ret == MMSYSERR_NOERROR) {

        pushBack(whdr2, subTrack);

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

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

        m_devImp->m_isPlaying = true;

        m_devImp->m_stopped   = false;

      }

    }

    return;

  }

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

    WAVEHDR *whdr1 = 0;

    WAVEHDR *whdr2 = 0;

    WAVEHDR *whdr3 = 0;

    MMRESULT ret;

    TSoundTrackP riseTrack, decayTrack;

    int sampleSize = subTrack->getSampleSize();

    // cresce

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

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

    // traccia

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

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

    // decresce

    decayTrack = 0;

    if (m_lastOffset) {

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

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

    }

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

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

      if (ret == MMSYSERR_NOERROR) {

        pushBack(whdr1, riseTrack);

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

      }

    }

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

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

      if (ret == MMSYSERR_NOERROR) {

        pushBack(whdr2, subTrack);

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

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

        m_devImp->m_isPlaying = true;

        m_devImp->m_stopped   = false;

      }

    }

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

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

      if (ret == MMSYSERR_NOERROR) {

        pushBack(whdr3, decayTrack);

        if (decayTrack->isSampleSigned())

          m_lastOffset = 0;

        else

          m_lastOffset = 127;

      }

    }

    return;

  }

  if (m_queuedItems.size() < 10) {

    WAVEHDR *whdr1 = 0;

    WAVEHDR *whdr2 = 0;

    WAVEHDR *whdr  = new WAVEHDR;

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

    whdr->dwBufferLength =

        subTrack->getSampleSize() * subTrack->getSampleCount();

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

    whdr->dwFlags = 0;

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

    int sampleSize         = subTrack->getSampleSize();

    TSoundTrackP riseTrack = 0;

    if (m_lastOffset)  /// devo fare ilcross fade

    {

      int offset;

      getAmplitude(offset, subTrack, 0L);

      offset = m_lastOffset - offset;

      if (offset) {

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

        memcpy(whdr->lpData, st->getRawData(),

               st->getSampleCount() * sampleSize);

      }

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

    {

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

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

    }

    whdr->dwUser = count;

    ++count;

    MMRESULT ret =

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

    if (ret != MMSYSERR_NOERROR) {

      delete[] whdr->lpData;

      delete whdr;

      return;

    }

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

    TSoundTrackP decayTrack = 0;

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

      if (m_lastOffset)  // devo fare il fadeOut

      {

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

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

      }

    }

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

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

      if (ret == MMSYSERR_NOERROR) {

        pushBack(whdr1, riseTrack);

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

      }

    }

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

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

      if (ret == MMSYSERR_NOERROR) {

        pushBack(whdr, subTrack);

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

        {

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

          m_devImp->m_isPlaying = true;

          m_devImp->m_stopped   = false;

        }

      }

    }

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

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

      if (ret == MMSYSERR_NOERROR) {

        pushBack(whdr2, decayTrack);

        if (decayTrack->isSampleSigned())

          m_lastOffset = 0;

        else

          m_lastOffset = 127;

      }

    }

    return;

  }

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

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

    MMRESULT ret =

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

    if (ret == MMSYSERR_NOERROR) {

      delete[] item->lpData;

      delete item;

    }

    m_items.pop_front();

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

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

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

      int offset;

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

      offset = m_lastOffset - offset;

      if (offset) {

        TSoundTrackP st =

            TSop::crossFade(m_lastTrack, m_items.front().second, 0.3);

        memcpy(item->lpData, st->getRawData(),

               st->getSampleCount() * sampleSize);

      }

    }

  }

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

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

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

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

}

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

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

WAVEHDR *WavehdrQueue::get() {

  TThread::MutexLocker sl(&m_mutex);

  if (m_items.size() == 0) return 0;

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

  assert(whdr->dwFlags & WHDR_PREPARED);

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

  getAmplitude(m_lastOffset, m_items.front().second,

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

  m_items.pop_front();

  return whdr;

}

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

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

bool WavehdrQueue::popFront(int count) {

  TThread::MutexLocker sl(&m_mutex);

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

  if (m_queuedItems.size() <= 0) return false;

  WAVEHDR *whdr = m_queuedItems.front();

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

  // notifiche di WHDR_DONE

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

    MMRESULT ret =

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

    if (ret == MMSYSERR_NOERROR) {

      m_queuedItems.pop_front();

      delete[] whdr->lpData;

      delete whdr;

      whdr = m_queuedItems.front();

    }

  }

  assert(whdr->dwFlags & WHDR_DONE);

  m_queuedItems.pop_front();

  delete[] whdr->lpData;

  delete whdr;

  return true;

}

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

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

  TThread::MutexLocker sl(&m_mutex);

  m_queuedItems.push_back(whdr);

  m_lastTrack = st;

}

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

int WavehdrQueue::size() {

  TThread::MutexLocker sl(&m_mutex);

  int size = m_queuedItems.size();

  return size;

}

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

void WavehdrQueue::clear() {

  TThread::MutexLocker sl(&m_mutex);

  m_items.clear();

  m_lastTrack = TSoundTrackP();

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

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

    WAVEHDR *wvhdr = *it;

    delete[] wvhdr->lpData;

    delete wvhdr;

  }

  m_queuedItems.clear();

}

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

bool WavehdrQueue::isAllQueuedItemsPlayed() {

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

  bool finished = true;

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

    WAVEHDR *wvhdr = *it;

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

  }

  return finished;

}

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

TSoundOutputDeviceImp::TSoundOutputDeviceImp()

    : m_stopped(true)

    , m_isPlaying(false)

    , m_looped(false)

    , m_scrubbing(false)

    , m_wout(0) {

  m_whdrQueue = new WavehdrQueue(this, 4);

  insertAllRate();

  if (!verifyRate())

    throw TSoundDeviceException(TSoundDeviceException::FailedInit,

                                "Unable to verify supported rates");

  m_closeDevice = CreateEvent(NULL,   // no security attributes

                              FALSE,  // auto-reset event

                              FALSE,  // initial state is not signaled

                              NULL);  // object not named

}

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

TSoundOutputDeviceImp::~TSoundOutputDeviceImp() { delete m_whdrQueue; }

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

bool TSoundOutputDeviceImp::doOpenDevice(const TSoundTrackFormat &format) {

  WAVEFORMATEX wf;

  wf.wFormatTag      = WAVE_FORMAT_PCM;

  wf.nChannels       = format.m_channelCount;

  wf.nSamplesPerSec  = format.m_sampleRate;

  wf.wBitsPerSample  = format.m_bitPerSample;

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

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

  wf.cbSize          = 0;

  TThread::MutexLocker sl(&m_mutex);

  CloseHandle(CreateThread(NULL, 0, MyWaveOutCallbackThread, (LPVOID)this, 0,

                           &m_notifyThreadId));

  MMRESULT ret;

  if ((ret = waveOutOpen(&m_wout, WAVE_MAPPER, &wf, (DWORD)m_notifyThreadId,

                         (DWORD)this, CALLBACK_THREAD)) != MMSYSERR_NOERROR) {

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

      ;

  }

  if (ret != MMSYSERR_NOERROR) return false;

  if (ret != MMSYSERR_NOERROR) return false;

  m_currentFormat = format;

  return (ret == MMSYSERR_NOERROR);

}

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

bool TSoundOutputDeviceImp::doPlay(WAVEHDR *whdr,

                                   const TSoundTrackFormat format) {

  TThread::MutexLocker sl(&m_mutex);

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

  MMRESULT ret;

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

  if (ret != MMSYSERR_NOERROR) return false;

  m_stopped   = false;

  m_isPlaying = true;

  return true;

}

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

bool TSoundOutputDeviceImp::doCloseDevice() {

  TThread::MutexLocker sl(&m_mutex);

  if (m_wout) {

    MMRESULT ret = waveOutReset(m_wout);

    if (ret != MMSYSERR_NOERROR) return false;

    ret = waveOutClose(m_wout);

    if (ret != MMSYSERR_NOERROR) return false;

    m_wout      = 0;

    m_stopped   = true;

    m_isPlaying = false;

    m_looped    = false;

  }

  PostThreadMessage(m_notifyThreadId, WM_QUIT, 0, 0);

  return true;

}

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

void TSoundOutputDeviceImp::insertAllRate() {

  m_supportedRate.insert(8000);

  m_supportedRate.insert(11025);

  m_supportedRate.insert(16000);

  m_supportedRate.insert(22050);

  m_supportedRate.insert(32000);

  m_supportedRate.insert(44100);

  m_supportedRate.insert(48000);

}

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

bool TSoundOutputDeviceImp::verifyRate() {

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

  for (it = m_supportedRate.begin(); it != m_supportedRate.end();) {

    MMRESULT ret;

    WAVEFORMATEX wf;

    wf.wFormatTag      = WAVE_FORMAT_PCM;

    wf.nChannels       = 1;

    wf.nSamplesPerSec  = *it;

    wf.wBitsPerSample  = 8;

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

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

    wf.cbSize          = 0;

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

    if (ret == MMSYSERR_NOERROR) {

      ++it;

      continue;

    }

    if (ret == WAVERR_BADFORMAT)

      it = m_supportedRate.erase(it);

    else

      return false;

  }

  if (m_supportedRate.end() == m_supportedRate.begin()) return false;

  return true;

}

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

TSoundOutputDevice::TSoundOutputDevice() : m_imp(new TSoundOutputDeviceImp()) {}

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

TSoundOutputDevice::~TSoundOutputDevice() {

  close();

  WaitForSingleObject(m_imp->m_closeDevice, INFINITE);

  CloseHandle(m_imp->m_closeDevice);

}

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

namespace {

DWORD WINAPI MyWaveOutCallbackThread(LPVOID lpParameter) {

  TSoundOutputDeviceImp *devImp = (TSoundOutputDeviceImp *)lpParameter;

  if (!devImp) return 0;

  MSG msg;

  BOOL bRet;

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

    if (bRet == -1) {

      // si e' verificato un errore

      break;

    }

    switch (msg.message) {

    case MM_WOM_DONE: {

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

      {

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

        if (devImp->m_looped) {

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

          continue;

        }

      }

      WAVEHDR *whdr = 0;

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

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

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

        WaitForSingleObject(devImp->m_closeDevice, INFINITE);

        CloseHandle(devImp->m_closeDevice);

        MMRESULT ret =

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

        if (ret == MMSYSERR_NOERROR) {

          delete pWaveHdr->lpData;

          delete pWaveHdr;

        }

      }

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

        std::set<tsoundoutputdevicelistener *="">::iterator it =</tsoundoutputdevicelistener>

            devImp->m_listeners.begin();

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

#ifndef TNZCORE_LIGHT

          EndPlayMsg *event = new EndPlayMsg(*it);

          event->send();

#else

          assert(false);

#endif

        }

        devImp->doCloseDevice();

      }

      continue;

    }

    case MM_WOM_CLOSE:

      break;

    default:

      continue;

    }

  }

  SetEvent(devImp->m_closeDevice);

  return 0;

}

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

  TSoundTrackP snd = st;

  amplitude        = 0;

  int k            = 0;

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

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

  amplitude /= k;

}

}

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

bool TSoundOutputDevice::installed() {

  int ndev = waveOutGetNumDevs();

  if (ndev <= 0) return false;

  return true;

}

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

bool TSoundOutputDevice::open(const TSoundTrackP &st) {

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

}

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

void TSoundOutputDevice::attach(TSoundOutputDeviceListener *listener) {

  m_imp->m_listeners.insert(listener);

}

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

void TSoundOutputDevice::detach(TSoundOutputDeviceListener *listener) {

  m_imp->m_listeners.erase(listener);

}

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

void TSoundOutputDevice::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,

                              bool loop, bool scrubbing) {

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

  if (!st->getSampleCount()) return;

  TSoundTrackFormat format;

  TSoundTrackP subTrack;

  {

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

    if (m_imp->m_looped)

      throw TSoundDeviceException(

          TSoundDeviceException::Busy,

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

    format = st->getFormat();

    try {

      TSoundTrackFormat fmt = getPreferredFormat(format);

      if (fmt != format) {

        throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,

                                    "Unsupported Format");

      }

    } catch (TSoundDeviceException &e) {

      throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,

                                  e.getMessage());

    }

    assert(s1 >= s0);

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

    m_imp->m_looped    = loop;

    m_imp->m_scrubbing = scrubbing;

  }

  if (!m_imp->m_wout) m_imp->doOpenDevice(format);

  m_imp->m_whdrQueue->put(subTrack);

}

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

void TSoundOutputDevice::stop() {

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

    MMRESULT ret = waveOutReset(m_imp->m_wout);

    if (ret != MMSYSERR_NOERROR) return;

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

    m_imp->m_looped    = false;

    m_imp->m_stopped   = true;

    m_imp->m_isPlaying = false;

    m_imp->m_whdrQueue->clear();

  }

}

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

bool TSoundOutputDevice::close() { return m_imp->doCloseDevice(); }

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

bool TSoundOutputDevice::isPlaying() const { return m_imp->m_isPlaying; }

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

bool TSoundOutputDevice::isAllQueuedItemsPlayed() {

  return m_imp->m_whdrQueue->isAllQueuedItemsPlayed();

}

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

bool TSoundOutputDevice::isLooping() {

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

  return m_imp->m_looped;

}

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

void TSoundOutputDevice::setLooping(bool loop) {

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

  m_imp->m_looped = loop;

}

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

TSoundTrackFormat TSoundOutputDevice::getPreferredFormat(TUINT32 sampleRate,

                                                         int channelCount,

                                                         int bitPerSample) {

  TSoundTrackFormat fmt;

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

  // vicini

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

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

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

                          m_imp->m_supportedRate.end());

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

      sampleRate = *(m_imp->m_supportedRate.rbegin());

    else

      throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,

                                  "There isn't a supported format");

  } else

    sampleRate = *it;

  if (bitPerSample <= 8)

    bitPerSample = 8;

  else if ((bitPerSample > 8 && bitPerSample < 16) || bitPerSample >= 16)

    bitPerSample = 16;

  if (bitPerSample >= 16)

    fmt.m_signedSample = true;

  else

    fmt.m_signedSample = false;

  // switch mono/stereo

  if (channelCount <= 1)

    channelCount = 1;

  else

    channelCount = 2;

  fmt.m_bitPerSample = bitPerSample;

  fmt.m_channelCount = channelCount;

  fmt.m_sampleRate   = sampleRate;

  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(TSoundDeviceException::UnsupportedFormat,

                                e.getMessage());

  }

}

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

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

// Classi per la gestione della registrazione

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

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

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

class WaveFormat : public WAVEFORMATEX {

public:

  WaveFormat(){};

  WaveFormat(unsigned char channelCount, unsigned TINT32 sampleRate,

             unsigned char bitPerSample);

  ~WaveFormat(){};

};

WaveFormat::WaveFormat(unsigned char channelCount, unsigned TINT32 sampleRate,

                       unsigned char bitPerSample) {

  wFormatTag      = WAVE_FORMAT_PCM;

  nChannels       = channelCount;

  nSamplesPerSec  = sampleRate;

  wBitsPerSample  = bitPerSample;

  nBlockAlign     = (channelCount * bitPerSample) >> 3;

  nAvgBytesPerSec = nBlockAlign * sampleRate;