Added the ability to manage the lifetime of MediaFoundation manually. Previously MediaFoundation was started up and shutdown automatically when the first and last MediaPlayer instance was created and deleted respectively, however these are heavy blocking operations and can introduce noticeable hitches. You can now opt out of the automatic management with MediaPlayer::Format::AutoInitialize(), however you are then required to manually call MediaPlayer::StaticInitialize() / MediaPlayer::StaticShutdown() at the beginning and end of your app's lifetime. This is useful when your application creates and deletes a lot of video player instances. Affects the MF backend only, on macOS this is a no-op.

Author: axjxwright

src/AX-MediaPlayer.cxx

@@ -56,6 +56,16 @@ namespace AX
             return *this;
         }
 
+        void MediaPlayer::StaticInitialize ( )
+        {
+            MediaPlayer::Impl::StaticInitialize ( );
+        }
+
+        void MediaPlayer::StaticShutdown ( )
+        {
+            MediaPlayer::Impl::StaticShutdown ( );
+        }
+
         MediaPlayerRef MediaPlayer::Create ( const ci::DataSourceRef & source, const MediaPlayer::Format& fmt )
         {
             return MediaPlayerRef ( new MediaPlayer ( source, fmt ) );

src/AX-MediaPlayer.h

@@ -62,11 +62,13 @@ namespace AX::Video
             Format & AudioOnly ( bool audioOnly ) { _audioOnly = audioOnly; return *this; }
             Format & AudioDevice ( const ci::audio::DeviceFwdRef & device );
             Format & HardwareAccelerated ( bool accelerated ) { _hardwareAccelerated = accelerated; return *this; }
+            Format & AutoInitialize ( bool autoInit ) { _autoInit = autoInit; return *this; }
 
             bool    IsAudioEnabled ( ) const { return _audioEnabled;  }
             bool    IsAudioOnly ( ) const { return _audioOnly; }
             bool    IsHardwareAccelerated ( ) const { return _hardwareAccelerated; }
             const std::string & AudioDeviceID ( ) const { return _audioDeviceId; }
+            bool    IsAutoInitialized ( ) const { return _autoInit; };
 
             Format ( ) { };
 
@@ -76,6 +78,7 @@ namespace AX::Video
             bool        _audioOnly{ false };
             bool        _hardwareAccelerated{ false };
             std::string _audioDeviceId{ "" };
+            bool        _autoInit{ true };
         };
 
         using   FrameLeaseRef = std::unique_ptr<FrameLease>;
@@ -85,6 +88,13 @@ namespace AX::Video
 
         static  MediaPlayerRef Create ( const ci::DataSourceRef & source, const Format & fmt = Format ( ) );
         static  MediaPlayerRef Create ( const ci::fs::path & filePath, const Format & fmt = Format ( ) );
+
+        // @note(andrew): If !fmt.IsAutoInitialized(), these are required to be called manually.
+        // The use case is to have any heavy initialization / shutdown not be tied to the lifetime
+        // of a specific MediaPlayer instance to remove hitches when creating and destroying 
+        // video players often.
+        static  void StaticInitialize ( );
+        static  void StaticShutdown ( );
 
         static  const std::string & ErrorToString ( Error error );
         inline const Format & GetFormat ( ) const { return _format; }

src/msw/AX-MediaPlayerMSWImpl.cxx

@@ -28,12 +28,13 @@ using namespace ci;
 namespace
 {
     static std::atomic_int kNumMediaFoundationInstances = 0;
+    static std::atomic_bool kIsMFInitialized = false;
 
     static void OnMediaPlayerCreated ( )
     {
         if ( kNumMediaFoundationInstances++ == 0 )
         {
-            MFStartup ( MF_VERSION );
+            kIsMFInitialized = SUCCEEDED ( MFStartup ( MF_VERSION ) );
         }
     }
 
@@ -42,6 +43,7 @@ namespace
         if ( --kNumMediaFoundationInstances == 0 )
         {
             MFShutdown ( );
+            kIsMFInitialized = false;
         }
     }
 
@@ -259,12 +261,31 @@ namespace AX::Video
         app::App::get ( )->dispatchSync ( [&] { callback ( ); } );
     }
 
+    void MediaPlayer::Impl::StaticInitialize ( )
+    {
+        if ( !kIsMFInitialized )
+        {
+            kIsMFInitialized = SUCCEEDED (MFStartup (MF_VERSION));
+        }
+    }
+
+    void MediaPlayer::Impl::StaticShutdown ( )
+    {
+        if ( kIsMFInitialized ) MFShutdown ( );
+        kIsMFInitialized = false;
+    }
+
     MediaPlayer::Impl::Impl ( MediaPlayer & owner, const DataSourceRef & source, const Format& format )
         : _owner ( owner )
         , _source ( source )
         , _format( format )
     {
-        OnMediaPlayerCreated ( );
+        if ( _format.IsAutoInitialized() ) OnMediaPlayerCreated ();
+        if ( !kIsMFInitialized )
+        {
+            throw std::runtime_error ("MediaFoundation not initialized! Set MediaPlayer::Format::AutoInitialize or call MediaPlayer::StaticInitialize() to manually manage lifetime!");
+            return;
+        }
 
         ComPtr<IMFMediaEngineClassFactory> factory;
         if ( SUCCEEDED ( CoCreateInstance ( CLSID_MFMediaEngineClassFactory, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS ( &factory ) ) ) )
@@ -745,6 +766,6 @@ namespace AX::Video
             _mediaEngine = nullptr;
         }
 
-        OnMediaPlayerDestroyed ( );
+        if ( _format.IsAutoInitialized() ) OnMediaPlayerDestroyed ( );
     }
 }

src/msw/AX-MediaPlayerMSWImpl.h

@@ -74,6 +74,9 @@ namespace AX::Video
         friend class DXGIRenderPath;
         friend class WICRenderPath;
 
+        static void StaticInitialize ( );
+        static void StaticShutdown ( );
+
         Impl    ( MediaPlayer & owner, const ci::DataSourceRef & source, const Format& format );
 
         bool    Update ( );