refactor(windows): simplify position and duration processing (#1553)

Gustl22 · SNNafi · web-flow · commit ca63c5a4b120 · 2023-06-27T18:15:12.000+02:00
# Description Use `double` for `position` and `duration` on windows implementation ## Related Issues Closes #1547 Co-authored-by: SNNAFI <shahriarnasim.nafi@gmail.com>
diff --git a/packages/audioplayers/example/integration_test/lib_test.dart b/packages/audioplayers/example/integration_test/lib_test.dart
@@ -28,18 +28,18 @@ void main() {
     source: UrlSource(wavUrl1),
     duration: const Duration(milliseconds: 451),
   );
+  final mp3Url1TestData = LibSourceTestData(
+    source: UrlSource(mp3Url1),
+    duration: const Duration(minutes: 3, seconds: 30, milliseconds: 77),
+  );
   final audioTestDataList = [
     if (features.hasUrlSource) wavUrl1TestData,
     if (features.hasUrlSource)
       LibSourceTestData(
         source: UrlSource(wavUrl2),
         duration: const Duration(seconds: 1, milliseconds: 068),
       ),
-    if (features.hasUrlSource)
-      LibSourceTestData(
-        source: UrlSource(mp3Url1),
-        duration: const Duration(minutes: 3, seconds: 30, milliseconds: 77),
-      ),
+    if (features.hasUrlSource) mp3Url1TestData,
     if (features.hasUrlSource)
       LibSourceTestData(
         source: UrlSource(mp3Url2),
@@ -393,6 +393,56 @@ void main() {
       }
     });
 
+    testWidgets('#seek with millisecond precision', (tester) async {
+      final platform = AudioplayersPlatformInterface.instance;
+
+      final playerId = 'somePlayerId${isLinux ? linuxPlayerCount++ : ''}';
+      await platform.create(playerId);
+
+      final preparedCompleter = Completer<void>();
+      final eventStream = platform.getEventStream(playerId);
+      final onPreparedSub = eventStream
+          .where((event) => event.eventType == AudioEventType.prepared)
+          .map((event) => event.isPrepared!)
+          .listen(
+        (isPrepared) {
+          if (isPrepared) {
+            preparedCompleter.complete();
+          }
+        },
+        onError: preparedCompleter.completeError,
+      );
+      if (isLinux) {
+        // FIXME(gustl22): Linux needs additional pump (#1507)
+        await tester.pump();
+      }
+      await platform.setSourceUrl(
+        playerId,
+        (mp3Url1TestData.source as UrlSource).url,
+      );
+      await preparedCompleter.future.timeout(const Duration(seconds: 30));
+
+      final seekCompleter = Completer<void>();
+      final onSeekSub = eventStream
+          .where((event) => event.eventType == AudioEventType.seekComplete)
+          .listen(
+        (_) {
+          seekCompleter.complete();
+        },
+        onError: seekCompleter.completeError,
+      );
+      await platform.seek(playerId, const Duration(milliseconds: 21));
+      await seekCompleter.future.timeout(const Duration(seconds: 30));
+      await onSeekSub.cancel();
+      expect(await platform.getCurrentPosition(playerId), 21);
+
+      await onPreparedSub.cancel();
+      if (!isLinux) {
+        // FIXME(gustl22): Linux not disposing properly (#1507)
+        await platform.dispose(playerId);
+      }
+    });
+
     testWidgets('Set same source twice (#1520)', (tester) async {
       final platform = AudioplayersPlatformInterface.instance;
 
diff --git a/packages/audioplayers/example/windows/runner/Runner.rc b/packages/audioplayers/example/windows/runner/Runner.rc
@@ -60,14 +60,14 @@ IDI_APP_ICON            ICON                    "resources\\app_icon.ico"
 // Version
 //
 
-#ifdef FLUTTER_BUILD_NUMBER
-#define VERSION_AS_NUMBER FLUTTER_BUILD_NUMBER
+#if defined(FLUTTER_VERSION_MAJOR) && defined(FLUTTER_VERSION_MINOR) && defined(FLUTTER_VERSION_PATCH) && defined(FLUTTER_VERSION_BUILD)
+#define VERSION_AS_NUMBER FLUTTER_VERSION_MAJOR,FLUTTER_VERSION_MINOR,FLUTTER_VERSION_PATCH,FLUTTER_VERSION_BUILD
 #else
-#define VERSION_AS_NUMBER 1,0,0
+#define VERSION_AS_NUMBER 1,0,0,0
 #endif
 
-#ifdef FLUTTER_BUILD_NAME
-#define VERSION_AS_STRING #FLUTTER_BUILD_NAME
+#if defined(FLUTTER_VERSION)
+#define VERSION_AS_STRING FLUTTER_VERSION
 #else
 #define VERSION_AS_STRING "1.0.0"
 #endif
diff --git a/packages/audioplayers_windows/windows/CMakeLists.txt b/packages/audioplayers_windows/windows/CMakeLists.txt
@@ -33,6 +33,7 @@ add_library(${PLUGIN_NAME} SHARED
   "audioplayers_windows_plugin.cpp"
   "audio_player.h"
   "audio_player.cpp"
+  "audioplayers_helpers.h"
   "event_stream_handler.h"
   "MediaEngineExtension.h"
   "MediaEngineExtension.cpp"
diff --git a/packages/audioplayers_windows/windows/MediaEngineWrapper.cpp b/packages/audioplayers_windows/windows/MediaEngineWrapper.cpp
@@ -18,6 +18,7 @@
 
 #include "MediaEngineWrapper.h"
 #include "MediaFoundationHelpers.h"
+#include "audioplayers_helpers.h"
 #include <Audioclient.h>
 
 using namespace Microsoft::WRL;
@@ -143,15 +144,14 @@ void MediaEngineWrapper::Shutdown()
     });
 }
 
-void MediaEngineWrapper::StartPlayingFrom(uint64_t timeStamp)
+void MediaEngineWrapper::StartPlayingFrom(double timestampInSeconds)
 {
     RunSyncInMTA([&]()
     {
         auto lock = m_lock.lock();
         if (m_mediaEngine == nullptr) {
             return;
         }
-        const double timestampInSeconds = ConvertHnsToSeconds(timeStamp);
         THROW_IF_FAILED(m_mediaEngine->SetCurrentTime(timestampInSeconds));
         THROW_IF_FAILED(m_mediaEngine->Play());
     });
@@ -233,52 +233,52 @@ bool MediaEngineWrapper::GetLooping()
     return looping;
 }
 
-void MediaEngineWrapper::SeekTo(uint64_t timeStamp)
+void MediaEngineWrapper::SeekTo(double timestampInSeconds)
 {
     RunSyncInMTA([&]()
     {
         auto lock = m_lock.lock();
         if (m_mediaEngine == nullptr) {
             return;
         }
-        const double timestampInSeconds = ConvertHnsToSeconds(timeStamp);
         THROW_IF_FAILED(m_mediaEngine->SetCurrentTime(timestampInSeconds));
     });
 }
 
-uint64_t MediaEngineWrapper::GetMediaTime()
+// Get media time in seconds
+double MediaEngineWrapper::GetMediaTime()
 {
-    uint64_t currentTimeInHns = 0;
+    double currentTimeInSeconds = 0;
     RunSyncInMTA([&]()
     {
         auto lock = m_lock.lock();
         if (m_mediaEngine == nullptr) {
             return;
         }
-        double currentTimeInSeconds = m_mediaEngine->GetCurrentTime();
-        currentTimeInHns = ConvertSecondsToHns(currentTimeInSeconds);
+        currentTimeInSeconds = m_mediaEngine->GetCurrentTime();
     });
-    return currentTimeInHns;
+    return currentTimeInSeconds;
 }
 
-uint64_t MediaEngineWrapper::GetDuration()
+// Get duration in seconds
+double MediaEngineWrapper::GetDuration()
 {
-    uint64_t durationInHns = 0;
+    double durationInSeconds = 0;
     RunSyncInMTA([&]()
     {
         auto lock = m_lock.lock();
         if (m_mediaEngine == nullptr) {
             return;
         }
-        double durationInSeconds = m_mediaEngine->GetDuration();
-        durationInHns = ConvertSecondsToHns(durationInSeconds);
+        durationInSeconds = m_mediaEngine->GetDuration();
     });
-    return durationInHns;
+    return durationInSeconds;
 }
 
-std::vector<std::tuple<uint64_t, uint64_t>> MediaEngineWrapper::GetBufferedRanges()
+// Get buffered ranges in milliseconds
+std::vector<std::tuple<int64_t, int64_t>> MediaEngineWrapper::GetBufferedRanges()
 {
-    std::vector<std::tuple<uint64_t, uint64_t>> result;
+    std::vector<std::tuple<int64_t, int64_t>> result;
     RunSyncInMTA([&]()
     {
         auto lock = m_lock.lock();
@@ -296,7 +296,7 @@ std::vector<std::tuple<uint64_t, uint64_t>> MediaEngineWrapper::GetBufferedRange
         {
             mediaTimeRange->GetStart(i, &start);
             mediaTimeRange->GetEnd(i, &end);
-            result.push_back(std::make_tuple(ConvertSecondsToHns(start), ConvertSecondsToHns(end)));
+            result.push_back(std::make_tuple(ConvertSecondsToMs(start), ConvertSecondsToMs(end)));
         }
     });
     return result;
diff --git a/packages/audioplayers_windows/windows/MediaEngineWrapper.h b/packages/audioplayers_windows/windows/MediaEngineWrapper.h
@@ -43,21 +43,21 @@ class MediaEngineWrapper : public winrt::implements<MediaEngineWrapper, IUnknown
     void Shutdown();
 
     // Control various aspects of playback
-    void StartPlayingFrom(uint64_t timeStamp);
+    void StartPlayingFrom(double timestampInSeconds);
     void Resume();
     void SetPlaybackRate(double playbackRate);
     void SetVolume(float volume);
     void SetBalance(double balance);
     void SetLooping(bool isLooping);
-    void SeekTo(uint64_t timeStamp);
+    void SeekTo(double timeStamp);
 
     // Query the current playback position
-    uint64_t GetMediaTime();
-    uint64_t GetDuration();
+    double GetMediaTime();
+    double GetDuration();
 
     bool GetLooping();
 
-    std::vector<std::tuple<uint64_t, uint64_t>> GetBufferedRanges();
+    std::vector<std::tuple<int64_t, int64_t>> GetBufferedRanges();
 
   private:
     wil::critical_section m_lock;
@@ -80,4 +80,4 @@ class MediaEngineWrapper : public winrt::implements<MediaEngineWrapper, IUnknown
     void OnSeekCompleted();
 };
 
-} // namespace media
+} // namespace media
diff --git a/packages/audioplayers_windows/windows/MediaFoundationHelpers.h b/packages/audioplayers_windows/windows/MediaFoundationHelpers.h
@@ -143,21 +143,4 @@ inline void RunSyncInMTA(std::function<void()> callback)
     }
 }
 
