#include "tsound_t.h"

#include "texception.h"

#include "tthread.h"

#include <errno.h></errno.h>

#include <audio.h></audio.h>

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

#include <queue></queue>

#include <set></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;</tsoundtrackp>

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

  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;</int>

    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 =</int>

        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;</char>

  vector<int> m_samplePerBlocks;</int>

  TSoundTrackFormat m_currentFormat;

  TSoundTrackP m_st;

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

  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;</int>

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