Gyroflow

https://docs.gyroflow.xyz/app
Admin
Gyroflow is a free and open-source, cross-platform video stabilization software that uses gyro data...
Tokens:6,438
Snippets:28
Trust Score:8.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Example: Stabilizing GoPro Hero 11 Video

Source: https://context7.com/context7/gyroflow_xyz_app/llms.txt

A specific example demonstrating the stabilization process for a GoPro Hero 11 video, including file loading, profile selection, and export settings.

```bash
# Example: Processing a GoPro Hero 11 video
# 1. Drag "GP0123.MP4" into Gyroflow
# 2. Lens profile auto-loads: "GoPro Hero 11 Black - 4K 16:9 Wide"
# 3. No sync needed (built-in timing is accurate)
# 4. Enable Horizon Lock if desired
# 5. Set Output path: "/Users/username/Videos/GP0123_stabilized.mp4"
# 6. Choose codec: H.265/HEVC, Bitrate: 150 Mbps, GPU encoding: ON
# 7. Click Export
```

--------------------------------

### macOS Installation via Homebrew

Source: https://docs.gyroflow.xyz/app/getting-started/installation

Installs Gyroflow using the Homebrew package manager on macOS. Includes commands for both initial installation and upgrading the application. Assumes Homebrew is already installed.

```bash
brew install gyroflow
brew update && brew upgrade gyroflow
```

--------------------------------

### Build and Run Gyroflow on Windows

Source: https://docs.gyroflow.xyz/app/technical-details/building-from-source

These commands are for building and running the Gyroflow application on Windows. They involve installing dependencies and compiling the project using the 'just' build tool.

```shell
just install-deps
just run
```

--------------------------------

### Install Gyroflow on Linux

Source: https://context7.com/context7/gyroflow_xyz_app/llms.txt

Instructions for installing Gyroflow on Linux via manual download and dependencies for GPU acceleration (NVIDIA, Intel, AMD).

```bash
wget https://gyroflow.xyz/download/Gyroflow-linux64.tar.gz
tar -xzf Gyroflow-linux64.tar.gz
cd Gyroflow-linux64
./Gyroflow

# Install Dependencies (Ubuntu/Debian)
sudo apt install libc++-dev libva2 libvdpau1 libasound2 libxkbcommon0 \
  libpulse0 libvulkan1

# NVIDIA GPU Support
sudo apt install nvidia-opencl-icd nvidia-vaapi-driver \
  nvidia-vdpau-driver nvidia-egl-icd nvidia-vulkan-icd \
  libnvcuvid1 libnvidia-encode1

# Intel GPU Support
sudo apt install intel-media-va-driver i965-va-driver \
  beignet-opencl-icd intel-opencl-icd

# AMD GPU Support
sudo apt install mesa-vdpau-drivers mesa-va-drivers mesa-opencl-icd \
  libegl-mesa0 mesa-vulkan-drivers
```

--------------------------------

### Gyroflow CLI Usage Examples

Source: https://context7.com/context7/gyroflow_xyz_app/llms.txt

Demonstrates various command-line options for processing videos with Gyroflow. This includes basic stabilization, applying presets, rendering from project files, watching folders, custom output parameters via JSON, synchronization parameters, output suffixes, overwriting files, parallel rendering, exporting project files and metadata, exporting STmaps, loading external gyro files, specifying GPU devices, disabling GPU decoding, setting actions when done, printing progress, and opening videos in the GUI. These examples cover a wide range of automation and batch processing scenarios.

