#include "tsound_t.h"
#include "texception.h"
#include "tthread.h"
#include "tthreadmessage.h"
 
#include <errno.h>
#include <unistd.h>
#include <queue>
#include <set>
 
#include <CoreServices/CoreServices.h>
#include <AudioUnit/AudioUnit.h>
#include <CoreAudio/CoreAudio.h>
#include <AudioToolbox/AudioToolbox.h>
using namespace std;
 
//==============================================================================
namespace {
TThread::Mutex MutexOut;
}
 
class TSoundOutputDeviceImp
    : public std::enable_shared_from_this<TSoundOutputDeviceImp> {
public:
  bool m_isPlaying;
  bool m_looped;
  TSoundTrackFormat m_currentFormat;
  std::set<int> m_supportedRate;
  bool m_opened;
  AudioFileID musicFileID;
  AudioUnit theOutputUnit;
  AudioStreamBasicDescription fileASBD;
  AudioStreamBasicDescription outputASBD;
  AudioConverterRef converter;
 
  TSoundOutputDeviceImp()
      : m_isPlaying(false)
      , m_looped(false)
      , m_supportedRate()
      , m_opened(false){};
 
  std::set<TSoundOutputDeviceListener *> m_listeners;
 
  ~TSoundOutputDeviceImp(){};
 
  bool doOpenDevice();
  bool doSetStreamFormat(const TSoundTrackFormat &format);
  bool doStopDevice();
  void play(const TSoundTrackP &st, TINT32 s0, TINT32 s1, bool loop,
            bool scrubbing);
};
 
//-----------------------------------------------------------------------------
namespace {
 
struct MyData {
  char *entireFileBuffer;
 
  UInt64 totalPacketCount;
  UInt64 fileByteCount;
  UInt32 maxPacketSize;
  UInt64 packetOffset;
  UInt64 byteOffset;
  bool m_doNotify;
 
  void *sourceBuffer;
  AudioConverterRef converter;
  std::shared_ptr<TSoundOutputDeviceImp> imp;
  bool isLooping;
  MyData()
      : entireFileBuffer(0)
      , totalPacketCount(0)
      , fileByteCount(0)
      , maxPacketSize(0)
      , packetOffset(0)
      , byteOffset(0)
      , sourceBuffer(0)
      , isLooping(false)
      , m_doNotify(true) {}
};
 
class PlayCompletedMsg : public TThread::Message {
  std::set<TSoundOutputDeviceListener *> m_listeners;
  MyData *m_data;
 
public:
  PlayCompletedMsg(MyData *data) : m_data(data) {}
 
  TThread::Message *clone() const { return new PlayCompletedMsg(*this); }
 
  void onDeliver() {
    if (m_data->imp) {
      if (m_data->m_doNotify == false) return;
      m_data->m_doNotify = false;
      if (m_data->imp->m_isPlaying) m_data->imp->doStopDevice();
      std::set<TSoundOutputDeviceListener *>::iterator it =
          m_data->imp->m_listeners.begin();
      for (; it != m_data->imp->m_listeners.end(); ++it)
        (*it)->onPlayCompleted();
    }
  }
};
}
 
#define checkStatus(err)                                                       \
  if (err) {                                                                   \
    printf("Error: 0x%x ->  %s: %d\n", (int)err, __FILE__, __LINE__);          \
    fflush(stdout);                                                            \
  }
 
