exposed extra functionality through IMFMediaEngineEx interface for approximate seeking

Author: axjxwright

samples/SimplePlayback/src/SimplePlaybackApp.cxx

@@ -30,6 +30,7 @@ class SimplePlaybackApp : public app::App
     AX::Video::MediaPlayer::Error _error{ AX::Video::MediaPlayer::Error::NoError };
 
     bool _hardwareAccelerated{ true };
+    bool _approximateSeeking{ true };
     gl::TextureRef _texture;
 };
 
@@ -40,7 +41,8 @@ void SimplePlaybackApp::setup ( )
     uint32_t flags = 0;
     if ( _hardwareAccelerated ) flags |= AX::Video::MediaPlayer::HardwareAccelerated;
 
-    _player = AX::Video::MediaPlayer::Create ( loadFile ( CINDER_PATH "\\samples\\QuickTimeBasic\\assets\\bbb.mp4" ), flags );
+    //_player = AX::Video::MediaPlayer::Create ( loadFile ( CINDER_PATH "\\samples\\QuickTimeBasic\\assets\\bbb.mp4" ), flags );
+    _player = AX::Video::MediaPlayer::Create ( loadFile ( "C:\\Dev\\Experiments\\8KVideo.mp4" ), flags );
     _player->OnSeekStart.connect ( [=] { std::cout << "OnSeekStart\n"; } );
     _player->OnSeekEnd.connect ( [=] { std::cout << "OnSeekEnd\n"; } );
     _player->OnComplete.connect ( [=] { std::cout << "OnComplete\n"; } );
@@ -103,9 +105,10 @@ void SimplePlaybackApp::draw ( )
         ui::Text ( "%.2f FPS", getAverageFps ( ) );
         ui::Text ( "Hardware Accelerated: %s, HasAudio: %s, HasVideo : %s", _player->IsHardwareAccelerated() ? "true" : "false", _player->HasAudio ( ) ? "true" : "false", _player->HasVideo ( ) ? "true" : "false" );
 
+        ui::Checkbox ( "Approximate Seeking", &_approximateSeeking );
         if ( ui::SliderFloat ( "Seek", &percent, 0.0f, 1.0f ) )
         {
-            _player->SeekToPercentage ( percent );
+            _player->SeekToPercentage ( percent, _approximateSeeking );
         }
 
         float rate = _player->GetPlaybackRate ( );

src/AX-MediaPlayer.cxx

@@ -125,14 +125,14 @@ namespace AX
             return _impl->GetSize ( );
         }
 
-        void MediaPlayer::SeekToSeconds ( float seconds )
+        void MediaPlayer::SeekToSeconds ( float seconds, bool approximate )
         {
-            return _impl->SeekToSeconds ( seconds );
+            return _impl->SeekToSeconds ( seconds, approximate );
         }
 
-        void MediaPlayer::SeekToPercentage ( float normalizedTime )
+        void MediaPlayer::SeekToPercentage ( float normalizedTime, bool approximate )
         {
-            return _impl->SeekToPercentage ( std::clamp ( normalizedTime, 0.0f, 1.0f ) );
+            return _impl->SeekToPercentage ( std::clamp ( normalizedTime, 0.0f, 1.0f ), approximate );
         }
 
         bool MediaPlayer::IsComplete ( ) const

src/AX-MediaPlayer.h

@@ -91,8 +91,8 @@ namespace AX::Video
         bool    HasAudio ( ) const;
         bool    HasVideo ( ) const;
 
-        void    SeekToSeconds ( float seconds );
-        void    SeekToPercentage ( float normalizedTime );
+        void    SeekToSeconds ( float seconds, bool approximate = false );
+        void    SeekToPercentage ( float normalizedTime, bool approximate = false );
 
         float   GetPositionInSeconds ( ) const;
         float   GetDurationInSeconds ( ) const;

src/Win32/AX-MediaPlayerWin32Impl.cxx

@@ -310,6 +310,8 @@ namespace AX::Video
 
                 _mediaEngine->SetSource ( SafeBSTR{ actualPath } );
                 _mediaEngine->Load ( );
+
+                _mediaEngine->QueryInterface ( _mediaEngineEx.GetAddressOf ( ) );
             }
         }
     }
@@ -532,19 +534,23 @@ namespace AX::Video
         return static_cast<float> ( _mediaEngine->GetCurrentTime ( ) );
     }
 
-    void MediaPlayer::Impl::SeekToSeconds ( float seconds )
+    void MediaPlayer::Impl::SeekToSeconds ( float seconds, bool approximate )
     {
-        if ( _mediaEngine )
+        if ( _mediaEngineEx )
+        {
+            _mediaEngineEx->SetCurrentTimeEx ( seconds, approximate ? MF_MEDIA_ENGINE_SEEK_MODE_APPROXIMATE : MF_MEDIA_ENGINE_SEEK_MODE_NORMAL );
+        }
+        else if ( _mediaEngine )
         {
             _mediaEngine->SetCurrentTime ( static_cast<double> ( seconds ) );
         }
     }
 
-    void MediaPlayer::Impl::SeekToPercentage ( float normalizedTime )
+    void MediaPlayer::Impl::SeekToPercentage ( float normalizedTime, bool approximate )
     {
         if ( _duration > 0.0f )
         {
-            SeekToSeconds ( normalizedTime * _duration );
+            SeekToSeconds ( normalizedTime * _duration, approximate );
         }
     }
 
@@ -639,6 +645,11 @@ namespace AX::Video
         _renderPath = nullptr;
         _hasNewFrame.store ( false );
 
+        // @todo(andrew): Do I need to ::Shutdown through the Ex interface
+        // or since it's likely just an upcasted IMFMediaEngine will the
+        // original interface suffice?
+        _mediaEngineEx = nullptr;
+        
         if ( _mediaEngine )
         {
             RunSynchronousInMTAThread ( [&]

src/Win32/AX-MediaPlayerWin32Impl.h

@@ -103,8 +103,8 @@ namespace AX::Video
 
         const   ci::ivec2 & GetSize ( ) const { return _size; }
 
-        void    SeekToSeconds ( float seconds );
-        void    SeekToPercentage ( float normalizedTime );
+        void    SeekToSeconds ( float seconds, bool approximate );
+        void    SeekToPercentage ( float normalizedTime, bool approximate );
 
         float   GetPositionInSeconds ( ) const;
         float   GetDurationInSeconds ( ) const { return _duration; }
@@ -131,6 +131,7 @@ namespace AX::Video
         ci::Surface8uRef            _surface{ nullptr };
         RenderPathRef               _renderPath;
         ComPtr<IMFMediaEngine>      _mediaEngine{ nullptr };
+        ComPtr<IMFMediaEngineEx>    _mediaEngineEx{ nullptr };
         mutable std::atomic_bool    _hasNewFrame{ false };
     };
 }