```bash
# Basic CLI usage - Stabilize a video file (sync-less cameras only)
gyroflow VIDEO_FILE.mp4

# Apply a preset/lens profile during processing
gyroflow VIDEO_FILE.mp4 --preset MY_SETTINGS.gyroflow

# Render from a project file
gyroflow MY_PROJECT.gyroflow

# Watch folder - Automatically stabilize new videos in a directory
gyroflow --watch /path/to/footage_folder/

# Custom output parameters with JSON configuration
gyroflow VIDEO.mp4 --out-params '{ "codec": "H.265/HEVC", "bitrate": 150, "use_gpu": true, "audio": true }'

# Synchronization parameters for cameras requiring sync
gyroflow VIDEO.mp4 --sync-params '{ "search_size": 3, "processing_resolution": 720 }'

# Custom output suffix
gyroflow VIDEO.mp4 --suffix "_stabilized"

# Overwrite existing output files
gyroflow VIDEO.mp4 --overwrite

# Parallel rendering (process multiple files simultaneously)
gyroflow VIDEO1.mp4 VIDEO2.mp4 VIDEO3.mp4 --parallel-renders 2

# Export project file instead of rendering video
# 1 = default project, 2 = with gyro data, 3 = with processed gyro, 4 = video + project
gyroflow VIDEO.mp4 --export-project 2

# Export metadata to JSON
# Type 1 = full metadata, 2 = parsed metadata, 3 = camera data
gyroflow VIDEO.mp4 --export-metadata "3:camera_data.json"

# Export metadata with custom fields
gyroflow VIDEO.mp4 --export-metadata "3:output.json" \
  --export-metadata-fields '{ "original": { "gyroscope": true, "accelerometer": true, "quaternion": true, "euler_angles": true }, "stabilized": { "quaternion": true, "euler_angles": true }, "zooming": { "minimal_fovs": true, "fovs": true, "focal_length": true } }'

# Export STmap (spatial transformation map)
# Type 1 = single frame, 2 = all frames
gyroflow VIDEO.mp4 --export-stmap "1:/path/to/stmaps/"

# Load external gyro file
gyroflow VIDEO.mp4 --gyro-file EXTERNAL_GYRO.csv

# Specify processing and rendering GPU devices
gyroflow VIDEO.mp4 --processing-device 0 --rendering-device "nvidia"

# Available rendering devices: "nvidia", "intel", "amd", "apple m"

# Disable GPU decoding (use CPU for video decoding)
gyroflow VIDEO.mp4 --no-gpu-decoding

# Shut down computer when done
# 1=shutdown, 2=reboot, 3=sleep, 4=hibernate, 5=logout
gyroflow VIDEO1.mp4 VIDEO2.mp4 --when-done 1

# Print progress to stdout
gyroflow VIDEO.mp4 --stdout-progress

# Open video in GUI
gyroflow --open VIDEO.mp4

# Complex example: Batch process with custom settings
gyroflow /footage/*.mp4 \
  --preset /presets/drone_settings.gyroflow \
  --suffix "_stable" \
  --overwrite \
  --parallel-renders 3 \
  --out-params '{ "codec": "H.264/AVC", "bitrate": 100, "use_gpu": true }' \
  --rendering-device "nvidia" \
  --stdout-progress

```

--------------------------------

### Build and Run Gyroflow on macOS

Source: https://docs.gyroflow.xyz/app/technical-details/building-from-source

These commands are for building and running the Gyroflow application on macOS. They include installing dependencies, compiling, and deploying the application.

```shell
just install-deps
just run
just deploy
just run
```

--------------------------------

### Build and Run Gyroflow for iOS

Source: https://docs.gyroflow.xyz/app/technical-details/building-from-source

These commands are for building and running the Gyroflow application on iOS. They include installing dependencies, configuring signing information, and compiling the application for device deployment.

```shell
just install-deps
just ios run
```

--------------------------------

### Linux Dependencies Installation

Source: https://docs.gyroflow.xyz/app/getting-started/installation

Installs essential dependencies for running Gyroflow on Debian/Ubuntu-based Linux distributions. Also provides commands for installing GPU-specific driver packages for NVIDIA, Intel, and AMD.

```bash
sudo apt install libc++-dev libva2 libvdpau1 libasound2 libxkbcommon0 libpulse0 libvulkan1
# NVIDIA
sudo apt install nvidia-opencl-icd nvidia-vaapi-driver nvidia-vdpau-driver nvidia-egl-icd nvidia-vulkan-icd libnvcuvid1 libnvidia-encode1
# Intel
sudo apt install intel-media-va-driver i965-va-driver beignet-opencl-icd intel-opencl-icd
# AMD
sudo apt install mesa-vdpau-drivers mesa-va-drivers mesa-opencl-icd libegl-mesa0 mesa-vulkan-drivers
```

