Unreal Engine (UE) Advent Calendar 2024 「Unreal 3DS」

// Fill out your copyright notice in the Description page of Project Settings.

using UnrealBuildTool;
using System.IO;

public class AC2024 : ModuleRules
{
  public AC2024(ReadOnlyTargetRules Target) : base(Target)
  {
    PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;

    PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });

    PrivateDependencyModuleNames.AddRange(new string[] {  });

        // Civetwebのヘッダーファイルとソースファイルのパスを設定
        string CivetwebPath = Path.Combine(ModuleDirectory, "Civetweb");
        PublicIncludePaths.Add(CivetwebPath);

        // Civetwebのソースファイルを手動でコンパイルに含める
        PrivateDependencyModuleNames.Add("Core");
        RuntimeDependencies.Add(Path.Combine(CivetwebPath, "civetweb.c"));
    PublicDefinitions.Add("NO_SSL");

    // Uncomment if you are using Slate UI
    // PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });

    // Uncomment if you are using online features
    // PrivateDependencyModuleNames.Add("OnlineSubsystem");

    // To include OnlineSubsystemSteam, add it to the plugins section in your uproject file with the Enabled attribute set to true
  }
}

http://[UEを起動しているマシンのIPアドレス]:9001/mjpeg

http://localhost:9001/mjpeg

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "CivetWeb/civetweb.h"
#include "Engine/TextureRenderTarget2D.h"

/**
 *
 */
class AC2024_API MyMotionJpegServer
{
public:
  MyMotionJpegServer();
  ~MyMotionJpegServer();

  void Start(UTextureRenderTarget2D* InLeftRenderTarget, UTextureRenderTarget2D* InRightRenderTarget, int32 InPort);
    void Stop();
    static TArray<FColor> CaptureFrame(UTextureRenderTarget2D* RenderTarget);
    static TArray<uint8> EncodeToJPEG(const TArray<FColor>& Pixels, int32 Width, int32 Height);

private:
    TWeakObjectPtr<UTextureRenderTarget2D> LeftRenderTarget;
    TWeakObjectPtr<UTextureRenderTarget2D> RightRenderTarget;

    int32 Port;
    bool bIsRunning;
    FCriticalSection CriticalSection;
    struct mg_context* Context;
    TUniquePtr<FThread> ServerThread;

    void RunServer();
    static int HandleMjpegRequest(struct mg_connection* conn, void* cbdata);
    static TArray<FColor> CombineFrames(const TArray<FColor>& LeftPixels, const TArray<FColor>& RightPixels, int32 Width, int32 Height);
};

// Fill out your copyright notice in the Description page of Project Settings.
#include "MyMotionJpegServer.h"
#include "ImageUtils.h"
#include "IImageWrapper.h"
#include "IImageWrapperModule.h"
#include "Modules/ModuleManager.h"
#include "RenderingThread.h"
#include "Async/Async.h"

/**
 * @brief Construct a new My Motion Jpeg Server:: My Motion Jpeg Server object
 *
 */
MyMotionJpegServer::MyMotionJpegServer(): Context(nullptr)
{
    // デフォルトポートの設定
    this->Port = 8080;

    // サーバスレッドの実行フラグ
    this->bIsRunning = false;
}

/**
 * @brief Destroy the My Motion Jpeg Server:: My Motion Jpeg Server object
 *
 */
MyMotionJpegServer::~MyMotionJpegServer()
{
    // サーバの停止
    Stop();
}

/**
 * @brief MotionJpegサーバの始動
 *
 * @param InLeftRenderTarget 左目カメラのRenderTarget2D
 * @param InRightRenderTarget 右目カメラのRenderTarget2D
 * @param InPort MotionJpegサーバのポート番号
 */
void MyMotionJpegServer::Start(UTextureRenderTarget2D* InLeftRenderTarget, UTextureRenderTarget2D* InRightRenderTarget, int32 InPort)
{
    // RenderTargetがnullまたは無効な場合はエラーを出力して終了
    if (!InLeftRenderTarget || !InLeftRenderTarget->IsValidLowLevelFast() ||
        !InRightRenderTarget || !InRightRenderTarget->IsValidLowLevelFast())
    {
        UE_LOG(LogTemp, Error, TEXT("Start: One or both RenderTargets are null or invalid."));
        return;
    }

    // 引数をメンバに保持
    LeftRenderTarget = InLeftRenderTarget;
    RightRenderTarget = InRightRenderTarget;
    Port = InPort;
    bIsRunning = true;

    // サーバスレッドの開始
    ServerThread = MakeUnique<FThread>(TEXT("MotionJpegServerThread"), [this]() { RunServer(); });
}

/**
 * @brief MotionJpegサーバの停止
 *
 */
void MyMotionJpegServer::Stop()
{
    // サーバスレッドの同期
    FScopeLock Lock(&CriticalSection);
    bIsRunning = false;

    // サーバスレッドの終了
    if (ServerThread.IsValid())
    {
        ServerThread->Join(); // サーバスレッドの終了を待つ
        ServerThread.Reset();
    }

    // MotionJpegサーバの停止
    if (Context)
    {
        mg_stop(Context);
        Context = nullptr;
    }
    UE_LOG(LogTemp, Log, TEXT("HTTP Server stopped"));
}

