#include "tsound_t.h"
#include "texception.h"
#include "tthread.h"

#include <errno.h>
#include <audio.h>
#include <unistd.h>
#include <queue>
#include <set>

// forward declaration
namespace {
bool isInterfaceSupported(int deviceType, int interfaceType);
bool setDefaultInput(TSoundInputDevice::Source type);
bool setDefaultOutput();
bool isChangeOutput(ULONG sampleRate);
}
//==============================================================================

class TSoundOutputDeviceImp {
public:
  ALport m_port;
  bool m_stopped;
  bool m_isPlaying;
  bool m_looped;
  TSoundTrackFormat m_currentFormat;
  std::queue<TSoundTrackP> m_queuedSoundTracks;
  std::set<int> m_supportedRate;

  TThread::Executor m_executor;
  TThread::Mutex m_mutex;

  TSoundOutputDeviceImp()
      : m_stopped(false)
      , m_isPlaying(false)
      , m_looped(false)
      , m_port(NULL)
      , m_queuedSoundTracks()
      , m_supportedRate(){};

  ~TSoundOutputDeviceImp(){};

  bool doOpenDevice(const TSoundTrackFormat &format);
  void insertAllRate();
  bool verifyRate();
};

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

bool TSoundOutputDeviceImp::doOpenDevice(const TSoundTrackFormat &format) {
  ALconfig config;
  ALpv pvbuf[3];

  m_currentFormat = format;

  // AL_MONITOR_CTL fa parte dei vecchi andrebbero trovati quelli nuovi
  pvbuf[0].param = AL_PORT_COUNT;
  pvbuf[1].param = AL_MONITOR_CTL;
  if (alGetParams(AL_DEFAULT_OUTPUT, pvbuf, 2) < 0)
    if (oserror() == AL_BAD_DEVICE_ACCESS)
      return false;  // throw TException("Could not access audio hardware.");

  if (!isInterfaceSupported(AL_DEFAULT_OUTPUT, AL_SPEAKER_IF_TYPE))
    return false;  // throw TException("Speakers are not supported");

  int dev = alGetResourceByName(AL_SYSTEM, (char *)"Headphone/Speaker",
                                AL_DEVICE_TYPE);
  if (!dev) return false;  // throw TException("invalid device speakers");

  pvbuf[0].param   = AL_DEFAULT_OUTPUT;
  pvbuf[0].value.i = dev;
  alSetParams(AL_SYSTEM, pvbuf, 1);

  ALfixed buf[2] = {alDoubleToFixed(0), alDoubleToFixed(0)};

  config = alNewConfig();
  // qui devo metterci gli altoparlanti e poi setto i valori per il default
  // output
  pvbuf[0].param     = AL_RATE;
  pvbuf[0].value.ll  = alDoubleToFixed((double)format.m_sampleRate);
  pvbuf[1].param     = AL_GAIN;
  pvbuf[1].value.ptr = buf;
  pvbuf[1].sizeIn    = 8;
  pvbuf[2].param     = AL_INTERFACE;
  pvbuf[2].value.i   = AL_SPEAKER_IF_TYPE;

  if (alSetParams(AL_DEFAULT_OUTPUT, pvbuf, 3) < 0) return false;
  // throw TException("Unable to set params for output device");

  if (alSetChannels(config, format.m_channelCount) == -1)
    return false;  // throw TException("Error to setting audio hardware.");

  int bytePerSample = format.m_bitPerSample >> 3;
  switch (bytePerSample) {
  case 3:
    bytePerSample++;
    break;
  default:
    break;
  }

  if (alSetWidth(config, bytePerSample) == -1)
    return false;  // throw TException("Error to setting audio hardware.");

  if (alSetSampFmt(config, AL_SAMPFMT_TWOSCOMP) == -1)
    return false;  // throw TException("Error to setting audio hardware.");

  if (alSetQueueSize(config, (TINT32)format.m_sampleRate) == -1)
    return false;  // throw TException("Error to setting audio hardware.");

  m_port = alOpenPort("AudioOutput", "w", config);
  if (!m_port) return false;  // throw TException("Could not open audio port.");

  alFreeConfig(config);
  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() {
  // Sample Rate
  ALparamInfo pinfo;
  int ret = alGetParamInfo(AL_DEFAULT_OUTPUT, AL_RATE, &pinfo);
  if (ret != -1 && pinfo.elementType == AL_FIXED_ELEM) {
    int min = (int)alFixedToDouble(pinfo.min.ll);
    int max = (int)alFixedToDouble(pinfo.max.ll);

    std::set<int>::iterator it;
    for (it = m_supportedRate.begin(); it != m_supportedRate.end(); ++it)
      if (*it < min || *it > max) m_supportedRate.erase(*it);
    if (m_supportedRate.end() == m_supportedRate.begin()) return false;
  } else if (ret == AL_BAD_PARAM)
    return false;
  else
    return false;
  return true;
}

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

class PlayTask : public TThread::Runnable {
public:
  TSoundOutputDeviceImp *m_devImp;
  TSoundTrackP m_sndtrack;

  PlayTask(TSoundOutputDeviceImp *devImp, const TSoundTrackP &st)
      : TThread::Runnable(), m_devImp(devImp), m_sndtrack(st){};

  ~PlayTask(){};

  void run();
};

void PlayTask::run() {
  int leftToPlay = m_sndtrack->getSampleCount();
  int i          = 0;

  if (!m_devImp->m_port ||
      (m_devImp->m_currentFormat != m_sndtrack->getFormat()) ||
      isChangeOutput(m_sndtrack->getSampleRate()))
    if (!m_devImp->doOpenDevice(m_sndtrack->getFormat())) return;

  while ((leftToPlay > 0) && m_devImp->m_isPlaying) {
    int fillable = alGetFillable(m_devImp->m_port);
    if (!fillable) continue;

    if (fillable < leftToPlay) {
      alWriteFrames(m_devImp->m_port, (void *)(m_sndtrack->getRawData() + i),
                    fillable);
      // ricorda getSampleSize restituisce m_sampleSize che comprende gia'
      // la moltiplicazione per il numero dei canali
      i += fillable * m_sndtrack->getSampleSize();
      leftToPlay -= fillable;
    } else {
      alWriteFrames(m_devImp->m_port, (void *)(m_sndtrack->getRawData() + i),
                    leftToPlay);
      leftToPlay = 0;
    }
  }

  if (!m_devImp->m_stopped) {
    while (ALgetfilled(m_devImp->m_port) > 0) sginap(1);
    {
      TThread::ScopedLock sl(m_devImp->m_mutex);
      if (!m_devImp->m_looped) m_devImp->m_queuedSoundTracks.pop();
      if (m_devImp->m_queuedSoundTracks.empty()) {
        m_devImp->m_isPlaying = false;
        m_devImp->m_stopped   = true;
        m_devImp->m_looped    = false;
      } else {
        m_devImp->m_executor.addTask(
            new PlayTask(m_devImp, m_devImp->m_queuedSoundTracks.front()));
      }
    }
  } else {
    alDiscardFrames(m_devImp->m_port, alGetFilled(m_devImp->m_port));
    while (!m_devImp->m_queuedSoundTracks.empty())
      m_devImp->m_queuedSoundTracks.pop();
  }
}

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

TSoundOutputDevice::TSoundOutputDevice() : m_imp(new TSoundOutputDeviceImp) {
  if (!setDefaultOutput())
    throw TSoundDeviceException(TSoundDeviceException::UnableSetDevice,
                                "Speaker not supported");
  try {
    supportsVolume();
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }
  m_imp->insertAllRate();
}

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

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

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

bool TSoundOutputDevice::installed() {
  if (alQueryValues(AL_SYSTEM, AL_DEFAULT_OUTPUT, 0, 0, 0, 0) <= 0)
    return false;
  return true;
}

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

bool TSoundOutputDevice::open(const TSoundTrackP &st) {
  if (!m_imp->doOpenDevice(st->getFormat()))
    throw TSoundDeviceException(
        TSoundDeviceException::UnableOpenDevice,
        "Problem to open the output device or set some params");
  return true;
}

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

bool TSoundOutputDevice::close() {
  stop();
  if (m_imp->m_port) alClosePort(m_imp->m_port);
  m_imp->m_port = NULL;

  return true;
}

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

void TSoundOutputDevice::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
                              bool loop, bool 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");

    m_imp->m_isPlaying = true;
    m_imp->m_stopped   = false;
    m_imp->m_looped    = loop;
  }

  TSoundTrackFormat fmt;
  try {
    fmt = getPreferredFormat(st->getFormat());
    if (fmt != st->getFormat()) {
      throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
                                  "Unsupported Format");
    }
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
                                e.getMessage());
  }

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

  // far partire il thread
  if (m_imp->m_queuedSoundTracks.empty()) {
    m_imp->m_queuedSoundTracks.push(subTrack);

    m_imp->m_executor.addTask(new PlayTask(m_imp, subTrack));
  } else
    m_imp->m_queuedSoundTracks.push(subTrack);
}

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

