rav1d

You can cross-compile rav1d using cargo --target. This requires setting the RUSTFLAGS environment variable to specify the correct linker for the target platform.

Supported Targets:

• x86_64-unknown-linux-gnu
• i686-unknown-linux-gnu
• armv7-unknown-linux-gnueabihf
• aarch64-unknown-linux-gnu
• riscv64gc-unknown-linux-gnu

Running tests under QEMU: If cross-compiling for QEMU execution, you must specify the +crt-static target feature in RUSTFLAGS.

# Example: Compiling for aarch64 from Ubuntu
RUSTFLAGS="-C linker=aarch64-linux-gnu-gcc" cargo build --target aarch64-unknown-linux-gnu

# Example: Compiling for QEMU with static CRT
RUSTFLAGS="-C target-feature=+crt-static -C linker=aarch64-linux-gnu-gcc" cargo build --target aarch64-unknown-linux-gnu

rav1d uses the original dav1d Meson test suite.

Prerequisites:

1. Install Meson.
2. Manually build rav1d using cargo before running tests. It is highly recommended to use the release or opt-dev profiles to prevent test timeouts.

Execution: Use the .github/workflows/test.sh helper script to run the suite.

# 1. Build the project
cargo build --release

# 2. Run tests using the helper script
.github/workflows/test.sh -r target/release/dav1d

The Rav1dLogger enum defines where log messages are directed. You can use it to switch between different output streams:

• Rav1dLogger::Stdout: Redirects logs to standard output.
• Rav1dLogger::Stderr: Redirects logs to standard error (the default).
• Rav1dLogger::Dav1d(Dav1dLogger): Uses a custom Dav1dLogger instance for C-style callback logging.

// Set logger to stdout
let logger = Rav1dLogger::Stdout;

// Set logger to stderr (default)
let logger = Rav1dLogger::Stderr;

rav1d uses feature flags to control assembly optimization and bitdepth support. All features are enabled by default.

Available Features:

• asm: Enables optimized assembly routines (requires nasm on x86).
• bitdepth_8: Enables 8-bit depth decoding.
• bitdepth_16: Enables 10 and 12-bit depth decoding.

To disable default features and selectively enable others (e.g., to test Rust fallback functions by disabling assembly), use --no-default-features and --features.

# Build without assembly routines, but keep bitdepth support
cargo build --no-default-features --features="bitdepth_8,bitdepth_16"

The Rav1dPicAllocator manages how Rav1dPicture memory is allocated and released.

• Default Allocator: Using Rav1dPicAllocator::default() provides a standard allocator that uses dav1d_default_picture_alloc and dav1d_default_picture_release. This default allocator is designed to work with a MemPool provided via a cookie.
• Custom Allocation: You can provide a custom alloc_picture_callback and release_picture_callback to control the lifecycle of picture buffers, which is useful for integrating with custom memory management systems or specialized hardware allocators.

To use rav1d, you must enable at least one bitdepth feature during compilation. If neither is enabled, the project will fail to compile.

Required features:

• bitdepth_8
• bitdepth_16

The librav1d library is designed as a drop-in replacement for libdav1d. It primarily exposes a C API via the librav1d.a library generated by cargo build.

• C Integration: Use the same API patterns as libdav1d. For detailed documentation, refer to the dav1d C API documentation.
• Rust Integration: Equivalent Rust functions are located in src/lib.rs.
• Note: A dedicated, idiomatic Rust API is planned for future releases.

Loop restoration in rav1d uses two types of parameters: general filter parameters and Self-Guided Filter (SGR) parameters.

LooprestorationParams

This structure holds the filter coefficients. It is aligned to 16 bytes and contains a filter field which is a 2D array of 8 i16 values: [[i16; 8]; 2].

LooprestorationParamsSgr

This structure defines the parameters for the Self-Guided Filter (SGR). It is used to control the SGR behavior via the sgr() and sgr_mut() methods on LooprestorationParams.

Fields:

• s0: u32 (SGR parameter 0)
• s1: u32 (SGR parameter 1)
• w0: i16 (Weight 0)
• w1: i16 (Weight 1)

// Example of accessing SGR parameters from LooprestorationParams
let sgr_params = params.sgr();
let s0 = sgr_params.s0;
let w0 = sgr_params.w0;

The retranspile.sh script provides several commands for managing the re-transpilation lifecycle of functions (fns).

./retranspile.sh transpile      # Re-transpile the C code
./retranspile.sh stash          # Stash all re-transpile changes
./retranspile.sh fn-diff <fn>   # Save diff for ${fn_name} to retranspile/${fn_name}.fn.diff
./retranspile.sh commit <fn>    # Commit the re-transpiled changes for ${fn_name}
./retranspile.sh cleanup <fn>   # Cleanup intermediate files for ${fn_name}
./retranspile.sh cleanup        # Cleanup all intermediate files