-constexpr uint64_t c_hnsPerSecond = 10000000;
-
-template<typename SecondsT>
-inline uint64_t ConvertSecondsToHns(SecondsT seconds)
-{
-    if (isinf(seconds))
-        return 0;
-    return static_cast<uint64_t>(seconds * c_hnsPerSecond);
-}
-
-template<typename HnsT>
-inline double ConvertHnsToSeconds(HnsT hns)
-{
-    return static_cast<double>(hns) / c_hnsPerSecond;
-}
-
-
-} // namespace media
+} // namespace media
diff --git a/packages/audioplayers_windows/windows/audio_player.cpp b/packages/audioplayers_windows/windows/audio_player.cpp
@@ -9,6 +9,8 @@
 #include <shobjidl.h>
 #include <windows.h>
 
+#include "audioplayers_helpers.h"
+
 #undef GetCurrentTime
 
 using namespace winrt;
@@ -145,8 +147,7 @@ void AudioPlayer::OnTimeUpdate() {
                   flutter::EncodableValue("audio.onCurrentPosition")},
                  {flutter::EncodableValue("value"),
                   flutter::EncodableValue(
-                      (int64_t)m_mediaEngineWrapper->GetMediaTime() /
-                      10000)}})));
+                      ConvertSecondsToMs(m_mediaEngineWrapper->GetMediaTime()))}})));
     }
 }
 
