ILCKEncoder Interface (Unreal)

What Problem Does This Solve?

ILCKEncoder abstracts platform-specific video encoding so you don’t have to:

Windows uses Media Foundation
Android uses NDK MediaCodec
Quest uses Vulkan texture interop

The interface lets LCK support multiple platforms with a single API. Most developers never interact with this directly—ULCKService handles it all.

When to Use This

Read this if:

Building a custom encoder (very advanced)
Debugging encoding issues
Understanding LCK’s internal architecture
Extending LCK to new platforms

Skip this if: You’re just using LCK for recording. Use ULCKService instead.

Interface Definition

class ILCKEncoder : public TSharedFromThis<ILCKEncoder, ESPMode::ThreadSafe>, public FRunnable
{
public:
    // Lifecycle
    virtual bool Open() noexcept = 0;
    virtual bool IsEncoding() const noexcept = 0;

    // Encoding
    virtual void EncodeTexture(FTextureRHIRef& Texture, float TimeSeconds) = 0;
    virtual void EncodeAudio(TArrayView<float> PCMData) = 0;

    // Finalization
    virtual void Save(TFunction<void(float)> ProgressCallback) = 0;

    // Queries
    [[nodiscard]] virtual float GetAudioTime() const noexcept = 0;

    // Dual output (v1.0)
    virtual void SetRecordToDisk(bool bRecord) { bRecordToDisk = bRecord; }
    virtual void AddPacketSink(ILCKPacketSink* Sink) {}
    virtual void RemovePacketSink(ILCKPacketSink* Sink) {}
    virtual void* GetNativeEncoderHandle() { return nullptr; }

    bool bRecordToDisk = true;
};

Method	What It Does	When It’s Called
`Open()`	Initialize encoder, allocate resources	Before first frame
`IsEncoding()`	Check if encoder is active	State queries
`EncodeTexture()`	Encode a video frame	Every frame during recording
`EncodeAudio()`	Encode audio samples	Audio callbacks
`Save()`	Finalize and write MP4 file	After last frame
`GetAudioTime()`	Get current audio timestamp	A/V sync
`SetRecordToDisk()`	Control disk output (false for stream-only)	Before encoding starts
`AddPacketSink()`	Register a packet sink for RTMP streaming	Before encoding starts
`RemovePacketSink()`	Unregister a packet sink	After streaming stops

Encoder Factory

Encoders are discovered and created via Unreal’s modular features system:

class ILCKEncoderFactory : public IModularFeature,
                           public TSharedFromThis<ILCKEncoderFactory, ESPMode::ThreadSafe>
{
public:
    static FName GetModularFeatureName() noexcept;

    [[nodiscard]] virtual const FString& GetEncoderName() const noexcept = 0;

    [[nodiscard]] virtual TSharedPtr<ILCKEncoder, ESPMode::ThreadSafe> CreateEncoder(
        uint32 Width,          // Video width (e.g., 1920)
        uint32 Height,         // Video height (e.g., 1080)
        uint32 VideoBitrate,   // Video bitrate in bps (e.g., 12000000 = 12 Mbps)
        uint32 Framerate,      // Target FPS (e.g., 60)
        uint32 Samplerate,     // Audio sample rate (e.g., 48000 Hz)
        uint32 AudioBitrate    // Audio bitrate in bps (e.g., 256000 = 256 Kbps)
    ) const noexcept = 0;
};

Finding an Encoder at Runtime

ILCKEncoderFactory* Factory = nullptr;
auto& ModularFeatures = IModularFeatures::Get();

if (ModularFeatures.IsModularFeatureAvailable(ILCKEncoderFactory::GetModularFeatureName()))
{
    Factory = &ModularFeatures.GetModularFeature<ILCKEncoderFactory>(
        ILCKEncoderFactory::GetModularFeatureName()
    );
}

if (Factory)
{
    UE_LOG(LogLCK, Log, TEXT("Encoder available: %s"), *Factory->GetEncoderName());
    
    // Create encoder
    TSharedPtr<ILCKEncoder> Encoder = Factory->CreateEncoder(
        1920, 1080,   // HD resolution
        12 << 20,     // 12 Mbps video bitrate
        60,           // 60 FPS
        48000,        // 48 kHz audio
        256000        // 256 Kbps audio bitrate
    );
}

Platform Implementations

Windows: FLCKWindowsEncoder

Technologies:

IMFSinkWriter — MP4 muxing
IMFTransform — H.264 video encoding
IMFMediaType — AAC audio encoding
Direct3D 11 texture interop

Key features:

Hardware-accelerated encoding via GPU
Triple-buffered texture pool (avoids GPU stalls)
Async encoding thread
Supports DX11 render targets

Error handling example:

HRESULT hr = SinkWriter->WriteSample(VideoStreamIndex, Sample);
if (FAILED(hr))
{
    UE_LOG(LogLCKEncoding, Error, TEXT("WriteSample failed: 0x%08X"), hr);
    
    // Common errors:
    // 0x80070057 = Invalid parameter
    // 0xC00D36B4 = Codec not found
    // 0x8007000E = Out of memory
}