void TSoundOutputDevice::stop() {
  if (!m_imp->m_isPlaying) return;

  TThread::ScopedLock sl(m_imp->m_mutex);
  m_imp->m_isPlaying = false;
  m_imp->m_stopped   = true;
  m_imp->m_looped    = false;
}

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

double TSoundOutputDevice::getVolume() {
  ALpv pv[1];
  ALfixed value[2];

  try {
    supportsVolume();
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }

  pv[0].param     = AL_GAIN;
  pv[0].value.ptr = value;
  pv[0].sizeIn    = 8;
  alGetParams(AL_DEFAULT_OUTPUT, pv, 1);

  double val =
      (((alFixedToDouble(value[0]) + alFixedToDouble(value[1])) / 2.) + 60.) /
      8.05;
  return val;
}

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

bool TSoundOutputDevice::setVolume(double volume) {
  ALpv pv[1];
  ALfixed value[2];

  try {
    supportsVolume();
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }

  double val = -60. + 8.05 * volume;
  value[0]   = alDoubleToFixed(val);
  value[1]   = alDoubleToFixed(val);

  pv[0].param     = AL_GAIN;
  pv[0].value.ptr = value;
  pv[0].sizeIn    = 8;
  if (alSetParams(AL_DEFAULT_OUTPUT, pv, 1) < 0) return false;
  return true;
}

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

