diff --git a/toonz/sources/common/tsound/tsound_qt.cpp b/toonz/sources/common/tsound/tsound_qt.cpp
index 50caa62..fd1d64f 100644
--- a/toonz/sources/common/tsound/tsound_qt.cpp
+++ b/toonz/sources/common/tsound/tsound_qt.cpp
@@ -25,105 +25,38 @@ 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){};
+  struct Output {
+    QByteArray   *m_byteArray;
+    QBuffer      *m_buffer;
+    QAudioOutput *m_audioOutput;
+    explicit Output(): m_byteArray(), m_buffer(), m_audioOutput() { }
+  };
+
+private:
+  double m_volume;
+  bool m_looping;
+  QList<Output> m_outputs;
 
+public:
   std::set<TSoundOutputDeviceListener *> m_listeners;
 
-  ~TSoundOutputDeviceImp(){};
+  TSoundOutputDeviceImp(): m_volume(0.5), m_looping(false) {};
+  ~TSoundOutputDeviceImp() { stop(); }
 
-  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);
-};
+  double getVolume() { return m_volume; }
+  double isLooping() { return m_looping; }
+  void prepareVolume(double x) { m_volume = x; }
+  void setLooping(bool x) { m_looping = x; } // looping not implemented here yet
 
-//-----------------------------------------------------------------------------
-namespace {
+  void clearAudioOutputs(bool keepActive = false);
+  QAudioOutput* createAudioOutput(QAudioFormat &format);
+  bool isPlaying();
+  void setVolume(double x);
+  void stop();
 
-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) {}
+  void play(const TSoundTrackP &st, TINT32 s0, TINT32 s1, bool loop, bool scrubbing);
 };
 
-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) {
@@ -148,13 +81,6 @@ 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;
 }
 
@@ -162,18 +88,11 @@ bool TSoundOutputDevice::open(const TSoundTrackP &st) {
 
 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);
 }
@@ -196,37 +115,16 @@ void TSoundOutputDevice::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
     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;
+void TSoundOutputDeviceImp::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1, bool loop, bool scrubbing) {
+  clearAudioOutputs(true);
+  m_looping = loop;
 
   QAudioFormat format;
-  QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
-
   format.setSampleSize(st->getBitPerSample());
   format.setCodec("audio/pcm");
   format.setChannelCount(st->getChannelCount());
@@ -235,49 +133,69 @@ void TSoundOutputDeviceImp::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
                            ? 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);
+
+  QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
+  if (!info.isFormatSupported((format)))
+    format = info.nearestFormat(format);
+
+  Output output;
+  qint64 totalPacketCount = s1 - s0;
+  qint64 fileByteCount    = (s1 - s0) * st->getSampleSize();
+  char*  entireFileBuffer = new char[fileByteCount];
+  memcpy(entireFileBuffer, st->getRawData() + s0 * st->getSampleSize(), fileByteCount);
+  output.m_byteArray = new QByteArray(entireFileBuffer, fileByteCount);
+
+  output.m_buffer = new QBuffer();
+  output.m_buffer->setBuffer(output.m_byteArray);
+  output.m_buffer->open(QIODevice::ReadOnly);
+  output.m_buffer->seek(0);
+
+  output.m_audioOutput = new QAudioOutput(format);
+  output.m_audioOutput->start(output.m_buffer);
+  output.m_audioOutput->setVolume(m_volume);
+
+  m_outputs.push_back(output);
+}
+
+//------------------------------------------------------------------------------
+
+void TSoundOutputDeviceImp::clearAudioOutputs(bool keepActive) {
+  for(QList<Output>::iterator i = m_outputs.begin(); i != m_outputs.end(); ) {
+    if (!keepActive || i->m_audioOutput->state() != QAudio::ActiveState) {
+      delete i->m_audioOutput;
+      delete i->m_buffer;
+      delete i->m_byteArray;
+      i = m_outputs.erase(i);
+    } else ++i;
   }
-  m_audioOutput->start(newBuffer);
-  m_audioOutput->setVolume(m_volume);
 }
 
 //------------------------------------------------------------------------------
 
-bool TSoundOutputDeviceImp::doStopDevice() {
-  m_isPlaying = false;
-  m_audioOutput->stop();
+bool TSoundOutputDeviceImp::isPlaying() {
+  clearAudioOutputs(true);
+  return !m_outputs.empty();
+}
 
-  return true;
+//------------------------------------------------------------------------------
+
+void TSoundOutputDeviceImp::setVolume(double x) {
+  prepareVolume(x);
+  clearAudioOutputs(true);
+  for(QList<Output>::iterator i = m_outputs.begin(); i != m_outputs.end(); ++i)
+    i->m_audioOutput->setVolume(x);
 }
 
 //------------------------------------------------------------------------------
 
-void TSoundOutputDevice::stop() {
-  if (m_imp->m_opened == false) return;
+void TSoundOutputDeviceImp::stop() {
+  clearAudioOutputs();
+}
 
-  m_imp->doStopDevice();
+//------------------------------------------------------------------------------
+
+void TSoundOutputDevice::stop() {
+  m_imp->stop();
 }
 
 //------------------------------------------------------------------------------
@@ -295,16 +213,13 @@ void TSoundOutputDevice::detach(TSoundOutputDeviceListener *listener) {
 //------------------------------------------------------------------------------
 
 double TSoundOutputDevice::getVolume() {
-  if (m_imp->m_audioOutput != NULL)
-  return m_imp->m_audioOutput->volume();
-  else return m_imp->m_volume;
+  return m_imp->getVolume();
 }
 
 //------------------------------------------------------------------------------
 
 bool TSoundOutputDevice::setVolume(double volume) {
-  m_imp->m_volume = volume;
-  m_imp->m_audioOutput->setVolume(volume);
+  m_imp->setVolume(volume);
   return true;
 }
 
@@ -314,15 +229,15 @@ bool TSoundOutputDevice::supportsVolume() { return true; }
 
 //------------------------------------------------------------------------------
 
-bool TSoundOutputDevice::isPlaying() const { return m_imp->m_isPlaying; }
+bool TSoundOutputDevice::isPlaying() const { return m_imp->isPlaying(); }
 
 //------------------------------------------------------------------------------
 
-bool TSoundOutputDevice::isLooping() { return m_imp->m_looped; }
+bool TSoundOutputDevice::isLooping() { return m_imp->isLooping(); }
 
 //------------------------------------------------------------------------------
 
-void TSoundOutputDevice::setLooping(bool loop) { m_imp->m_looped = loop; }
+void TSoundOutputDevice::setLooping(bool loop) { m_imp->setLooping(loop); }
 
 //------------------------------------------------------------------------------