805 lines
22 KiB
C++
805 lines
22 KiB
C++
|
|
|
|
#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;
|
|
}
|