1 files changed, 165 insertions, 116 deletions

diff --git a/src/aomusicplayer.cpp b/src/aomusicplayer.cpp
index 3f7c43ee..4265a463 100644
--- a/src/aomusicplayer.cpp
+++ b/src/aomusicplayer.cpp
@@ -1,77 +1,99 @@
 #include "aomusicplayer.h"
-#include "options.h"
 
-#include "bass.h"
 #include "file_functions.h"
+#include "options.h"
 
-AOMusicPlayer::AOMusicPlayer(QWidget *parent, AOApplication *p_ao_app)
-{
-  m_parent = parent;
-  ao_app = p_ao_app;
-}
+#include <bass.h>
+
+#include <QDebug>
+#include <QFuture>
+#include <QWidget>
+
+AOMusicPlayer::AOMusicPlayer(AOApplication *ao_app)
+    : ao_app(ao_app)
+{}
 
 AOMusicPlayer::~AOMusicPlayer()
 {
-  for (int n_stream = 0; n_stream < m_channelmax; ++n_stream) {
+  for (int n_stream = 0; n_stream < STREAM_COUNT; ++n_stream)
+  {
     BASS_ChannelStop(m_stream_list[n_stream]);
   }
 }
 
-QString AOMusicPlayer::play(QString p_song, int channel, bool loop,
-                         int effect_flags)
+QString AOMusicPlayer::playStream(QString song, int streamId, bool loopEnabled, int effectFlags)
 {
-  channel = channel % m_channelmax;
-  if (channel < 0) // wtf?
+  if (!ensureValidStreamId(streamId))
+  {
     return "[ERROR] Invalid Channel";
-  unsigned int flags = BASS_STREAM_PRESCAN | BASS_STREAM_AUTOFREE |
-                       BASS_UNICODE | BASS_ASYNCFILE;
-  unsigned int streaming_flags = BASS_STREAM_AUTOFREE;
-  if (loop) {
+  }
+
+  quint32 flags = BASS_STREAM_AUTOFREE;
+  if (loopEnabled)
+  {
     flags |= BASS_SAMPLE_LOOP;
-    streaming_flags |= BASS_SAMPLE_LOOP;
   }
-  QString f_path = p_song;
-  DWORD newstream;
-  if (f_path.startsWith("http")) {
 
-    if (!Options::getInstance().streamingEnabled()) {
-        BASS_ChannelStop(m_stream_list[channel]);
-        return QObject::tr("[MISSING] Streaming disabled.");
+  QString f_path = song;
+  DWORD newstream;
+  if (f_path.startsWith("http"))
+  {
+    if (!Options::getInstance().streamingEnabled())
+    {
+      BASS_ChannelStop(m_stream_list[streamId]);
+      return QObject::tr("[MISSING] Streaming disabled.");
     }
     QUrl l_url = QUrl(f_path);
-    newstream = BASS_StreamCreateURL(l_url.toEncoded().toStdString().c_str(), 0, streaming_flags, nullptr, 0);
+    newstream = BASS_StreamCreateURL(l_url.toEncoded().toStdString().c_str(), 0, flags, nullptr, 0);
   }
-  else {
-    f_path = ao_app->get_real_path(ao_app->get_music_path(p_song));
-    if (f_path.endsWith(".mo3") || f_path.endsWith(".xm") || f_path.endsWith(".mod") || f_path.endsWith(".s3m") || f_path.endsWith(".it") || f_path.endsWith(".mtm") || f_path.endsWith(".umx") )
-      newstream = BASS_MusicLoad(FALSE,f_path.utf16(), 0, 0, flags, 1);
+  else
+  {
+    flags |= BASS_STREAM_PRESCAN | BASS_UNICODE | BASS_ASYNCFILE;
+
+    f_path = ao_app->get_real_path(ao_app->get_music_path(song));
+
+    QString extension = f_path.split('.').last();
+    static const QStringList VALID_EXTENSION_LIST{"mo3", "xm", "mod", "s3m", "it", "mtm", "umx"};
+    if (VALID_EXTENSION_LIST.contains(extension, Qt::CaseInsensitive))
+    {
+      newstream = BASS_MusicLoad(FALSE, f_path.utf16(), 0, 0, flags, 1);
+    }
     else
+    {
       newstream = BASS_StreamCreateFile(FALSE, f_path.utf16(), 0, 0, flags);
+    }
   }
 
-  int error_code = BASS_ErrorGetCode();
-
+  int error = BASS_ErrorGetCode();
   if (Options::getInstance().audioOutputDevice() != "default")
-    BASS_ChannelSetDevice(m_stream_list[channel], BASS_GetDevice());
+  {
+    BASS_ChannelSetDevice(m_stream_list[streamId], BASS_GetDevice());
+  }
 
-  QString d_path = f_path + ".txt";
+  m_loop_start[streamId] = 0;
+  m_loop_end[streamId] = 0;
 
-  loop_start[channel] = 0;
-  loop_end[channel] = 0;
-  if (loop && file_exists(d_path)) // Contains loop/etc. information file
+  QString d_path = f_path + ".txt";
+  if (loopEnabled && file_exists(d_path)) // Contains loop/etc. information file
   {
     QStringList lines = ao_app->read_file(d_path).split("\n");
     bool seconds_mode = false;
-    foreach (QString line, lines) {
+    foreach (QString line, lines)
+    {
       QStringList args = line.split("=");
       if (args.size() < 2)
+      {
         continue;
+      }
       QString arg = args[0].trimmed();
-      if (arg == "seconds") {
-        if (args[1].trimmed() == "true") {
+      if (arg == "seconds")
+      {
+        if (args[1].trimmed() == "true")
+        {
           seconds_mode = true; // Use new epic behavior
           continue;
         }
+
         continue;
       }
 
@@ -86,117 +108,133 @@ QString AOMusicPlayer::play(QString p_song, int channel, bool loop,
 
       // Calculate the bytes for loop_start/loop_end to use with the sync proc
       QWORD bytes;
-      if (seconds_mode) {
-        bytes =
-            BASS_ChannelSeconds2Bytes(newstream, args[1].trimmed().toDouble());
+      if (seconds_mode)
+      {
+        bytes = BASS_ChannelSeconds2Bytes(newstream, args[1].trimmed().toDouble());
       }
-      else {
-        bytes = static_cast<QWORD>(args[1].trimmed().toUInt() * sample_size *
-                                   num_channels);
+      else
+      {
+        bytes = static_cast<QWORD>(args[1].trimmed().toUInt() * sample_size * num_channels);
       }
       if (arg == "loop_start")
-        loop_start[channel] = bytes;
+      {
+        m_loop_start[streamId] = bytes;
+      }
       else if (arg == "loop_length")
-        loop_end[channel] = loop_start[channel] + bytes;
+      {
+        m_loop_end[streamId] = m_loop_start[streamId] + bytes;
+      }
       else if (arg == "loop_end")
-        loop_end[channel] = bytes;
+      {
+        m_loop_end[streamId] = bytes;
+      }
     }
-    qDebug() << "Found data file for song" << p_song << "length"
-             << BASS_ChannelGetLength(newstream, BASS_POS_BYTE) << "loop start"
-             << loop_start[channel] << "loop end" << loop_end[channel];
+    qDebug() << "Found data file for song" << song << "length" << BASS_ChannelGetLength(newstream, BASS_POS_BYTE) << "loop start" << m_loop_start[streamId] << "loop end" << m_loop_end[streamId];
   }
 
-  if (BASS_ChannelIsActive(m_stream_list[channel]) == BASS_ACTIVE_PLAYING) {
-    DWORD oldstream = m_stream_list[channel];
+  if (BASS_ChannelIsActive(m_stream_list[streamId]) == BASS_ACTIVE_PLAYING)
+  {
+    DWORD oldstream = m_stream_list[streamId];
 
-    if (effect_flags & SYNC_POS) {
+    if (effectFlags & SYNC_POS)
+    {
       BASS_ChannelLock(oldstream, true);
       // Sync it with the new sample
-      BASS_ChannelSetPosition(newstream,
-                              BASS_ChannelGetPosition(oldstream, BASS_POS_BYTE),
-                              BASS_POS_BYTE);
+      BASS_ChannelSetPosition(newstream, BASS_ChannelGetPosition(oldstream, BASS_POS_BYTE), BASS_POS_BYTE);
       BASS_ChannelLock(oldstream, false);
     }
 
-    if ((effect_flags & FADE_OUT) && m_volume[channel] > 0) {
+    if ((effectFlags & FADE_OUT) && m_volume[streamId] > 0)
+    {
       // Fade out the other sample and stop it (due to -1)
-      BASS_ChannelSlideAttribute(oldstream, BASS_ATTRIB_VOL | BASS_SLIDE_LOG,
-                                 -1, 4000);
+      BASS_ChannelSlideAttribute(oldstream, BASS_ATTRIB_VOL | BASS_SLIDE_LOG, -1, 4000);
     }
     else
-      BASS_ChannelStop(
-          oldstream); // Stop the sample since we don't need it anymore
+    {
+      BASS_ChannelStop(oldstream); // Stop the sample since we don't need it anymore
+    }
   }
   else
-    BASS_ChannelStop(m_stream_list[channel]);
+  {
+    BASS_ChannelStop(m_stream_list[streamId]);
+  }
 
-  m_stream_list[channel] = newstream;
+  m_stream_list[streamId] = newstream;
   BASS_ChannelPlay(newstream, false);
-  if (effect_flags & FADE_IN) {
+  if (effectFlags & FADE_IN)
+  {
     // Fade in our sample
     BASS_ChannelSetAttribute(newstream, BASS_ATTRIB_VOL, 0);
-    BASS_ChannelSlideAttribute(newstream, BASS_ATTRIB_VOL,
-                               static_cast<float>(m_volume[channel] / 100.0f),
-                               1000);
+    BASS_ChannelSlideAttribute(newstream, BASS_ATTRIB_VOL, static_cast<float>(m_volume[streamId] / 100.0f), 1000);
   }
   else
-    this->set_volume(m_volume[channel], channel);
+  {
+    this->setStreamVolume(m_volume[streamId], streamId);
+  }
 
-  BASS_ChannelSetSync(newstream, BASS_SYNC_DEV_FAIL, 0,
-                      ao_app->BASSreset, 0);
+  BASS_ChannelSetSync(newstream, BASS_SYNC_DEV_FAIL, 0, ao_app->BASSreset, 0);
 
-  this->set_looping(loop, channel); // Have to do this here due to any
-                                    // crossfading-related changes, etc.
+  this->setStreamLooping(loopEnabled, streamId); // Have to do this here due to any
+                                                 // crossfading-related changes, etc.
 
-  bool is_stop = (p_song == "~stop.mp3");
-  QString p_song_clear = QUrl(p_song).fileName();
+  bool is_stop = (song == "~stop.mp3");
+  QString p_song_clear = QUrl(song).fileName();
   p_song_clear = p_song_clear.left(p_song_clear.lastIndexOf('.'));
 
-  if (is_stop && channel == 0) { // don't send text on channels besides 0
+  if (is_stop && streamId == 0)
+  { // don't send text on channels besides 0
     return QObject::tr("None");
   }
 
-  if (error_code == BASS_ERROR_HANDLE) { // Cheap hack to see if file missing
+  if (error == BASS_ERROR_HANDLE)
+  { // Cheap hack to see if file missing
     return QObject::tr("[MISSING] %1").arg(p_song_clear);
   }
 
-  if (p_song.startsWith("http") && channel == 0) {
+  if (song.startsWith("http") && streamId == 0)
+  {
     return QObject::tr("[STREAM] %1").arg(p_song_clear);
   }
 
-  if (channel == 0)
+  if (streamId == 0)
+  {
     return p_song_clear;
+  }
 
   return "";
 }
 
-void AOMusicPlayer::stop(int channel)
-{
-  BASS_ChannelStop(m_stream_list[channel]);
-}
-
-void AOMusicPlayer::set_muted(bool toggle)
+void AOMusicPlayer::setMuted(bool enabled)
 {
-  m_muted = toggle;
+  m_muted = enabled;
   // Update all volume based on the mute setting
-  for (int n_stream = 0; n_stream < m_channelmax; ++n_stream) {
-    set_volume(m_volume[n_stream], n_stream);
+  for (int n_stream = 0; n_stream < STREAM_COUNT; ++n_stream)
+  {
+    setStreamVolume(m_volume[n_stream], n_stream);
   }
 }
 
-void AOMusicPlayer::set_volume(int p_value, int channel)
+void AOMusicPlayer::setStreamVolume(int value, int streamId)
 {
-  m_volume[channel] = p_value;
+  if (!ensureValidStreamId(streamId))
+  {
+    qWarning().noquote() << QObject::tr("Invalid stream ID '%2'").arg(streamId);
+    return;
+  }
+
+  m_volume[streamId] = value;
   // If muted, volume will always be 0
-  float volume = (m_volume[channel] / 100.0f) * !m_muted;
-  if (channel < 0) {
-    for (int n_stream = 0; n_stream < m_channelmax; ++n_stream) {
-      BASS_ChannelSetAttribute(m_stream_list[n_stream], BASS_ATTRIB_VOL,
-                               volume);
+  float volume = (m_volume[streamId] / 100.0f) * !m_muted;
+  if (streamId < 0)
+  {
+    for (int n_stream = 0; n_stream < STREAM_COUNT; ++n_stream)
+    {
+      BASS_ChannelSetAttribute(m_stream_list[n_stream], BASS_ATTRIB_VOL, volume);
     }
   }
-  else {
-    BASS_ChannelSetAttribute(m_stream_list[channel], BASS_ATTRIB_VOL, volume);
+  else
+  {
+    BASS_ChannelSetAttribute(m_stream_list[streamId], BASS_ATTRIB_VOL, volume);
   }
 }
 
@@ -210,37 +248,48 @@ void CALLBACK loopProc(HSYNC handle, DWORD channel, DWORD data, void *user)
   BASS_ChannelLock(channel, false);
 }
 
-void AOMusicPlayer::set_looping(bool loop_song, int channel)
+void AOMusicPlayer::setStreamLooping(bool enabled, int streamId)
 {
-  if (!loop_song) {
-    if (BASS_ChannelFlags(m_stream_list[channel], 0, 0) & BASS_SAMPLE_LOOP)
-      BASS_ChannelFlags(m_stream_list[channel], 0,
+  if (!ensureValidStreamId(streamId))
+  {
+    qWarning().noquote() << QObject::tr("Invalid stream ID '%2'").arg(streamId);
+    return;
+  }
+
+  if (!enabled)
+  {
+    if (BASS_ChannelFlags(m_stream_list[streamId], 0, 0) & BASS_SAMPLE_LOOP)
+    {
+      BASS_ChannelFlags(m_stream_list[streamId], 0,
                         BASS_SAMPLE_LOOP); // remove the LOOP flag
-    BASS_ChannelRemoveSync(m_stream_list[channel], loop_sync[channel]);
-    loop_sync[channel] = 0;
+    }
+    BASS_ChannelRemoveSync(m_stream_list[streamId], m_loop_sync[streamId]);
+    m_loop_sync[streamId] = 0;
     return;
   }
 
-  BASS_ChannelFlags(m_stream_list[channel], BASS_SAMPLE_LOOP,
+  BASS_ChannelFlags(m_stream_list[streamId], BASS_SAMPLE_LOOP,
                     BASS_SAMPLE_LOOP); // set the LOOP flag
-  if (loop_sync[channel] != 0) {
-    BASS_ChannelRemoveSync(m_stream_list[channel],
-                           loop_sync[channel]); // remove the sync
-    loop_sync[channel] = 0;
+  if (m_loop_sync[streamId] != 0)
+  {
+    BASS_ChannelRemoveSync(m_stream_list[streamId],
+                           m_loop_sync[streamId]); // remove the sync
+    m_loop_sync[streamId] = 0;
   }
 
-  if (loop_start[channel] < loop_end[channel])
+  if (m_loop_start[streamId] < m_loop_end[streamId])
   {
-    //Loop when the endpoint is reached.
-    loop_sync[channel] = BASS_ChannelSetSync(
-        m_stream_list[channel], BASS_SYNC_POS | BASS_SYNC_MIXTIME,
-        loop_end[channel], loopProc, &loop_start[channel]);
+    // Loop when the endpoint is reached.
+    m_loop_sync[streamId] = BASS_ChannelSetSync(m_stream_list[streamId], BASS_SYNC_POS | BASS_SYNC_MIXTIME, m_loop_end[streamId], loopProc, &m_loop_start[streamId]);
   }
   else
   {
-    //Loop when the end of the file is reached.
-    loop_sync[channel] = BASS_ChannelSetSync(
-        m_stream_list[channel], BASS_SYNC_END | BASS_SYNC_MIXTIME,
-        0, loopProc, &loop_start[channel]);
+    // Loop when the end of the file is reached.
+    m_loop_sync[streamId] = BASS_ChannelSetSync(m_stream_list[streamId], BASS_SYNC_END | BASS_SYNC_MIXTIME, 0, loopProc, &m_loop_start[streamId]);
   }
 }
+
+bool AOMusicPlayer::ensureValidStreamId(int streamId)
+{
+  return (streamId >= 0 && streamId < STREAM_COUNT);
+}