bool TSoundOutputDevice::supportsVolume() {
  ALparamInfo pinfo;
  int ret;
  ret        = alGetParamInfo(AL_DEFAULT_OUTPUT, AL_GAIN, &pinfo);
  double min = alFixedToDouble(pinfo.min.ll);
  double max = alFixedToDouble(pinfo.max.ll);
  if ((ret != -1) && (min != max) && (max != 0.0))
    return true;
  else if ((ret == AL_BAD_PARAM) || ((min == max) && (max == 0.0)))
    throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
                                "It is impossible to chamge setting of volume");
  else
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Output device is not accessible");
}

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

bool TSoundOutputDevice::isPlaying() const { 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;
}

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

TSoundTrackFormat TSoundOutputDevice::getPreferredFormat(ULONG sampleRate,
                                                         int channelCount,
                                                         int bitPerSample) {
  TSoundTrackFormat fmt;
  int ret;

  if (!m_imp->verifyRate())
    throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
                                "There isn't any support rate");

  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;
  }

  int value;
  ALvalue vals[32];
  if ((ret = alQueryValues(AL_DEFAULT_OUTPUT, AL_CHANNELS, vals, 32, 0, 0)) > 0)
    for (int i = 0; i < ret; ++i) value = vals[i].i;
  else if (oserror() == AL_BAD_PARAM)
    throw TSoundDeviceException(
        TSoundDeviceException::NoMixer,
        "It is impossible ask for the max numbers of channels supported");
  else
    throw TSoundDeviceException(
        TSoundDeviceException::NoMixer,
        "It is impossibile information about ouput device");

  if (value > 2) value = 2;
  if (channelCount > value)
    channelCount = value;
  else if (channelCount <= 0)
    channelCount = 1;

  if (bitPerSample <= 8)
    bitPerSample = 8;
  else if (bitPerSample <= 16)
    bitPerSample = 16;
  else
    bitPerSample = 24;

  fmt.m_bitPerSample = bitPerSample;
  fmt.m_channelCount = channelCount;
  fmt.m_sampleRate   = sampleRate;
  fmt.m_signedSample = true;

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