extern "C" {
// This is an example of a Input Procedure from a call to
// AudioConverterFillComplexBuffer.
// The total amount of data needed is "ioNumberDataPackets" when this method is
// first called.
// On exit, "ioNumberDataPackets" must be set to the actual amount of data
// obtained.
// Upon completion, all new input data must point to the AudioBufferList in the
// parameter ( "ioData" )
OSStatus MyACComplexInputProc(
    AudioConverterRef inAudioConverter, UInt32 *ioNumberDataPackets,
    AudioBufferList *ioData,
    AudioStreamPacketDescription **outDataPacketDescription, void *inUserData) {
  OSStatus err       = noErr;
  UInt32 bytesCopied = 0;
 
  MyData *myData = static_cast<MyData *>(inUserData);
 
  // initialize in case of failure
  ioData->mBuffers[0].mData         = NULL;
  ioData->mBuffers[0].mDataByteSize = 0;
 
  {
    // TThread::ScopedLock sl(MutexOut);
    if (myData->imp->m_isPlaying == false) return noErr;
  }
 
  // if there are not enough packets to satisfy request, then read what's left
  if (myData->packetOffset + *ioNumberDataPackets > myData->totalPacketCount)
    *ioNumberDataPackets = myData->totalPacketCount - myData->packetOffset;
 
  // do nothing if there are no packets available
  if (*ioNumberDataPackets) {
    if (myData->sourceBuffer != NULL) {
      free(myData->sourceBuffer);
      myData->sourceBuffer = NULL;
    }
 
    // the total amount of data requested by the AudioConverter
    bytesCopied = *ioNumberDataPackets * myData->maxPacketSize;
    // alloc a small buffer for the AudioConverter to use.
    myData->sourceBuffer = (void *)calloc(1, bytesCopied);
    // copy the amount of data needed (bytesCopied) from buffer of audio file
    memcpy(myData->sourceBuffer, myData->entireFileBuffer + myData->byteOffset,
           bytesCopied);
 
    // keep track of where we want to read from next time
    myData->byteOffset += *ioNumberDataPackets * myData->maxPacketSize;
    myData->packetOffset += *ioNumberDataPackets;
 
    ioData->mBuffers[0].mData = myData->sourceBuffer;  // tell the Audio
                                                       // Converter where it's
                                                       // source data is
    ioData->mBuffers[0].mDataByteSize =
        bytesCopied;  // tell the Audio Converter how much data in each buffer
  } else {
    // there aren't any more packets to read.
    // Set the amount of data read (mDataByteSize) to zero
    // and return noErr to signal the AudioConverter there are
    // no packets left.
 
    ioData->mBuffers[0].mData         = NULL;
    ioData->mBuffers[0].mDataByteSize = 0;
    delete[] myData->entireFileBuffer;
    myData->entireFileBuffer = 0;
    err                      = noErr;
    /*
{
TThread::ScopedLock sl(MutexOut);
*(myData->isPlaying) = false;   //questo lo faccio nel main thread
}
*/
    PlayCompletedMsg(myData).send();
  }
 
  return err;
}
 
OSStatus MyFileRenderProc(void *inRefCon,
                          AudioUnitRenderActionFlags *inActionFlags,
                          const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber,
                          UInt32 inNumFrames, AudioBufferList *ioData) {
  MyData *myData                = static_cast<MyData *>(inRefCon);
  OSStatus err                  = noErr;
  void *inInputDataProcUserData = inRefCon;
  AudioStreamPacketDescription *outPacketDescription = NULL;
  // To obtain a data buffer of converted data from a complex input
  // source(compressed files, etc.)
  // use AudioConverterFillComplexBuffer.  The total amount of data requested is
  // "inNumFrames" and
  // on return is set to the actual amount of data recieved.
  // All converted data is returned to "ioData" (AudioBufferList).
  err = AudioConverterFillComplexBuffer(myData->converter, MyACComplexInputProc,
                                        inInputDataProcUserData, &inNumFrames,
                                        ioData, outPacketDescription);
 
  /*Parameters for AudioConverterFillComplexBuffer()
converter - the converter being used
ACComplexInputProc() - input procedure to supply data to the Audio Converter
inInputDataProcUserData - Used to hold any data that needs to be passed on.  Not
needed in this example.
inNumFrames - The amount of requested data.  On output, this
number is the amount actually received.
ioData - Buffer of the converted data recieved on return
outPacketDescription - contains the format of the returned data.  Not used in
this example.
*/
 
  // checkStatus(err);
  return err;
}
 
}  // extern "C"
 
