Split out observed MPV proprties into separate methods

diff --git a/backendplugins/backend_mpv/backendmpv.cpp b/backendplugins/backend_mpv/backendmpv.cpp
index 40a3c6ea8be8f433ae8a1f20cf1e10311f65e835..30048276386b8031684b944e1d7b80b72742fda9 100644 (file)
--- a/backendplugins/backend_mpv/backendmpv.cpp
+++ b/backendplugins/backend_mpv/backendmpv.cpp
@@ -248,11 +248,9 @@ decltype(auto) readProperty(struct mpv_event_property *property) {
   return MpvProperty<TYPE>::read(property);
 }
 
-int MpvInstance::readTrackIndex(struct mpv_event_property *property) {
-  const auto str = readProperty<MPV_FORMAT_STRING>(property);
-  qCDebug(mpvBackend).nospace() << "Trying to read id from >" << str << "<";
+int MpvInstance::readTrackIndex(const QString &qstr) {
+  qCDebug(mpvBackend).nospace() << "Trying to read id from >" << qstr << "<";
 
-  const auto qstr = QString::fromUtf8(str);
   bool ok = false;
   const int id = qstr.toInt(&ok);
   return ok ? id : NoTrack;
@@ -278,84 +276,42 @@ void MpvInstance::onPropertyChange(mpv_event_property *property) {
     return;
   }
   if (strcmp(property->name, "pause") == 0) {
-    auto paused = readProperty<MPV_FORMAT_FLAG>(property);
-    auto state = paused ? PlayerPluginInterface::PlayState::Paused
-                        : PlayerPluginInterface::PlayState::Playing;
-    if (!m_loadedFile)
-      state = PlayerPluginInterface::PlayState::Stopped;
-    m_player->playStateChanged(state);
+    const auto paused = readProperty<MPV_FORMAT_FLAG>(property);
+    onPauseChanged(paused);
   } else if (strcmp(property->name, "duration") == 0) {
-    m_player->playbackDurationChanged(
-        static_cast<PlayerPluginInterface::TimeStamp>(
-            readProperty<MPV_FORMAT_DOUBLE>(property)));
+    const auto duration = static_cast<PlayerPluginInterface::TimeStamp>(
+        readProperty<MPV_FORMAT_DOUBLE>(property));
+    onDurationChanged(duration);
   } else if (strcmp(property->name, "playback-time") == 0) {
-    m_player->playbackPositionChanged(
-        static_cast<PlayerPluginInterface::TimeStamp>(
-            readProperty<MPV_FORMAT_DOUBLE>(property)));
+    const double time = static_cast<PlayerPluginInterface::TimeStamp>(
+        readProperty<MPV_FORMAT_DOUBLE>(property));
+    onPlaybackTimeChanged(time);
   } else if (strcmp(property->name, VOLUME) == 0) {
-    if (m_volumeToSet > 0) {
-      qCDebug(mpvBackend)
-          << "Requested volume still not set, skipping this update";
-    } else {
-      m_player->playbackVolumeChanged(
-          static_cast<PlayerPluginInterface::Volume>(
-              readProperty<MPV_FORMAT_DOUBLE>(property) / 100.0));
-    }
+    const double volume = static_cast<PlayerPluginInterface::Volume>(
+        readProperty<MPV_FORMAT_DOUBLE>(property) / 100.0);
+    onVolumeChanged(volume);
   } else if (strcmp(property->name, "track-list") == 0) {
     const auto node = readProperty<MPV_FORMAT_NODE>(property);
     const auto variant = mpv::qt::node_to_variant(node);
-    qCDebug(mpvBackend) << "TRACKS" << variant;
-
-    PlayerPluginInterface::TrackList videoTracks;
-    PlayerPluginInterface::TrackList audioTracks;
-    PlayerPluginInterface::TrackList subtitleTracks;
-    for (const auto &v : variant.toList()) {
-      const auto &map = v.toMap();
-      const auto &type = map["type"].toString();
-      auto &tracks = [&]() -> PlayerPluginInterface::TrackList & {
-        if (type == "video") {
-          return videoTracks;
-        }
-        if (type == "audio") {
-          return audioTracks;
-        }
-        return subtitleTracks;
-      }();
-      const auto track = PlayerPluginInterface::Track{
-          map["title"].toString(), map["lang"].toString(), map["id"].toInt()};
-      tracks << track;
-    }
-    m_player->backendVideoTracksChanged(videoTracks);
-    m_player->backendAudioTracksChanged(audioTracks);
-    m_player->backendSubtitleTracksChanged(subtitleTracks);
-
+    onTrackListChanged(std::move(variant));
   } else if (strcmp(property->name, "vid") == 0) {
-    const int trackIndex = readTrackIndex(property);
-    m_player->backendCurrentVideoTrackChanged(trackIndex);
-
+    auto str =
+        QString::fromLocal8Bit(readProperty<MPV_FORMAT_STRING>(property));
+    onVidChanged(std::move(str));
   } else if (strcmp(property->name, "aid") == 0) {
-    const int trackIndex = readTrackIndex(property);
-    m_player->backendCurrentAudioTrackChanged(trackIndex);
-
+    auto str =
+        QString::fromLocal8Bit(readProperty<MPV_FORMAT_STRING>(property));
+    onAidChanged(std::move(str));
   } else if (strcmp(property->name, "sid") == 0) {
-    const int trackIndex = readTrackIndex(property);
-    m_player->backendCurrentSubtitleTrackChanged(trackIndex);
-
+    auto str =
+        QString::fromLocal8Bit(readProperty<MPV_FORMAT_STRING>(property));
+    onSidChanged(std::move(str));
   } else if (strcmp(property->name, "chapter-list") == 0) {
     const auto node = readProperty<MPV_FORMAT_NODE>(property);
     const auto variant = mpv::qt::node_to_variant(node);
-    qCDebug(mpvBackend) << "CHAPTERS" << variant;
-
-    PlayerPluginInterface::ChapterList chapters;
-    for (const auto &v : variant.toList()) {
-      const auto map = v.toMap();
-      chapters << PlayerPluginInterface::Chapter{map["title"].toString(),
-                                                 map["time"].toDouble()};
-    }
-    m_player->backendChaptersChanged(chapters);
+    onChapterListChanged(std::move(variant));
   } else if (strcmp(property->name, "idle-active") == 0) {
-    m_player->playStateChanged(PlayerPluginInterface::PlayState::Stopped);
-    m_player->backendReadyToPlay();
+    onIdleActiveChanged();
   } else {
     qCWarning(mpvBackend) << "Change notification for not handled property"
                           << property->name;
@@ -407,6 +363,90 @@ void MpvInstance::onAudioReconfig() {
   }
 }
 
+void MpvInstance::onPauseChanged(bool paused) {
+  auto state = paused ? PlayerPluginInterface::PlayState::Paused
+                      : PlayerPluginInterface::PlayState::Playing;
+  if (!m_loadedFile)
+    state = PlayerPluginInterface::PlayState::Stopped;
+  m_player->playStateChanged(state);
+}
+
+void MpvInstance::onDurationChanged(double duration) {
+  m_player->playbackDurationChanged(duration);
+}
+
+void MpvInstance::onPlaybackTimeChanged(double time) {
+  m_player->playbackPositionChanged(time);
+}
+
+void MpvInstance::onVolumeChanged(double volume) {
+  if (m_volumeToSet > 0) {
+    qCDebug(mpvBackend)
+        << "Requested volume still not set, skipping this update";
+  } else {
+    m_player->playbackVolumeChanged(volume);
+  }
+}
+
+void MpvInstance::onTrackListChanged(QVariant variant) {
+  qCDebug(mpvBackend) << "TRACKS" << variant;
+
+  PlayerPluginInterface::TrackList videoTracks;
+  PlayerPluginInterface::TrackList audioTracks;
+  PlayerPluginInterface::TrackList subtitleTracks;
+  for (const auto &v : variant.toList()) {
+    const auto &map = v.toMap();
+    const auto &type = map["type"].toString();
+    auto &tracks = [&]() -> PlayerPluginInterface::TrackList & {
+      if (type == "video") {
+        return videoTracks;
+      }
+      if (type == "audio") {
+        return audioTracks;
+      }
+      return subtitleTracks;
+    }();
+    const auto track = PlayerPluginInterface::Track{
+        map["title"].toString(), map["lang"].toString(), map["id"].toInt()};
+    tracks << track;
+  }
+  m_player->backendVideoTracksChanged(videoTracks);
+  m_player->backendAudioTracksChanged(audioTracks);
+  m_player->backendSubtitleTracksChanged(subtitleTracks);
+}
+
+void MpvInstance::onVidChanged(const QString &vid) {
+  const int trackIndex = readTrackIndex(vid);
+  m_player->backendCurrentVideoTrackChanged(trackIndex);
+}
+
+void MpvInstance::onAidChanged(const QString &aid) {
+  const int trackIndex = readTrackIndex(aid);
+  m_player->backendCurrentAudioTrackChanged(trackIndex);
+}
+
+void MpvInstance::onSidChanged(const QString &sid) {
+  const int trackIndex = readTrackIndex(sid);
+  m_player->backendCurrentSubtitleTrackChanged(trackIndex);
+}
+
+void MpvInstance::onChapterListChanged(QVariant variant) {
+  qCDebug(mpvBackend) << "CHAPTERS" << variant;
+
+  PlayerPluginInterface::ChapterList chapters;
+  for (const auto &v : variant.toList()) {
+    const auto map = v.toMap();
+    chapters << PlayerPluginInterface::Chapter{map["title"].toString(),
+                                               map["time"].toDouble()};
+  }
+  m_player->backendChaptersChanged(chapters);
+}
+
+void MpvInstance::onIdleActiveChanged() {
+  m_player->playStateChanged(PlayerPluginInterface::PlayState::Stopped);
+  m_player->backendReadyToPlay();
+}
+
 void MpvInstance::mpvWakeupCb(void *obj) {
   auto self = static_cast<BackendMpv *>(obj);
   QMetaObject::invokeMethod(self, "processMpvEvents", Qt::QueuedConnection);

diff --git a/backendplugins/backend_mpv/backendmpv.h b/backendplugins/backend_mpv/backendmpv.h
index 69013d3dc863d00b4949b909a0cefc6a7a4f1a96..4a9872ce84e245c20bae97fc70ff6fe240eee073 100644 (file)
--- a/backendplugins/backend_mpv/backendmpv.h
+++ b/backendplugins/backend_mpv/backendmpv.h
@@ -66,7 +66,18 @@ private:
   void onEndFile(mpv_event_end_file *);
   void onAudioReconfig();
 
-  int readTrackIndex(struct mpv_event_property *);
+  void onPauseChanged(bool paused);
+  void onDurationChanged(double duration);
+  void onPlaybackTimeChanged(double time);
+  void onVolumeChanged(double volume);
+  void onTrackListChanged(QVariant trackList);
+  void onVidChanged(const QString &vid);
+  void onAidChanged(const QString &aid);
+  void onSidChanged(const QString &sid);
+  void onChapterListChanged(QVariant trackList);
+  void onIdleActiveChanged();
+
+  int readTrackIndex(const QString &qstr);
 
   std::unique_ptr<mpv::EventHandler<MpvInstance>> m_eventHandler;
   PlayerPluginInterface *m_player = nullptr;