diff --git a/toonz/sources/common/tsound/tsound_mac.cpp b/toonz/sources/common/tsound/tsound_mac.cpp
deleted file mode 100644
index 50caa62..0000000
--- a/toonz/sources/common/tsound/tsound_mac.cpp
+++ /dev/null
@@ -1,477 +0,0 @@
-
-
-#include "tsound_t.h"
-#include "texception.h"
-#include "tthread.h"
-#include "tthreadmessage.h"
-
-#include <errno.h>
-#include <unistd.h>
-#include <queue>
-#include <set>
-
-#include <QByteArray>
-#include <QAudioFormat>
-#include <QBuffer>
-#include <QAudioOutput>
-
-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;
- double m_volume = 0.5;
-
- QAudioOutput *m_audioOutput;
- QBuffer *m_buffer;
-
- 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);
- void prepareVolume(double volume);
-};
-
-//-----------------------------------------------------------------------------
-namespace {
-
-struct MyData {
- char *entireFileBuffer;
-
- quint64 totalPacketCount;
- quint64 fileByteCount;
- quint32 maxPacketSize;
- quint64 packetOffset;
- quint64 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); \
- }
-
-bool TSoundOutputDeviceImp::doOpenDevice() {
- m_opened = false;
- m_audioOutput = NULL;
- m_opened = true;
- return m_opened;
-}
-
-bool TSoundOutputDeviceImp::doSetStreamFormat(const TSoundTrackFormat &format) {
- if (!m_opened) doOpenDevice();
- if (!m_opened) return false;
- 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;
- return true;
-}
-
-//------------------------------------------------------------------------------
-
-void TSoundOutputDeviceImp::prepareVolume(double volume) {
- m_volume = volume;
-}
-
-//------------------------------------------------------------------------------
-
-void TSoundOutputDevice::prepareVolume(double volume) {
- m_imp->prepareVolume(volume);
-}
-
-//------------------------------------------------------------------------------
-
-void TSoundOutputDevice::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
- bool loop, bool scrubbing) {
- 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;
-
- MyData *myData = new MyData();
-
- myData->imp = shared_from_this();
- myData->totalPacketCount = s1 - s0;
- myData->fileByteCount = (s1 - s0) * st->getSampleSize();
- myData->entireFileBuffer = new char[myData->fileByteCount];
-
- memcpy(myData->entireFileBuffer, st->getRawData() + s0 * st->getSampleSize(),
- myData->fileByteCount);
-
- m_isPlaying = true;
- myData->isLooping = loop;
-
- QAudioFormat format;
- QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
-
- format.setSampleSize(st->getBitPerSample());
- format.setCodec("audio/pcm");
- format.setChannelCount(st->getChannelCount());
- format.setByteOrder(QAudioFormat::LittleEndian);
- format.setSampleType(st->getFormat().m_signedSample
- ? QAudioFormat::SignedInt
- : QAudioFormat::UnSignedInt);
- format.setSampleRate(st->getSampleRate());
- QList<QAudioFormat::Endian> sbos = info.supportedByteOrders();
- QList<int> sccs = info.supportedChannelCounts();
- QList<int> ssrs = info.supportedSampleRates();
- QList<QAudioFormat::SampleType> sstypes = info.supportedSampleTypes();
- QList<int> ssss = info.supportedSampleSizes();
- QStringList supCodes = info.supportedCodecs();
- if (!info.isFormatSupported((format))) {
- format = info.nearestFormat(format);
- int newChannels = format.channelCount();
- int newBitsPerSample = format.sampleSize();
- int newSampleRate = format.sampleRate();
- QAudioFormat::SampleType newSampleType = format.sampleType();
- QAudioFormat::Endian newBo = format.byteOrder();
- }
- int test = st->getSampleCount() / st->getSampleRate();
- QByteArray *data =
- new QByteArray(myData->entireFileBuffer, myData->fileByteCount);
- QBuffer *newBuffer = new QBuffer;
- newBuffer->setBuffer(data);
- newBuffer->open(QIODevice::ReadOnly);
- newBuffer->seek(0);
- if (m_audioOutput == NULL) {
- m_audioOutput = new QAudioOutput(format, NULL);
- }
- m_audioOutput->start(newBuffer);
- m_audioOutput->setVolume(m_volume);
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDeviceImp::doStopDevice() {
- m_isPlaying = false;
- m_audioOutput->stop();
-
- return true;
-}
-
-//------------------------------------------------------------------------------
-
-void TSoundOutputDevice::stop() {
- if (m_imp->m_opened == false) return;
-
- 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_audioOutput != NULL)
- return m_imp->m_audioOutput->volume();
- else return m_imp->m_volume;
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::setVolume(double volume) {
- m_imp->m_volume = volume;
- m_imp->m_audioOutput->setVolume(volume);
- return true;
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::supportsVolume() { return true; }
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::isPlaying() const { return m_imp->m_isPlaying; }
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::isLooping() { return m_imp->m_looped; }
-
-//------------------------------------------------------------------------------
-
-void TSoundOutputDevice::setLooping(bool loop) { 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) {
- return getPreferredFormat(format.m_sampleRate, format.m_channelCount,
- format.m_bitPerSample);
-}
-
-//==============================================================================
-//==============================================================================
-// 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; }
diff --git a/toonz/sources/common/tsound/tsound_qt.cpp b/toonz/sources/common/tsound/tsound_qt.cpp
new file mode 100644
index 0000000..50caa62
--- /dev/null
+++ b/toonz/sources/common/tsound/tsound_qt.cpp
@@ -0,0 +1,477 @@
+
+
+#include "tsound_t.h"
+#include "texception.h"
+#include "tthread.h"
+#include "tthreadmessage.h"
+
+#include <errno.h>
+#include <unistd.h>
+#include <queue>
+#include <set>
+
+#include <QByteArray>
+#include <QAudioFormat>
+#include <QBuffer>
+#include <QAudioOutput>
+
+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;
+ double m_volume = 0.5;
+
+ QAudioOutput *m_audioOutput;
+ QBuffer *m_buffer;
+
+ 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);
+ void prepareVolume(double volume);
+};
+
+//-----------------------------------------------------------------------------
+namespace {
+
+struct MyData {
+ char *entireFileBuffer;
+
+ quint64 totalPacketCount;
+ quint64 fileByteCount;
+ quint32 maxPacketSize;
+ quint64 packetOffset;
+ quint64 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); \
+ }
+
+bool TSoundOutputDeviceImp::doOpenDevice() {
+ m_opened = false;
+ m_audioOutput = NULL;
+ m_opened = true;
+ return m_opened;
+}
+
+bool TSoundOutputDeviceImp::doSetStreamFormat(const TSoundTrackFormat &format) {
+ if (!m_opened) doOpenDevice();
+ if (!m_opened) return false;
+ 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;
+ return true;
+}
+
+//------------------------------------------------------------------------------
+
+void TSoundOutputDeviceImp::prepareVolume(double volume) {
+ m_volume = volume;
+}
+
+//------------------------------------------------------------------------------
+
+void TSoundOutputDevice::prepareVolume(double volume) {
+ m_imp->prepareVolume(volume);
+}
+
+//------------------------------------------------------------------------------
+
+void TSoundOutputDevice::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
+ bool loop, bool scrubbing) {
+ 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;
+
+ MyData *myData = new MyData();
+
+ myData->imp = shared_from_this();
+ myData->totalPacketCount = s1 - s0;
+ myData->fileByteCount = (s1 - s0) * st->getSampleSize();
+ myData->entireFileBuffer = new char[myData->fileByteCount];
+
+ memcpy(myData->entireFileBuffer, st->getRawData() + s0 * st->getSampleSize(),
+ myData->fileByteCount);
+
+ m_isPlaying = true;
+ myData->isLooping = loop;
+
+ QAudioFormat format;
+ QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
+
+ format.setSampleSize(st->getBitPerSample());
+ format.setCodec("audio/pcm");
+ format.setChannelCount(st->getChannelCount());
+ format.setByteOrder(QAudioFormat::LittleEndian);
+ format.setSampleType(st->getFormat().m_signedSample
+ ? QAudioFormat::SignedInt
+ : QAudioFormat::UnSignedInt);
+ format.setSampleRate(st->getSampleRate());
+ QList<QAudioFormat::Endian> sbos = info.supportedByteOrders();
+ QList<int> sccs = info.supportedChannelCounts();
+ QList<int> ssrs = info.supportedSampleRates();
+ QList<QAudioFormat::SampleType> sstypes = info.supportedSampleTypes();
+ QList<int> ssss = info.supportedSampleSizes();
+ QStringList supCodes = info.supportedCodecs();
+ if (!info.isFormatSupported((format))) {
+ format = info.nearestFormat(format);
+ int newChannels = format.channelCount();
+ int newBitsPerSample = format.sampleSize();
+ int newSampleRate = format.sampleRate();
+ QAudioFormat::SampleType newSampleType = format.sampleType();
+ QAudioFormat::Endian newBo = format.byteOrder();
+ }
+ int test = st->getSampleCount() / st->getSampleRate();
+ QByteArray *data =
+ new QByteArray(myData->entireFileBuffer, myData->fileByteCount);
+ QBuffer *newBuffer = new QBuffer;
+ newBuffer->setBuffer(data);
+ newBuffer->open(QIODevice::ReadOnly);
+ newBuffer->seek(0);
+ if (m_audioOutput == NULL) {
+ m_audioOutput = new QAudioOutput(format, NULL);
+ }
+ m_audioOutput->start(newBuffer);
+ m_audioOutput->setVolume(m_volume);
+}
+
+//------------------------------------------------------------------------------
+
+bool TSoundOutputDeviceImp::doStopDevice() {
+ m_isPlaying = false;
+ m_audioOutput->stop();
+
+ return true;
+}
+
+//------------------------------------------------------------------------------
+
+void TSoundOutputDevice::stop() {
+ if (m_imp->m_opened == false) return;
+
+ 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_audioOutput != NULL)
+ return m_imp->m_audioOutput->volume();
+ else return m_imp->m_volume;
+}
+
+//------------------------------------------------------------------------------
+
+bool TSoundOutputDevice::setVolume(double volume) {
+ m_imp->m_volume = volume;
+ m_imp->m_audioOutput->setVolume(volume);
+ return true;
+}
+
+//------------------------------------------------------------------------------
+
+bool TSoundOutputDevice::supportsVolume() { return true; }
+
+//------------------------------------------------------------------------------
+
+bool TSoundOutputDevice::isPlaying() const { return m_imp->m_isPlaying; }
+
+//------------------------------------------------------------------------------
+
+bool TSoundOutputDevice::isLooping() { return m_imp->m_looped; }
+
+//------------------------------------------------------------------------------
+
+void TSoundOutputDevice::setLooping(bool loop) { 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) {
+ return getPreferredFormat(format.m_sampleRate, format.m_channelCount,
+ format.m_bitPerSample);
+}
+
+//==============================================================================
+//==============================================================================
+// 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; }
diff --git a/toonz/sources/common/tsound/tsound_sdl.cpp b/toonz/sources/common/tsound/tsound_sdl.cpp
deleted file mode 100644
index c5473ca..0000000
--- a/toonz/sources/common/tsound/tsound_sdl.cpp
+++ /dev/null
@@ -1,551 +0,0 @@
-
-#include "tsound_t.h"
-#include "texception.h"
-#include "tthread.h"
-#include "tthreadmessage.h"
-
-#include <errno.h>
-#include <unistd.h>
-#include <queue>
-#include <set>
-
-#include <SDL2/SDL.h>
-using namespace std;
-
-//==============================================================================
-namespace {
-TThread::Mutex MutexOut;
-}
-
-namespace {
-
-struct MyData {
- char *entireFileBuffer;
-
- int totalPacketCount;
- int fileByteCount;
- // UInt32 maxPacketSize;
- // UInt64 packetOffset;
- int byteOffset;
- bool m_doNotify;
-
- void *sourceBuffer;
- // AudioConverterRef converter;
- TSoundOutputDeviceImp *imp;
- bool isLooping;
- MyData()
- : entireFileBuffer(0)
- , totalPacketCount(0)
- , fileByteCount(0)
- , /*maxPacketSize(0), packetOffset(0),*/ byteOffset(0)
- , sourceBuffer(0)
- , isLooping(false)
- , imp(0)
- , m_doNotify(true) {}
-};
-}
-
-class TSoundOutputDeviceImp {
-public:
- bool m_isPlaying;
- bool m_looped;
- TSoundTrackFormat m_currentFormat;
- std::set<int> m_supportedRate;
- bool m_opened;
- struct MyData *m_data;
- int m_volume;
-
- TSoundOutputDeviceImp()
- : m_isPlaying(false)
- , m_looped(false)
- , m_supportedRate()
- , m_opened(false)
- , m_data(NULL)
- , m_volume(SDL_MIX_MAXVOLUME){};
-
- std::set<TSoundOutputDeviceListener *> m_listeners;
-
- ~TSoundOutputDeviceImp(){};
-
- bool doOpenDevice(const TSoundTrackFormat &format);
- bool doStopDevice();
- void play(const TSoundTrackP &st, TINT32 s0, TINT32 s1, bool loop,
- bool scrubbing);
-};
-
-//-----------------------------------------------------------------------------
-namespace {
-
-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;
- std::set<TSoundOutputDeviceListener *>::iterator it =
- m_data->imp->m_listeners.begin();
- for (; it != m_data->imp->m_listeners.end(); ++it)
- (*it)->onPlayCompleted();
- if (m_data->imp->m_isPlaying) m_data->imp->doStopDevice();
- }
- }
-};
-}
-
-#define checkStatus(err) \
- if (err) { \
- printf("Error: 0x%x -> %s: %d\n", (int)err, __FILE__, __LINE__); \
- fflush(stdout); \
- }
-
-extern "C" {
-
-static void sdl_fill_audio(void *udata, Uint8 *stream, int len) {
- TSoundOutputDeviceImp *_this = (TSoundOutputDeviceImp *)udata;
- MyData *myData = _this->m_data;
-
- /* Only play if we have data left */
- if (myData == NULL) return;
- {
- // TThread::ScopedLock sl(MutexOut);
- if (myData->imp->m_isPlaying == false) return;
- }
-
- int audio_len = myData->fileByteCount - myData->byteOffset;
- if (audio_len <= 0) {
- delete[] myData->entireFileBuffer;
- myData->entireFileBuffer = 0;
-#if 0
- {
- TThread::ScopedLock sl(MutexOut);
- *(myData->isPlaying) = false; //questo lo faccio nel main thread
- }
-#endif
- PlayCompletedMsg(myData).send();
- return;
- }
-
- /* Mix as much data as possible */
- len = min(audio_len, len);
- SDL_memset(stream, 0, len);
- SDL_MixAudio(stream, (Uint8 *)myData->entireFileBuffer + myData->byteOffset,
- len, _this->m_volume);
- myData->byteOffset += len;
-}
-
-} // extern "C"
-
-bool TSoundOutputDeviceImp::doOpenDevice(const TSoundTrackFormat &format) {
- SDL_AudioSpec wanted;
-
- static bool first = true; // TODO: should be shared with InputDevice
- if (first) {
- SDL_Init(SDL_INIT_AUDIO);
- first = false;
- }
-
- if (m_opened) {
- SDL_CloseAudio();
- // we'll just reopen right away
- }
-
- wanted.freq = format.m_sampleRate;
- switch (format.m_bitPerSample) {
- case 8:
- wanted.format = AUDIO_S8;
- break;
- case 16:
- wanted.format = AUDIO_S16;
- break;
- default:
- throw TSoundDeviceException(TSoundDeviceException::UnableOpenDevice,
- "invalid bits per sample");
- return false;
- }
- wanted.channels = format.m_channelCount; /* 1 = mono, 2 = stereo */
- wanted.samples = 1024; /* Good low-latency value for callback */
- wanted.callback = sdl_fill_audio;
- wanted.userdata = this;
-
- /* Open the audio device, forcing the desired format */
- if (SDL_OpenAudio(&wanted, NULL) < 0) {
- std::string msg("Couldn't open audio: ");
- msg += SDL_GetError();
- throw TSoundDeviceException(TSoundDeviceException::UnableOpenDevice, msg);
- return false;
- }
-
- m_opened = true;
- return m_opened;
-}
-
-//==============================================================================
-
-TSoundOutputDevice::TSoundOutputDevice() : m_imp(new TSoundOutputDeviceImp) {
-#if 0
- try {
- supportsVolume();
- } catch (TSoundDeviceException &e) {
- throw TSoundDeviceException(e.getType(), e.getMessage());
- }
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-TSoundOutputDevice::~TSoundOutputDevice() {
- stop();
- close();
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::installed() { return true; }
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::open(const TSoundTrackP &st) {
- if (!m_imp->doOpenDevice(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;
- 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 (!doOpenDevice(st->getFormat())) return;
-
- MyData *myData = new MyData();
-
- myData->imp = this;
- myData->totalPacketCount = s1 - s0;
- myData->fileByteCount = (s1 - s0) * st->getSampleSize();
- myData->entireFileBuffer = new char[myData->fileByteCount];
-
- memcpy(myData->entireFileBuffer, st->getRawData() + s0 * st->getSampleSize(),
- myData->fileByteCount);
-
- // 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;
-
- m_data = myData;
- SDL_PauseAudio(0);
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDeviceImp::doStopDevice() {
- SDL_PauseAudio(1);
- m_isPlaying = false;
- delete m_data;
- m_data = NULL;
- SDL_CloseAudio();
- m_opened = false;
- 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);
-}
-
-#if 0
-//------------------------------------------------------------------------------
-
-double TSoundOutputDevice::getVolume()
-{
- if (!m_imp->m_opened)
- m_imp->doOpenDevice();
-
- double vol = m_volume / SDL_MIX_MAXVOLUME;
-
- return (vol < 0. ? 0. : vol);
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::setVolume(double volume)
-{
- Float32 vol = volume;
-
- m_imp->m_volume = (int)(volume * SDL_MIX_MAXVOLUME);
- return true;
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::supportsVolume()
-{
- return true;
-}
-
-#endif
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::isPlaying() const {
- // TThread::ScopedLock sl(MutexOut);
- // TODO: handle actually queuing items?
- return m_imp->m_isPlaying;
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::isAllQueuedItemsPlayed() {
- // TThread::ScopedLock sl(MutexOut);
- return m_imp->m_data == NULL;
-}
-
-//------------------------------------------------------------------------------
-
-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) {
- if (bitPerSample > 16) bitPerSample = 16;
- // not sure SDL supports more than 2 channels
- if (channelCount > 2) channelCount = 2;
- TSoundTrackFormat fmt(sampleRate, bitPerSample, channelCount, true);
- return fmt;
-}
-
-//------------------------------------------------------------------------------
-
-TSoundTrackFormat TSoundOutputDevice::getPreferredFormat(
- const TSoundTrackFormat &format) {
-#if 0
- try {
-#endif
- return getPreferredFormat(format.m_sampleRate, format.m_channelCount,
- format.m_bitPerSample);
-#if 0
- }
- catch (TSoundDeviceException &e) {
- throw TSoundDeviceException( e.getType(), e.getMessage());
- }
-#endif
-}
-
-//==============================================================================
-//==============================================================================
-// 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() {
-#if 0
- if(m_imp->m_port)
- alClosePort(m_imp->m_port);
- delete m_imp;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundInputDevice::installed() {
-#if 0
- if (alQueryValues(AL_SYSTEM, AL_DEFAULT_INPUT, 0, 0, 0, 0) <= 0)
- return false;
-#endif
- 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) {
-#if 0
- try {
-#endif
- return getPreferredFormat(format.m_sampleRate, format.m_channelCount,
- format.m_bitPerSample);
-#if 0
- }
- catch (TSoundDeviceException &e) {
- throw TSoundDeviceException( e.getType(), e.getMessage());
- }
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundInputDevice::isRecording() { return m_imp->m_isRecording; }
diff --git a/toonz/sources/common/tsound/tsound_x.cpp b/toonz/sources/common/tsound/tsound_x.cpp
deleted file mode 100644
index 120acca..0000000
--- a/toonz/sources/common/tsound/tsound_x.cpp
+++ /dev/null
@@ -1,1294 +0,0 @@
-
-
-#include "tsound_t.h"
-#include "texception.h"
-#include "tthread.h"
-
-#include <errno.h>
-#ifdef __sgi
-#include <audio.h>
-#endif
-#include <unistd.h>
-#include <queue>
-#include <set>
-
-#ifndef __sgi
-// Warning, this file is for SGI currently,
-// otherwise we just stub out the functions.
-typedef unsigned long ULONG;
-typedef void *ALport;
-typedef void *ALvalue;
-typedef void *ALpv;
-#endif
-
-// 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();
-};
-
-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;
-}
-
-bool TSoundOutputDeviceImp::doOpenDevice(const TSoundTrackFormat &format) {
-#ifdef __sgi
- 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;
-#else
- return false;
-#endif
-}
-
-//-----------------------------------------------------------------------------
-
-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() {
-#ifdef __sgi
- // 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;
-#endif
- 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() {
-#ifdef __sgi
- 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();
- }
-#endif
-}
-
-//==============================================================================
-
-TSoundOutputDevice::TSoundOutputDevice() : m_imp(new TSoundOutputDeviceImp) {
-#ifdef __sgi
- if (!setDefaultOutput())
- throw TSoundDeviceException(TSoundDeviceException::UnableSetDevice,
- "Speaker not supported");
- try {
- supportsVolume();
- } catch (TSoundDeviceException &e) {
- throw TSoundDeviceException(e.getType(), e.getMessage());
- }
- m_imp->insertAllRate();
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-TSoundOutputDevice::~TSoundOutputDevice() {
- close();
- delete m_imp;
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::installed() {
-#ifdef __sgi
- if (alQueryValues(AL_SYSTEM, AL_DEFAULT_OUTPUT, 0, 0, 0, 0) <= 0)
- return false;
-#endif
- 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() {
-#ifdef __sgi
- stop();
- if (m_imp->m_port) alClosePort(m_imp->m_port);
- m_imp->m_port = NULL;
-#endif
- return true;
-}
-
-//------------------------------------------------------------------------------
-
-void TSoundOutputDevice::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
- bool loop, bool scrubbing) {
-#ifdef __sgi
- 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);
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-void TSoundOutputDevice::stop() {
-#ifdef __sgi
- 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;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-#if 0
-double TSoundOutputDevice::getVolume() {
-#ifdef __sgi
- 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;
-#else
- return 0.0f;
-#endif
-}
-#endif
-
-//------------------------------------------------------------------------------
-
-#if 0
-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;
-}
-#endif
-
-//------------------------------------------------------------------------------
-
-#if 0
-bool TSoundOutputDevice::supportsVolume()
-{
-#ifdef __sgi
- 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");
-#else
- return true;
-#endif
-}
-#endif
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::isPlaying() const { return m_imp->m_isPlaying; }
-
-//------------------------------------------------------------------------------
-
-bool TSoundOutputDevice::isLooping() {
-#ifdef __sgi
- TThread::ScopedLock sl(m_imp->m_mutex);
- return m_imp->m_looped;
-#else
- return false;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-void TSoundOutputDevice::setLooping(bool loop) {
-#ifdef __sgi
- TThread::ScopedLock sl(m_imp->m_mutex);
- m_imp->m_looped = loop;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-TSoundTrackFormat TSoundOutputDevice::getPreferredFormat(TUINT32 sampleRate,
- int channelCount,
- int bitPerSample) {
- TSoundTrackFormat fmt;
-#ifdef __sgi
- 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;
-#endif
-
- 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) {
-#ifdef __sgi
- 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);
-#endif
- 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() {
-#ifdef __sgi
- // 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;
-#endif
- 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() {
-#ifdef __sgi
- 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;
-#endif
-}
-
-//==============================================================================
-
-TSoundInputDevice::TSoundInputDevice() : m_imp(new TSoundInputDeviceImp) {}
-
-//------------------------------------------------------------------------------
-
-TSoundInputDevice::~TSoundInputDevice() {
-#ifdef __sgi
- if (m_imp->m_port) alClosePort(m_imp->m_port);
-#endif
- delete m_imp;
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundInputDevice::installed() {
-#ifdef __sgi
- if (alQueryValues(AL_SYSTEM, AL_DEFAULT_INPUT, 0, 0, 0, 0) <= 0) return false;
-#endif
- 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;
-#ifdef __sgi
- 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();
- }
-#endif
- return st;
-}
-
-//------------------------------------------------------------------------------
-
-double TSoundInputDevice::getVolume() {
-#ifdef __sgi
- 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;
-#else
- return 0.0f;
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundInputDevice::setVolume(double volume) {
-#ifdef __sgi
- 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);
-#endif
- return true;
-}
-
-//------------------------------------------------------------------------------
-
-bool TSoundInputDevice::supportsVolume() {
-#ifdef __sgi
- 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");
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-TSoundTrackFormat TSoundInputDevice::getPreferredFormat(TUINT32 sampleRate,
- int channelCount,
- int bitPerSample) {
- TSoundTrackFormat fmt;
-#ifdef __sgi
- 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;
-#endif
- 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) {
-#ifdef __sgi
- 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;
- }
- }
-#endif
- return false;
-}
-
-//------------------------------------------------------------------------------
-
-bool setDefaultInput(TSoundInputDevice::Source type) {
-#ifdef __sgi
- 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");
-#endif
- return true;
-}
-
-//------------------------------------------------------------------------------
-
-bool setDefaultOutput() {
-#ifdef __sgi
- 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");
-#endif
- 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;
-#ifdef __sgi
- 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);
- }
- }
- }
-#endif
- 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;
-#ifdef __sgi
-
- 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);
- }
- }
- }
-#endif
- return devList;
-}
-
-//------------------------------------------------------------------------------
-
-string getResourceLabel(int resourceID) {
-#ifdef __sgi
- 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);
-#else
- return "";
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-// verify the samplerate of the select device is changed from another
-// application
-bool isChangeOutput(ULONG sampleRate) {
-#ifdef __sgi
- 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;
-#else
- return true;
-#endif
-}
-}
diff --git a/toonz/sources/include/tsound.h b/toonz/sources/include/tsound.h
index f635fa9..b75b150 100644
--- a/toonz/sources/include/tsound.h
+++ b/toonz/sources/include/tsound.h
@@ -372,7 +372,7 @@ Returns true if on the machine there is an audio card installed correctly
bool isFormatSupported(const TSoundTrackFormat &);
-#ifdef MACOSX
+#ifndef _WIN32
//! Returns true if is possible to change volume setting on current input
//! interface
bool supportsVolume();
@@ -412,7 +412,7 @@ interaction between sound and mouse
//! Returns if the device is busy with a playback
bool isPlaying() const;
-#ifndef MACOSX
+#ifdef _WIN32
//! Return true if the playback of all soundtracks is ended.
bool isAllQueuedItemsPlayed();
#endif
diff --git a/toonz/sources/tnzcore/CMakeLists.txt b/toonz/sources/tnzcore/CMakeLists.txt
index a46db6d..16603f9 100644
--- a/toonz/sources/tnzcore/CMakeLists.txt
+++ b/toonz/sources/tnzcore/CMakeLists.txt
@@ -252,18 +252,12 @@ if(BUILD_TARGET_WIN)
)
elseif(BUILD_TARGET_APPLE)
set(SOURCES ${SOURCES}
- ../common/tsound/tsound_mac.cpp
+ ../common/tsound/tsound_qt.cpp
)
elseif(BUILD_TARGET_UNIX)
- if(SDL_LIB_FOUND)
- set(SOURCES ${SOURCES}
- ../common/tsound/tsound_sdl.cpp
- )
- else()
- set(SOURCES ${SOURCES}
- ../common/tsound/tsound_x.cpp
- )
- endif()
+ set(SOURCES ${SOURCES}
+ ../common/tsound/tsound_qt.cpp
+ )
endif()
add_translation(tnzcore ${HEADERS} ${SOURCES})
diff --git a/toonz/sources/toonzlib/txshsoundcolumn.cpp b/toonz/sources/toonzlib/txshsoundcolumn.cpp
index 98c2265..63a9474 100644
--- a/toonz/sources/toonzlib/txshsoundcolumn.cpp
+++ b/toonz/sources/toonzlib/txshsoundcolumn.cpp
@@ -788,7 +788,7 @@ void TXshSoundColumn::updateFrameRate(double fps) {
void TXshSoundColumn::setVolume(double value) {
m_volume = tcrop<double>(value, 0.0, 1.0);
if (m_player && m_player->isPlaying())
-#ifdef MACOSX
+#ifndef _WIN32
m_player->setVolume(m_volume);
#else
stop();
@@ -808,7 +808,7 @@ void TXshSoundColumn::play(TSoundTrackP soundtrack, int s0, int s1, bool loop) {
if (m_player) {
try {
-#ifdef MACOSX
+#ifndef _WIN32
m_player->prepareVolume(m_volume);
TSoundTrackP mixedTrack = soundtrack;
#else
@@ -818,7 +818,7 @@ void TXshSoundColumn::play(TSoundTrackP soundtrack, int s0, int s1, bool loop) {
#endif
m_player->play(mixedTrack, s0, s1, loop);
m_currentPlaySoundTrack = mixedTrack;
-#ifndef MACOSX
+#ifdef _WIN32
m_timer.start();
#endif
} catch (TSoundDeviceException &) {
@@ -934,7 +934,7 @@ void TXshSoundColumn::clear() {
//-----------------------------------------------------------------------------
void TXshSoundColumn::onTimerOut() {
-#ifndef MACOSX
+#ifdef _WIN32
if (m_player && m_player->isAllQueuedItemsPlayed()) stop();
#endif
}
@@ -1002,7 +1002,7 @@ TSoundTrackP TXshSoundColumn::getOverallSoundTrack(int fromFrame, int toFrame,
// We prefer to have 22050 as a maximum sampleRate (to avoid crashes or
// another issues)
-#ifndef MACOSX
+#ifdef _WIN32
if (format.m_sampleRate >= 44100) format.m_sampleRate = 22050;
#else
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());