Triple-buffered texture pool:

// Why triple buffering?
// 1. GPU is rendering to texture 0
// 2. Encoder is reading from texture 1  
// 3. Texture 2 is free for next frame
// Result: No GPU-CPU sync stalls

class FTexturePool
{
    static constexpr int32 PoolSize = 3;
    TArray<FTextureRHIRef> Textures;
    int32 CurrentIndex = 0;
    
public:
    FTextureRHIRef GetNextTexture()
    {
        FTextureRHIRef Texture = Textures[CurrentIndex];
        CurrentIndex = (CurrentIndex + 1) % PoolSize;
        return Texture;
    }
};

Android: FLCKAndroidEncoder

Technologies:

AMediaCodec — H.264/AAC hardware encoding
AMediaMuxer — MP4 container
Vulkan/EGL texture interop
Android Hardware Buffer

Key features:

Hardware-accelerated encoding on Quest
Vulkan texture export via EGL
Low-latency pipeline
Direct write to device storage

Vulkan interop flow:

// 1. Export Vulkan texture to Android Hardware Buffer
VkExternalMemoryHandleTypeFlagBits HandleType = 
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;

// 2. Import into MediaCodec surface
AMediaCodec_queueInputBuffer(Codec, BufferIndex, 0, Size, TimeUs, 0);

// 3. MediaCodec encodes directly from GPU memory
// No CPU-side texture readback needed!

Why Vulkan interop is critical:

Quest uses Vulkan for rendering
CPU readback would be too slow (kills performance)
EGL interop lets encoder access GPU memory directly
This is why LCKVulkan module must load at EarliestPossible phase

Data Flow

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  Scene Capture  │────>│  Render Target  │────>│  Texture Pool   │
│  Component      │     │  (RenderTarget) │     │  (3 buffers)    │
└─────────────────┘     └─────────────────┘     └────────┬────────┘
                                                         │
                                                         v
┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   MP4 File      │<────│  Video Encoder  │<────│  GPU Readback   │
│  (Movies dir)   │     │  (H.264, AAC)   │     │  (RHI Command)  │
└─────────────────┘     └─────────────────┘     └─────────────────┘
                                ↑
                                │
                    ┌───────────┴───────────┐
                    │   Audio Mixer         │
                    │   (Game, Mic, Vivox)  │
                    └───────────────────────┘

Audio Encoding

Audio flows from audio sources → mixer → encoder:

void ILCKEncoder::EncodeAudio(TArrayView<float> PCMData)
{
    // Input: 32-bit float, interleaved stereo
    // Sample rate: typically 48000 Hz
    // Format: [L, R, L, R, L, R, ...]
    
    // Convert float (-1.0 to 1.0) to int16
    TArray<int16> IntSamples;
    IntSamples.SetNum(PCMData.Num());
    
    for (int32 i = 0; i < PCMData.Num(); ++i)
    {
        float Sample = FMath::Clamp(PCMData[i], -1.0f, 1.0f);
        IntSamples[i] = static_cast<int16>(Sample * 32767.0f);
    }
    
    // Pass to platform encoder
    // Windows: IMFTransform (AAC)
    // Android: AMediaCodec (AAC)
}

Thread Safety

Encoding runs on a dedicated background thread:

class ILCKEncoder : public FRunnable
{
protected:
    FRunnableThread* EncoderThread;
    FCriticalSection EncodingMutex;
    TQueue<FEncodingTask> TaskQueue;
    std::atomic<bool> bShouldRun;
    
public:
    virtual uint32 Run() override
    {
        while (bShouldRun)
        {
            FEncodingTask Task;
            if (TaskQueue.Dequeue(Task))
            {
                FScopeLock Lock(&EncodingMutex);
                ProcessTask(Task);
            }
        }
        return 0;
    }
};

Why threading matters:

Encoding is CPU-intensive
Running on game thread would cause stuttering
Background thread keeps game smooth
Queue-based design prevents race conditions

Creating a Custom Encoder

This is advanced usage. Most developers should use the built-in platform encoders. Only create a custom encoder if:

You need a different codec (HEVC, VP9)
You need a different container (WebM, AVI)
You’re porting LCK to a new platform

Step 1: Implement ILCKEncoder

class FMyCustomEncoder : public ILCKEncoder
{
public:
    virtual bool Open() noexcept override
    {
        // Initialize your encoder
        // Allocate buffers, set up codec
        bIsActive = true;
        return true;
    }

    virtual bool IsEncoding() const noexcept override
    {
        return bIsActive;
    }

    virtual void EncodeTexture(FTextureRHIRef& Texture, float TimeSeconds) override
    {
        // 1. Read texture from GPU
        // 2. Convert to encoder's expected format
        // 3. Pass to codec
    }

