Merge pull request #274 from ffmpeginteropx/fix-leaks

Author: lukasf

Source/D3D11VideoSampleProvider.h

@@ -45,6 +45,21 @@ namespace FFmpegInteropX
             }
         }
 
+    public:
+
+        virtual ~D3D11VideoSampleProvider()
+        {
+            ReleaseTrackedSamples();
+        }
+
+        virtual void Flush() override
+        {
+            UncompressedVideoSampleProvider::Flush();
+            ReturnTrackedSamples();
+        }
+
+    internal:
+
         virtual HRESULT CreateBufferFromFrame(IBuffer^* pBuffer, IDirect3DSurface^* surface, AVFrame* avFrame, int64_t& framePts, int64_t& frameDuration) override
         {
             HRESULT hr = S_OK;
@@ -120,20 +135,46 @@ namespace FFmpegInteropX
         {
             if (sample->Direct3D11Surface)
             {
-                samples.insert(reinterpret_cast<IUnknown*>(sample));
-                sample->Processed += ref new Windows::Foundation::TypedEventHandler<Windows::Media::Core::MediaStreamSample^, Platform::Object^>(this, &D3D11VideoSampleProvider::OnProcessed);
+                std::lock_guard<std::mutex> lock(samplesMutex);
+
+                // AddRef the sample on native interface to prevent it from being collected before Processed is called
+                auto sampleNative = reinterpret_cast<IUnknown*>(sample);
+                sampleNative->AddRef();
+
+                // Attach Processed event and store in samples list
+                auto token = sample->Processed += ref new Windows::Foundation::TypedEventHandler<Windows::Media::Core::MediaStreamSample^, Platform::Object^>(this, &D3D11VideoSampleProvider::OnProcessed);
+                trackedSamples[sampleNative] = token;
             }
 
             return UncompressedVideoSampleProvider::SetSampleProperties(sample);
         };
 
         void OnProcessed(Windows::Media::Core::MediaStreamSample^ sender, Platform::Object^ args)
         {
-            auto unknown = reinterpret_cast<IUnknown*>(sender->Direct3D11Surface);
+            std::lock_guard<std::mutex> lock(samplesMutex);
+
+            auto sampleNative = reinterpret_cast<IUnknown*>(sender);
+            auto mapEntry = trackedSamples.find(sampleNative);
+            if (mapEntry == trackedSamples.end())
+            {
+                // sample was already released during Flush() or destructor
+            }
+            else
+            {
+                // Release the sample's native interface and return texture to pool
+                sampleNative->Release();
+                trackedSamples.erase(mapEntry);
+
+                ReturnTextureToPool(sender);
+            }
+        }
+
+        void ReturnTextureToPool(MediaStreamSample^ sample)
+        {
             IDXGISurface* surface = NULL;
             ID3D11Texture2D* texture = NULL;
 
-            HRESULT hr = DirectXInteropHelper::GetDXGISurface(sender->Direct3D11Surface, &surface);
+            HRESULT hr = DirectXInteropHelper::GetDXGISurface(sample->Direct3D11Surface, &surface);
 
             if (SUCCEEDED(hr))
             {
@@ -145,12 +186,45 @@ namespace FFmpegInteropX
                 texturePool->ReturnTexture(texture);
             }
 
-            samples.erase(reinterpret_cast<IUnknown*>(sender));
-
             SAFE_RELEASE(surface);
             SAFE_RELEASE(texture);
         }
 
+        void ReleaseTrackedSamples()
+        {
+            std::lock_guard<std::mutex> lock(samplesMutex);
+            for (auto entry : trackedSamples)
+            {
+                // detach Processed event and release native interface
+                auto sampleNative = entry.first;
+                auto sample = reinterpret_cast<MediaStreamSample^>(sampleNative);
+
+                sample->Processed -= entry.second;
+                sampleNative->Release();
+            }
+
+            trackedSamples.clear();
+        }
+
+        void ReturnTrackedSamples()
+        {
+            std::lock_guard<std::mutex> lock(samplesMutex);
+            for (auto entry : trackedSamples)
+            {
+                // detach Processed event and release native interface
+                auto sampleNative = entry.first;
+                auto sample = reinterpret_cast<MediaStreamSample^>(sampleNative);
+
+                sample->Processed -= entry.second;
+                sampleNative->Release();
+
+                // return texture to pool
+                ReturnTextureToPool(sample);
+            }
+
+            trackedSamples.clear();
+        }
+
         virtual HRESULT SetHardwareDevice(ID3D11Device* device, ID3D11DeviceContext* context, AVBufferRef* avHardwareContext) override
         {
             HRESULT hr = S_OK;
@@ -379,8 +453,8 @@ namespace FFmpegInteropX
         }
 
         TexturePool^ texturePool;
-        std::set<IUnknown*> samples;
-
+        std::map<IUnknown*,EventRegistrationToken> trackedSamples;
+        std::mutex samplesMutex;
     };
 }
 

