Fix crashes on shipping builds

Author: genail

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Fixes
 
 - Compilation errors on shipping builds
+- Crashes on shipping builds
 
 ## 1.0.2
 

Source/BetaHubBugReporter/Private/BH_Async.h

@@ -0,0 +1,125 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Misc/ScopeLock.h"
+#include "HAL/CriticalSection.h"
+#include "Memory.h"
+
+template <typename T>
+class BH_AsyncPool
+{
+    template <typename T>
+    struct FBH_AsyncElement
+    {
+        bool bInUse;
+        T* Pointer;
+
+        FBH_AsyncElement(T* InPointer)
+            : bInUse(false)
+            , Pointer(InPointer)
+        {
+        }
+
+        bool IsInUse() const
+        {
+            return bInUse;
+        }
+
+        void SetInUse(bool InUse)
+        {
+            bInUse = InUse;
+        }
+
+        T* GetPointer()
+        {
+            return Pointer;
+        }
+    };
+    
+    TArray<FBH_AsyncElement<T>> Pool;
+    FCriticalSection CriticalSection;
+
+    public:
+    
+    BH_AsyncPool(int32 Size = 4)
+    {
+        for (int32 i = 0; i < Size; i++)
+        {
+            Pool.Add(FBH_AsyncElement<T>(new T()));
+        }
+    }
+
+    ~BH_AsyncPool()
+    {
+        for (FBH_AsyncElement<T> Element : Pool)
+        {
+            delete Element.GetPointer();
+        }
+    }
+
+    T* GetElement()
+    {
+        FScopeLock Lock(&CriticalSection);
+        for (FBH_AsyncElement<T> &Element : Pool)
+        {
+            if (!Element.IsInUse())
+            {
+                Element.SetInUse(true);
+                return Element.GetPointer();
+            }
+        }
+        return nullptr;
+    }
+
+    void ReleaseElement(T* Pointer)
+    {
+        FScopeLock Lock(&CriticalSection);
+        for (FBH_AsyncElement<T> &Element : Pool)
+        {
+            if (Element.GetPointer() == Pointer)
+            {
+                Element.SetInUse(false);
+                return;
+            }
+        }
+    }
+};
+
+template <typename T>
+class BH_AsyncQueue
+{
+    TArray<T*> Queue;
+    FCriticalSection CriticalSection;
+
+    public:
+
+    BH_AsyncQueue()
+    {
+    }
+
+    ~BH_AsyncQueue()
+    {
+        for (T* Element : Queue)
+        {
+            delete Element;
+        }
+    }
+
+    void Enqueue(T* Element)
+    {
+        FScopeLock Lock(&CriticalSection);
+        Queue.Add(Element);
+    }
+
+    T* Dequeue()
+    {
+        FScopeLock Lock(&CriticalSection);
+        if (Queue.Num() > 0)
+        {
+            T* Element = Queue[0];
+            Queue.RemoveAt(0);
+            return Element;
+        }
+        return nullptr;
+    }
+};

Source/BetaHubBugReporter/Private/BH_DoubleAsyncBuffer.h

@@ -20,7 +20,11 @@ bool ConvertRAWSurfaceDataToFLinearColor(EPixelFormat Format, uint32 Width, uint
 #endif
 
 UBH_GameRecorder::UBH_GameRecorder(const FObjectInitializer& ObjectInitializer)
-    : Super(ObjectInitializer), bIsRecording(false), bCopyTextureStarted(false), StagingTexture(nullptr), BackTextureWidth(0), BackTextureHeight(0)
+    : Super(ObjectInitializer)
+    , bIsRecording(false)
+    , bCopyTextureStarted(false)
+    , StagingTexture(nullptr)
+    , RawFrameBufferPool(3)
 {
     FrameBuffer = ObjectInitializer.CreateDefaultSubobject<UBH_FrameBuffer>(this, TEXT("FrameBuffer"));
 }
@@ -162,32 +166,33 @@ void UBH_GameRecorder::Tick(float DeltaTime)
     {
         AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [this]()
         {
-            FScopeLock Lock(&AsyncTextureProcessingLock);
-            
-            BackTextureLock.Lock();
-            TextureBuffer.SwapBuffers(); // swap back with current
-
-            const uint8 *RawData = reinterpret_cast<const uint8*>(TextureBuffer.GetCurrentBuffer());
-            int32 RawDataWidth = BackTextureWidth;
-            int32 RawDataHeight = BackTextureHeight;
+            BH_RawFrameBuffer<uint8>* TextureBuffer = RawFrameBufferQueue.Dequeue();
+            if (!TextureBuffer)
+            {
+                // no texture buffer in the queue, nothing to process
+                return;
+            }
 
-            BackTextureLock.Unlock();
-            
             // Make sure that PendingPixels is of the correct size
-            int32 NumPixels = RawDataWidth * RawDataHeight;
+            int32 NumPixels = TextureBuffer->GetWidth() * TextureBuffer->GetHeight();
 
             if (PendingLinearPixels.Num() != NumPixels)
             {
                 PendingLinearPixels.SetNumUninitialized(NumPixels);
                 PendingPixels.SetNumUninitialized(NumPixels);
             }
 
-            uint32 Pitch = GPixelFormats[StagingTextureFormat].BlockBytes * RawDataWidth;
+            uint32 Pitch = GPixelFormats[StagingTextureFormat].BlockBytes * TextureBuffer->GetWidth();
 
 
             // Convert raw surface data to linear color
-            ConvertRAWSurfaceDataToFLinearColor(StagingTextureFormat, RawDataWidth, RawDataHeight, const_cast<uint8*>(RawData),
-                Pitch, PendingLinearPixels.GetData(), FReadSurfaceDataFlags({}));
+            ConvertRAWSurfaceDataToFLinearColor(
+                StagingTextureFormat,
+                TextureBuffer->GetWidth(), TextureBuffer->GetHeight(),
+                TextureBuffer->GetData(),
+                Pitch,
+                PendingLinearPixels.GetData(),
+                FReadSurfaceDataFlags({}));
 
             // Convert linear color to FColor
             for (int32 i = 0; i < NumPixels; ++i)
@@ -196,7 +201,7 @@ void UBH_GameRecorder::Tick(float DeltaTime)
             }
 
             // Resize image to frame
-            ResizeImageToFrame(PendingPixels, RawDataWidth, RawDataHeight, FrameWidth, FrameHeight, ResizedPixels);
+            ResizeImageToFrame(PendingPixels, TextureBuffer->GetWidth(), TextureBuffer->GetHeight(), FrameWidth, FrameHeight, ResizedPixels);
 
             // Set frame data on the game thread
             AsyncTask(ENamedThreads::GameThread, [this]()
@@ -206,6 +211,7 @@ void UBH_GameRecorder::Tick(float DeltaTime)
 
             // only when I complete this, allow another read pixels
             bCopyTextureStarted = false;
+            RawFrameBufferPool.ReleaseElement(TextureBuffer);
         });
     }
 }
