IVR – User Guide

Welcome to the user guide for the Insane Video Recorder (IVR), the powerful plugin that simplifies the recording of videos and image sequences directly within Unreal Engine. This guide will walk you through the entire process, from initial setup to advanced recording techniques.

IVR has been designed to offer maximum flexibility and control over your recording workflow, allowing you to capture high-quality content for various purposes, whether for cinematic sequences, gameplay recording, or generating image datasets.

Key features of IVR include:

• Easy integration with Blueprint to control all aspects of recording.
• Support for different frame sources: render target capture, simulated frames, image folders, video files, and webcams.
• Recording individual takes and automatically concatenating them into a master video.
• Customizable video settings such as resolution, FPS, codec, and bitrate.
• Real-time frame output for immediate processing and visualization.
• Advanced feature extraction using OpenCV (if enabled) for real-time analysis of frames.

Get ready to elevate your video production in Unreal Engine with IVR!

1. Setup and Basic Usage

To start using IVR, you need to add the IVRCaptureComponent to an Actor in your level. This component is the central hub for all recording functionalities.

1.1. Adding the IVRCaptureComponent

Drag and drop the IVRCaptureComponent from the Components panel into an Actor in your level, such as your Player Character, a dedicated recording Actor, or the GameMode. This component will then expose all its functions and customizable properties in the Details panel.

1.2. Configuring Recording Settings (VideoSettings)

The VideoSettings (of type FIVR_VideoSettings) property within your IVRCaptureComponent allows you to define how your video will be captured. This is a crucial step to ensure the output matches your needs.

Key Properties:

• Width (Integer), Height (Integer): Output resolution of the video (e.g., 1920×1080).
• FPS (Float): Frames per second of the recorded video.
• Codec (String): Video codec to use (e.g., “H264”, “VP9”).
• Bitrate (Integer): Video bitrate in bits per second (bps), influencing quality and file size (e.g., 5000000 for 5 Mbps).
• PixelFormat (String): Pixel format for raw video input (e.g., “bgra”).
• FrameSourceType (Enum EIVRFrameSourceType): Defines the source of the frames for recording:
  • Simulated: Generates a simple, changing visual pattern. Useful for testing the recording pipeline without external input.
  • RenderTarget: Captures what a USceneCaptureComponent2D sees. This is the most common type for in-game recording.
  • Folder: Reads a sequence of images from a specified folder (e.g., PNG, JPG) and plays them as a video.
  • VideoFile: Reads frames from an existing video file (e.g., MP4, AVI) to process or transcode.
  • Webcam: Captures live video from a connected webcam.

1.3. Starting and Stopping Recording

Use the Start Recording and Stop Recording functions in Blueprint to control the recording process. These functions trigger the entire recording pipeline, including FFmpeg operations.

Blueprint Example: Basic Recording from a SceneCaptureComponent2D

(Your Actor Blueprint, e.g., a Camera Actor)

[Event Input: Key 'R' (Pressed)]
    |
    |---- Get IVRCaptureComponent (Self) ----> (Promote to Variable: IVRCaptureComponent_Ref)
    |                                                                |
    |                                                                |---- Set (IVRCaptureComponent_Ref->VideoSettings.Width = 1920)
    |                                                                |
    |                                                                |---- Set (IVRCaptureComponent_Ref->VideoSettings.Height = 1080)
    |                                                                |
    |                                                                |---- Set (IVRCaptureComponent_Ref->VideoSettings.FPS = 30.0)
    |                                                                |
    |                                                                |---- Set (IVRCaptureComponent_Ref->VideoSettings.FrameSourceType = RenderTarget)
    |                                                                |
    |                                                                |---- IVRCaptureComponent_Ref->Start Recording
    |                                                                |
    |                                                                |---- Print String (String: "Recording Started!")

[Event Input: Key 'T' (Pressed)]
    |
    |---- Get IVRCaptureComponent (Self) ----> IVRCaptureComponent_Ref (variable)
    |                                                               |
    |                                                               |---- Stop Recording
    |                                                               |
    |                                                               |---- Print String (String: "Recording Stopped!")

• The recorded video files will be saved by default in [YourProjectDirectory]/Saved/Recordings/.
• Each recording is initially saved as individual “takes” (e.g., Take_001.mp4).
• After stopping the overall recording session, these takes are automatically concatenated into a “master” video file.

2. Advanced Recording Techniques

2.1. Individual Takes and Master Video Generation

IVR allows you to organize your recordings into “takes” and combine them into a single “master” video. This is ideal for managing multiple segments of a longer recording or for creating different versions of a scene.

• TakeDuration (Float): Defines the duration in seconds for each individual take. After this duration, IVR automatically closes the current take and starts a new one.
• bAutoStartNewTake (Boolean): If TRUE, a new take will automatically start after the previous one finishes. If FALSE, recording will stop after the current take duration.

When you call Stop Recording on the IVRCaptureComponent, all completed takes from that session are concatenated into a single master video file, and the individual take files are then deleted. The master video filename includes a timestamp and a session ID for easy identification.

2.2. Frame Sources Details

The FrameSourceType property in VideoSettings is critical as it determines how IVR acquires video frames. Each type has specific configuration properties:

• Simulated:
  • IVR_FrameTint (Linear Color): Sets a tint color for the generated frames.
  • IVR_UseRandomPattern (Boolean): If true, generates a random color pattern; otherwise, a static color.
• RenderTarget:
  • IVR_FollowActor (Actor Reference): If set, the capture component will automatically orient itself to look at this Actor.
  • IVR_CineCameraFOV (Float): Field of View for the internal USceneCaptureComponent2D.
  • IVR_EnableCinematicPostProcessing (Boolean): Enables/disables basic cinematic post-processing settings for the capture.
• Folder:
  • IVR_FramesFolder (String): Path to the folder containing the image sequence.
  • IVR_FolderPlaybackFPS (Float): Playback speed (FPS) for the image sequence.
  • IVR_LoopFolderPlayback (Boolean): If true, loops the image sequence playback.
• VideoFile:
  • IVR_VideoFilePath (String): Path to the video file to read frames from.
  • IVR_VideoPlaybackSpeed (Float): Playback speed for the video file.
  • IVR_LoopVideoPlayback (Boolean): If true, loops the video file playback.
• Webcam:
  • IVR_WebcamIndex (Integer): Index of the webcam to use (0 for default, 1 for second, etc.).
  • IVR_WebcamResolution (Vector 2D): Desired resolution for webcam capture.
  • IVR_WebcamFPS (Float): Desired FPS for webcam capture.

2.3. Real-Time Frame Output and Feature Extraction

IVR can output frames in real-time directly within Unreal Engine, allowing for immediate visualization, processing, or interaction in Blueprint. This mode bypasses file recording and activates advanced analysis capabilities.

• bEnableRTFrames (Boolean): Located in VideoSettings, if TRUE, IVR will not save to disk. Instead, frames are sent via the OnRealTimeFrameReady delegate.
• OnRealTimeFrameReady (Dynamic Multicast Delegate): This delegate is fired every time a new frame is processed in real-time. It passes an FIVR_JustRTFrame structure containing:
  • RawDataBuffer (Array of uint8): The raw pixel data (BGRA) of the frame.
  • LiveTexture (UTexture2D*): A dynamically updated UTexture2D object that you can bind to UMG Image widgets for real-time display.
  • Features (Structure FIVR_JustRTFeatures): Contains advanced analysis data if `bDebugDrawFeatures` is true:
    • JustRTInterestPoints (Array of FIVR_JustRTPoint): Detected shapes (quadrilaterals/rectangles) and Shi-Tomasi corners, including their 2D screen positions and deprojected 3D world locations/directions.
    • NumOfQuads, NumOfRectangles: Counts of detected quadrilaterals and non-square rectangles.
    • HistogramRed, HistogramGreen, HistogramBlue: Normalized color histograms for each channel.
• bDebugDrawFeatures (Boolean): If enabled, detected features (shapes, corners) are drawn directly onto the LiveTexture, providing visual feedback.

Blueprint Example: Displaying Real-Time Output and Features

(Your Actor Blueprint)

[Event BeginPlay]
    |
    |---- Get IVRCaptureComponent (Self) ----> (Promote to Variable: IVRCaptureComponent_Ref)
    |                                                                |
    |                                                                |---- Bind Event to OnRealTimeFrameReady
    |                                                                |         |
    |                                                                |         |---- Custom Event (OnRTFrameReceived)
    |
    |---- Set (IVRCaptureComponent_Ref->VideoSettings.bEnableRTFrames = True)
    |---- Set (IVRCaptureComponent_Ref->VideoSettings.bDebugDrawFeatures = True)
    |---- IVRCaptureComponent_Ref->Start Recording

[Custom Event: OnRTFrameReceived] (Input: FrameData (FIVR_JustRTFrame))
    |
    |---- Print String (String: "RT Frame received! Quads: " + FrameData.Features.NumOfQuads)
    |---- Set Brush From Texture (Your UMG Image Widget, Texture: FrameData.LiveTexture)
    |---- (Process FrameData.Features for custom logic or display)

2.4. Video Preparation and Export

IVR provides functions to prepare videos for recording (ensuring compatibility with OpenCV if needed) and to export recorded content into widely compatible formats.

• Prepare Video for Recording: Transcodes a source video into a format optimized for OpenCV capture. This is a blocking operation and runs in a background thread.
  • InSourceVideoPath (String): Full path to the original video.
  • OutPreparedVideoPath (String): Full path for the transcoded video.
  • bOverwrite (Boolean): If true, overwrites the output file if it exists.
• Export Video to Compatible Format: Transcodes a video (e.g., a master recording) into a user-defined compatible format for distribution. This is also a blocking operation.
  • InSourceVideoPath (String): Full path to the input video.
  • OutCompatibleVideoPath (String): Full path for the exported video.
  • bOverwrite (Boolean): If true, overwrites the output file.
  • EncodingSettings (FIVR_VideoSettings): Custom encoding settings for the output video (codec, bitrate, etc.).

2.5. Events and Callbacks

IVR exposes several Blueprint-assignable delegates for status feedback:

• OnRecordingStarted: Fired when the recording process begins.
• OnRecordingPaused: Fired when recording is paused.
• OnRecordingResumed: Fired when recording is resumed.
• OnRecordingStopped: Fired when the recording process ends and the master video is generated.

These delegates allow you to integrate recording status into your game UI or gameplay logic.