Source/FFmpegMediaSource.cpp

@@ -120,7 +120,11 @@ FFmpegMediaSource::~FFmpegMediaSource()
     videoStreams.clear();
 
     avformat_close_input(&avFormatCtx);
-    av_free(avIOCtx);
+
+    // must set opaque pointer to NULL, othewise ffmpeg will assume it is some internal URLContext and crash trying to free it
+    avIOCtx->opaque = NULL;
+    avio_closep(&avIOCtx);
+    
     av_dict_free(&avDict);
 
     if (fileStreamData != nullptr)
@@ -143,7 +147,11 @@ FFmpegMediaSource::~FFmpegMediaSource()
     SAFE_RELEASE(deviceContext);
     SAFE_RELEASE(deviceManager);
 
-    PlaybackSession = nullptr;
+    if (PlaybackSession)
+    {
+        PlaybackSession->PositionChanged -= sessionPositionEvent;
+        PlaybackSession = nullptr;
+    }
 
     mutexGuard.unlock();
 }
@@ -1600,13 +1608,6 @@ void FFmpegMediaSource::OnStarting(MediaStreamSource^ sender, MediaStreamSourceS
     // Perform seek operation when MediaStreamSource received seek event from MediaElement
     if (request->StartPosition && request->StartPosition->Value.Duration <= mediaDuration.Duration && (!isFirstSeek || request->StartPosition->Value.Duration > 0))
     {
-        TimeSpan actualPosition = request->StartPosition->Value;
-        auto hr = Seek(request->StartPosition->Value, actualPosition, true);
-        if (SUCCEEDED(hr))
-        {
-            request->SetActualStartPosition(actualPosition);
-        }
-
         if (currentVideoStream && !currentVideoStream->IsEnabled)
         {
             currentVideoStream->EnableStream();
@@ -1616,6 +1617,13 @@ void FFmpegMediaSource::OnStarting(MediaStreamSource^ sender, MediaStreamSourceS
         {
             currentAudioStream->EnableStream();
         }
+
+        TimeSpan actualPosition = request->StartPosition->Value;
+        auto hr = Seek(request->StartPosition->Value, actualPosition, true);
+        if (SUCCEEDED(hr))
+        {
+            request->SetActualStartPosition(actualPosition);
+        }
     }
 
     isFirstSeek = false;

Source/StringUtils.h

@@ -22,9 +22,11 @@ namespace FFmpegInteropX
         {
             if (!char_array) return std::wstring(L"");
 
-            std::string s_str = std::string(char_array);
-            std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
-            std::wstring wid_str = myconv.from_bytes(s_str);
+            auto required_size = MultiByteToWideChar(CP_UTF8, 0, char_array, -1, NULL, 0);
+            wchar_t* buffer = (wchar_t*)calloc(required_size, sizeof(wchar_t));
+            auto result = MultiByteToWideChar(CP_UTF8, 0, char_array, -1, buffer, required_size);
+            std::wstring wid_str = std::wstring(buffer);
+            free(buffer);
             return wid_str;
         }
 
@@ -39,13 +41,15 @@ namespace FFmpegInteropX
             return ref new Platform::String(input.c_str(), (unsigned int)input.length());
         }
 
-
         static std::string PlatformStringToUtf8String(String^ value)
         {
-            std::wstring strW(value->Begin(), value->Length());
-            std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
-            return myconv.to_bytes(strW);
+            int required_size = WideCharToMultiByte(CP_UTF8, 0, value->Data(), -1, NULL, 0, NULL, NULL);
+            char* buffer = (char*)calloc(required_size, sizeof(char));
+            auto result = WideCharToMultiByte(CP_UTF8, 0, value->Data(), -1, buffer, required_size, NULL, NULL);
+            std::string s_str = std::string(buffer);
+            free(buffer);
+            return s_str;
         }
 
     };
-}
+}