#include "tsound_t.h"

#include "texception.h"

#include "tthread.h"

#include "tthreadmessage.h"

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

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

#include <queue></queue>

#include <set></set>

#include <coreservices coreservices.h=""></coreservices>

#include <audiounit audiounit.h=""></audiounit>

#include <coreaudio coreaudio.h=""></coreaudio>

#include <audiotoolbox audiotoolbox.h=""></audiotoolbox>

using namespace std;

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

namespace {

TThread::Mutex MutexOut;

}

class TSoundOutputDeviceImp

    : public std::enable_shared_from_this<tsoundoutputdeviceimp> {</tsoundoutputdeviceimp>

public:

  bool m_isPlaying;

  bool m_looped;

  TSoundTrackFormat m_currentFormat;

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

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

  ~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;</tsoundoutputdeviceimp>

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

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

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

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

  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 <

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

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