@@ -332,25 +338,31 @@ void UBH_GameRecorder::ReadPixels()
             FViewport* Viewport = GEngine->GameViewport->Viewport;
             if (!Viewport) return;
 
+            BH_RawFrameBuffer<uint8>* TextureBuffer = RawFrameBufferPool.GetElement();
+            if (!TextureBuffer)
+            {
+                // no texture buffer available at this time
+                // UE_LOG(LogTemp, Error, TEXT("No texture buffer available."));
+                return;
+            }
+
             FRHICopyTextureInfo CopyInfo;
             RHICmdList.CopyTexture(GEngine->GameViewport->Viewport->GetRenderTargetTexture(), StagingTexture, CopyInfo);
 
-            void* RawDataTemp = nullptr;
-            int32 RawDataWidthTemp = 0;
-            int32 RawDataHeightTemp = 0;
-
-            RHICmdList.MapStagingSurface(StagingTexture, RawDataTemp, RawDataWidthTemp, RawDataHeightTemp);
+            void* RawData = nullptr;
+            int32 RawDataWidth = 0;
+            int32 RawDataHeight = 0;
 
-            // copy the memory, because RawDataTemp is temporary
-            BackTextureLock.Lock();
+            RHICmdList.MapStagingSurface(StagingTexture, RawData, RawDataWidth, RawDataHeight);
 
-            TextureBuffer.MemCopyFrom(
-                reinterpret_cast<uint8*>(RawDataTemp),
-                RawDataWidthTemp * RawDataHeightTemp * GPixelFormats[StagingTextureFormat].BlockBytes);
-            BackTextureWidth = RawDataWidthTemp;
-            BackTextureHeight = RawDataHeightTemp;
+            TextureBuffer->CopyFrom(
+                reinterpret_cast<uint8*>(RawData),
+                RawDataWidth,
+                RawDataHeight,
+                GPixelFormats[StagingTextureFormat].BlockBytes);
 
-            BackTextureLock.Unlock();
+            // async queue for processing
+            RawFrameBufferQueue.Enqueue(TextureBuffer);
 
             RHICmdList.UnmapStagingSurface(StagingTexture);
         }

Source/BetaHubBugReporter/Private/BH_GameRecorder.cpp

@@ -7,7 +7,8 @@
 #include "BH_FrameBuffer.h"
 #include "UObject/NoExportTypes.h"
 #include "BH_SceneCaptureActor.h"
-#include "BH_DoubleAsyncBuffer.h"
+#include "BH_Async.h"
+#include "BH_RawFrameBuffer.h"
 #include "BH_GameRecorder.generated.h"
 
 UCLASS()
@@ -66,11 +67,8 @@ class BETAHUBBUGREPORTER_API UBH_GameRecorder : public UObject, public FTickable
     int32 FrameHeight;
     FDateTime LastCaptureTime;
 
-    BH_DoubleAsyncBuffer<uint8> TextureBuffer;
-    int32 BackTextureWidth;
-    int32 BackTextureHeight;
-    FCriticalSection BackTextureLock;
-    FCriticalSection AsyncTextureProcessingLock;
+    BH_AsyncQueue<BH_RawFrameBuffer<uint8>> RawFrameBufferQueue;
+    BH_AsyncPool<BH_RawFrameBuffer<uint8>> RawFrameBufferPool;
 
     void CaptureFrame();
     void CaptureRenderTargetFrame();