void PrintStreamDesc(AudioStreamBasicDescription *inDesc) {
  if (!inDesc) {
    printf("Can't print a NULL desc!\n");
    return;
  }
 
  printf("- - - - - - - - - - - - - - - - - - - -\n");
  printf("  Sample Rate:%f\n", inDesc->mSampleRate);
  printf("  Format ID:%.*s\n", (int)sizeof(inDesc->mFormatID),
         (char *)&inDesc->mFormatID);
  printf("  Format Flags:%lX\n", inDesc->mFormatFlags);
  printf("  Bytes per Packet:%ld\n", inDesc->mBytesPerPacket);
  printf("  Frames per Packet:%ld\n", inDesc->mFramesPerPacket);
  printf("  Bytes per Frame:%ld\n", inDesc->mBytesPerFrame);
  printf("  Channels per Frame:%ld\n", inDesc->mChannelsPerFrame);
  printf("  Bits per Channel:%ld\n", inDesc->mBitsPerChannel);
  printf("- - - - - - - - - - - - - - - - - - - -\n");
}
 
bool TSoundOutputDeviceImp::doOpenDevice() {
  m_opened     = false;
  OSStatus err = noErr;
  ComponentDescription desc;
  Component comp;
 
  desc.componentType    = kAudioUnitType_Output;
  desc.componentSubType = kAudioUnitSubType_DefaultOutput;
  // all Audio Units in AUComponent.h must use "kAudioUnitManufacturer_Apple" as
  // the Manufacturer
  desc.componentManufacturer = kAudioUnitManufacturer_Apple;
  desc.componentFlags        = 0;
  desc.componentFlagsMask    = 0;
 
  comp = FindNextComponent(
      NULL, &desc);  // Finds an component that meets the desc spec's
  if (comp == NULL) return false;
  err = OpenAComponent(comp, &theOutputUnit);  // gains access to the services
                                               // provided by the component
  if (err) return false;
 
  UInt32 size;
  Boolean outWritable;
  UInt32 theInputBus = 0;
  // Gets the size of the Stream Format Property and if it is writable
  err =
      AudioUnitGetPropertyInfo(theOutputUnit, kAudioUnitProperty_StreamFormat,
                               kAudioUnitScope_Output, 0, &size, &outWritable);
  // Get the current stream format of the output
  err = AudioUnitGetProperty(theOutputUnit, kAudioUnitProperty_StreamFormat,
                             kAudioUnitScope_Output, 0, &outputASBD, &size);
  checkStatus(err);
  // Set the stream format of the output to match the input
  err = AudioUnitSetProperty(theOutputUnit, kAudioUnitProperty_StreamFormat,
                             kAudioUnitScope_Input, theInputBus, &outputASBD,
                             size);
  checkStatus(err);
 
  // Initialize AudioUnit, alloc mem buffers for processing
  err = AudioUnitInitialize(theOutputUnit);
  checkStatus(err);
  if (err == noErr) m_opened = true;
  return m_opened;
}
 