//==============================================================================
//==============================================================================
//                REGISTRAZIONE
//==============================================================================
//==============================================================================

class TSoundInputDeviceImp {
public:
  ALport m_port;
  bool m_stopped;
  bool m_isRecording;
  bool m_oneShotRecording;

  TINT32 m_recordedSampleCount;

  vector<char *> m_recordedBlocks;
  vector<int> m_samplePerBlocks;
  TSoundTrackFormat m_currentFormat;
  TSoundTrackP m_st;
  std::set<int> m_supportedRate;

  TThread::Executor m_executor;

  TSoundInputDeviceImp()
      : m_stopped(false)
      , m_isRecording(false)
      , m_port(NULL)
      , m_recordedBlocks()
      , m_samplePerBlocks()
      , m_recordedSampleCount(0)
      , m_oneShotRecording(false)
      , m_st(0)
      , m_supportedRate(){};

  ~TSoundInputDeviceImp(){};

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

bool TSoundInputDeviceImp::doOpenDevice(const TSoundTrackFormat &format,
                                        TSoundInputDevice::Source devType) {
  ALconfig config;
  ALpv pvbuf[2];

  m_currentFormat = format;

  // AL_MONITOR_CTL fa parte dei vecchi andrebbero trovati quelli nuovi
  pvbuf[0].param = AL_PORT_COUNT;
  pvbuf[1].param = AL_MONITOR_CTL;
  if (alGetParams(AL_DEFAULT_INPUT, pvbuf, 2) < 0)
    if (oserror() == AL_BAD_DEVICE_ACCESS)
      return false;  // throw TException("Could not access audio hardware.");

  config = alNewConfig();

  if (!setDefaultInput(devType))
    return false;  // throw TException("Could not set the input device
                   // specified");

  pvbuf[0].param    = AL_RATE;
  pvbuf[0].value.ll = alDoubleToFixed(format.m_sampleRate);

  ALfixed buf[2]     = {alDoubleToFixed(0), alDoubleToFixed(0)};
  pvbuf[1].param     = AL_GAIN;
  pvbuf[1].value.ptr = buf;
  pvbuf[1].sizeIn    = 8;

  if (alSetParams(AL_DEFAULT_INPUT, pvbuf, 2) < 0)
    return false;  // throw TException("Problem to set params ");

  if (alSetChannels(config, format.m_channelCount) == -1)
    return false;  // throw TException("Error to setting audio hardware.");

  int bytePerSample = format.m_bitPerSample >> 3;
  switch (bytePerSample) {
  case 3:
    bytePerSample++;
    break;
  default:
    break;
  }
  if (alSetWidth(config, bytePerSample) == -1)
    return false;  // throw TException("Error to setting audio hardware.");

  if (alSetSampFmt(config, AL_SAMPFMT_TWOSCOMP) == -1)
    return false;  // throw TException("Error to setting audio hardware.");

  if (alSetQueueSize(config, (TINT32)format.m_sampleRate) == -1)
    return false;  // throw TException("Error to setting audio hardware.");

  alSetDevice(config, AL_DEFAULT_INPUT);

  m_port = alOpenPort("AudioInput", "r", config);
  if (!m_port) return false;  // throw TException("Could not open audio port.");

  alFreeConfig(config);
  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() {
  // Sample Rate
  ALparamInfo pinfo;
  int ret = alGetParamInfo(AL_DEFAULT_INPUT, AL_RATE, &pinfo);
  if (ret != -1 && pinfo.elementType == AL_FIXED_ELEM) {
    int min = (int)alFixedToDouble(pinfo.min.ll);
    int max = (int)alFixedToDouble(pinfo.max.ll);

    std::set<int>::iterator it;
    for (it = m_supportedRate.begin(); it != m_supportedRate.end(); ++it)
      if (*it < min || *it > max) m_supportedRate.erase(*it);
    if (m_supportedRate.end() == m_supportedRate.begin()) return false;
  } else if (ret == AL_BAD_PARAM)
    return false;
  else
    return false;
  return true;
}

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

class RecordTask : public TThread::Runnable {
public:
  TSoundInputDeviceImp *m_devImp;
  int m_ByteToSample;

  RecordTask(TSoundInputDeviceImp *devImp, int numByte)
      : TThread::Runnable(), m_devImp(devImp), m_ByteToSample(numByte){};

  ~RecordTask(){};

  void run();
};

void RecordTask::run() {
  TINT32 byteRecordedSample = 0;
  int filled                = alGetFilled(m_devImp->m_port);

  if (m_devImp->m_oneShotRecording) {
    char *rawData = m_devImp->m_recordedBlocks.front();
    int sampleSize;

    if ((m_devImp->m_currentFormat.m_bitPerSample >> 3) == 3)
      sampleSize = 4;
    else
      sampleSize = (m_devImp->m_currentFormat.m_bitPerSample >> 3);

    sampleSize *= m_devImp->m_currentFormat.m_channelCount;
    while ((byteRecordedSample <= (m_ByteToSample - filled * sampleSize)) &&
           m_devImp->m_isRecording) {
      alReadFrames(m_devImp->m_port, (void *)(rawData + byteRecordedSample),
                   filled);
      byteRecordedSample += filled * sampleSize;
      filled = alGetFilled(m_devImp->m_port);
    }

    if (m_devImp->m_isRecording) {
      alReadFrames(m_devImp->m_port, (void *)(rawData + byteRecordedSample),
                   (m_ByteToSample - byteRecordedSample) / sampleSize);
      while (alGetFillable(m_devImp->m_port) > 0) sginap(1);
    }
  } else {
    while (m_devImp->m_isRecording) {
      filled = alGetFilled(m_devImp->m_port);
      if (filled > 0) {
        char *dataBuffer = new char[filled * m_ByteToSample];
        m_devImp->m_recordedBlocks.push_back(dataBuffer);
        m_devImp->m_samplePerBlocks.push_back(filled * m_ByteToSample);

        alReadFrames(m_devImp->m_port, (void *)dataBuffer, filled);
        m_devImp->m_recordedSampleCount += filled;
      }
    }
    while (alGetFillable(m_devImp->m_port) > 0) sginap(1);
  }
  alClosePort(m_devImp->m_port);
  m_devImp->m_port    = 0;
  m_devImp->m_stopped = true;
}

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

TSoundInputDevice::TSoundInputDevice() : m_imp(new TSoundInputDeviceImp) {}

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

TSoundInputDevice::~TSoundInputDevice() {
  if (m_imp->m_port) alClosePort(m_imp->m_port);
  delete m_imp;
}

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

bool TSoundInputDevice::installed() {
  if (alQueryValues(AL_SYSTEM, AL_DEFAULT_INPUT, 0, 0, 0, 0) <= 0) return false;
  return true;
}

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

void TSoundInputDevice::record(const TSoundTrackFormat &format,
                               TSoundInputDevice::Source type) {
  if (m_imp->m_isRecording == true)
    throw TSoundDeviceException(TSoundDeviceException::Busy,
                                "Just another recoding is in progress");

  m_imp->m_recordedBlocks.clear();
  m_imp->m_samplePerBlocks.clear();

  // registra creando una nuova traccia
  m_imp->m_oneShotRecording = false;

  if (!setDefaultInput(type))
    throw TSoundDeviceException(TSoundDeviceException::UnableSetDevice,
                                "Error to set the input device");

  m_imp->insertAllRate();
  TSoundTrackFormat fmt;

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

  if (!m_imp->m_port) m_imp->doOpenDevice(format, type);

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

  int bytePerSample = format.m_bitPerSample >> 3;
  switch (bytePerSample) {
  case 3:
    bytePerSample++;
    break;
  default:
    break;
  }
  bytePerSample *= format.m_channelCount;

  // far partire il thread
  /*TRecordThread *recordThread = new TRecordThread(m_imp, bytePerSample);
  if (!recordThread)
  {
  m_imp->m_isRecording = false;
  m_imp->m_stopped = true;
throw TSoundDeviceException(
TSoundDeviceException::UnablePrepare,
"Unable to create the recording thread");
  }
recordThread->start();*/
  m_imp->m_executor.addTask(new RecordTask(m_imp, bytePerSample));
}

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

void TSoundInputDevice::record(const TSoundTrackP &st,
                               TSoundInputDevice::Source type) {
  if (m_imp->m_isRecording == true)
    throw TSoundDeviceException(TSoundDeviceException::Busy,
                                "Just another recoding is in progress");

  m_imp->m_recordedBlocks.clear();
  m_imp->m_samplePerBlocks.clear();

  if (!setDefaultInput(type))
    throw TSoundDeviceException(TSoundDeviceException::UnableSetDevice,
                                "Error to set the input device");

  m_imp->insertAllRate();
  TSoundTrackFormat fmt;

  try {
    fmt = getPreferredFormat(st->getFormat());
    if (fmt != st->getFormat()) {
      throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
                                  "Unsupported Format");
    }
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
                                e.getMessage());
  }

