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