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