--------------------------------

### Build and Deploy Gyroflow for Android on Windows

Source: https://docs.gyroflow.xyz/app/technical-details/building-from-source

These commands are specific to building and deploying the Gyroflow application for Android on a Windows environment. They involve installing Android-specific dependencies and compiling the APK.

```shell
just android install-deps
just android deploy
```

--------------------------------

### Gyroflow CLI Usage and Options

Source: https://docs.gyroflow.xyz/app/advanced-usage/command-line-cli

This snippet outlines the general usage of the Gyroflow CLI, including positional arguments for input files and a comprehensive list of available options for controlling video processing, output parameters, synchronization, and device selection. It specifies defaults and provides examples for complex parameters.

```bash
Usage: gyroflow [<input...>] [-f] [-j <parallel-renders>] [-d <when-done>] [-p <out-params>] [-t <suffix>] [-s <sync-params>] [--stdout-progress] [--export-project <export-project>] [--export-metadata <export-metadata>] [--export-metadata-fields <export-metadata-fields>] [--export-stmap <export-stmap>] [--preset <preset>] [--open <open>] [--watch <watch>] [-g <gyro-file>] [-b <processing-device>] [-r <rendering-device>] [--no-gpu-decoding] [--version]

Gyroflow v1.6.2
Video stabilization using gyroscope data

Positional Arguments:
  input             input files: videos, project files, lens profiles, presets

Options:
  -f, --overwrite   overwrite if output file exists, default: false
  -j, --parallel-renders
                    number of parallel renders, default: 1
  -d, --when-done   when done: 1 - shut down; 2 - reboot; 3 - sleep; 4 -
                    hibernate; 5 - logout
  -p, --out-params  output parameters, eg. "{{ 'codec': 'H.265/HEVC',
                    'bitrate': 150, 'use_gpu': true, 'audio': true }}"
  -t, --suffix      default output suffix, eg. "_stabilized"
  -s, --sync-params synchronization parameters, eg. "{{ 'search_size': 3,
                    'processing_resolution': 720 }}"
  --stdout-progress print progress to stdout in addition to progress bars
  --export-project  export project file instead of rendering: 1 - default
                    project, 2 - with gyro data, 3 - with processed gyro data, 4
                    - video + project file
  --export-metadata export metadata instead of rendering. <type>:<path>, where
                    type is 1 - full metadata, 2 - parsed metadata, 3 - camera
                    data. Eg. "3:camera.json"
  --export-metadata-fields
                    fields to include in the exported camera metadata file.
                    Defaults to all: "{{ 'original': {{ 'gyroscope': true,
                    'accelerometer': true, 'quaternion': true, 'euler_angles':
                    true }}, 'stabilized': {{ 'quaternion': true,
                    'euler_angles': true }}, 'zooming': {{ 'minimal_fovs':
                    true, 'fovs': true, 'focal_length': true }} }}"
  --export-stmap    export STmap instead of rendering. <type>:<folder_path>,
                    where type is 1 - single frame, 2 - all frames. Eg.
                    "1:C:/stmaps/"
  --preset          preset (file or content directly), eg. "{{ 'version': 2,
                    'stabilization': {{ 'fov': 1.5 }} }}"
  --open            open file in the GUI (video or project)
  --watch           watch folder for automated processing
  -g, --gyro-file   gyro file path
  -b, --processing-device
                    processing device index. By default it uses the one set in
                    the GUI
  -r, --rendering-device
                    rendering device, specify the GPU type. Eg. "nvidia",
                    "intel", "amd", "apple m"
  --no-gpu-decoding don't use gpu video decoding, default: false
  --version         print app version
  --help, help      display usage information

```

--------------------------------

### GCSV Log Format Example - CSV

