1173 lines
35 KiB
C++
1173 lines
35 KiB
C++
|
|
|
|
#include "tsound_t.h"
|
|
#include "texception.h"
|
|
#include "tthread.h"
|
|
|
|
#include <errno.h>
|
|
#include <audio.h>
|
|
#include <unistd.h>
|
|
#include <queue>
|
|
#include <set>
|
|
|
|
// forward declaration
|
|
namespace {
|
|
bool isInterfaceSupported(int deviceType, int interfaceType);
|
|
bool setDefaultInput(TSoundInputDevice::Source type);
|
|
bool setDefaultOutput();
|
|
bool isChangeOutput(ULONG sampleRate);
|
|
}
|
|
//==============================================================================
|
|
|
|
class TSoundOutputDeviceImp {
|
|
public:
|
|
ALport m_port;
|
|
bool m_stopped;
|
|
bool m_isPlaying;
|
|
bool m_looped;
|
|
TSoundTrackFormat m_currentFormat;
|
|
std::queue<TSoundTrackP> m_queuedSoundTracks;
|
|
std::set<int> m_supportedRate;
|
|
|
|
TThread::Executor m_executor;
|
|
TThread::Mutex m_mutex;
|
|
|
|
TSoundOutputDeviceImp()
|
|
: m_stopped(false)
|
|
, m_isPlaying(false)
|
|
, m_looped(false)
|
|
, m_port(NULL)
|
|
, m_queuedSoundTracks()
|
|
, m_supportedRate(){};
|
|
|
|
~TSoundOutputDeviceImp(){};
|
|
|
|
bool doOpenDevice(const TSoundTrackFormat &format);
|
|
void insertAllRate();
|
|
bool verifyRate();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDeviceImp::doOpenDevice(const TSoundTrackFormat &format) {
|
|
ALconfig config;
|
|
ALpv pvbuf[3];
|
|
|
|
m_currentFormat = format;
|
|
|
|
// AL_MONITOR_CTL fa parte dei vecchi andrebbero trovati quelli nuovi
|
|
pvbuf[0].param = AL_PORT_COUNT;
|
|
pvbuf[1].param = AL_MONITOR_CTL;
|
|
if (alGetParams(AL_DEFAULT_OUTPUT, pvbuf, 2) < 0)
|
|
if (oserror() == AL_BAD_DEVICE_ACCESS)
|
|
return false; // throw TException("Could not access audio hardware.");
|
|
|
|
if (!isInterfaceSupported(AL_DEFAULT_OUTPUT, AL_SPEAKER_IF_TYPE))
|
|
return false; // throw TException("Speakers are not supported");
|
|
|
|
int dev = alGetResourceByName(AL_SYSTEM, (char *)"Headphone/Speaker",
|
|
AL_DEVICE_TYPE);
|
|
if (!dev) return false; // throw TException("invalid device speakers");
|
|
|
|
pvbuf[0].param = AL_DEFAULT_OUTPUT;
|
|
pvbuf[0].value.i = dev;
|
|
alSetParams(AL_SYSTEM, pvbuf, 1);
|
|
|
|
ALfixed buf[2] = {alDoubleToFixed(0), alDoubleToFixed(0)};
|
|
|
|
config = alNewConfig();
|
|
// qui devo metterci gli altoparlanti e poi setto i valori per il default
|
|
// output
|
|
pvbuf[0].param = AL_RATE;
|
|
pvbuf[0].value.ll = alDoubleToFixed((double)format.m_sampleRate);
|
|
pvbuf[1].param = AL_GAIN;
|
|
pvbuf[1].value.ptr = buf;
|
|
pvbuf[1].sizeIn = 8;
|
|
pvbuf[2].param = AL_INTERFACE;
|
|
pvbuf[2].value.i = AL_SPEAKER_IF_TYPE;
|
|
|
|
if (alSetParams(AL_DEFAULT_OUTPUT, pvbuf, 3) < 0) return false;
|
|
// throw TException("Unable to set params for output device");
|
|
|
|
if (alSetChannels(config, format.m_channelCount) == -1)
|
|
return false; // throw TException("Error to setting audio hardware.");
|
|
|
|
int bytePerSample = format.m_bitPerSample >> 3;
|
|
switch (bytePerSample) {
|
|
case 3:
|
|
bytePerSample++;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (alSetWidth(config, bytePerSample) == -1)
|
|
return false; // throw TException("Error to setting audio hardware.");
|
|
|
|
if (alSetSampFmt(config, AL_SAMPFMT_TWOSCOMP) == -1)
|
|
return false; // throw TException("Error to setting audio hardware.");
|
|
|
|
if (alSetQueueSize(config, (TINT32)format.m_sampleRate) == -1)
|
|
return false; // throw TException("Error to setting audio hardware.");
|
|
|
|
m_port = alOpenPort("AudioOutput", "w", config);
|
|
if (!m_port) return false; // throw TException("Could not open audio port.");
|
|
|
|
alFreeConfig(config);
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDeviceImp::insertAllRate() {
|
|
m_supportedRate.insert(8000);
|
|
m_supportedRate.insert(11025);
|
|
m_supportedRate.insert(16000);
|
|
m_supportedRate.insert(22050);
|
|
m_supportedRate.insert(32000);
|
|
m_supportedRate.insert(44100);
|
|
m_supportedRate.insert(48000);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDeviceImp::verifyRate() {
|
|
// Sample Rate
|
|
ALparamInfo pinfo;
|
|
int ret = alGetParamInfo(AL_DEFAULT_OUTPUT, AL_RATE, &pinfo);
|
|
if (ret != -1 && pinfo.elementType == AL_FIXED_ELEM) {
|
|
int min = (int)alFixedToDouble(pinfo.min.ll);
|
|
int max = (int)alFixedToDouble(pinfo.max.ll);
|
|
|
|
std::set<int>::iterator it;
|
|
for (it = m_supportedRate.begin(); it != m_supportedRate.end(); ++it)
|
|
if (*it < min || *it > max) m_supportedRate.erase(*it);
|
|
if (m_supportedRate.end() == m_supportedRate.begin()) return false;
|
|
} else if (ret == AL_BAD_PARAM)
|
|
return false;
|
|
else
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
//==============================================================================
|
|
|
|
class PlayTask : public TThread::Runnable {
|
|
public:
|
|
TSoundOutputDeviceImp *m_devImp;
|
|
TSoundTrackP m_sndtrack;
|
|
|
|
PlayTask(TSoundOutputDeviceImp *devImp, const TSoundTrackP &st)
|
|
: TThread::Runnable(), m_devImp(devImp), m_sndtrack(st){};
|
|
|
|
~PlayTask(){};
|
|
|
|
void run();
|
|
};
|
|
|
|
void PlayTask::run() {
|
|
int leftToPlay = m_sndtrack->getSampleCount();
|
|
int i = 0;
|
|
|
|
if (!m_devImp->m_port ||
|
|
(m_devImp->m_currentFormat != m_sndtrack->getFormat()) ||
|
|
isChangeOutput(m_sndtrack->getSampleRate()))
|
|
if (!m_devImp->doOpenDevice(m_sndtrack->getFormat())) return;
|
|
|
|
while ((leftToPlay > 0) && m_devImp->m_isPlaying) {
|
|
int fillable = alGetFillable(m_devImp->m_port);
|
|
if (!fillable) continue;
|
|
|
|
if (fillable < leftToPlay) {
|
|
alWriteFrames(m_devImp->m_port, (void *)(m_sndtrack->getRawData() + i),
|
|
fillable);
|
|
// ricorda getSampleSize restituisce m_sampleSize che comprende gia'
|
|
// la moltiplicazione per il numero dei canali
|
|
i += fillable * m_sndtrack->getSampleSize();
|
|
leftToPlay -= fillable;
|
|
} else {
|
|
alWriteFrames(m_devImp->m_port, (void *)(m_sndtrack->getRawData() + i),
|
|
leftToPlay);
|
|
leftToPlay = 0;
|
|
}
|
|
}
|
|
|
|
if (!m_devImp->m_stopped) {
|
|
while (ALgetfilled(m_devImp->m_port) > 0) sginap(1);
|
|
{
|
|
TThread::ScopedLock sl(m_devImp->m_mutex);
|
|
if (!m_devImp->m_looped) m_devImp->m_queuedSoundTracks.pop();
|
|
if (m_devImp->m_queuedSoundTracks.empty()) {
|
|
m_devImp->m_isPlaying = false;
|
|
m_devImp->m_stopped = true;
|
|
m_devImp->m_looped = false;
|
|
} else {
|
|
m_devImp->m_executor.addTask(
|
|
new PlayTask(m_devImp, m_devImp->m_queuedSoundTracks.front()));
|
|
}
|
|
}
|
|
} else {
|
|
alDiscardFrames(m_devImp->m_port, alGetFilled(m_devImp->m_port));
|
|
while (!m_devImp->m_queuedSoundTracks.empty())
|
|
m_devImp->m_queuedSoundTracks.pop();
|
|
}
|
|
}
|
|
|
|
//==============================================================================
|
|
|
|
TSoundOutputDevice::TSoundOutputDevice() : m_imp(new TSoundOutputDeviceImp) {
|
|
if (!setDefaultOutput())
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableSetDevice,
|
|
"Speaker not supported");
|
|
try {
|
|
supportsVolume();
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
m_imp->insertAllRate();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundOutputDevice::~TSoundOutputDevice() {
|
|
close();
|
|
delete m_imp;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::installed() {
|
|
if (alQueryValues(AL_SYSTEM, AL_DEFAULT_OUTPUT, 0, 0, 0, 0) <= 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::open(const TSoundTrackP &st) {
|
|
if (!m_imp->doOpenDevice(st->getFormat()))
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnableOpenDevice,
|
|
"Problem to open the output device or set some params");
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::close() {
|
|
stop();
|
|
if (m_imp->m_port) alClosePort(m_imp->m_port);
|
|
m_imp->m_port = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDevice::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
|
|
bool loop, bool scrubbing) {
|
|
if (!st->getSampleCount()) return;
|
|
|
|
{
|
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
|
if (m_imp->m_looped)
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::Busy,
|
|
"Unable to queue another playback when the sound player is looping");
|
|
|
|
m_imp->m_isPlaying = true;
|
|
m_imp->m_stopped = false;
|
|
m_imp->m_looped = loop;
|
|
}
|
|
|
|
TSoundTrackFormat fmt;
|
|
try {
|
|
fmt = getPreferredFormat(st->getFormat());
|
|
if (fmt != st->getFormat()) {
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"Unsupported Format");
|
|
}
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
e.getMessage());
|
|
}
|
|
|
|
assert(s1 >= s0);
|
|
TSoundTrackP subTrack = st->extract(s0, s1);
|
|
|
|
// far partire il thread
|
|
if (m_imp->m_queuedSoundTracks.empty()) {
|
|
m_imp->m_queuedSoundTracks.push(subTrack);
|
|
|
|
m_imp->m_executor.addTask(new PlayTask(m_imp, subTrack));
|
|
} else
|
|
m_imp->m_queuedSoundTracks.push(subTrack);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDevice::stop() {
|
|
if (!m_imp->m_isPlaying) return;
|
|
|
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
|
m_imp->m_isPlaying = false;
|
|
m_imp->m_stopped = true;
|
|
m_imp->m_looped = false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
double TSoundOutputDevice::getVolume() {
|
|
ALpv pv[1];
|
|
ALfixed value[2];
|
|
|
|
try {
|
|
supportsVolume();
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
|
|
pv[0].param = AL_GAIN;
|
|
pv[0].value.ptr = value;
|
|
pv[0].sizeIn = 8;
|
|
alGetParams(AL_DEFAULT_OUTPUT, pv, 1);
|
|
|
|
double val =
|
|
(((alFixedToDouble(value[0]) + alFixedToDouble(value[1])) / 2.) + 60.) /
|
|
8.05;
|
|
return val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::setVolume(double volume) {
|
|
ALpv pv[1];
|
|
ALfixed value[2];
|
|
|
|
try {
|
|
supportsVolume();
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
|
|
double val = -60. + 8.05 * volume;
|
|
value[0] = alDoubleToFixed(val);
|
|
value[1] = alDoubleToFixed(val);
|
|
|
|
pv[0].param = AL_GAIN;
|
|
pv[0].value.ptr = value;
|
|
pv[0].sizeIn = 8;
|
|
if (alSetParams(AL_DEFAULT_OUTPUT, pv, 1) < 0) return false;
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::supportsVolume() {
|
|
ALparamInfo pinfo;
|
|
int ret;
|
|
ret = alGetParamInfo(AL_DEFAULT_OUTPUT, AL_GAIN, &pinfo);
|
|
double min = alFixedToDouble(pinfo.min.ll);
|
|
double max = alFixedToDouble(pinfo.max.ll);
|
|
if ((ret != -1) && (min != max) && (max != 0.0))
|
|
return true;
|
|
else if ((ret == AL_BAD_PARAM) || ((min == max) && (max == 0.0)))
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
|
|
"It is impossible to chamge setting of volume");
|
|
else
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Output device is not accessible");
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::isPlaying() const { return m_imp->m_isPlaying; }
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::isLooping() {
|
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
|
return m_imp->m_looped;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDevice::setLooping(bool loop) {
|
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
|
m_imp->m_looped = loop;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundTrackFormat TSoundOutputDevice::getPreferredFormat(ULONG sampleRate,
|
|
int channelCount,
|
|
int bitPerSample) {
|
|
TSoundTrackFormat fmt;
|
|
int ret;
|
|
|
|
if (!m_imp->verifyRate())
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"There isn't any support rate");
|
|
|
|
if (m_imp->m_supportedRate.find((int)sampleRate) ==
|
|
m_imp->m_supportedRate.end()) {
|
|
std::set<int>::iterator it =
|
|
m_imp->m_supportedRate.lower_bound((int)sampleRate);
|
|
if (it == m_imp->m_supportedRate.end()) {
|
|
it = std::max_element(m_imp->m_supportedRate.begin(),
|
|
m_imp->m_supportedRate.end());
|
|
if (it != m_imp->m_supportedRate.end())
|
|
sampleRate = *(m_imp->m_supportedRate.rbegin());
|
|
else
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"There isn't a supported rate");
|
|
} else
|
|
sampleRate = *it;
|
|
}
|
|
|
|
int value;
|
|
ALvalue vals[32];
|
|
if ((ret = alQueryValues(AL_DEFAULT_OUTPUT, AL_CHANNELS, vals, 32, 0, 0)) > 0)
|
|
for (int i = 0; i < ret; ++i) value = vals[i].i;
|
|
else if (oserror() == AL_BAD_PARAM)
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::NoMixer,
|
|
"It is impossible ask for the max numbers of channels supported");
|
|
else
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::NoMixer,
|
|
"It is impossibile information about ouput device");
|
|
|
|
if (value > 2) value = 2;
|
|
if (channelCount > value)
|
|
channelCount = value;
|
|
else if (channelCount <= 0)
|
|
channelCount = 1;
|
|
|
|
if (bitPerSample <= 8)
|
|
bitPerSample = 8;
|
|
else if (bitPerSample <= 16)
|
|
bitPerSample = 16;
|
|
else
|
|
bitPerSample = 24;
|
|
|
|
fmt.m_bitPerSample = bitPerSample;
|
|
fmt.m_channelCount = channelCount;
|
|
fmt.m_sampleRate = sampleRate;
|
|
fmt.m_signedSample = 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;
|
|
|
|
TINT32 m_recordedSampleCount;
|
|
|
|
vector<char *> m_recordedBlocks;
|
|
vector<int> m_samplePerBlocks;
|
|
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_recordedBlocks()
|
|
, m_samplePerBlocks()
|
|
, m_recordedSampleCount(0)
|
|
, m_oneShotRecording(false)
|
|
, m_st(0)
|
|
, m_supportedRate(){};
|
|
|
|
~TSoundInputDeviceImp(){};
|
|
|
|
bool doOpenDevice(const TSoundTrackFormat &format,
|
|
TSoundInputDevice::Source devType);
|
|
void insertAllRate();
|
|
bool verifyRate();
|
|
};
|
|
|
|
bool TSoundInputDeviceImp::doOpenDevice(const TSoundTrackFormat &format,
|
|
TSoundInputDevice::Source devType) {
|
|
ALconfig config;
|
|
ALpv pvbuf[2];
|
|
|
|
m_currentFormat = format;
|
|
|
|
// AL_MONITOR_CTL fa parte dei vecchi andrebbero trovati quelli nuovi
|
|
pvbuf[0].param = AL_PORT_COUNT;
|
|
pvbuf[1].param = AL_MONITOR_CTL;
|
|
if (alGetParams(AL_DEFAULT_INPUT, pvbuf, 2) < 0)
|
|
if (oserror() == AL_BAD_DEVICE_ACCESS)
|
|
return false; // throw TException("Could not access audio hardware.");
|
|
|
|
config = alNewConfig();
|
|
|
|
if (!setDefaultInput(devType))
|
|
return false; // throw TException("Could not set the input device
|
|
// specified");
|
|
|
|
pvbuf[0].param = AL_RATE;
|
|
pvbuf[0].value.ll = alDoubleToFixed(format.m_sampleRate);
|
|
|
|
ALfixed buf[2] = {alDoubleToFixed(0), alDoubleToFixed(0)};
|
|
pvbuf[1].param = AL_GAIN;
|
|
pvbuf[1].value.ptr = buf;
|
|
pvbuf[1].sizeIn = 8;
|
|
|
|
if (alSetParams(AL_DEFAULT_INPUT, pvbuf, 2) < 0)
|
|
return false; // throw TException("Problem to set params ");
|
|
|
|
if (alSetChannels(config, format.m_channelCount) == -1)
|
|
return false; // throw TException("Error to setting audio hardware.");
|
|
|
|
int bytePerSample = format.m_bitPerSample >> 3;
|
|
switch (bytePerSample) {
|
|
case 3:
|
|
bytePerSample++;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (alSetWidth(config, bytePerSample) == -1)
|
|
return false; // throw TException("Error to setting audio hardware.");
|
|
|
|
if (alSetSampFmt(config, AL_SAMPFMT_TWOSCOMP) == -1)
|
|
return false; // throw TException("Error to setting audio hardware.");
|
|
|
|
if (alSetQueueSize(config, (TINT32)format.m_sampleRate) == -1)
|
|
return false; // throw TException("Error to setting audio hardware.");
|
|
|
|
alSetDevice(config, AL_DEFAULT_INPUT);
|
|
|
|
m_port = alOpenPort("AudioInput", "r", config);
|
|
if (!m_port) return false; // throw TException("Could not open audio port.");
|
|
|
|
alFreeConfig(config);
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSoundInputDeviceImp::insertAllRate() {
|
|
m_supportedRate.insert(8000);
|
|
m_supportedRate.insert(11025);
|
|
m_supportedRate.insert(16000);
|
|
m_supportedRate.insert(22050);
|
|
m_supportedRate.insert(32000);
|
|
m_supportedRate.insert(44100);
|
|
m_supportedRate.insert(48000);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TSoundInputDeviceImp::verifyRate() {
|
|
// Sample Rate
|
|
ALparamInfo pinfo;
|
|
int ret = alGetParamInfo(AL_DEFAULT_INPUT, AL_RATE, &pinfo);
|
|
if (ret != -1 && pinfo.elementType == AL_FIXED_ELEM) {
|
|
int min = (int)alFixedToDouble(pinfo.min.ll);
|
|
int max = (int)alFixedToDouble(pinfo.max.ll);
|
|
|
|
std::set<int>::iterator it;
|
|
for (it = m_supportedRate.begin(); it != m_supportedRate.end(); ++it)
|
|
if (*it < min || *it > max) m_supportedRate.erase(*it);
|
|
if (m_supportedRate.end() == m_supportedRate.begin()) return false;
|
|
} else if (ret == AL_BAD_PARAM)
|
|
return false;
|
|
else
|
|
return false;
|
|
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() {
|
|
TINT32 byteRecordedSample = 0;
|
|
int filled = alGetFilled(m_devImp->m_port);
|
|
|
|
if (m_devImp->m_oneShotRecording) {
|
|
char *rawData = m_devImp->m_recordedBlocks.front();
|
|
int sampleSize;
|
|
|
|
if ((m_devImp->m_currentFormat.m_bitPerSample >> 3) == 3)
|
|
sampleSize = 4;
|
|
else
|
|
sampleSize = (m_devImp->m_currentFormat.m_bitPerSample >> 3);
|
|
|
|
sampleSize *= m_devImp->m_currentFormat.m_channelCount;
|
|
while ((byteRecordedSample <= (m_ByteToSample - filled * sampleSize)) &&
|
|
m_devImp->m_isRecording) {
|
|
alReadFrames(m_devImp->m_port, (void *)(rawData + byteRecordedSample),
|
|
filled);
|
|
byteRecordedSample += filled * sampleSize;
|
|
filled = alGetFilled(m_devImp->m_port);
|
|
}
|
|
|
|
if (m_devImp->m_isRecording) {
|
|
alReadFrames(m_devImp->m_port, (void *)(rawData + byteRecordedSample),
|
|
(m_ByteToSample - byteRecordedSample) / sampleSize);
|
|
while (alGetFillable(m_devImp->m_port) > 0) sginap(1);
|
|
}
|
|
} else {
|
|
while (m_devImp->m_isRecording) {
|
|
filled = alGetFilled(m_devImp->m_port);
|
|
if (filled > 0) {
|
|
char *dataBuffer = new char[filled * m_ByteToSample];
|
|
m_devImp->m_recordedBlocks.push_back(dataBuffer);
|
|
m_devImp->m_samplePerBlocks.push_back(filled * m_ByteToSample);
|
|
|
|
alReadFrames(m_devImp->m_port, (void *)dataBuffer, filled);
|
|
m_devImp->m_recordedSampleCount += filled;
|
|
}
|
|
}
|
|
while (alGetFillable(m_devImp->m_port) > 0) sginap(1);
|
|
}
|
|
alClosePort(m_devImp->m_port);
|
|
m_devImp->m_port = 0;
|
|
m_devImp->m_stopped = true;
|
|
}
|
|
|
|
//==============================================================================
|
|
|
|
TSoundInputDevice::TSoundInputDevice() : m_imp(new TSoundInputDeviceImp) {}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundInputDevice::~TSoundInputDevice() {
|
|
if (m_imp->m_port) alClosePort(m_imp->m_port);
|
|
delete m_imp;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
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) {
|
|
if (m_imp->m_isRecording == true)
|
|
throw TSoundDeviceException(TSoundDeviceException::Busy,
|
|
"Just another recoding is in progress");
|
|
|
|
m_imp->m_recordedBlocks.clear();
|
|
m_imp->m_samplePerBlocks.clear();
|
|
|
|
// registra creando una nuova traccia
|
|
m_imp->m_oneShotRecording = false;
|
|
|
|
if (!setDefaultInput(type))
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableSetDevice,
|
|
"Error to set the input device");
|
|
|
|
m_imp->insertAllRate();
|
|
TSoundTrackFormat fmt;
|
|
|
|
try {
|
|
fmt = getPreferredFormat(format);
|
|
if (fmt != format) {
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"Unsupported Format");
|
|
}
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
e.getMessage());
|
|
}
|
|
|
|
if (!m_imp->m_port) m_imp->doOpenDevice(format, type);
|
|
|
|
m_imp->m_currentFormat = format;
|
|
m_imp->m_isRecording = true;
|
|
m_imp->m_stopped = false;
|
|
m_imp->m_recordedSampleCount = 0;
|
|
|
|
int bytePerSample = format.m_bitPerSample >> 3;
|
|
switch (bytePerSample) {
|
|
case 3:
|
|
bytePerSample++;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
bytePerSample *= format.m_channelCount;
|
|
|
|
// far partire il thread
|
|
/*TRecordThread *recordThread = new TRecordThread(m_imp, bytePerSample);
|
|
if (!recordThread)
|
|
{
|
|
m_imp->m_isRecording = false;
|
|
m_imp->m_stopped = true;
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnablePrepare,
|
|
"Unable to create the recording thread");
|
|
}
|
|
recordThread->start();*/
|
|
m_imp->m_executor.addTask(new RecordTask(m_imp, bytePerSample));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundInputDevice::record(const TSoundTrackP &st,
|
|
TSoundInputDevice::Source type) {
|
|
if (m_imp->m_isRecording == true)
|
|
throw TSoundDeviceException(TSoundDeviceException::Busy,
|
|
"Just another recoding is in progress");
|
|
|
|
m_imp->m_recordedBlocks.clear();
|
|
m_imp->m_samplePerBlocks.clear();
|
|
|
|
if (!setDefaultInput(type))
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableSetDevice,
|
|
"Error to set the input device");
|
|
|
|
m_imp->insertAllRate();
|
|
TSoundTrackFormat fmt;
|
|
|
|
try {
|
|
fmt = getPreferredFormat(st->getFormat());
|
|
if (fmt != st->getFormat()) {
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"Unsupported Format");
|
|
}
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
e.getMessage());
|
|
}
|
|
|
|
if (!m_imp->m_port)
|
|
if (!m_imp->doOpenDevice(st->getFormat(), type))
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableOpenDevice,
|
|
"Unable to open input device");
|
|
|
|
// Sovrascive un'intera o parte di traccia gia' esistente
|
|
m_imp->m_oneShotRecording = true;
|
|
m_imp->m_currentFormat = st->getFormat();
|
|
m_imp->m_isRecording = true;
|
|
m_imp->m_stopped = false;
|
|
m_imp->m_recordedSampleCount = 0;
|
|
m_imp->m_st = st;
|
|
|
|
m_imp->m_recordedBlocks.push_back((char *)st->getRawData());
|
|
|
|
int totByteToSample = st->getSampleCount() * st->getSampleSize();
|
|
|
|
// far partire il thread
|
|
/*TRecordThread *recordThread = new TRecordThread(m_imp, totByteToSample);
|
|
if (!recordThread)
|
|
{
|
|
m_imp->m_isRecording = false;
|
|
m_imp->m_stopped = true;
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnablePrepare,
|
|
"Unable to create the recording thread");
|
|
}
|
|
recordThread->start();*/
|
|
m_imp->m_executor.addTask(new RecordTask(m_imp, totByteToSample));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundTrackP TSoundInputDevice::stop() {
|
|
TSoundTrackP st;
|
|
|
|
if (!m_imp->m_isRecording)
|
|
throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
|
|
"No recording process is in execution");
|
|
|
|
m_imp->m_isRecording = false;
|
|
|
|
alDiscardFrames(m_imp->m_port, alGetFilled(m_imp->m_port));
|
|
|
|
while (!m_imp->m_stopped) sginap(1);
|
|
|
|
if (m_imp->m_oneShotRecording)
|
|
st = m_imp->m_st;
|
|
else {
|
|
st = TSoundTrack::create(m_imp->m_currentFormat,
|
|
m_imp->m_recordedSampleCount);
|
|
TINT32 bytesCopied = 0;
|
|
|
|
for (int i = 0; i < (int)m_imp->m_recordedBlocks.size(); ++i) {
|
|
memcpy((void *)(st->getRawData() + bytesCopied),
|
|
m_imp->m_recordedBlocks[i], m_imp->m_samplePerBlocks[i]);
|
|
|
|
delete[] m_imp->m_recordedBlocks[i];
|
|
|
|
bytesCopied += m_imp->m_samplePerBlocks[i];
|
|
}
|
|
m_imp->m_samplePerBlocks.clear();
|
|
}
|
|
return st;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
double TSoundInputDevice::getVolume() {
|
|
ALpv pv[1];
|
|
ALfixed value[2];
|
|
|
|
try {
|
|
supportsVolume();
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
|
|
pv[0].param = AL_GAIN;
|
|
pv[0].value.ptr = value;
|
|
pv[0].sizeIn = 8;
|
|
alGetParams(AL_DEFAULT_INPUT, pv, 1);
|
|
|
|
double val =
|
|
(((alFixedToDouble(value[0]) + alFixedToDouble(value[1])) / 2.) + 60.) /
|
|
8.05;
|
|
return val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundInputDevice::setVolume(double volume) {
|
|
ALpv pv[1];
|
|
ALfixed value[2];
|
|
|
|
try {
|
|
supportsVolume();
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
|
|
double val = -60. + 8.05 * volume;
|
|
value[0] = alDoubleToFixed(val);
|
|
value[1] = alDoubleToFixed(val);
|
|
|
|
pv[0].param = AL_GAIN;
|
|
pv[0].value.ptr = value;
|
|
pv[0].sizeIn = 8;
|
|
alSetParams(AL_DEFAULT_INPUT, pv, 1);
|
|
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundInputDevice::supportsVolume() {
|
|
ALparamInfo pinfo;
|
|
int ret;
|
|
ret = alGetParamInfo(AL_DEFAULT_INPUT, AL_GAIN, &pinfo);
|
|
double min = alFixedToDouble(pinfo.min.ll);
|
|
double max = alFixedToDouble(pinfo.max.ll);
|
|
if ((ret != -1) && (min != max) && (max != 0.0))
|
|
return true;
|
|
else if ((ret == AL_BAD_PARAM) || ((min == max) && (max == 0.0)))
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
|
|
"It is impossible to chamge setting of volume");
|
|
else
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Output device is not accessible");
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundTrackFormat TSoundInputDevice::getPreferredFormat(ULONG sampleRate,
|
|
int channelCount,
|
|
int bitPerSample) {
|
|
TSoundTrackFormat fmt;
|
|
int ret;
|
|
|
|
if (!m_imp->verifyRate())
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"There isn't any support rate");
|
|
|
|
if (m_imp->m_supportedRate.find((int)sampleRate) ==
|
|
m_imp->m_supportedRate.end()) {
|
|
std::set<int>::iterator it =
|
|
m_imp->m_supportedRate.lower_bound((int)sampleRate);
|
|
if (it == m_imp->m_supportedRate.end()) {
|
|
it = std::max_element(m_imp->m_supportedRate.begin(),
|
|
m_imp->m_supportedRate.end());
|
|
if (it != m_imp->m_supportedRate.end())
|
|
sampleRate = *(m_imp->m_supportedRate.rbegin());
|
|
else
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"There isn't a supported rate");
|
|
} else
|
|
sampleRate = *it;
|
|
}
|
|
|
|
int value;
|
|
ALvalue vals[32];
|
|
if ((ret = alQueryValues(AL_DEFAULT_INPUT, AL_CHANNELS, vals, 32, 0, 0)) > 0)
|
|
for (int i = 0; i < ret; ++i) value = vals[i].i;
|
|
else if (oserror() == AL_BAD_PARAM)
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::NoMixer,
|
|
"It is impossible ask for the max nembers of channels supported");
|
|
else
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::NoMixer,
|
|
"It is impossibile information about ouput device");
|
|
|
|
if (value > 2) value = 2;
|
|
if (channelCount > value)
|
|
channelCount = value;
|
|
else if (channelCount <= 0)
|
|
channelCount = 1;
|
|
|
|
if (bitPerSample <= 8)
|
|
bitPerSample = 8;
|
|
else if (bitPerSample <= 16)
|
|
bitPerSample = 16;
|
|
else
|
|
bitPerSample = 24;
|
|
|
|
fmt.m_bitPerSample = bitPerSample;
|
|
fmt.m_channelCount = channelCount;
|
|
fmt.m_sampleRate = sampleRate;
|
|
fmt.m_signedSample = true;
|
|
|
|
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; }
|
|
|
|
//******************************************************************************
|
|
//******************************************************************************
|
|
// funzioni per l'interazione con
|
|
// la
|
|
// libreria
|
|
// audio
|
|
//******************************************************************************
|
|
//******************************************************************************
|
|
namespace {
|
|
bool isInterfaceSupported(int deviceType, int interfaceType) {
|
|
ALvalue vals[16];
|
|
int devNum;
|
|
|
|
if ((devNum = alQueryValues(AL_SYSTEM, deviceType, vals, 16, 0, 0)) > 0) {
|
|
int i;
|
|
for (i = 0; i < devNum; ++i) {
|
|
ALpv quals[2];
|
|
quals[0].param = AL_TYPE;
|
|
quals[0].value.i = interfaceType;
|
|
if (alQueryValues(vals[i].i, AL_INTERFACE, 0, 0, quals, 1) > 0)
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool setDefaultInput(TSoundInputDevice::Source type) {
|
|
string label;
|
|
|
|
switch (type) {
|
|
case TSoundInputDevice::LineIn:
|
|
label = "Line In";
|
|
break;
|
|
case TSoundInputDevice::DigitalIn:
|
|
label = "AES Input";
|
|
break;
|
|
default:
|
|
label = "Microphone";
|
|
}
|
|
|
|
int dev =
|
|
alGetResourceByName(AL_SYSTEM, (char *)label.c_str(), AL_DEVICE_TYPE);
|
|
if (!dev) return false; // throw TException("Error to set input device");
|
|
int itf;
|
|
if (itf = alGetResourceByName(AL_SYSTEM, (char *)label.c_str(),
|
|
AL_INTERFACE_TYPE)) {
|
|
ALpv p;
|
|
|
|
p.param = AL_INTERFACE;
|
|
p.value.i = itf;
|
|
if (alSetParams(dev, &p, 1) < 0 || p.sizeOut < 0)
|
|
return false; // throw TException("Error to set input device");
|
|
}
|
|
|
|
ALpv param;
|
|
|
|
param.param = AL_DEFAULT_INPUT;
|
|
param.value.i = dev;
|
|
if (alSetParams(AL_SYSTEM, ¶m, 1) < 0)
|
|
return false; // throw TException("Error to set input device");
|
|
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool setDefaultOutput() {
|
|
ALpv pvbuf[1];
|
|
|
|
if (!isInterfaceSupported(AL_DEFAULT_OUTPUT, AL_SPEAKER_IF_TYPE))
|
|
return false; // throw TException("Speakers are not supported");
|
|
|
|
int dev = alGetResourceByName(AL_SYSTEM, (char *)"Headphone/Speaker",
|
|
AL_DEVICE_TYPE);
|
|
if (!dev) return false; // throw TException("invalid device speakers");
|
|
|
|
pvbuf[0].param = AL_DEFAULT_OUTPUT;
|
|
pvbuf[0].value.i = dev;
|
|
alSetParams(AL_SYSTEM, pvbuf, 1);
|
|
|
|
// qui devo metterci gli altoparlanti e poi setto i valori per il default
|
|
// output
|
|
pvbuf[0].param = AL_INTERFACE;
|
|
pvbuf[0].value.i = AL_SPEAKER_IF_TYPE;
|
|
|
|
if (alSetParams(AL_DEFAULT_OUTPUT, pvbuf, 1) < 0)
|
|
return false; // throw TException("Unable to set output device params");
|
|
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// return the indexes of all input device of a particular type
|
|
list<int> getInputDevice(int deviceType) {
|
|
ALvalue vals[16];
|
|
ALpv quals[1];
|
|
list<int> devList;
|
|
int devNum;
|
|
|
|
quals[0].param = AL_TYPE;
|
|
quals[0].value.i = deviceType;
|
|
if ((devNum = alQueryValues(AL_SYSTEM, AL_DEFAULT_INPUT, vals, 16, quals,
|
|
1)) > 0) {
|
|
int i;
|
|
for (i = 0; i < devNum; ++i) {
|
|
int itf;
|
|
ALvalue val[16];
|
|
if ((itf = alQueryValues(i, AL_INTERFACE, val, 16, 0, 0)) > 0) {
|
|
int j;
|
|
for (j = 0; j < itf; ++j) devList.push_back(vals[j].i);
|
|
}
|
|
}
|
|
}
|
|
|
|
return devList;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// return the indexes of all input device of a particular type and interface
|
|
list<int> getInputDevice(int deviceType, int itfType) {
|
|
ALvalue vals[16];
|
|
ALpv quals[1];
|
|
list<int> devList;
|
|
int devNum;
|
|
|
|
quals[0].param = AL_TYPE;
|
|
quals[0].value.i = deviceType;
|
|
if ((devNum = alQueryValues(AL_SYSTEM, AL_DEFAULT_INPUT, vals, 16, quals,
|
|
1)) > 0) {
|
|
int i;
|
|
for (i = 0; i < devNum; ++i) {
|
|
int itf;
|
|
ALvalue val[16];
|
|
quals[0].param = AL_TYPE;
|
|
quals[0].value.i = itfType;
|
|
if ((itf = alQueryValues(i, AL_INTERFACE, val, 16, quals, 1)) > 0) {
|
|
int j;
|
|
for (j = 0; j < itf; ++j) devList.push_back(vals[j].i);
|
|
}
|
|
}
|
|
}
|
|
|
|
return devList;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
string getResourceLabel(int resourceID) {
|
|
ALpv par[1];
|
|
char l[32];
|
|
|
|
par[0].param = AL_LABEL;
|
|
par[0].value.ptr = l;
|
|
par[0].sizeIn = 32;
|
|
|
|
alGetParams(resourceID, par, 1);
|
|
|
|
return string(l);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// verify the samplerate of the select device is changed from another
|
|
// application
|
|
bool isChangeOutput(ULONG sampleRate) {
|
|
ALpv par[2];
|
|
char l[32];
|
|
|
|
par[0].param = AL_LABEL;
|
|
par[0].value.ptr = l;
|
|
par[0].sizeIn = 32;
|
|
par[1].param = AL_RATE;
|
|
|
|
alGetParams(AL_DEFAULT_OUTPUT, par, 2);
|
|
if ((strcmp(l, "Analog Out") != 0) ||
|
|
(alFixedToDouble(par[1].value.ll) != sampleRate))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|