    virtual void EncodeAudio(TArrayView<float> PCMData) override
    {
        // 1. Convert float to int16
        // 2. Pass to audio codec
    }

    virtual void Save(TFunction<void(float)> ProgressCallback) override
    {
        // 1. Flush encoder
        // 2. Write file
        // 3. Call ProgressCallback(0.0 to 1.0)
        bIsActive = false;
    }

    virtual float GetAudioTime() const noexcept override
    {
        return CurrentAudioTime;
    }

private:
    bool bIsActive = false;
    float CurrentAudioTime = 0.0f;
};

Step 2: Create Factory

class FMyEncoderFactory : public ILCKEncoderFactory
{
public:
    virtual const FString& GetEncoderName() const noexcept override
    {
        static const FString Name = TEXT("MyCustomEncoder");
        return Name;
    }

    virtual TSharedPtr<ILCKEncoder, ESPMode::ThreadSafe> CreateEncoder(
        uint32 Width, uint32 Height, uint32 VideoBitrate,
        uint32 Framerate, uint32 Samplerate, uint32 AudioBitrate) const noexcept override
    {
        TSharedPtr<FMyCustomEncoder, ESPMode::ThreadSafe> Encoder =
            MakeShared<FMyCustomEncoder, ESPMode::ThreadSafe>();

        // Configure encoder with provided parameters
        // ...

        return Encoder;
    }
};

Step 3: Register via Modular Features

class FMyEncoderModule : public IModuleInterface
{
private:
    FMyEncoderFactory EncoderFactory;
    
public:
    virtual void StartupModule() override
    {
        // Register encoder factory
        IModularFeatures::Get().RegisterModularFeature(
            ILCKEncoderFactory::GetModularFeatureName(),
            &EncoderFactory
        );
        
        UE_LOG(LogLCK, Log, TEXT("MyCustomEncoder registered"));
    }
    
    virtual void ShutdownModule() override
    {
        // Unregister
        IModularFeatures::Get().UnregisterModularFeature(
            ILCKEncoderFactory::GetModularFeatureName(),
            &EncoderFactory
        );
    }
};

IMPLEMENT_MODULE(FMyEncoderModule, MyEncoder)

Debugging Encoder Issues

Enable Verbose Logging

; DefaultEngine.ini
[Core.Log]
LogLCKEncoding=VeryVerbose

What you’ll see:

LogLCKEncoding: Encoder initialized: Windows Media Foundation
LogLCKEncoding: Video: 1920x1080 @ 60fps, 12 Mbps
LogLCKEncoding: Audio: 48000 Hz stereo, 256 Kbps
LogLCKEncoding: Frame 0 encoded (8.2ms)
LogLCKEncoding: Frame 30 encoded (7.9ms)
LogLCKEncoding: Audio buffer: 2048 samples, 42.7ms
LogLCKEncoding: Finalizing video file...
LogLCKEncoding: MP4 saved: C:/Users/.../recording_001.mp4

Common Encoder Errors

Windows:

LogLCKEncoding: Error: IMFSinkWriter creation failed (0xC00D36B4)

Fix: H.264 codec not installed (rare on Windows 10/11)

Android:

LogLCKEncoding: Error: AMediaCodec configure failed

Fix: Unsupported resolution or bitrate for device

Vulkan interop:

LogLCKEncoding: Error: Vulkan texture export failed

Fix: Ensure LCKVulkan module loads at EarliestPossible phase

Key Takeaways

Platform abstraction — One interface, multiple implementations

Modular features — Runtime encoder discovery and creation

Triple buffering — Prevents GPU stalls on texture readback

Background thread — Encoding doesn’t block game thread

Most devs don’t need this — Use ULCKService for recording

Architecture — How encoders fit into the system
Module Loading — Platform-specific encoder modules
Service Interface — High-level recording API
Best Practices — Encoding performance tips

​What Problem Does This Solve?

​When to Use This

​Interface Definition

​Encoder Factory

​Finding an Encoder at Runtime

​Platform Implementations

​Windows: FLCKWindowsEncoder

​Android: FLCKAndroidEncoder

​Data Flow

​Audio Encoding

​Thread Safety

​Creating a Custom Encoder

​Step 1: Implement ILCKEncoder

​Step 2: Create Factory

​Step 3: Register via Modular Features

​Debugging Encoder Issues

​Enable Verbose Logging

​Common Encoder Errors

​Key Takeaways

​Related

What Problem Does This Solve?

When to Use This

Interface Definition

Encoder Factory

Finding an Encoder at Runtime

Platform Implementations

Windows: FLCKWindowsEncoder

Android: FLCKAndroidEncoder

Data Flow

Audio Encoding

Thread Safety

Creating a Custom Encoder

Step 1: Implement ILCKEncoder

Step 2: Create Factory

Step 3: Register via Modular Features

Debugging Encoder Issues

Enable Verbose Logging

Common Encoder Errors

Key Takeaways

Related