  if (!m_imp->m_port)
    if (!m_imp->doOpenDevice(st->getFormat(), type))
      throw TSoundDeviceException(TSoundDeviceException::UnableOpenDevice,
                                  "Unable to open input device");

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

  int totByteToSample = st->getSampleCount() * st->getSampleSize();

  // far partire il thread
  /*TRecordThread *recordThread = new TRecordThread(m_imp, totByteToSample);
  if (!recordThread)
  {
  m_imp->m_isRecording = false;
  m_imp->m_stopped = true;
throw TSoundDeviceException(
TSoundDeviceException::UnablePrepare,
"Unable to create the recording thread");
  }
recordThread->start();*/
  m_imp->m_executor.addTask(new RecordTask(m_imp, totByteToSample));
}

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

TSoundTrackP TSoundInputDevice::stop() {
  TSoundTrackP st;

  if (!m_imp->m_isRecording)
    throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
                                "No recording process is in execution");

  m_imp->m_isRecording = false;

  alDiscardFrames(m_imp->m_port, alGetFilled(m_imp->m_port));

  while (!m_imp->m_stopped) sginap(1);

  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() {
  ALpv pv[1];
  ALfixed value[2];

  try {
    supportsVolume();
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }

  pv[0].param     = AL_GAIN;
  pv[0].value.ptr = value;
  pv[0].sizeIn    = 8;
  alGetParams(AL_DEFAULT_INPUT, pv, 1);

  double val =
      (((alFixedToDouble(value[0]) + alFixedToDouble(value[1])) / 2.) + 60.) /
      8.05;
  return val;
}

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

