toolchain.yml

name: toolchain
run-name: "${{ inputs.run_name != '' && format('{0} ({1})', inputs.run_name, inputs.compiler) || format('{0} ({1})', github.workflow, inputs.compiler) }}"

on: 
  # schedule:
  #   - cron:  '0 12 * * *'
  workflow_dispatch:
    inputs:
      build_target:
        description: "Build target"
        required: false
        default: "all-64bit"
        type: choice
        options:
        - 32bit
        - 64bit
        - 64bit-v3
        - all-64bit
        - all
      compiler:
        required: false
        default: "gcc"
        type: choice
        options:
        - gcc
        - clang
      no_save_cache:
        description: "Don't save caches after success build"
        required: false
        default: false
        type: boolean
      skip_llvm_build:
        description: "Skip building llvm if compiler is clang"
        required: false
        default: false
        type: boolean
      trigger_build:
        description: "Trigger mpv build action after success build"
        required: false
        default: true
        type: boolean
      release:
        description: "Publish a release"
        required: false
        default: false
        type: boolean
      run_name:
        description: 'The name displayed in the list of workflow runs'
        required: false

jobs:
  params:
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.script.outputs.matrix }}
      cache_suffix: ${{ steps.suffix.outputs.cache_suffix }}
    steps:
      - id: script
        uses: actions/github-script@v7
        with:
          script: |
            let matrix = {};
            let build_target = "${{ inputs.build_target }}"
            switch ( build_target ) {
              case "32bit":
                matrix.bit = ["32"];
                break;
              case "64bit":
                matrix.bit = ["64"];
                break;
              case "64bit-v3":
                matrix.bit = ["64-v3"];
                break;
              case "all-64bit":
                matrix.bit = ["64","64-v3"];
                break;
              case "all":
                matrix.bit = ["32","64","64-v3"];
                break;
              default:
                matrix.bit = ["64","64-v3"];
                break;
            }
            core.setOutput("matrix",JSON.stringify(matrix));

      - id: suffix
        run: |
          cache_suffix="$(date "+%Y-%m-%d")-${{ github.run_id }}-${{ github.run_attempt }}"
          echo "cache_suffix=$cache_suffix" >> "$GITHUB_OUTPUT"

  build_llvm:
    name: Build LLVM
    needs: params
    if: ${{ inputs.compiler =='clang' && inputs.skip_llvm_build != true }}
    continue-on-error: true
    runs-on: ubuntu-latest
    container:
      image: archlinux/archlinux:base-devel
    steps:
      - name: Install Dependencies
        run: |
          sudo echo -e "[multilib]\nInclude = /etc/pacman.d/mirrorlist" >> /etc/pacman.conf
          sudo pacman -Syu --noconfirm
          sudo pacman -S --noconfirm --needed git gyp ninja cmake ragel yasm nasm asciidoc enca gperf unzip xz gcc-multilib clang lld libc++ libc++abi python-pip curl lib32-glib2 wget python-cairo
          mkdir -p /home/opt/7zip
          wget -qO - https://www.7-zip.org/a/7z2301-linux-x64.tar.xz | tar -xJf - -C /home/opt/7zip 7zzs
          sudo ln -s /home/opt/7zip/7zzs /usr/bin/7z
          pip3 install -U --break-system-packages setuptools rst2pdf mako jsonschema meson
          git config --global user.name "github-actions[bot]"
          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
          git config --global pull.rebase true
          git config --global rebase.autoStash true
          git config --global fetch.prune true
      - name: Checkout toolchain
        uses: actions/checkout@v4
        with:
          repository: shinchiro/mpv-winbuild-cmake
          path: mpv-winbuild-cmake
      - name: Build LLVM
        shell: bash
        run: |
          cd mpv-winbuild-cmake
          bit="64-v3"
          compiler="${{ inputs.compiler }}"
          gitdir=$(pwd)
          clang_root=$(pwd)/clang_root
          buildroot=$(pwd)
          srcdir=$(pwd)/src_packages

          arch="x86_64"
          gcc_arch=-DGCC_ARCH=x86-64-v3
          x86_64_level=-v3

          set -x
          if [[ "$(ls -A ../patch/*.patch)" ]]; then
            for patch in ../patch/*.patch ; do
              git am --3way "$patch" || git am --abort
            done
          fi
          clang_option="-DCMAKE_INSTALL_PREFIX=$clang_root -DMINGW_INSTALL_PREFIX=$buildroot/build$bit/install/$arch-w64-mingw32"
          cmake -DTARGET_ARCH=$arch-w64-mingw32 $gcc_arch -DCOMPILER_TOOLCHAIN=$compiler $clang_option -DSINGLE_SOURCE_LOCATION=$srcdir -DRUSTUP_LOCATION=$buildroot/install_rustup -G Ninja -H$gitdir -B$buildroot/build$bit
          set +x
          stdbuf -oL bash -c "ninja -C $buildroot/build$bit llvm" | 
            while IFS= read -r line
            do
              echo "$line"
              if grep -q "ninja: build stopped" <<< "$line"; then
                exit 1
              fi
            done
      - name: Save llvm cache
        uses: actions/cache/save@v4.0.0
        with: 
          path: |
            mpv-winbuild-cmake/clang_root
          key: llvm-${{ needs.params.outputs.cache_suffix }}

      - name: Collect logs
        if: ${{ always() }}
        run: |
          sudo 7z a logs.7z $(find mpv-winbuild-cmake -type f -iname "*-*.log" -or -wholename "*/ffbuild/config.log")
      - name: upload logs
        uses: actions/upload-artifact@v4
        if: ${{ always() }}
        with:
          name: llvm_logs
          path: logs.7z

  build:
    name: Build Toolchain
    needs: [params,build_llvm]
    if: ${{ always() && !contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') }}
    runs-on: ubuntu-latest
    container:
      image: archlinux/archlinux:base-devel
    continue-on-error: true
    strategy:
      matrix: ${{ fromJson(needs.params.outputs.matrix) }}

    steps:
      - name: Install Dependencies
        run: |
          sudo echo -e "[multilib]\nInclude = /etc/pacman.d/mirrorlist" >> /etc/pacman.conf
          sudo pacman -Syu --noconfirm
          sudo pacman -S --noconfirm --needed git gyp ninja cmake ragel yasm nasm asciidoc enca gperf unzip xz gcc-multilib clang lld libc++ libc++abi python-pip curl lib32-glib2 wget python-cairo
          mkdir -p /home/opt/7zip
          wget -qO - https://www.7-zip.org/a/7z2301-linux-x64.tar.xz | tar -xJf - -C /home/opt/7zip 7zzs
          sudo ln -s /home/opt/7zip/7zzs /usr/bin/7z
          pip3 install -U --break-system-packages setuptools rst2pdf mako jsonschema meson
          git config --global user.name "github-actions[bot]"
          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
          git config --global pull.rebase true
          git config --global rebase.autoStash true
          git config --global fetch.prune true
      - name: Checkout toolchain
        uses: actions/checkout@v4
        with:
          repository: shinchiro/mpv-winbuild-cmake
          path: mpv-winbuild-cmake

      - name: Restore llvm cache
        if: ${{ inputs.compiler =='clang' }}
        uses: actions/cache/restore@v4.0.0
        with: 
          fail-on-cache-miss: true
          path: |
            mpv-winbuild-cmake/clang_root
          key: llvm-${{ needs.params.outputs.cache_suffix }}
          restore-keys: |
            llvm-

      - name: Build Toolchain
        shell: bash
        run: |
          cd mpv-winbuild-cmake
          bit="${{ matrix.bit }}"
          compiler="${{ inputs.compiler }}"
          gitdir=$(pwd)
          clang_root=$(pwd)/clang_root
          buildroot=$(pwd)
          srcdir=$(pwd)/src_packages

          if [ $bit == "32" ]; then
              arch="i686"
          elif [ $bit == "64" ]; then
              arch="x86_64"
          elif [ $bit == "64-v3" ]; then
              arch="x86_64"
              gcc_arch=-DGCC_ARCH=x86-64-v3
              x86_64_level=-v3
          fi
          set -x
          if [[ "$(ls -A ../patch/*.patch)" ]]; then
            for patch in ../patch/*.patch ; do
              git am --3way "$patch" || git am --abort
            done
          fi
          if [ "$compiler" == "gcc" ]; then
            command="ninja -C $buildroot/build$bit gcc"
          elif [ "$compiler" == "clang" ]; then
            clang_option="-DCMAKE_INSTALL_PREFIX=$clang_root -DMINGW_INSTALL_PREFIX=$buildroot/build$bit/install/$arch-w64-mingw32"
            command="ninja -C $buildroot/build$bit rebuild_cache && cmake --build $buildroot/build$bit --target llvm-download && ninja -C $buildroot/build$bit llvm-clang && ninja -C $buildroot/build$bit rustup"
          fi
          cmake -DTARGET_ARCH=$arch-w64-mingw32 $gcc_arch -DCOMPILER_TOOLCHAIN=$compiler $clang_option -DSINGLE_SOURCE_LOCATION=$srcdir -DRUSTUP_LOCATION=$buildroot/install_rustup -G Ninja -H$gitdir -B$buildroot/build$bit
          set +x
          stdbuf -oL bash -c "$command" | 
            while IFS= read -r line
            do
              echo "$line"
              if grep -q "ninja: build stopped" <<< "$line"; then
                exit 1
              fi
            done
          ninja -C $buildroot/build$bit cargo-clean

      - name: Save Toolchain Cache
        if: ${{ inputs.no_save_cache != true }}
        uses: actions/cache/save@v4.0.0
        with:
          path: ${{ github.workspace }}/mpv-winbuild-cmake/build${{ matrix.bit }}
          key: toolchain-${{ inputs.compiler }}-build${{ matrix.bit }}-${{ needs.params.outputs.cache_suffix }}

      - name: Save clang_root cache
        if: ${{ inputs.compiler =='clang' && inputs.no_save_cache != true }}
        uses: actions/cache/save@v4.0.0
        with: 
          path: ${{ github.workspace }}/mpv-winbuild-cmake/clang_root
          key: ${{ matrix.bit }}-clang_root-${{ needs.params.outputs.cache_suffix }}
      - name: Save Rust Cache
        if: ${{ inputs.no_save_cache != true }}
        uses: actions/cache/save@v4.0.0
        with:
          path: ${{ github.workspace }}/mpv-winbuild-cmake/install_rustup
          key: rust-${{ needs.params.outputs.cache_suffix }}
          
      - name: Collect logs
        if: ${{ always() }}
        run: |
          sudo 7z a logs.7z $(find mpv-winbuild-cmake -type f -iname "*-*.log" -or -wholename "*/ffbuild/config.log")
      - name: upload logs
        uses: actions/upload-artifact@v4
        if: ${{ always() }}
        with:
          name: ${{ matrix.bit }}_logs
          path: logs.7z


  trigger:
    needs: [build,params]
    if: ${{ always() && inputs.trigger_build != false && !contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') }}
    runs-on: ubuntu-latest

    steps:
      - name: Trigger mpv build workflow
        uses: actions/github-script@v7
        with:
          retries: 3
          script: |
            let build_target=new Set();
            const release = ${{ inputs.release }};
            const targets = {"build64-v3":"64bit-v3","build64":"64bit","build32":"32bit"}
            const repo="${{github.repository}}".split('/')[1];
            const cache_suffix="${{ needs.params.outputs.cache_suffix }}";
            const cache = await github.rest.actions.getActionsCacheList({
              owner: '${{github.repository_owner}}',
              repo,
              ref: '${{github.ref}}',
              key: 'toolchain-${{ inputs.compiler }}-',
              sort: 'created_at',
              per_page: 20,
            })
            if(cache?.data?.actions_caches){
              let success=cache.data.actions_caches.filter((i) => i.key.endsWith(cache_suffix));
              for(const i of success){
                for(const [key, value] of Object.entries(targets)){
                  if (i.key.includes(key)) {
                    build_target.add(value);
                    core.info(`Found success ${value} build cache: ${i.key}.`)
                    break;
                  }
                }
              }
            }
            if(build_target.size>0){
              if(build_target.has("64bit-v3") && build_target.has("64bit")) {
                build_target.delete("64bit-v3");
                build_target.delete("64bit");
                build_target.add("all-64bit");
              }
              if(build_target.has("all-64bit") && build_target.has("32bit")) {
                build_target.delete("all-64bit");
                build_target.delete("32bit");
                build_target.add("all");
              }
              for (const t of build_target){
                await github.rest.actions.createWorkflowDispatch({
                  owner: '${{github.repository_owner}}',
                  repo,
                  ref: '${{github.ref}}',
                  workflow_id: 'mpv.yml',
                  inputs: {
                    build_target: t,
                    compiler: "${{ inputs.compiler }}",
                    needclean: true,
                    release: release
                  }
                })
              }
            } else {
              core.setFailed("Don't find any success build cache");
            }