bool TSoundOutputDeviceImp::doSetStreamFormat(const TSoundTrackFormat &format) {
  if (!m_opened) doOpenDevice();
  if (!m_opened) return false;
 
  fileASBD.mSampleRate  = format.m_sampleRate;
  fileASBD.mFormatID    = kAudioFormatLinearPCM;
  fileASBD.mFormatFlags = 14;
  /*
Standard flags: kAudioFormatFlagIsFloat = (1L << 0)
kAudioFormatFlagIsBigEndian = (1L << 1)
kAudioFormatFlagIsSignedInteger = (1L << 2)
kAudioFormatFlagIsPacked = (1L << 3)
kAudioFormatFlagIsAlignedHigh = (1L << 4)
kAudioFormatFlagIsNonInterleaved = (1L << 5)
kAudioFormatFlagsAreAllClear = (1L << 31)
 
Linear PCM flags:
kLinearPCMFormatFlagIsFloat = kAudioFormatFlagIsFloat
kLinearPCMFormatFlagIsBigEndian = kAudioFormatFlagIsBigEndian
kLinearPCMFormatFlagIsSignedInteger = kAudioFormatFlagIsSignedInteger
kLinearPCMFormatFlagIsPacked = kAudioFormatFlagIsPacked
kLinearPCMFormatFlagIsAlignedHigh = kAudioFormatFlagIsAlignedHigh
kLinearPCMFormatFlagIsNonInterleaved = kAudioFormatFlagIsNonInterleaved
kLinearPCMFormatFlagsAreAllClear = kAudioFormatFlagsAreAllClear
*/
  fileASBD.mBytesPerPacket =
      (format.m_bitPerSample >> 3) * format.m_channelCount;
  fileASBD.mFramesPerPacket = 1;
  fileASBD.mBytesPerFrame =
      (format.m_bitPerSample >> 3) * format.m_channelCount;
  fileASBD.mChannelsPerFrame = format.m_channelCount;
  fileASBD.mBitsPerChannel   = format.m_bitPerSample;
  fileASBD.mReserved         = 0;
  // PrintStreamDesc(&fileASBD);
  m_opened = true;
  return true;
}
 
//==============================================================================
 
TSoundOutputDevice::TSoundOutputDevice() : m_imp(new TSoundOutputDeviceImp) {
  try {
    supportsVolume();
  } catch (TSoundDeviceException &e) {
    throw TSoundDeviceException(e.getType(), e.getMessage());
  }
}
 
//------------------------------------------------------------------------------
 
TSoundOutputDevice::~TSoundOutputDevice() {
  stop();
  close();
}
 
//------------------------------------------------------------------------------
 
bool TSoundOutputDevice::installed() { return true; }
 
//------------------------------------------------------------------------------
 
bool TSoundOutputDevice::open(const TSoundTrackP &st) {
  if (!m_imp->doOpenDevice())
    throw TSoundDeviceException(TSoundDeviceException::UnableOpenDevice,
                                "Problem to open the output device");
  if (!m_imp->doSetStreamFormat(st->getFormat()))
    throw TSoundDeviceException(
        TSoundDeviceException::UnableOpenDevice,
        "Problem to open the output device setting some params");
  return true;
}
 
//------------------------------------------------------------------------------
 
bool TSoundOutputDevice::close() {
  stop();
  m_imp->m_opened = false;
  AudioUnitUninitialize(
      m_imp->theOutputUnit);  // release resources without closing the component
  CloseComponent(m_imp->theOutputUnit);  // Terminates your application's access
                                         // to the services provided
  return true;
}
 
//------------------------------------------------------------------------------
 
void TSoundOutputDevice::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
                              bool loop, bool scrubbing) {
  // TThread::ScopedLock sl(MutexOut);
  int lastSample = st->getSampleCount() - 1;
  notLessThan(0, s0);
  notLessThan(0, s1);
 
  notMoreThan(lastSample, s0);
  notMoreThan(lastSample, s1);
 
  if (s0 > s1) {
#ifdef DEBUG
    cout << "s0 > s1; reorder" << endl;
#endif
    swap(s0, s1);
  }
 
  if (isPlaying()) {
#ifdef DEBUG
    cout << "is playing, stop it!" << endl;
#endif
    stop();
  }
  m_imp->play(st, s0, s1, loop, scrubbing);
}
 
//------------------------------------------------------------------------------
 
