> ## Documentation Index
> Fetch the complete documentation index at: https://docs.liv.tv/llms.txt
> Use this file to discover all available pages before exploring further.

# Frequently Asked Questions

> Frequently asked questions about LIV Camera Kit for Unreal Engine. Installation, recording, streaming, audio, compatibility, and pricing.

## General

<AccordionGroup>
  <Accordion title="What is LIV Camera Kit (LCK)?">
    LCK is an in-game camera SDK for Unity and Unreal Engine that lets developers add user-spawnable cameras, video recording, screenshot capture, and live streaming to their games. It is the official capture solution for Meta Quest, integrated in 300+ Quest apps.
  </Accordion>

  <Accordion title="What Unreal Engine versions are supported?">
    Unreal Engine 5.4+ and Meta Fork.
  </Accordion>

  <Accordion title="What platforms does LCK support?">
    Meta Quest 2, Quest 3, Quest 3s, and Windows PCVR (DirectX 11 or Vulkan). On Android (Quest), Vulkan is required — OpenGL ES is not supported for video encoding.
  </Accordion>

  <Accordion title="How do I get the SDK?">
    Register on the [LIV Developer Dashboard](https://dashboard.liv.tv/dev/login), create your game entry, and download the SDK. See the [Installation guide](/unreal/installation).
  </Accordion>

  <Accordion title="Is LCK free to use?">
    LCK is free for developers. See the [SDK License Agreement](https://www.liv.tv/legal/sdk-license-agreement) for terms.
  </Accordion>

  <Accordion title="What plugins are included in the SDK?">
    The SDK is modular. **Required:** LCK (core recording & encoding), LCKAudio (audio interface). **Recommended:** LCKUI (3D button components), LCKTablet (virtual tablet interface), LCKUnrealAudio (Unreal Engine audio capture). **Optional:** LCKOboe (Android low-latency mic), LCKFMOD, LCKWwise, LCKVivox (audio middleware integrations — disabled by default, require third-party plugins).
  </Accordion>

  <Accordion title="How do I report bugs or get help?">
    Join the [LIV Discord community](https://discord.com/invite/liv) for direct support.
  </Accordion>
</AccordionGroup>

## Recording

<AccordionGroup>
  <Accordion title="What recording quality presets are available?">
    Four quality profiles are pre-configured:

    | Profile | Resolution  | Framerate | Video Bitrate | Audio Bitrate |
    | ------- | ----------- | --------- | ------------- | ------------- |
    | SD      | 1280 x 720  | 30 fps    | 4 Mbps        | 128 Kbps      |
    | HD      | 1920 x 1080 | 60 fps    | 12 Mbps       | 256 Kbps      |
    | 2K      | 2560 x 1440 | 60 fps    | 20 Mbps       | 320 Kbps      |
    | 4K      | 3840 x 2160 | 60 fps    | 35 Mbps       | 320 Kbps      |

    All profiles use 48 kHz audio sample rate. Framerate and bitrate are adjustable per profile in **Project Settings > Plugins > LCK SDK**.
  </Accordion>

  <Accordion title="What is the output file format?">
    Recordings are saved as MP4 files (H.264 video, AAC audio). Photos are saved as PNG files.
  </Accordion>

  <Accordion title="Where are recordings and photos saved?">
    **Android (Quest):** Videos are saved to `Movies/{GameName}` and photos to `Pictures/{GameName}`.

    **Windows:** Videos are saved to `{User}/Videos/{GameName}` and photos to `{User}/Pictures/{GameName}`.

    The `{GameName}` subfolder name is set in **Project Settings > Plugins > LCK SDK > Game Name**.
  </Accordion>

  <Accordion title="Can users take screenshots?">
    Yes. Call `Service->TakePhoto()` or use the tablet UI photo button. Photos are captured as a single frame from the active scene capture component and saved as PNG to the platform's gallery.
  </Accordion>

  <Accordion title="Can I control recording programmatically?">
    Yes. The `ULCKRecorderSubsystem` (a `UTickableWorldSubsystem`) provides full recording control:

    ```cpp theme={null}
    ULCKRecorderSubsystem* Recorder = GetWorld()->GetSubsystem<ULCKRecorderSubsystem>();
    Recorder->StartRecording();   // Start
    Recorder->StopRecording();    // Stop
    Recorder->TakePhoto();        // Capture a photo
    Recorder->IsRecording();      // Query state
    Recorder->GetTime();          // Current duration in seconds
    ```

    Async variants (`StartRecordingAsync`, `StopRecordingAsync`) are also available with completion and progress callbacks.
  </Accordion>

  <Accordion title="Can I pause and resume a recording?">
    Yes. If using the LCKTablet plugin, `ULCKService` provides `PauseRecording()` and `ResumeRecording()`. The recording state transitions to `ELCKRecordingState::Paused` and back to `Recording` when resumed. Paused segments are excluded from the final output.
  </Accordion>

  <Accordion title="Does recording work in Preview mode?">
    Yes. Use `Recorder->StartPreview()` to start capturing frames without encoding to disk. This is useful for live camera preview and composition. Call `Recorder->StopPreview()` to stop.
  </Accordion>

  <Accordion title="Why is my Tracking ID required?">
    Recording will not work without a valid Tracking ID. Get one from [https://dashboard.liv.tv/dev/login](https://dashboard.liv.tv/dev/login?welcome=false).
  </Accordion>
</AccordionGroup>

## Camera & Tablet

<AccordionGroup>
  <Accordion title="What camera modes are included?">
    Three modes ship with the tablet:

    * **Selfie** — Front/back facing camera attached to the tablet. Default: 80° FOV, 50% smoothness, 2.0m follow distance, follow mode off.
    * **First-Person** — Captures from the player's HMD perspective. Default: 90° FOV, 75% smoothness.
    * **Third-Person** — Follows the player at a distance via SpringArm. Default: 90° FOV, 100% smoothness, 2.0m distance, -30° pitch.

    All modes support adjustable FOV (20°-120°, step 5°), smoothness (0%-100%, step 5%), and distance (0.5-10.0m, step 0.5).
  </Accordion>

  <Accordion title="How do I spawn the tablet?">
    Place `ALCKTablet` (or `BP_LCKTablet`) in your level, or spawn it programmatically:

    ```cpp theme={null}
    ALCKTablet* Tablet = GetWorld()->SpawnActor<ALCKTablet>();
    ```

    The tablet auto-initializes on BeginPlay, loading saved user preferences (camera mode, FOV, quality, etc.) from disk.
  </Accordion>

  <Accordion title="Are camera settings saved between sessions?">
    Yes. The tablet uses a JSON-based save system (`FLCKJsonSaveHelper`) that persists all user preferences: camera mode, FOV per mode, smoothness, follow distance, screen orientation, video quality, and camera facing. Settings are saved automatically on change and loaded on BeginPlay.
  </Accordion>

  <Accordion title="How does VR controller interaction work?">
    Tablet buttons use collision-based interaction. Each button has a `UBoxComponent` for collision detection. When a VR controller (or any collider) overlaps a button, `ButtonPressed` fires; when overlap ends, `ButtonReleased` fires. Buttons include an automatic cooldown to prevent double-triggers.
  </Accordion>

  <Accordion title="Can I add custom buttons to the tablet?">
    Yes. Create a class extending `ULCKBaseButton` (or `ULCKToggle` / `ULCKStepper` for toggles or step controls), override `ButtonPressed()`, and add it to the tablet component hierarchy. Register it with the `ULCKUISystem` to enable UI feedback. See the existing button implementations in the LCKUI plugin for examples.
  </Accordion>
</AccordionGroup>

## Audio

<AccordionGroup>
  <Accordion title="What audio engines are supported?">
    Five audio source plugins are available:

    | Plugin         | Channels                | Platforms      | Notes                        |
    | -------------- | ----------------------- | -------------- | ---------------------------- |
    | LCKUnrealAudio | Game + Microphone       | All            | Built-in, enabled by default |
    | LCKFMOD        | Game only               | Win64, Android | Requires FMODStudio plugin   |
    | LCKWwise       | Game only               | Win64, Android | Requires Wwise plugin        |
    | LCKOboe        | Microphone only         | Android only   | Low-latency via Google Oboe  |
    | LCKVivox       | Microphone + Voice Chat | Win64, Android | Requires VivoxCore plugin    |

    Game audio middleware priority: **FMOD > Wwise > UnrealAudio**. Only one game audio middleware should be active at a time.
  </Accordion>

  <Accordion title="How do I enable FMOD, Wwise, or Vivox audio?">
    These plugins are **disabled by default** because they require third-party plugins to compile. To enable:

    1. Install the third-party plugin (FMODStudio, Wwise, or VivoxCore)
    2. Set `"Enabled": true` for both the third-party plugin and the LCK audio plugin in your `.uproject`
    3. Rebuild the project

    If using FMOD or Wwise for game audio, disable "Game Audio" in the UnrealAudio settings to avoid conflicts.
  </Accordion>

  <Accordion title="Can I use Vivox alongside FMOD or Wwise?">
    Yes. LCKVivox captures voice chat audio (incoming voice + outgoing microphone), not game audio. It can safely coexist with FMOD/Wwise/UnrealAudio without conflicts.
  </Accordion>

  <Accordion title="What audio format do sources provide?">
    All audio sources deliver 32-bit float PCM, interleaved stereo (L,R,L,R...) at 48 kHz by default. The sample rate is queried from the active audio device at capture start.
  </Accordion>

  <Accordion title="Audio callbacks may come from different threads — how do I handle this?">
    Audio data callbacks can fire on the audio render thread, audio capture thread, or middleware threads depending on the source. If you need to process audio on the game thread, queue it:

    ```cpp theme={null}
    AsyncTask(ENamedThreads::GameThread, [Data = TArray<float>(PCM)]() {
        ProcessAudioOnGameThread(Data);
    });
    ```

    LCKVivox has the most robust thread safety (uses `TAtomic` for all state). FMOD/Wwise copy buffers to TArrays before dispatching. The built-in `FLCKAudioMix` class handles thread-safe mixing internally.
  </Accordion>
</AccordionGroup>

## Platform-Specific

<AccordionGroup>
  <Accordion title="Is Vulkan required on Android?">
    **Yes.** The LCK encoder on Android uses Vulkan + EGL texture interop for hardware-accelerated H.264 encoding. OpenGL ES is **not supported** for video encoding. Ensure Vulkan is enabled in your Android project settings and OpenGL ES is removed.
  </Accordion>

  <Accordion title="What Android permissions does LCK need?">
    * `RECORD_AUDIO` — Required for microphone capture (must be requested at runtime on Android 6.0+)
    * `WRITE_EXTERNAL_STORAGE` / `READ_EXTERNAL_STORAGE` — Only needed on Android 9 and below; Android 10+ uses scoped storage via MediaStore automatically
  </Accordion>

  <Accordion title="What Quest devices are supported?">
    | Device         | Status       | Recommended Quality             |
    | -------------- | ------------ | ------------------------------- |
    | Meta Quest 2   | Full Support | SD (720p) or HD (1080p) @ 30fps |
    | Meta Quest 3   | Full Support | HD (1080p) @ 60fps              |
    | Meta Quest 3s  | Full Support | HD (1080p) @ 60fps              |
    | Meta Quest Pro | Full Support | HD (1080p) @ 60fps              |
  </Accordion>

  <Accordion title="How do I reduce performance impact on Quest?">
    1. Use SD (720p) or HD (1080p) at 30 fps
    2. Lower the video bitrate (4 Mbps is good for SD)
    3. Use `Preview` mode for camera composition before recording
    4. The hardware encoder runs on a dedicated chip and has minimal impact on game framerate — the main cost is the scene capture component rendering an extra view
  </Accordion>

  <Accordion title="Windows encoder fails to initialize — what do I check?">
    1. Verify Windows Media Foundation is available (built into Windows 10+)
    2. Ensure your GPU drivers are up to date (NVIDIA, AMD, or Intel)
    3. Check that the `AVCodecsCore` plugin is enabled in your project
    4. Look for errors in the `LogLCKEncoding` log category
  </Accordion>
</AccordionGroup>

## Integration & Setup

<AccordionGroup>
  <Accordion title="What is the difference between ULCKService and ULCKRecorderSubsystem?">
    **`ULCKRecorderSubsystem`** (in LCKCore) is the low-level recording API — a `UTickableWorldSubsystem` that handles encoding, frame capture, and file output. Access it via `GetWorld()->GetSubsystem<ULCKRecorderSubsystem>()`.

    **`ULCKService`** (in LCKTablet) is a high-level wrapper that adds pause/resume, error delegates (`OnRecordingError`, `OnRecordingSaveFinished`), quality profile management, and integration with the tablet UI. Access it through the tablet or create one programmatically.

    Use `ULCKService` if you want the full feature set. Use `ULCKRecorderSubsystem` directly if you need minimal integration without the LCKTablet plugin.
  </Accordion>

  <Accordion title="What modules do I add to my Build.cs?">
    **Minimal (recording only):**

    ```csharp theme={null}
    PublicDependencyModuleNames.AddRange(new string[] {
        "LCKCore",
        "LCKAudio"
    });
    ```

    **Full (with tablet UI):**

    ```csharp theme={null}
    PublicDependencyModuleNames.AddRange(new string[] {
        "LCKCore",
        "LCKAudio",
        "LCKUI",
        "LCKTablet"
    });
    ```
  </Accordion>

  <Accordion title="What is the module loading order?">
    The SDK loads modules in this order:

    1. **LCKVulkan** (EarliestPossible) — Vulkan support layer
    2. Platform encoders: **LCKWindowsEncoder** or **LCKAndroidEncoder** (Default phase)
    3. **LCKAudio** (PostDefault) — Audio interface
    4. **LCKCore** (PostDefault) — Core recording subsystem
    5. Audio middleware plugins (LCKFMOD, LCKWwise, LCKVivox, LCKOboe) and UI plugins (LCKUI, LCKTablet) load at Default phase

    `LCKVulkan` must load first as it provides the Vulkan context required by platform encoders. LCKAudio and LCKCore load at PostDefault to ensure platform encoders are already registered.
  </Accordion>

  <Accordion title="Do I need to set up a scene capture component manually?">
    If you use the **LCKTablet**, it creates and manages a `USceneCaptureComponent2D` automatically. If you use the recording API directly without the tablet, you need to either pass a capture component to `SetupRecorder()` or set one later via `SetSceneCaptureComponent()`.
  </Accordion>

  <Accordion title="What telemetry does the SDK collect?">
    The SDK sends anonymized usage events (recording start/stop, errors, performance metrics) to `errors.liv.tv`. Device telemetry is enabled by default and can be disabled in Project Settings. Location telemetry is disabled by default. A valid Tracking ID is required.
  </Accordion>
</AccordionGroup>

## Constraints & Limitations

<AccordionGroup>
  <Accordion title="Can I record and stream at the same time?">
    Recording and streaming share the same hardware encoder. Streaming can piggyback on an active recording encoder, but a new recording cannot start while streaming is active. Stop streaming before starting a recording.
  </Accordion>

  <Accordion title="Are 2K and 4K recording available on Quest?">
    No. Only SD (720p) and HD (1080p) quality options are available on Meta Quest devices. 2K and 4K profiles are Windows-only due to hardware encoder limitations.
  </Accordion>

  <Accordion title="Why is Quest 2 HD capped at 30 fps / 8 Mbps?">
    The Quest 2 hardware encoder cannot reliably sustain 1080p at 60 fps. HD is automatically capped to 30 fps and 8 Mbps on Quest 2. Quest 3 and Quest 3S do not have this cap.
  </Accordion>

  <Accordion title="Why doesn't Wwise show microphone level?">
    `GetVolume()` returns 0 for the Wwise audio source. Mic level indicators will not work with LCKWwise. Use LCKFMOD, LCKOboe, or LCKUnrealAudio if you need mic level display.
  </Accordion>

  <Accordion title="Why doesn't Wwise capture microphone audio?">
    LCKWwise captures game audio only. To capture microphone audio alongside Wwise, pair it with LCKOboe (Android), LCKUnrealAudio, or LCKVivox.
  </Accordion>

  <Accordion title="Why doesn't FMOD capture microphone audio?">
    LCKFMOD captures game audio only. To capture microphone audio alongside FMOD, pair it with LCKOboe (Android) or LCKUnrealAudio.
  </Accordion>

  <Accordion title="Why doesn't Oboe capture game audio?">
    LCKOboe captures microphone audio only via the Android Oboe low-latency API. To capture game audio alongside Oboe, pair it with LCKFMOD, LCKWwise, or LCKUnrealAudio.
  </Accordion>

  <Accordion title="Why is there no audio in my recording?">
    If no audio middleware plugin (LCKFMOD, LCKWwise, LCKVivox) is configured, and LCKUnrealAudio is not enabled, recordings will have no game audio. Enable LCKUnrealAudio as a fallback.
  </Accordion>

  <Accordion title="Does LaunchHub() work on Windows?">
    `LaunchHub()` is a no-op on Windows — the LIV Hub companion app is Android-only. `IsHubInstalled()` returns `true` on non-Android platforms to avoid blocking UI flows.
  </Accordion>

  <Accordion title="Does gallery save work on Windows?">
    On Windows, recordings are saved to `{User}/Videos/{GameName}` and photos to `{User}/Pictures/{GameName}`. The `LCKAndroidGallery` module (with progress callback for MediaStore) is Android-only.
  </Accordion>

  <Accordion title="Does SIGPIPE handling affect my app?">
    On Android and Linux, the LCKStreaming plugin globally suppresses `SIGPIPE` via `signal(SIGPIPE, SIG_IGN)` to prevent crashes from broken RTMP sockets. This may affect other libraries in the same process that rely on `SIGPIPE` signals.
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Recording doesn't start — what should I check?">
    1. Verify the **Tracking ID** is set and valid (UUID v4) in Project Settings
    2. Ensure a valid `USceneCaptureComponent2D` is registered
    3. On Android, confirm **Vulkan** is enabled (not OpenGL ES)
    4. Check `LogLCK` and `LogLCKEncoding` log categories for errors
    5. If using the LCKTablet plugin, subscribe to `ULCKService::OnRecordingError` for runtime error messages. If using `ULCKRecorderSubsystem` directly, check log categories for errors
  </Accordion>

  <Accordion title="Video is black but audio works">
    The scene capture component is likely not rendering:

    1. Verify the capture component is enabled and visible
    2. Check that a valid render target is assigned
    3. Ensure the capture component resolution matches the recording profile
    4. Try `CaptureComponent->CaptureScene()` to force a manual capture
  </Accordion>

  <Accordion title="No audio in recording">
    1. Verify at least one audio plugin is enabled (LCKUnrealAudio is the default)
    2. On Android, ensure the `RECORD_AUDIO` permission is granted at runtime
    3. Check that audio sources are registered: look for `"Found LCK Audio Source"` in logs
    4. If using FMOD or Wwise, disable "Game Audio" in UnrealAudio settings to avoid conflicts
  </Accordion>

  <Accordion title="How do I enable verbose logging?">
    Add to `DefaultEngine.ini`:

    ```ini theme={null}
    [Core.Log]
    LogLCK=VeryVerbose
    LogLCKEncoding=VeryVerbose
    LogLCKAudio=VeryVerbose
    LogLCKUI=Verbose
    LogLCKTablet=Verbose
    ```
  </Accordion>
</AccordionGroup>