/**
 * @brief RenderTargetからフレームをキャプチャ
 *
 * @param RenderTarget 対象となるRenderTarget2D
 * @return TArray<FColor> キャプチャしたフレームのピクセルデータ
 */
TArray<FColor> MyMotionJpegServer::CaptureFrame(UTextureRenderTarget2D* RenderTarget)
{
    // 戻り値のピクセルデータ
    TArray<FColor> Pixels;

    // RenderTargetがnullまたは無効な場合はエラーを出力して終了
    if (!RenderTarget || !RenderTarget->IsValidLowLevelFast())
    {
        UE_LOG(LogTemp, Error, TEXT("CaptureFrame: RenderTarget is null or invalid."));
        return Pixels;
    }

    // ピクセルデータの取得
    FGraphEventRef Task = FFunctionGraphTask::CreateAndDispatchWhenReady([&]()
    {
        FTextureRenderTargetResource* RenderTargetResource = RenderTarget->GameThread_GetRenderTargetResource();
        if (RenderTargetResource)
        {
            RenderTargetResource->ReadPixels(Pixels);
        }
    }, TStatId(), nullptr, ENamedThreads::GameThread);

    // ピクセルデータの取得を待つ
    FTaskGraphInterface::Get().WaitUntilTaskCompletes(Task);

    // ピクセルデータの返却
    return Pixels;
}

/**
 * @brief ピクセルデータをJPEGにエンコード
 *
 * @param Pixels ピクセルデータ
 * @param Width 幅
 * @param Height 高さ
 * @return TArray<uint8> JPEGエンコードされたデータ
 */
TArray<uint8> MyMotionJpegServer::EncodeToJPEG(const TArray<FColor>& Pixels, int32 Width, int32 Height)
{
    int32 Quality = 75;

    TArray<uint8> JpegData;

    // IImageWrapperModuleを取得
    IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));

    // JPEG用のImageWrapperを作成
    TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::JPEG);
    if (!ImageWrapper.IsValid())
    {
        UE_LOG(LogTemp, Error, TEXT("Failed to create ImageWrapper for JPEG."));
        return JpegData;
    }

    // ピクセルデータをBGRAからRGBAに変換
    TArray<uint8> RawData;
    RawData.SetNum(Width * Height * 4);
    for (int32 i = 0; i < Pixels.Num(); ++i)
    {
        RawData[i * 4 + 0] = Pixels[i].R;
        RawData[i * 4 + 1] = Pixels[i].G;
        RawData[i * 4 + 2] = Pixels[i].B;
        RawData[i * 4 + 3] = Pixels[i].A;
    }

    // 画像データをJPEGフォーマットに圧縮
    if (ImageWrapper->SetRaw(RawData.GetData(), RawData.Num(), Width, Height, ERGBFormat::RGBA, 8))
    {
        JpegData = ImageWrapper->GetCompressed(Quality);
    }
    else
    {
        UE_LOG(LogTemp, Error, TEXT("Failed to compress image to JPEG."));
    }

    return JpegData;
}

/**
 * @brief 画像を左右に並べて結合
 *
 * @param LeftPixels 左画像ピクセル
 * @param RightPixels 右画像ピクセル
 * @param Width 幅
 * @param Height 高さ
 * @return TArray<FColor> 結合された画像ピクセル
 */
TArray<FColor> MyMotionJpegServer::CombineFrames(const TArray<FColor>& LeftPixels, const TArray<FColor>& RightPixels, int32 Width, int32 Height)
{
    TArray<FColor> CombinedPixels;
    CombinedPixels.SetNum(Width * 2 * Height);

    for (int32 Y = 0; Y < Height; ++Y)
    {
        for (int32 X = 0; X < Width; ++X)
        {
            // 左の画像ピクセル
            CombinedPixels[Y * Width * 2 + X] = LeftPixels[Y * Width + X];
            // 右の画像ピクセル
            CombinedPixels[Y * Width * 2 + X + Width] = RightPixels[Y * Width + X];
        }
    }

    return CombinedPixels;
}

/**
 * @brief MotionJpegサーバの起動
 *
 */
void MyMotionJpegServer::RunServer()
{
    // ポート番号の文字列化
    const FString PortStr = FString::FromInt(Port);

    // CivetWebのオプション設定
    const char* options[] = {
        "listening_ports", TCHAR_TO_ANSI(*PortStr), nullptr
    };

    // HTTPサーバの開始
    {
        FScopeLock Lock(&CriticalSection);
        Context = mg_start(nullptr, nullptr, options);
    }

    // HTTPサーバの開始に失敗した場合はエラーを出力して終了
    if (!Context)
    {
        UE_LOG(LogTemp, Error, TEXT("Failed to start HTTP Server on port %d"), Port);
        return;
    }

    // HTTPリクエストハンドラの設定(mjpegにアクセスした時の処理)
    mg_set_request_handler(Context, "/mjpeg", HandleMjpegRequest, this);
    UE_LOG(LogTemp, Log, TEXT("HTTP Server started on port %d"), Port);
}

