OnComplete signals don't fire on windows on looping videos. Apparently this is by design according to the underlying spec but it means it has to be emulated by watching for indicative state changes leading up to a loop.

Author: axjxwright

samples/SimplePlayback/src/SimplePlaybackApp.cxx

@@ -70,6 +70,7 @@ void SimplePlaybackApp::loadDefaultVideo()
 {
     auto fmt = AX::Video::MediaPlayer::Format().HardwareAccelerated( _hardwareAccelerated );
     _player = AX::Video::MediaPlayer::Create( CINDER_PATH "/samples/QuickTimeBasic/assets/bbb.mp4", fmt );
+    _player->SetLoop ( true );
     connectSignals();
     _player->Play();
 }

src/AX-MediaPlayer.cxx

@@ -154,6 +154,11 @@ namespace AX
             return _impl->SeekToPercentage ( std::clamp ( normalizedTime, 0.0f, 1.0f ), approximate );
         }
 
+        void MediaPlayer::FrameStep ( int delta )
+        {
+            return _impl->FrameStep ( delta );
+        }
+
         bool MediaPlayer::IsComplete ( ) const
         {
             return _impl->IsComplete ( );

src/AX-MediaPlayer.h

@@ -122,6 +122,8 @@ namespace AX::Video
         void    SeekToSeconds ( float seconds, bool approximate = false );
         void    SeekToPercentage ( float normalizedTime, bool approximate = false );
 
+        void    FrameStep ( int delta );
+
         float   GetPositionInSeconds ( ) const;
         float   GetDurationInSeconds ( ) const;
 

src/msw/AX-MediaPlayerMSWImpl.cxx

@@ -391,12 +391,29 @@ namespace AX::Video
             case MF_MEDIA_ENGINE_EVENT_SEEKING:
             {
                 _owner.OnSeekStart.emit();
+                _timeInSecondsAtStartOfSeek = _owner.GetPositionInSeconds ( );
                 break;
             }
 
             case MF_MEDIA_ENGINE_EVENT_SEEKED:
             {
                 _owner.OnSeekEnd.emit();
+                if ( _owner.IsLooping ( ) )
+                {
+                    // @NOTE(andrew): Since the complete event is not fired on looping videos,
+                    // the best metric I was able to rely on was an EVENT_SEEKING with current time 0
+                    // followed by an EVENT_SEEKED, also at time 0. My crude hack is to try and keep
+                    // track of the current time when these are fired and if they're both zero 
+                    // (or close to it) then to assume a loop has taken place. Not perfect, but 
+                    // since the MFMediaEngine follows the HTML5 video spec, you can take it up
+                    // with the brains trust at the W3C ;)
+
+                    auto now = _owner.GetPositionInSeconds ( );
+                    if ( now < 0.05f && ( ( now - _timeInSecondsAtStartOfSeek ) < 0.01f ) )
+                    {
+                        _owner.OnComplete.emit ( );
+                    }
+                }
                 break;
             }
 
@@ -410,7 +427,7 @@ namespace AX::Video
             {
                 _owner.OnBufferingEnd.emit();
                 break;
-            }
+            }   
 
             case MF_MEDIA_ENGINE_EVENT_ERROR:
             {
@@ -607,6 +624,14 @@ namespace AX::Video
         }
     }
 
+    void MediaPlayer::Impl::FrameStep ( int delta )
+    {
+        if ( _mediaEngineEx )
+        {
+            _mediaEngineEx->FrameStep ( delta > 0 ? true : false );
+        }
+    }
+
     bool MediaPlayer::Impl::IsComplete ( ) const
     {
         if ( _mediaEngine )

src/msw/AX-MediaPlayerMSWImpl.h

@@ -112,6 +112,8 @@ namespace AX::Video
         float   GetPositionInSeconds ( ) const;
         float   GetDurationInSeconds ( ) const { return _duration; }
 
+        void    FrameStep ( int delta );
+
         bool    CheckNewFrame ( ) const { return _hasNewFrame.load ( ); }
         const   ci::Surface8uRef & GetSurface ( ) const;
         MediaPlayer::FrameLeaseRef GetTexture ( ) const;
@@ -141,6 +143,12 @@ namespace AX::Video
         ComPtr<IMFMediaEngineEx>    _mediaEngineEx{ nullptr };
         mutable std::atomic_bool    _hasNewFrame{ false };
         std::mutex                  _eventMutex;
+
+        // This is to try and determine if a loop has occurred
+        // since there's no loop event and it's indistinguishable 
+        // from a regular user loop
+        float                       _timeInSecondsAtStartOfSeek{ 0.0f }; 
+
         struct Event
         {
             DWORD eventId{ 0 };