void TSoundOutputDeviceImp::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
                                 bool loop, bool scrubbing) {
  if (!doSetStreamFormat(st->getFormat())) return;
 
  OSStatus err   = noErr;
  MyData *myData = new MyData();
 
  myData->imp            = shared_from_this();
  UInt32 magicCookieSize = 0;
  // PrintStreamDesc(&outputASBD);
  err = AudioConverterNew(&fileASBD, &outputASBD, &converter);
  checkStatus(err);
  err = AudioFileGetPropertyInfo(musicFileID, kAudioFilePropertyMagicCookieData,
                                 &magicCookieSize, NULL);
 
  if (err == noErr) {
    void *magicCookie = calloc(1, magicCookieSize);
    if (magicCookie) {
      // Get Magic Cookie data from Audio File
      err = AudioFileGetProperty(musicFileID, kAudioFilePropertyMagicCookieData,
                                 &magicCookieSize, magicCookie);
 
      // Give the AudioConverter the magic cookie decompression params if there
      // are any
      if (err == noErr) {
        err = AudioConverterSetProperty(myData->converter,
                                        kAudioConverterDecompressionMagicCookie,
                                        magicCookieSize, magicCookie);
      }
      err = noErr;
      if (magicCookie) free(magicCookie);
    }
  } else  // this is OK because some audio data doesn't need magic cookie data
    err = noErr;
 
  checkStatus(err);
  myData->converter        = converter;
  myData->totalPacketCount = s1 - s0;
  myData->fileByteCount    = (s1 - s0) * st->getSampleSize();
  myData->entireFileBuffer = new char[myData->fileByteCount];
 
#if defined(i386)
  if (st->getBitPerSample() == 16) {
    int i;
    USHORT *dst = (USHORT *)(myData->entireFileBuffer);
    USHORT *src = (USHORT *)(st->getRawData() + s0 * st->getSampleSize());
 
    for (i = 0; i < myData->fileByteCount / 2; i++) *dst++ = swapUshort(*src++);
  } else
    memcpy(myData->entireFileBuffer,
           st->getRawData() + s0 * st->getSampleSize(), myData->fileByteCount);
#else
  memcpy(myData->entireFileBuffer, st->getRawData() + s0 * st->getSampleSize(),
         myData->fileByteCount);
#endif
 
  myData->maxPacketSize = fileASBD.mFramesPerPacket * fileASBD.mBytesPerFrame;
  {
    // TThread::ScopedLock sl(MutexOut);
    m_isPlaying = true;
  }
  myData->isLooping = loop;
 
  // cout << "total packet count = " << myData->totalPacketCount <<endl;
  // cout << "filebytecount " << myData->fileByteCount << endl;
 
  AURenderCallbackStruct renderCallback;
  memset(&renderCallback, 0, sizeof(AURenderCallbackStruct));
 
  renderCallback.inputProc       = MyFileRenderProc;
  renderCallback.inputProcRefCon = myData;
 
  // Sets the callback for the Audio Unit to the renderCallback
  err =
      AudioUnitSetProperty(theOutputUnit, kAudioUnitProperty_SetRenderCallback,
                           kAudioUnitScope_Input, 0, &renderCallback,
                           sizeof(AURenderCallbackStruct));
 
  checkStatus(err);
 
  err = AudioOutputUnitStart(theOutputUnit);
 
  checkStatus(err);
}
 
//------------------------------------------------------------------------------
 
bool TSoundOutputDeviceImp::doStopDevice() {
  m_isPlaying = false;
  AudioOutputUnitStop(
      theOutputUnit);  // you must stop the audio unit from processing
  AudioConverterDispose(
      converter);  // deallocates the memory used by inAudioConverter
  return true;
}
 
//------------------------------------------------------------------------------
 
void TSoundOutputDevice::stop() {
  // TThread::ScopedLock sl(MutexOut);
  if (m_imp->m_opened == false) return;
 
  // TThread::ScopedLock sl(MutexOut);
  m_imp->doStopDevice();
}
 
//------------------------------------------------------------------------------
 
void TSoundOutputDevice::attach(TSoundOutputDeviceListener *listener) {
  m_imp->m_listeners.insert(listener);
}
 
//------------------------------------------------------------------------------
 
void TSoundOutputDevice::detach(TSoundOutputDeviceListener *listener) {
  m_imp->m_listeners.erase(listener);
}
 