/**
 * @brief MotionJpegストリーミング処理
 *
 * @param conn CivetWebのコネクション
 * @param cbdata CivetWebのコールバックデータ
 * @return int ステータスコード
 */
int MyMotionJpegServer::HandleMjpegRequest(struct mg_connection* conn, void* cbdata)
{
    // Civetweb取得
    MyMotionJpegServer* Server = static_cast<MyMotionJpegServer*>(cbdata);

    // RenderTargetがnullまたは無効な場合はエラーを出力して終了
    if (!Server || !Server->LeftRenderTarget.IsValid() || !Server->RightRenderTarget.IsValid())
    {
        mg_printf(conn, "HTTP/1.1 500 Internal Server Error\
\
\
\
");
        return 500;
    }

    // HTTPレスポンスヘッダの設定
    mg_printf(conn,
              "HTTP/1.1 200 OK\
\
"
              "Content-Type: multipart/x-mixed-replace; boundary=frame\
\
\
\
");

    // フレームのキャプチャとストリーミング
    while (Server->bIsRunning && conn != nullptr)
    {
        // 左右のRenderTargetからフレームをキャプチャ
        TArray<FColor> LeftPixels = CaptureFrame(Server->LeftRenderTarget.Get());
        TArray<FColor> RightPixels = CaptureFrame(Server->RightRenderTarget.Get());

        // フレームのキャプチャに失敗した場合はエラーを出力して終了
        if (LeftPixels.Num() == 0 || RightPixels.Num() == 0)
        {
            UE_LOG(LogTemp, Warning, TEXT("HandleMjpegRequest: Failed to capture frame."));
            break;
        }

        // 左右のフレームを結合
        TArray<FColor> CombinedPixels = CombineFrames(LeftPixels, RightPixels,
                                                      Server->LeftRenderTarget->SizeX,
                                                      Server->LeftRenderTarget->SizeY);

        // JPEGエンコード
        TArray<uint8> JpegData = EncodeToJPEG(CombinedPixels,
                                              Server->LeftRenderTarget->SizeX * 2,
                                              Server->LeftRenderTarget->SizeY);

        // JPEGストリーミング
        int written = mg_printf(conn,
                  "--frame\
\
"
                  "Content-Type: image/jpeg\
\
"
                  "Content-Length: %zu\
\
\
\
",
                  JpegData.Num());
        if (written <= 0){ break; }

        written = mg_write(conn, JpegData.GetData(), JpegData.Num());
        if (written <= 0){ break; }

        written = mg_printf(conn, "\
\
");
        if (written <= 0){ break; }

        // フレーム間隔待機
        FPlatformProcess::Sleep(0.033); // フレーム間隔（30FPS）
    }

    // ステータスコードの返却
    return 200;
}

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "Subsystems/WorldSubsystem.h"
#include "MyMotionJpegServer.h"
#include "MyWorldSubsystem.generated.h"

/**
 *
 */
UCLASS()
class AC2024_API UMyWorldSubsystem : public UWorldSubsystem
{
  GENERATED_BODY()

public:
    // Subsystemの初期化処理
    virtual void Initialize(FSubsystemCollectionBase& Collection) override;

    // Subsystemの終了処理
    virtual void Deinitialize() override;

  // MotionJpegServerを開始する
  UFUNCTION(BlueprintCallable, Category = "MotionJpegServer")
  void StartMotionJpegServer(UTextureRenderTarget2D* LeftRenderTarget, UTextureRenderTarget2D* RightRenderTarget, int32 Port);

private:
  // MotionJpegServer
  TUniquePtr<MyMotionJpegServer> MotionJpegServer;
};

// Fill out your copyright notice in the Description page of Project Settings.

#include "MyWorldSubsystem.h"

/**
 * @brief コンストラクタ
 *
 * @param Collection
 */
void UMyWorldSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
    Super::Initialize(Collection);
}

/**
 * @brief デストラクタ
 *
 */
void UMyWorldSubsystem::Deinitialize()
{
    // MotionJpegServerを安全に解放
    if (MotionJpegServer)
    {
        MotionJpegServer->Stop();
        MotionJpegServer.Reset();
    }

    Super::Deinitialize();
}

/**
 * @brief MotionJpegServerを開始する
 *
 * @param LeftRenderTarget 左目カメラのRebderTarget2D
 * @param RightRenderTarget 右目カメラのRenderTarget2D
 * @param Port 起動ポート
 */
void UMyWorldSubsystem::StartMotionJpegServer(UTextureRenderTarget2D* LeftRenderTarget, UTextureRenderTarget2D* RightRenderTarget, int32 Port)
{
    if (!MotionJpegServer.IsValid())
    {
        // MotionJpegServerを作成して起動
        MotionJpegServer = MakeUnique<MyMotionJpegServer>();
        MotionJpegServer->Start(LeftRenderTarget, RightRenderTarget, Port);
    }
}