Source: https://docs.gyroflow.xyz/app/technical-details/gcsv-format

This snippet demonstrates the structure of a GCSV log file containing gyroscope and accelerometer data. It includes header information such as version, ID, orientation, and scaling factors, followed by timestamped sensor readings.

```csv
GYROFLOW IMU LOG
version,1.3
id,custom_logger_name
orientation,YxZ
note,development_test
fwversion,FIRMWARE_0.1.0
timestamp,1644159993
vendor,potatocam
videofilename,videofilename.mp4
lensprofile,potatocam/potatocam_mark1_prime_7_5mm_4k
lens_info,wide
frame_readout_time,15.23
frame_readout_direction,0
tscale,0.001
gscale,0.00122173047
ascale,0.00048828125
t,gx,gy,gz,ax,ay,az
0,39,86,183,-1137,-15689,-2986
1,56,100,202,-1179,-15694,-2887
2,63,108,218,-1247,-15702,-2794
3,71,108,243,-1308,-15675,-2727
4,83,101,268,-1420,-15662,-2661
5,101,93,294,-1575,-15661,-2629
6,121,95,319,-1677,-15654,-2639
7,143,97,348,-1709,-15673,-2654
8,163,98,362,-1704,-15691,-2685
9,173,93,371,-1678,-15698,-2736
10,181,98,375,-1623,-15697,-2810
11,173,105,365,-1578,-15693,-2929
12,159,111,363,-1555,-15711,-3057
13,157,113,348,-1540,-15747,-3159
14,157,118,327,-1542,-15780,-3246
15,153,123,310,-1595,-15812,-3319
...
```

--------------------------------

### GCSV Log Format Example with Magnetometer - CSV

Source: https://docs.gyroflow.xyz/app/technical-details/gcsv-format

This snippet illustrates an extended GCSV log file that includes magnetometer data in addition to gyroscope and accelerometer readings. It shows the 'mscale' field for magnetometer scaling and the 'mx,my,mz' columns in the data section.

```csv
GYROFLOW IMU LOG
version,1.3
id,custom_logger_name
orientation,YxZ
note,development_test
fwversion,FIRMWARE_0.1.0
timestamp,1644159993
vendor,potatocam
videofilename,videofilename.mp4
lensprofile,potatocam_mark1_prime_7_5mm_4k
tscale,0.001
gscale,0.00122173047
ascale,0.00048828125
mscale,0.00059875488
t,gx,gy,gz,ax,ay,az,mx,my,mz
0,39,86,183,-1137,-15689,-2986,123,345,546
1,56,100,202,-1179,-15694,-2887,124,344,560
...
```

--------------------------------

### Gyroflow CLI Basic Rendering

Source: https://docs.gyroflow.xyz/app/advanced-usage/command-line-cli

Demonstrates the fundamental command for rendering a stabilized video file. It shows how to specify the input video and optionally apply a preset file for custom settings and lens profiles.

```bash
Gyroflow.exe YOUR_FILE.mp4
Gyroflow.exe --preset YOUR_PRESET.gyroflow YOUR_FILE.mp4
```

--------------------------------

### Comment out CLI run in gyroflow.rs

Source: https://docs.gyroflow.xyz/app/technical-details/building-from-source

This Rust code snippet shows how to comment out the `cli::run()` function call in `gyroflow.rs`. This is a step required for enabling QML debugging.

```rust
// cli::run();

```

--------------------------------

### Run Gyroflow with QML Debugger Args

Source: https://docs.gyroflow.xyz/app/technical-details/building-from-source

This command runs the Gyroflow application with arguments enabling the QML JavaScript debugger. It's used for debugging QML code in conjunction with Qt Creator.

```shell
cargo run -- "-qmljsdebugger=port:1234,block,services:CanvasFrameRate,EngineControl,DebugMessages"
```

--------------------------------

### Compile Gyroflow in Profile Mode for Windows

Source: https://docs.gyroflow.xyz/app/technical-details/building-from-source