bool TSoundInputDevice::setVolume(double volume) {
  ALpv pv[1];
  ALfixed value[2];

  try {
    supportsVolume();
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }

  double val = -60. + 8.05 * volume;
  value[0]   = alDoubleToFixed(val);
  value[1]   = alDoubleToFixed(val);

  pv[0].param     = AL_GAIN;
  pv[0].value.ptr = value;
  pv[0].sizeIn    = 8;
  alSetParams(AL_DEFAULT_INPUT, pv, 1);

  return true;
}

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

bool TSoundInputDevice::supportsVolume() {
  ALparamInfo pinfo;
  int ret;
  ret        = alGetParamInfo(AL_DEFAULT_INPUT, AL_GAIN, &pinfo);
  double min = alFixedToDouble(pinfo.min.ll);
  double max = alFixedToDouble(pinfo.max.ll);
  if ((ret != -1) && (min != max) && (max != 0.0))
    return true;
  else if ((ret == AL_BAD_PARAM) || ((min == max) && (max == 0.0)))
    throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
                                "It is impossible to chamge setting of volume");
  else
    throw TSoundDeviceException(TSoundDeviceException::NoMixer,
                                "Output device is not accessible");
}

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

TSoundTrackFormat TSoundInputDevice::getPreferredFormat(ULONG sampleRate,
                                                        int channelCount,
                                                        int bitPerSample) {
  TSoundTrackFormat fmt;
  int ret;

  if (!m_imp->verifyRate())
    throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
                                "There isn't any support rate");

  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;
  }

  int value;
  ALvalue vals[32];
  if ((ret = alQueryValues(AL_DEFAULT_INPUT, AL_CHANNELS, vals, 32, 0, 0)) > 0)
    for (int i = 0; i < ret; ++i) value = vals[i].i;
  else if (oserror() == AL_BAD_PARAM)
    throw TSoundDeviceException(
        TSoundDeviceException::NoMixer,
        "It is impossible ask for the max nembers of channels supported");
  else
    throw TSoundDeviceException(
        TSoundDeviceException::NoMixer,
        "It is impossibile information about ouput device");

  if (value > 2) value = 2;
  if (channelCount > value)
    channelCount = value;
  else if (channelCount <= 0)
    channelCount = 1;

  if (bitPerSample <= 8)
    bitPerSample = 8;
  else if (bitPerSample <= 16)
    bitPerSample = 16;
  else
    bitPerSample = 24;

  fmt.m_bitPerSample = bitPerSample;
  fmt.m_channelCount = channelCount;
  fmt.m_sampleRate   = sampleRate;
  fmt.m_signedSample = true;

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

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

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

