rav1e.yml

name: rav1e

on:
  push:
    branches:
      - master
      - 0.*
  pull_request:
    branches:
      - master
      - 0.*

jobs:
  rustfmt-clippy:
    runs-on: ubuntu-22.04

    steps:
      - uses: actions/checkout@v4
      - uses: ilammy/setup-nasm@v1
      - name: Install stable
        uses: dtolnay/rust-toolchain@stable
        with:
          components: clippy, rustfmt
      - name: Run rustfmt
        run: |
          cargo fmt -- --check --verbose
      - name: Run clippy
        uses: clechasseur/rs-clippy-check@v3
        with:
          args: -- -D warnings

  msrv:
    runs-on: ubuntu-22.04

    env:
      CARGO_INCREMENTAL: 0
      RUSTFLAGS: '-Dwarnings'

    steps:
      - uses: actions/checkout@v4

      # Minimum version in build.rs
      - name: Install NASM 2.15
        uses: ilammy/setup-nasm@v1
        with:
          version: 2.15

      # Minimum version in Cargo.toml
      - name: Install Rust 1.74.0
        uses: dtolnay/rust-toolchain@1.74.0
        with:
          targets: wasm32-unknown-unknown, wasm32-wasi

      - uses: Swatinem/rust-cache@v2
        with:
          prefix-key: v1-rust

      - name: Run cargo check
        run: cargo check

      - name: Run cargo check (wasm32)
        run: >
          cargo check
          --target wasm32-unknown-unknown
          --no-default-features
          -F wasm

      - name: Run cargo check (wasi)
        run: >
          cargo check
          --target wasm32-wasi
          --no-default-features

  wasi:
    runs-on: ubuntu-22.04
    needs: [rustfmt-clippy, msrv]

    env:
      CARGO_INCREMENTAL: 0
      RUSTFLAGS: '-Dwarnings'
      CARGO_TARGET_WASM32_WASI_RUNNER: wasmtime

    steps:
      - uses: actions/checkout@v4

      - name: Install wasmtime
        uses: taiki-e/install-action@wasmtime

      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: wasm32-wasi
      - uses: Swatinem/rust-cache@v2

      - name: Run tests
        run: >
          cargo test
          --target wasm32-wasi
          --no-default-features

  build-unix:
    strategy:
      matrix:
        conf:
          - beta-build
          - 1.74.0-tests
          - aom-tests
          - dav1d-tests
          - no-asm-tests
          - grcov-codecov
          - bench
          - doc
          - cargo-c
          - check-no-default
          - check-extra-feats
          - check-unstable-feats
          - fuzz
        include:
          - conf: beta-build
            toolchain: beta
          - conf: 1.74.0-tests
            toolchain: 1.74.0
          - conf: aom-tests
            toolchain: stable
          - conf: dav1d-tests
            toolchain: stable
          - conf: dav1d-tests-arm64
            toolchain: stable
          - conf: no-asm-tests
            toolchain: stable
          - conf: grcov-codecov
            toolchain: stable
          - conf: bench
            toolchain: stable
          - conf: doc
            toolchain: stable
          - conf: cargo-c
            toolchain: stable
          - conf: check-no-default
            toolchain: stable
          - conf: check-extra-feats
            toolchain: stable
          - conf: check-unstable-feats
            toolchain: stable
          - conf: fuzz
            toolchain: stable

    env:
      RUST_BACKTRACE: full
      RUSTC_WRAPPER: sccache
      SCCACHE_CACHE_SIZE: 300M
      SCCACHE_DIR: /home/runner/.cache/sccache
      SCCACHE_IDLE_TIMEOUT: 0

    runs-on: ubuntu-22.04
    needs: [rustfmt-clippy, msrv]

    steps:
      - uses: actions/checkout@v4
      - name: Set no-asm-tests env vars
        if: matrix.conf == 'no-asm-tests'
        run: |
          echo "name=RAV1E_CPU_TARGET::rust" >> $GITHUB_ENV
      - name: Install sccache
        env:
          LINK: https://github.com/mozilla/sccache/releases/download
          SCCACHE_VERSION: 0.2.15
        run: |
          SCCACHE_FILE=sccache-v$SCCACHE_VERSION-x86_64-unknown-linux-musl
          mkdir -p $HOME/.local/bin
          curl -L "$LINK/v$SCCACHE_VERSION/$SCCACHE_FILE.tar.gz" | tar xz
          chmod +x $SCCACHE_FILE/sccache
          mv -f $SCCACHE_FILE/sccache $HOME/.local/bin/sccache
          echo "$HOME/.local/bin" >> $GITHUB_PATH
      - name: Install dependencies
        if: matrix.conf != 'dav1d-tests-arm64'
        run: |
          sudo sed -i 's/jammy/lunar/g' /etc/apt/sources.list
          sudo rm /etc/apt/sources.list.d/*.list
          sudo apt update
          sudo apt install nasm libaom-dev meson ninja-build nasm
      - name: Install cargo-c
        if: matrix.conf == 'cargo-c'
        env:
          LINK: https://github.com/lu-zero/cargo-c/releases/latest/download
        run: |
          curl -L "$LINK/cargo-c-x86_64-unknown-linux-musl.tar.gz" |
          tar xz -C $HOME/.cargo/bin
      - name: Install grcov
        if: matrix.conf == 'grcov-codecov'
        env:
          LINK: https://github.com/mozilla/grcov/releases/latest/download
        run: |
          curl -L "$LINK/grcov-x86_64-unknown-linux-musl.tar.bz2" |
          tar xj -C $HOME/.cargo/bin
      - name: Install Intel SDE
        if: matrix.conf == 'grcov-codecov'
        uses: petarpetrovt/setup-sde@v2.4
      - name: Install ${{ matrix.toolchain }}
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ matrix.toolchain }}
      - name: Install llvm-tools-preview
        if: matrix.conf == 'grcov-codecov'
        run: |
          rustup component add llvm-tools-preview
      - name: Install aarch64 toolchain, qemu-user and libdav1d deps
        if: matrix.conf == 'dav1d-tests-arm64'
        env:
          LINK: http://ports.ubuntu.com/ubuntu-ports/pool
        run: |
          rustup target add aarch64-unknown-linux-gnu
          { echo 'deb [arch=amd64] http://azure.archive.ubuntu.com/ubuntu lunar main universe'
            echo 'deb [arch=amd64] http://azure.archive.ubuntu.com/ubuntu lunar-updates main universe'
            echo 'deb [arch=arm64] http://azure.ports.ubuntu.com/ lunar main universe'
          } | sudo tee /etc/apt/sources.list
          sudo dpkg --add-architecture arm64
          sudo apt update
          sudo apt install qemu-user gcc-aarch64-linux-gnu meson ninja-build nasm
      - name: Generate Cargo.version for cache key
        run: |
          cargo --version > Cargo.version
      - name: Cache cargo registry
        uses: actions/cache@v4
        continue-on-error: true
        with:
          path: ~/.cargo/registry/cache
          key: ${{ runner.os }}-${{ matrix.conf }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
          restore-keys: |
            ${{ runner.os }}-${{ matrix.conf }}-cargo-registry-
      - name: Cache sccache output
        uses: actions/cache@v4
        continue-on-error: true
        with:
          path: /home/runner/.cache/sccache
          key: ${{ runner.os }}-${{ matrix.conf }}-sccache-${{ hashFiles('**/Cargo.*') }}
          restore-keys: |
            ${{ runner.os }}-${{ matrix.conf }}-sccache-
      - name: Start sccache server
        run: |
          sccache --start-server
      - name: Run 1.74.0 tests
        if: matrix.toolchain == '1.74.0' && matrix.conf == '1.74.0-tests'
        run: |
          cargo test --workspace --verbose \
                     --features=decode_test,decode_test_dav1d,quick_test,capi
      - name: Run aom tests
        if: matrix.toolchain == 'stable' && matrix.conf == 'aom-tests'
        run: |
          cargo test --workspace --verbose --release \
                     --features=decode_test \
                     --color=always -- --color=always --ignored
      - name: Run dav1d tests
        if: matrix.toolchain == 'stable' && (matrix.conf == 'dav1d-tests' || matrix.conf == 'no-asm-tests')
        run: |
          cargo test --workspace --verbose --release \
                     --features=decode_test_dav1d \
                     --color=always -- --color=always --ignored
      - name: Run dav1d tests (arm64)
        if: matrix.conf == 'dav1d-tests-arm64'
        env:
          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_RUNNER: qemu-aarch64 -L /usr/aarch64-linux-gnu
          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_RUSTFLAGS: -Clinker=aarch64-linux-gnu-gcc
          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
          PKG_CONFIG_SYSROOT_DIR: /
        run: |
          cargo test --lib --verbose --release --target=aarch64-unknown-linux-gnu \
                     --no-default-features --features=asm,decode_test_dav1d -- \
                     --include-ignored
      - name: Run build
        if: matrix.conf == 'beta-build'
        run: |
          cargo build --verbose
      - name: Run bench
        if: matrix.toolchain == 'stable' && matrix.conf == 'bench'
        run: |
          cargo bench --features=bench --no-run --verbose
      - name: Run doc
        if: matrix.toolchain == 'stable' && matrix.conf == 'doc'
        run: |
          cargo doc --verbose --no-deps
      - name: Check no default features
        if: matrix.toolchain == 'stable' && matrix.conf == 'check-no-default'
        run: |
          cargo check --no-default-features
      - name: Check extra features
        if: matrix.toolchain == 'stable' && matrix.conf == 'check-extra-feats'
        run: |
          cargo check --features=check_asm,capi,dump_lookahead_data,serialize,bench,tracing --all-targets
      - name: Check extra features
        if: matrix.toolchain == 'stable' && matrix.conf == 'check-unstable-feats'
        run: |
          cargo check --features=unstable,channel-api
      - name: Run cargo-c
        if: matrix.conf == 'cargo-c'
        env:
          CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
        run: |
          cargo fetch
          cargo cbuild --offline
      - name: Install cargo-fuzz
        if: matrix.conf == 'fuzz'
        run: |
          cargo install cargo-fuzz
      - name: Run cargo-fuzz
        if: matrix.conf == 'fuzz'
        run: |
          cargo fuzz build --sanitizer none
      - name: Run cargo clean
        if: matrix.conf == 'grcov-codecov'
        run: |
          cargo clean

      - name: Run tests with coverage
        if: matrix.conf == 'grcov-codecov'
        env:
          CARGO_INCREMENTAL: 0
          LLVM_PROFILE_FILE: "rav1e-%p-%m.profraw"
          RUSTFLAGS: >
            -Cinstrument-coverage -Ccodegen-units=1 -Clink-dead-code
            -Coverflow-checks=off
          RUSTDOCFLAGS: >
            -Cinstrument-coverage -Ccodegen-units=1 -Clink-dead-code
            -Coverflow-checks=off
          CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER: >
            ${{ env.SDE_PATH }}/sde -icx --
        run: |
          cargo test --workspace --verbose --target x86_64-unknown-linux-gnu \
                     --features=decode_test,decode_test_dav1d,quick_test
      - name: Run unit tests
        if: matrix.conf == 'no-asm-tests'
        run: |
          cargo test --workspace --verbose
      - name: Run grcov
        if: matrix.conf == 'grcov-codecov'
        run: |
          grcov . --binary-path ./target/x86_64-unknown-linux-gnu/debug/  -s . \
                -t lcov --branch --ignore-not-existing --ignore "/*" \
                --ignore "../*" --ignore "target/*" --ignore "examples/*" \
                --ignore "tests/*" --ignore "src/test_encode_decode/*" \
                --ignore "src/x86/*" --ignore "src/ext/x86/*" \
                --excl-line "grcov-excl-line|.*unreachable.*" \
                --ignore "tools/*" --ignore "crates/*" -o lcov.info
      - name: Stop sccache server
        run: |
          sccache --stop-server
      - name: Codecov upload
        if: matrix.conf == 'grcov-codecov'
        uses: codecov/codecov-action@v4
        with:
          files: lcov.info

  build-macos:
    strategy:
      matrix:
        include:
          - name: Cargo build (x64)
            conf: cargo-build
            target: x86_64-apple-darwin
          - name: Cargo test (x64)
            conf: cargo-test
            target: x86_64-apple-darwin
          - name: Cargo C-build (x64)
            conf: cargo-c
            target: x86_64-apple-darwin
          - name: Cargo build (Arm64)
            conf: cargo-build
            target: aarch64-apple-darwin
          - name: Cargo C-build (Arm64)
            conf: cargo-c
            target: aarch64-apple-darwin

    env:
      RUST_BACKTRACE: full
      RUSTC_WRAPPER: sccache
      SCCACHE_CACHE_SIZE: 300M
      SCCACHE_DIR: /Users/runner/Library/Caches/Mozilla.sccache

    runs-on: macos-latest
    needs: [rustfmt-clippy, msrv]

    steps:
      - uses: actions/checkout@v4
      - name: Install sccache
        run: |
          brew install sccache
      - name: Install nasm
        run: |
          brew install nasm
      - name: Install cargo-c
        if: matrix.conf == 'cargo-c'
        run: |
          brew install cargo-c
      - name: Install Rust
        uses: dtolnay/rust-toolchain@stable
        with:
          target: ${{ matrix.target }}
      - name: Generate Cargo.version for cache key
        run: |
          cargo --version > Cargo.version
      - name: Cache cargo registry
        uses: actions/cache@v4
        continue-on-error: true
        with:
          path: ~/.cargo/registry/cache
          key: ${{ runner.os }}-${{ matrix.conf }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
          restore-keys: |
            ${{ runner.os }}-${{ matrix.conf }}-cargo-registry-
      - name: Cache sccache output
        uses: actions/cache@v4
        continue-on-error: true
        with:
          path: /Users/runner/Library/Caches/Mozilla.sccache
          key: ${{ runner.os }}-${{ matrix.conf }}-sccache-${{ hashFiles('**/Cargo.*') }}
          restore-keys: |
            ${{ runner.os }}-${{ matrix.conf }}-sccache-
      - name: Start sccache server
        run: |
          sccache --start-server
      - name: Build
        if: matrix.conf == 'cargo-build'
        run: |
          cargo build --release --target=${{ matrix.target }}
      - name: Test
        if: matrix.conf == 'cargo-test'
        run: |
          cargo test --workspace --verbose --target=${{ matrix.target }}
      - name: Run cargo-c
        if: matrix.conf == 'cargo-c'
        env:
          CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
        run: |
          cargo fetch
          cargo cbuild --target=${{ matrix.target }} --offline
      - name: Stop sccache server
        run: |
          sccache --stop-server

  build-windows:
    strategy:
      matrix:
        include:
          - conf: cargo-build
            target: x86_64-pc-windows-msvc
          - conf: cargo-test
            target: x86_64-pc-windows-msvc
          - conf: cargo-c
            target: x86_64-pc-windows-gnu

    env:
      RUST_BACKTRACE: full
      RUSTC_WRAPPER: sccache
      SCCACHE_CACHE_SIZE: 300M
      SCCACHE_DIR: C:\sccache

    runs-on: windows-latest
    needs: [rustfmt-clippy, msrv]

    steps:
      - uses: actions/checkout@v4
      - uses: ilammy/setup-nasm@v1
      - name: Install sccache
        run: |
          $LINK = "https://github.com/mozilla/sccache/releases/download/0.2.12"
          $SCCACHE_FILE = "sccache-0.2.12-x86_64-pc-windows-msvc"
          curl -LO "$LINK/$SCCACHE_FILE.tar.gz"
          tar xzf "$SCCACHE_FILE.tar.gz"
          echo "$Env:GITHUB_WORKSPACE/$SCCACHE_FILE" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
      - name: Install stable-${{ matrix.target }}
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: stable-${{ matrix.target }}
      - name: Install cargo-c
        if: matrix.conf == 'cargo-c'
        run: |
          $LINK = "https://github.com/lu-zero/cargo-c/releases/latest/download"
          $CARGO_C_FILE = "cargo-c-windows-msvc"
          curl -LO "$LINK/$CARGO_C_FILE.zip"
          7z e -y "$CARGO_C_FILE.zip" -o"${env:USERPROFILE}\.cargo\bin"
      - name: Generate Cargo.version for cache key
        run: |
          cargo --version > Cargo.version
      - name: Cache cargo registry
        uses: actions/cache@v4
        continue-on-error: true
        with:
          path: ~/.cargo/registry/cache
          key: ${{ runner.os }}-${{ matrix.conf }}-${{ matrix.target }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
          restore-keys: |
            ${{ runner.os }}-${{ matrix.conf }}-${{ matrix.target }}-cargo-registry-
      - name: Cache sccache output
        uses: actions/cache@v4
        continue-on-error: true
        with:
          path: C:\sccache
          key: ${{ runner.os }}-${{ matrix.conf }}-${{ matrix.target }}-sccache-${{ hashFiles('**/Cargo.*') }}
          restore-keys: |
            ${{ runner.os }}-${{ matrix.conf }}-${{ matrix.target }}-sccache-
      - name: Start sccache server
        run: |
          sccache --start-server
      - name: Build
        if: matrix.conf == 'cargo-build'
        run: |
          cargo build --release
      - name: Test
        if: matrix.conf == 'cargo-test'
        run: |
          cargo test --workspace --verbose
      - name: Run cargo-c
        if: matrix.conf == 'cargo-c'
        env:
          CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
        run: |
          cargo fetch
          cargo cbuild --offline
      - name: Stop sccache server
        run: |
          sccache --stop-server