@@ -158,8 +159,7 @@ void AudioPlayer::OnDurationUpdate() {
                   flutter::EncodableValue("audio.onDuration")},
                  {flutter::EncodableValue("value"),
                   flutter::EncodableValue(
-                      (int64_t)m_mediaEngineWrapper->GetDuration() /
-                      10000)}})));
+                      ConvertSecondsToMs(m_mediaEngineWrapper->GetDuration()))}})));
     }
 }
 
@@ -236,12 +236,12 @@ void AudioPlayer::Resume() {
     OnDurationUpdate();
 }
 
-int64_t AudioPlayer::GetPosition() {
+double AudioPlayer::GetPosition() {
     return m_mediaEngineWrapper->GetMediaTime();
 }
 
-int64_t AudioPlayer::GetDuration() {
+double AudioPlayer::GetDuration() {
     return m_mediaEngineWrapper->GetDuration();
 }
 
-void AudioPlayer::SeekTo(int64_t seek) { m_mediaEngineWrapper->SeekTo(seek); }
+void AudioPlayer::SeekTo(double seek) { m_mediaEngineWrapper->SeekTo(seek); }
diff --git a/packages/audioplayers_windows/windows/audio_player.h b/packages/audioplayers_windows/windows/audio_player.h
@@ -69,11 +69,11 @@ class AudioPlayer {
 
     bool GetLooping();
 
-    int64_t GetPosition();
+    double GetPosition();
 
-    int64_t GetDuration();
+    double GetDuration();
 
-    void SeekTo(int64_t seek);
+    void SeekTo(double seek);
 
     void SetSourceUrl(std::string url);
 
diff --git a/packages/audioplayers_windows/windows/audioplayers_helpers.h b/packages/audioplayers_windows/windows/audioplayers_helpers.h
@@ -0,0 +1,15 @@
+constexpr int64_t c_msPerSecond = 1000;
+
+template<typename SecondsT>
+inline int64_t ConvertSecondsToMs(SecondsT seconds)
+{
+    if (isinf(seconds))
+        return 0;
+    return static_cast<int64_t>(seconds * c_msPerSecond);
+}
+
+template<typename MsT>
+inline double ConvertMsToSeconds(MsT ms)
+{
+    return static_cast<double>(ms) / c_msPerSecond;
+}
diff --git a/packages/audioplayers_windows/windows/audioplayers_windows_plugin.cpp b/packages/audioplayers_windows/windows/audioplayers_windows_plugin.cpp
@@ -16,6 +16,7 @@
 #include <sstream>
 
 #include "audio_player.h"
+#include "audioplayers_helpers.h"
 
 namespace {
 
@@ -170,9 +171,9 @@ void AudioplayersWindowsPlugin::HandleMethodCall(
         player->SeekTo(0);
         result->Success(EncodableValue(1));
     } else if (method_call.method_name().compare("seek") == 0) {
-        auto position = GetArgument<int>("position", args,
-                                         (int)(player->GetPosition() / 10000));
-        player->SeekTo(static_cast<int64_t>(position * 10000.0));
+        auto positionInMs = GetArgument<int>("position", args,
+                                         (int)ConvertSecondsToMs(player->GetPosition()));
+        player->SeekTo(ConvertMsToSeconds(positionInMs));
         result->Success(EncodableValue(1));
     } else if (method_call.method_name().compare("setSourceUrl") == 0) {
         auto url = GetArgument<std::string>("url", args, std::string());
@@ -185,13 +186,13 @@ void AudioplayersWindowsPlugin::HandleMethodCall(
         std::thread(&AudioPlayer::SetSourceUrl, player, url).detach();
         result->Success(EncodableValue(1));
     } else if (method_call.method_name().compare("getDuration") == 0) {
-        result->Success(EncodableValue(player->GetDuration() / 10000));
+        result->Success(EncodableValue(ConvertSecondsToMs(player->GetDuration())));
     } else if (method_call.method_name().compare("setVolume") == 0) {
         auto volume = GetArgument<double>("volume", args, 1.0);
         player->SetVolume(volume);
         result->Success(EncodableValue(1));
     } else if (method_call.method_name().compare("getCurrentPosition") == 0) {
-        result->Success(EncodableValue(player->GetPosition() / 10000));
+        result->Success(EncodableValue(ConvertSecondsToMs(player->GetPosition())));
     } else if (method_call.method_name().compare("setPlaybackRate") == 0) {
         auto playbackRate = GetArgument<double>("playbackRate", args, 1.0);
         player->SetPlaybackSpeed(playbackRate);

Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@`
`18`	`18`
`19`	`19`	`#include "MediaEngineWrapper.h"`
`20`	`20`	`#include "MediaFoundationHelpers.h"`
	`21`	`+#include "audioplayers_helpers.h"`
`21`	`22`	`#include <Audioclient.h>`
`22`	`23`
`23`	`24`	`using namespace Microsoft::WRL;`
`@@ -143,15 +144,14 @@ void MediaEngineWrapper::Shutdown()`
`143`	`144`	`});`
`144`	`145`	`}`
`145`	`146`
`146`		`-void MediaEngineWrapper::StartPlayingFrom(uint64_t timeStamp)`
	`147`	`+void MediaEngineWrapper::StartPlayingFrom(double timestampInSeconds)`
`147`	`148`	`{`
`148`	`149`	`RunSyncInMTA([&]()`
`149`	`150`	`{`
`150`	`151`	`auto lock = m_lock.lock();`
`151`	`152`	`if (m_mediaEngine == nullptr) {`
`152`	`153`	`return;`
`153`	`154`	`}`
`154`		`- const double timestampInSeconds = ConvertHnsToSeconds(timeStamp);`
`155`	`155`	`THROW_IF_FAILED(m_mediaEngine->SetCurrentTime(timestampInSeconds));`
`156`	`156`	`THROW_IF_FAILED(m_mediaEngine->Play());`
`157`	`157`	`});`
`@@ -233,52 +233,52 @@ bool MediaEngineWrapper::GetLooping()`
`233`	`233`	`return looping;`
`234`	`234`	`}`
`235`	`235`
`236`		`-void MediaEngineWrapper::SeekTo(uint64_t timeStamp)`
	`236`	`+void MediaEngineWrapper::SeekTo(double timestampInSeconds)`
`237`	`237`	`{`
`238`	`238`	`RunSyncInMTA([&]()`
`239`	`239`	`{`
`240`	`240`	`auto lock = m_lock.lock();`
`241`	`241`	`if (m_mediaEngine == nullptr) {`
`242`	`242`	`return;`
`243`	`243`	`}`
`244`		`- const double timestampInSeconds = ConvertHnsToSeconds(timeStamp);`
`245`	`244`	`THROW_IF_FAILED(m_mediaEngine->SetCurrentTime(timestampInSeconds));`
`246`	`245`	`});`
`247`	`246`	`}`
`248`	`247`
`249`		`-uint64_t MediaEngineWrapper::GetMediaTime()`
	`248`	`+// Get media time in seconds`
	`249`	`+double MediaEngineWrapper::GetMediaTime()`
`250`	`250`	`{`
`251`		`- uint64_t currentTimeInHns = 0;`
	`251`	`+ double currentTimeInSeconds = 0;`
`252`	`252`	`RunSyncInMTA([&]()`
`253`	`253`	`{`
`254`	`254`	`auto lock = m_lock.lock();`
`255`	`255`	`if (m_mediaEngine == nullptr) {`
`256`	`256`	`return;`
`257`	`257`	`}`
`258`		`- double currentTimeInSeconds = m_mediaEngine->GetCurrentTime();`
`259`		`- currentTimeInHns = ConvertSecondsToHns(currentTimeInSeconds);`
	`258`	`+ currentTimeInSeconds = m_mediaEngine->GetCurrentTime();`
`260`	`259`	`});`
`261`		`- return currentTimeInHns;`
	`260`	`+ return currentTimeInSeconds;`
`262`	`261`	`}`
`263`	`262`
`264`		`-uint64_t MediaEngineWrapper::GetDuration()`
	`263`	`+// Get duration in seconds`
	`264`	`+double MediaEngineWrapper::GetDuration()`
`265`	`265`	`{`
`266`		`- uint64_t durationInHns = 0;`
	`266`	`+ double durationInSeconds = 0;`
`267`	`267`	`RunSyncInMTA([&]()`
`268`	`268`	`{`
`269`	`269`	`auto lock = m_lock.lock();`
`270`	`270`	`if (m_mediaEngine == nullptr) {`
`271`	`271`	`return;`
`272`	`272`	`}`
`273`		`- double durationInSeconds = m_mediaEngine->GetDuration();`
`274`		`- durationInHns = ConvertSecondsToHns(durationInSeconds);`
	`273`	`+ durationInSeconds = m_mediaEngine->GetDuration();`
`275`	`274`	`});`
`276`		`- return durationInHns;`
	`275`	`+ return durationInSeconds;`
`277`	`276`	`}`
`278`	`277`
`279`		`-std::vector<std::tuple<uint64_t, uint64_t>> MediaEngineWrapper::GetBufferedRanges()`
	`278`	`+// Get buffered ranges in milliseconds`
	`279`	`+std::vector<std::tuple<int64_t, int64_t>> MediaEngineWrapper::GetBufferedRanges()`
`280`	`280`	`{`
`281`		`- std::vector<std::tuple<uint64_t, uint64_t>> result;`
	`281`	`+ std::vector<std::tuple<int64_t, int64_t>> result;`
`282`	`282`	`RunSyncInMTA([&]()`
`283`	`283`	`{`
`284`	`284`	`auto lock = m_lock.lock();`
`@@ -296,7 +296,7 @@ std::vector<std::tuple<uint64_t, uint64_t>> MediaEngineWrapper::GetBufferedRange`
`296`	`296`	`{`
`297`	`297`	`mediaTimeRange->GetStart(i, &start);`
`298`	`298`	`mediaTimeRange->GetEnd(i, &end);`
`299`		`- result.push_back(std::make_tuple(ConvertSecondsToHns(start), ConvertSecondsToHns(end)));`
	`299`	`+ result.push_back(std::make_tuple(ConvertSecondsToMs(start), ConvertSecondsToMs(end)));`
`300`	`300`	`}`
`301`	`301`	`});`
`302`	`302`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@`
`9`	`9`	`#include <shobjidl.h>`
`10`	`10`	`#include <windows.h>`
`11`	`11`
	`12`	`+#include "audioplayers_helpers.h"`
	`13`	`+`
`12`	`14`	`#undef GetCurrentTime`
`13`	`15`
`14`	`16`	`using namespace winrt;`
`@@ -145,8 +147,7 @@ void AudioPlayer::OnTimeUpdate() {`
`145`	`147`	`flutter::EncodableValue("audio.onCurrentPosition")},`
`146`	`148`	`{flutter::EncodableValue("value"),`
`147`	`149`	`flutter::EncodableValue(`
`148`		`- (int64_t)m_mediaEngineWrapper->GetMediaTime() /`
`149`		`- 10000)}})));`
	`150`	`+ ConvertSecondsToMs(m_mediaEngineWrapper->GetMediaTime()))}})));`
`150`	`151`	`}`
`151`	`152`	`}`
`152`	`153`
`@@ -158,8 +159,7 @@ void AudioPlayer::OnDurationUpdate() {`
`158`	`159`	`flutter::EncodableValue("audio.onDuration")},`
`159`	`160`	`{flutter::EncodableValue("value"),`
`160`	`161`	`flutter::EncodableValue(`
`161`		`- (int64_t)m_mediaEngineWrapper->GetDuration() /`
`162`		`- 10000)}})));`
	`162`	`+ ConvertSecondsToMs(m_mediaEngineWrapper->GetDuration()))}})));`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`
`@@ -236,12 +236,12 @@ void AudioPlayer::Resume() {`
`236`	`236`	`OnDurationUpdate();`
`237`	`237`	`}`
`238`	`238`
`239`		`-int64_t AudioPlayer::GetPosition() {`
	`239`	`+double AudioPlayer::GetPosition() {`
`240`	`240`	`return m_mediaEngineWrapper->GetMediaTime();`
`241`	`241`	`}`
`242`	`242`
`243`		`-int64_t AudioPlayer::GetDuration() {`
	`243`	`+double AudioPlayer::GetDuration() {`
`244`	`244`	`return m_mediaEngineWrapper->GetDuration();`
`245`	`245`	`}`
`246`	`246`
`247`		`-void AudioPlayer::SeekTo(int64_t seek) { m_mediaEngineWrapper->SeekTo(seek); }`
	`247`	`+void AudioPlayer::SeekTo(double seek) { m_mediaEngineWrapper->SeekTo(seek); }`