//------------------------------------------------------------------------------
 
double TSoundOutputDevice::getVolume() {
  if (!m_imp->m_opened) m_imp->doOpenDevice();
 
  Float32 leftVol, rightVol;
  AudioUnitGetParameter(m_imp->theOutputUnit, kHALOutputParam_Volume,
                        kAudioUnitScope_Output, 0, &leftVol);
 
  AudioUnitGetParameter(m_imp->theOutputUnit, kHALOutputParam_Volume,
                        kAudioUnitScope_Output, 0, &rightVol);
  double vol = (leftVol + rightVol) / 2;
 
  return (vol < 0. ? 0. : vol);
}
 
//------------------------------------------------------------------------------
 
bool TSoundOutputDevice::setVolume(double volume) {
  Float32 vol = volume;
  AudioUnitSetParameter(m_imp->theOutputUnit, kHALOutputParam_Volume,
                        kAudioUnitScope_Output, 0, vol, 0);
 
  AudioUnitSetParameter(m_imp->theOutputUnit, kHALOutputParam_Volume,
                        kAudioUnitScope_Output, 0, vol, 0);
  return true;
}
 
//------------------------------------------------------------------------------
 
bool TSoundOutputDevice::supportsVolume() { return true; }
 
//------------------------------------------------------------------------------
 
bool TSoundOutputDevice::isPlaying() const {
  // TThread::ScopedLock sl(MutexOut);
  return m_imp->m_isPlaying;
}
 
//------------------------------------------------------------------------------
 
bool TSoundOutputDevice::isLooping() {
  // TThread::ScopedLock sl(MutexOut);
  return m_imp->m_looped;
}
 
//------------------------------------------------------------------------------
 
void TSoundOutputDevice::setLooping(bool loop) {
  // TThread::ScopedLock sl(MutexOut);
  m_imp->m_looped = loop;
}
 
//------------------------------------------------------------------------------
 
TSoundTrackFormat TSoundOutputDevice::getPreferredFormat(TUINT32 sampleRate,
                                                         int channelCount,
                                                         int bitPerSample) {
  TSoundTrackFormat fmt(sampleRate, bitPerSample, channelCount, 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;
 
  long m_recordedSampleCount;
 
  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_oneShotRecording(false)
      , m_recordedSampleCount(0)
      , m_st(0)
      , m_supportedRate(){};
 
  ~TSoundInputDeviceImp(){};
 
  bool doOpenDevice(const TSoundTrackFormat &format,
                    TSoundInputDevice::Source devType);
};
 
bool TSoundInputDeviceImp::doOpenDevice(const TSoundTrackFormat &format,
                                        TSoundInputDevice::Source devType) {
  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() {}
 
//==============================================================================
 
TSoundInputDevice::TSoundInputDevice() : m_imp(new TSoundInputDeviceImp) {}
 
//------------------------------------------------------------------------------
 
TSoundInputDevice::~TSoundInputDevice() {}
 
//------------------------------------------------------------------------------
 
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) {}
 
//------------------------------------------------------------------------------
 
void TSoundInputDevice::record(const TSoundTrackP &st,
                               TSoundInputDevice::Source type) {}
 
//------------------------------------------------------------------------------
 
TSoundTrackP TSoundInputDevice::stop() {
  TSoundTrackP st;
  return st;
}
 
//------------------------------------------------------------------------------
 
double TSoundInputDevice::getVolume() { return 0.0; }
 
//------------------------------------------------------------------------------
 
bool TSoundInputDevice::setVolume(double volume) { return true; }
 
//------------------------------------------------------------------------------
 
bool TSoundInputDevice::supportsVolume() { return true; }
 
//------------------------------------------------------------------------------
 
TSoundTrackFormat TSoundInputDevice::getPreferredFormat(TUINT32 sampleRate,
                                                        int channelCount,
                                                        int bitPerSample) {
  TSoundTrackFormat fmt;
  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; }