//******************************************************************************
//******************************************************************************
//						funzioni per l'interazione con
// la
// libreria
// audio
//******************************************************************************
//******************************************************************************
namespace {
bool isInterfaceSupported(int deviceType, int interfaceType) {
  ALvalue vals[16];
  int devNum;

  if ((devNum = alQueryValues(AL_SYSTEM, deviceType, vals, 16, 0, 0)) > 0) {
    int i;
    for (i = 0; i < devNum; ++i) {
      ALpv quals[2];
      quals[0].param   = AL_TYPE;
      quals[0].value.i = interfaceType;
      if (alQueryValues(vals[i].i, AL_INTERFACE, 0, 0, quals, 1) > 0)
        return true;
    }
  }
  return false;
}

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

bool setDefaultInput(TSoundInputDevice::Source type) {
  string label;

  switch (type) {
  case TSoundInputDevice::LineIn:
    label = "Line In";
    break;
  case TSoundInputDevice::DigitalIn:
    label = "AES Input";
    break;
  default:
    label = "Microphone";
  }

  int dev =
      alGetResourceByName(AL_SYSTEM, (char *)label.c_str(), AL_DEVICE_TYPE);
  if (!dev) return false;  // throw TException("Error to set input device");
  int itf;
  if (itf = alGetResourceByName(AL_SYSTEM, (char *)label.c_str(),
                                AL_INTERFACE_TYPE)) {
    ALpv p;

    p.param   = AL_INTERFACE;
    p.value.i = itf;
    if (alSetParams(dev, &p, 1) < 0 || p.sizeOut < 0)
      return false;  // throw TException("Error to set input device");
  }

  ALpv param;

  param.param   = AL_DEFAULT_INPUT;
  param.value.i = dev;
  if (alSetParams(AL_SYSTEM, &param, 1) < 0)
    return false;  // throw TException("Error to set input device");

  return true;
}

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

bool setDefaultOutput() {
  ALpv pvbuf[1];

  if (!isInterfaceSupported(AL_DEFAULT_OUTPUT, AL_SPEAKER_IF_TYPE))
    return false;  // throw TException("Speakers are not supported");

  int dev = alGetResourceByName(AL_SYSTEM, (char *)"Headphone/Speaker",
                                AL_DEVICE_TYPE);
  if (!dev) return false;  // throw TException("invalid device speakers");

  pvbuf[0].param   = AL_DEFAULT_OUTPUT;
  pvbuf[0].value.i = dev;
  alSetParams(AL_SYSTEM, pvbuf, 1);

  // qui devo metterci gli altoparlanti e poi setto i valori per il default
  // output
  pvbuf[0].param   = AL_INTERFACE;
  pvbuf[0].value.i = AL_SPEAKER_IF_TYPE;

  if (alSetParams(AL_DEFAULT_OUTPUT, pvbuf, 1) < 0)
    return false;  // throw TException("Unable to set output device params");

  return true;
}

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

// return the indexes of all input device of a particular type
list<int> getInputDevice(int deviceType) {
  ALvalue vals[16];
  ALpv quals[1];
  list<int> devList;
  int devNum;

  quals[0].param   = AL_TYPE;
  quals[0].value.i = deviceType;
  if ((devNum = alQueryValues(AL_SYSTEM, AL_DEFAULT_INPUT, vals, 16, quals,
                              1)) > 0) {
    int i;
    for (i = 0; i < devNum; ++i) {
      int itf;
      ALvalue val[16];
      if ((itf = alQueryValues(i, AL_INTERFACE, val, 16, 0, 0)) > 0) {
        int j;
        for (j = 0; j < itf; ++j) devList.push_back(vals[j].i);
      }
    }
  }

  return devList;
}

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

// return the indexes of all input device of a particular type and interface
list<int> getInputDevice(int deviceType, int itfType) {
  ALvalue vals[16];
  ALpv quals[1];
  list<int> devList;
  int devNum;

  quals[0].param   = AL_TYPE;
  quals[0].value.i = deviceType;
  if ((devNum = alQueryValues(AL_SYSTEM, AL_DEFAULT_INPUT, vals, 16, quals,
                              1)) > 0) {
    int i;
    for (i = 0; i < devNum; ++i) {
      int itf;
      ALvalue val[16];
      quals[0].param   = AL_TYPE;
      quals[0].value.i = itfType;
      if ((itf = alQueryValues(i, AL_INTERFACE, val, 16, quals, 1)) > 0) {
        int j;
        for (j = 0; j < itf; ++j) devList.push_back(vals[j].i);
      }
    }
  }

  return devList;
}

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

string getResourceLabel(int resourceID) {
  ALpv par[1];
  char l[32];

  par[0].param     = AL_LABEL;
  par[0].value.ptr = l;
  par[0].sizeIn    = 32;

  alGetParams(resourceID, par, 1);

  return string(l);
}

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

// verify the samplerate of the select device is changed from another
// application
bool isChangeOutput(ULONG sampleRate) {
  ALpv par[2];
  char l[32];

  par[0].param     = AL_LABEL;
  par[0].value.ptr = l;
  par[0].sizeIn    = 32;
  par[1].param     = AL_RATE;

  alGetParams(AL_DEFAULT_OUTPUT, par, 2);
  if ((strcmp(l, "Analog Out") != 0) ||
      (alFixedToDouble(par[1].value.ll) != sampleRate))
    return true;
  else
    return false;
}
}