This command compiles the Gyroflow application in a specific 'profile' mode for performance analysis on Windows using Cargo. It's intended to be used in conjunction with Visual Studio's performance profiler.

```shell
cargo run --profile profile
```

--------------------------------

### Enable QML Debugging in build.rs

Source: https://docs.gyroflow.xyz/app/technical-details/building-from-source

This Rust code snippet demonstrates how to uncomment a line in the build script (`build.rs`) to enable QML debugging. This is a prerequisite for using the QML debugger.

```rust
config.define("QT_QML_DEBUG", None);

```

--------------------------------

### Basic Stabilization Workflow (Manual Sync)

Source: https://context7.com/context7/gyroflow_xyz_app/llms.txt

Steps for stabilizing video from cameras requiring manual gyro data synchronization. This involves loading the video, lens profile, synchronizing motion data points, and exporting.

```bash
# Workflow for cameras requiring synchronization (RED, RunCam, Hawkeye, older GoPros)
# 1. Load video file into Gyroflow
# 2. Select or load appropriate lens profile from Lens Profile dropdown
# 3. Verify motion data is loaded (Motion data section)
# 4. Synchronization:
#    - Locate section with significant motion in all directions
#    - Right-click on timeline → "Auto sync here"
#    - Verify lighter optical flow lines overlap darker gyro lines on chart
#    - Add 2-3 sync points throughout the video
#    - All sync point values should be similar (e.g., 10ms, 12ms, 16ms is good)
#    - Delete any red/contradicting sync points
#    - Play video to verify stabilization is working
# 5. Adjust stabilization parameters as needed
# 6. Export stabilized video
```

--------------------------------

### Basic Stabilization Workflow (Built-in Sync)

Source: https://context7.com/context7/gyroflow_xyz_app/llms.txt

Steps for stabilizing video from cameras with built-in gyro data synchronization. This process involves loading the video, verifying lens profile, and adjusting settings before export.

```bash
# Workflow for cameras with built-in sync (GoPro 8+, DJI, Sony, Insta360, Blackmagic)
# 1. Open Gyroflow application
# 2. Drag and drop your video file into Gyroflow
# 3. Lens profile should load automatically (verify in Lens Profile section)
# 4. No synchronization needed - gyro timing is accurate by default
# 5. Adjust stabilization settings:
#    - FOV: 1.0 (default, uses maximum pixels without black borders)
#    - Smoothness: 0.5 (default, range 0-1+, higher = smoother but more zoom)
#    - Horizon lock: Enable if you want level horizon (uses more zoom)
#    - Zooming mode: Dynamic zooming (recommended)
# 6. Set output path at bottom of window
# 7. Click blue "Export" button to render
```

--------------------------------

### Gyroflow CLI Watch Folder

Source: https://docs.gyroflow.xyz/app/advanced-usage/command-line-cli

Illustrates how to configure the Gyroflow CLI to automatically stabilize new video files added to a specified directory. This is useful for batch processing footage as it's ingested.

```bash
Gyroflow.exe --watch C:\MY_FOOTAGE\
```

--------------------------------

### Gyroflow Protobuf Schema Definition

Source: https://docs.gyroflow.xyz/app/technical-details/gyroflow-protobuf

The main Protobuf definition file for Gyroflow. It includes messages for overall data structure, camera and clip metadata, and individual frame information. This schema is essential for reading and writing Gyroflow data files.

```protobuf
syntax = "proto3";

// Main entry point of the data
// The first message will contain the Header with CameraMetadata and ClipMetadata
// All subsequent per-frame samples will contain the FrameMetadata, without Header
message Main {
    string magic_string     = 1; // Magic string useful for format detection in binary data. Always "GyroflowProtobuf"
    uint32 protocol_version = 2; // Version of the protocol, currently 1.

    Header        header = 3;
    FrameMetadata frame  = 4;
}

// One-time metadata containing information about the camera, lens and this particular video clip
message Header {
    message CameraMetadata {
                 string camera_brand         = 1; // Camera manufacturer
                 string camera_model         = 2; // Camera model
        optional string camera_serial_number = 3; // Camera serial number
        optional string firmware_version     = 4; // Camera firmware version
                 string lens_brand           = 5; // Lens manufacturer
                 string lens_model           = 6; // Lens model
                 uint32 pixel_pitch_nm       = 7; // Sensor pixel pitch in nanometers
                 uint32 sensor_pixel_width   = 8; // Full sensor width in pixels
                 uint32 sensor_pixel_height  = 9; // Full sensor height in pixels
        optional float  crop_factor          = 10; // Crop factor in relation to full frame sensor size. e.g. 1.6x for APS-C
        optional string lens_profile         = 11; // The Gyroflow lens identifier, or a path to lens profile json file (relative to the `camera_presets` directory), or the json contents directly
        optional string imu_orientation      = 12; // IMU orientation used by Gyroflow as XYZ, Xyz, Zyx etc. Defaults to "XYZ". Read more in the Gyroflow documentation about this orientation convention.
        optional Quaternion imu_rotation     = 13; // Arbitrary IMU rotation. Applies to the raw IMU samples (FrameMetadata.imu field).
        optional Quaternion quats_rotation   = 14; // Arbitrary IMU rotation. Applies to the quaternions after sensor fusion (FrameMetadata.quaternions field).
        optional string additional_data      = 15; // Optional note or additional data. If it starts with {, it will be parsed as JSON
    }
    message ClipMetadata {
        enum ReadoutDirection {
            TopToBottom = 0; // Sensor reads pixels from top to bottom.
            BottomToTop = 1; // Sensor reads pixels from bottom to top.
            RightToLeft = 2; // Sensor reads pixels from right to left.
            LeftToRight = 3; // Sensor reads pixels from right to left.
        }

        uint32 frame_width            = 1; // Video frame width in pixels
        uint32 frame_height           = 2; // Video frame height in pixels
        float  duration_us            = 3; // Clip duration in microseconds
        float  record_frame_rate      = 4; // Recording frame rate
        float  sensor_frame_rate      = 5; // Sensor frame rate. In most cases it will be equal to `record_frame_rate`
        float  file_frame_rate        = 6; // File frame rate. May be different in VFR mode. e.g. 120 fps recorded as 30 fps file
        int32  rotation_degrees       = 7; // Video rotation in degrees. For example 180 degrees for upside-down, or 90 for vertical mode.
        uint32 imu_sample_rate        = 8; // Sampling rate of the IMU chip.
        optional string color_profile = 9; // Shooting color profile, eg. Natural, Log, etc
        float  pixel_aspect_ratio     = 10; // For anamorphic lenses
        float  frame_readout_time_us  = 11; // Time it takes to read the video frame from the sensor, for rolling shutter correction. NOTE: It should be the time between first row of pixels to the last row of pixels, not for full sensor readout (if the crop is involved).
        ReadoutDirection frame_readout_direction = 12; // Frame readout direction
    }

    CameraMetadata camera = 1;
    ClipMetadata   clip   = 2;
}

message FrameMetadata {
    double start_timestamp_us = 1; // Frame capture start - the timestamp when the first row of pixels was captured. Internal camera clock timestamp. Unit: microseconds
    double end_timestamp_us   = 2; // Frame capture end - the timestamp when the last row of pixels was captured. Internal camera clock timestamp. Unit: microseconds
    uint32 frame_number       = 3; // Frame number in sequence. The first frame of the video clip should have this set to 1.

    optional uint32 iso                       = 4; // ISO Value
    optional float  exposure_time_us          = 5; // Actual exposure time in microseconds
    optional uint32 white_balance_kelvin      = 6; // White balance in kelvins
    optional float  white_balance_tint        = 7; // White balance tint value

```

--------------------------------

### Custom Encoder Options for AMD Bitrate Bug

Source: https://docs.gyroflow.xyz/app/hardware-acceleration/amd

This snippet provides custom encoder options to work around a known bug in some AMD GPU encoders that limits the bitrate to 20 Mbps when targeting over 100 Mbps. It suggests using the Constant Quantization Parameter (CQP) rate control method with specific QP values for I-frames and P-frames.

```bash
-rc cqp -qp_i 28 -qp_p 28
```

--------------------------------

### Betaflight CLI Commands for Blackbox Logging

Source: https://docs.gyroflow.xyz/app/advanced-usage/using-external-gyro-source/flight-controller

These CLI commands are used in Betaflight configurator to disable specific data logging elements, optimizing blackbox recording space for Gyroflow. This reduces the amount of data logged by disabling PIDs, RC commands, setpoints, battery, magnetometer, altitude, RSSI, debug information, motors, and GPS.

```cli
set blackbox_disable_pids = ON
set blackbox_disable_rc = ON
set blackbox_disable_setpoint = ON
set blackbox_disable_bat = ON
set blackbox_disable_mag = ON
set blackbox_disable_alt = ON
set blackbox_disable_rssi = ON
set blackbox_disable_debug = ON
set blackbox_disable_motors = ON
set blackbox_disable_gps = ON
```

--------------------------------

### IBISData Structure Definition

Source: https://docs.gyroflow.xyz/app/technical-details/gyroflow-protobuf

Defines the structure for IBISData, which contains information about sensor shifts and roll angle. It includes the sampling timestamp, X and Y sensor shifts in nanometers, and the sensor roll angle in degrees.

```protobuf
message IBISData {
    double sample_timestamp_us = 1; // Exact timestamp of the sampling time from the internal camera clock. Unit: microseconds
    float shift_x = 2; // X Sensor shift value in nanometers
    float shift_y = 3; // Y Sensor shift value in nanometers
    float roll_angle_degrees = 4; // Sensor roll rotation angle in degrees.
}
```

--------------------------------

### MeshWarpData Structure Definition

Source: https://docs.gyroflow.xyz/app/technical-details/gyroflow-protobuf

Defines the structure for MeshWarpData, used in EISData to represent mesh warp transformations. It includes the grid width and height, and a repeated list of float values representing the new positions of coordinates within the grid.

```protobuf
message MeshWarpData {
    int32 grid_width  = 1; // Number of video frame divisions in the horizontal direction.
    int32 grid_height = 2; // Number of video frame divisions in the vertical direction.
    repeated float values = 3; // grid_width * grid_height float numbers representing new position of a coordinate at X and Y grid position.
}
```

--------------------------------

### EISData Structure Definition

Source: https://docs.gyroflow.xyz/app/technical-details/gyroflow-protobuf

Defines the structure for EISData, which describes Electronic Image Stabilization data. It supports different EIS types (QUATERNION, MESH_WARP, MATRIX_4X4) and includes optional fields for quaternion, mesh warp data, or a 4x4 transformation matrix.

```protobuf
message EISData {
    enum EISDataType {
        QUATERNION = 0; // Rotation only, indicates how the frame was rotated internally by the camera EIS, from pixels read from the sensor to the final pixels in the encoded video file.
        MESH_WARP  = 1; // Mesh warp. Allows for arbitrary mapping of the video frame. Contains exact transform/deform of the video frame read from the sensor to the final pixels in the encoded video file.
        MATRIX_4X4 = 2; // 4x4 matrix - rotation, translation and scaling. Indicates how the frame was transformed in the 3d space by the camera EIS, from pixels read from the sensor to the final pixels in the encoded video file.
    }
    optional double sample_timestamp_us = 1; // Exact timestamp of the sampling time from the internal camera clock. Unit: microseconds. Timestamp is ignored if there's only one entry of EISData per frame.
    EISDataType type                    = 2; // Type of EIS. Can be quaternion, mesh warp or 4x4 transform matrix.
    optional Quaternion quaternion      = 3; // If type is QUATERNION, this field contains the quaternion data
    optional MeshWarpData mesh_warp     = 4; // If type is MESH_WARP, this field contains the mesh values
    repeated float matrix_4x4           = 5; // If type is MATRIX_4x4, this field contains the 16 float matrix values (row-major order).
}
```
Tokens:
Raw