linux.yml

name: Linux Builds

on:
  push:
    tags:
      - '[1-9].[0-9]+'
      - '[1-9].[0-9]+.[0-9]+'
  workflow_dispatch:
    inputs:
      debug:
        description: 'Debug build'
        required: true
        type: boolean

jobs:
  build:
    strategy:
      matrix:
        os: [ubuntu-22.04, ubuntu-22.04-arm]
        include:
          - os: ubuntu-22.04
            arch: x86_64
          - os: ubuntu-22.04-arm
            arch: arm64
      fail-fast: false
    
    runs-on: ${{ matrix.os }}

    permissions:
      contents: write
    
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          path: repo

      - name: Get version
        run: |
          cd repo
          if [ "$GITHUB_REF_TYPE" = "tag" ]; then
              echo "ART_VERSION=$GITHUB_REF_NAME" >> $GITHUB_ENV
          else
              echo "ART_VERSION=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
          fi
        
      - name: Install base dependencies
        run: |
          sudo apt update
          DEBIAN_FRONTEND=noninteractive sudo apt install -y \
            git \
            build-essential \
            cmake \
            curl \
            pkg-config \
            libgtk-3-dev \
            libgtkmm-3.0-dev \
            librsvg2-dev \
            liblcms2-dev \
            libfftw3-dev \
            libtiff5-dev \
            libcanberra-gtk3-dev \
            libinih-dev \
            libbrotli-dev \
            libexpat1-dev \
            gvfs \
            wget
          sudo python3 -m pip install meson
          if [ "${{ matrix.arch }}" = "x86_64" ]; then
              ninja_zip=ninja-linux.zip
          else
              ninja_zip=ninja-linux-aarch64.zip
          fi
          wget https://github.com/ninja-build/ninja/releases/download/v1.12.1/${ninja_zip}
          unzip ${ninja_zip}
          sudo mv ninja /usr/local/bin

      - name: Install LCMS2
        run: |
          LCMS2_VERSION='2.16'
          wget https://downloads.sourceforge.net/project/lcms/lcms/${LCMS2_VERSION}/lcms2-${LCMS2_VERSION}.tar.gz
          tar xzf lcms2-${LCMS2_VERSION}.tar.gz
          cd lcms2-${LCMS2_VERSION}
          autoreconf -i
          ./configure --with-fastfloat
          make -j$(nproc)
          sudo make install
          cd ..

      - name: Install Exiv2
        run: |
          EXIV2_VERSION='0.28.8'
          mkdir exiv2
          cd exiv2
          wget https://github.com/Exiv2/exiv2/archive/refs/tags/v${EXIV2_VERSION}.tar.gz
          tar xzf v${EXIV2_VERSION}.tar.gz
          mkdir build
          cd build
          cmake ../exiv2-${EXIV2_VERSION} -DCMAKE_BUILD_TYPE=Release -DEXIV2_ENABLE_BMFF=1
          make -j$(nproc)
          sudo make install
          cd ../..

      - name: Install Lensfun
        run: |
          LENSFUN_VERSION='0.3.4'
          git clone --depth 1 --branch "v$LENSFUN_VERSION" https://github.com/lensfun/lensfun.git
          mkdir build_lensfun
          cd build_lensfun
          cmake -DCMAKE_BUILD_TYPE=Release ../lensfun
          make -j$(nproc)
          sudo make install
          cd ..

      - name: Install LibRaw
        run: |
          git clone --depth 1 https://github.com/LibRaw/LibRaw.git
          cd LibRaw
          autoreconf -i
          CPPFLAGS=-DUSE_X3FTOOLS ./configure
          make -j$(nproc)
          sudo make install
          cd ..

      - name: Install CTL
        run: |
          git clone --depth 1 https://github.com/ampas/CTL.git
          mkdir build-CTL
          cd build-CTL
          cmake \
            -DCMAKE_BUILD_TYPE=Release \
            -DCMAKE_CXX_FLAGS=-fpermissive \
            ../CTL
          make -j$(nproc)
          sudo make install
          cd ..

      - name: Install OpenColorIO
        run: |
          OCIO_VERSION='2.4.1'
          mkdir ocio
          cd ocio
          wget https://github.com/AcademySoftwareFoundation/OpenColorIO/archive/refs/tags/v${OCIO_VERSION}.tar.gz
          tar xzf v${OCIO_VERSION}.tar.gz
          mkdir build
          cd build
          cmake \
            -DCMAKE_BUILD_TYPE=Release \
            -DOCIO_BUILD_PYTHON=OFF \
            -DOCIO_BUILD_APPS=0 \
            -DOCIO_BUILD_TESTS=0 \
            -DOCIO_BUILD_GPU_TESTS=0 \
            ../OpenColorIO-${OCIO_VERSION}
          make -j$(nproc)
          sudo make install
          cd ../..

      - name: Install mi-malloc
        run: |
          MIMALLOC_VERSION='2.1.7'
          mkdir mimalloc
          cd mimalloc
          wget https://github.com/microsoft/mimalloc/archive/refs/tags/v${MIMALLOC_VERSION}.tar.gz
          tar xzf v${MIMALLOC_VERSION}.tar.gz
          mkdir build
          cd build
          cmake \
            -DCMAKE_BUILD_TYPE=Release \
            ../mimalloc-${MIMALLOC_VERSION}
          make -j$(nproc)
          sudo make install
          cd ../..

      - if: ${{ matrix.arch == 'arm64' }}
        name: Install SIMDE
        run: |
          wget https://github.com/simd-everywhere/simde/archive/refs/tags/v0.8.2.tar.gz
          tar xzf v0.8.2.tar.gz
          cd simde-0.8.2
          meson setup build -Dbuildtype=release -Dtests=false
          sudo meson install -C build
          
      - name: Configure build
        run: |
          BUILDTYPE=Release
          if [ "${{ inputs.debug }}" = "true" ]; then
              echo "Configuring a Debug build"
              BUILDTYPE=Debug
          fi
          if [ "${{ matrix.arch }}" = "arm64" ]; then
              ART_SIMDE=1
          else
              ART_SIMDE=0
          fi
          sudo ldconfig
          mkdir build
          cd build
          cmake \
            -DCMAKE_BUILD_TYPE=$BUILDTYPE \
            -DBUILD_BUNDLE=1 \
            -DENABLE_CTL=1 \
            -DENABLE_LIBRAW=1 \
            -DCTL_INCLUDE_DIR=/usr/local/include/CTL \
            -DCMAKE_LIBRARY_PATH=/usr/local/lib \
            -DENABLE_SIMDE=${ART_SIMDE} \
            ../repo
          cd ..

      - name: Build
        run: |
          cd build
          make -j$(nproc)
          make install

      - name: Include Lensfun
        run: |
          PYTHONPATH=/usr/local/lib/python3.8/site-packages lensfun-update-data

      - name: Install glib 2.83
        run: |
          wget https://download.gnome.org/sources/glib/2.83/glib-2.83.3.tar.xz
          tar xJf glib-2.83.3.tar.xz
          cd glib-2.83.3
          meson setup build \
            -Dbuildtype=release \
            -Dglib_debug=disabled \
            -Dprefix=/opt/glib
          meson compile -C build
          sudo meson install -C build
          
      - name: Create bundle
        env:
          GITHUB_AUTH: ${{ secrets.GITHUB_TOKEN }}
        run: |
          ART_NAME="ART-${ART_VERSION}"
          DBG=
          if [ "${{ inputs.debug }}" = "true" ]; then
              echo "Creating a Debug bundle"
              DBG=-d
              ART_NAME="${ART_NAME}-debug"
              cd build/Debug
          else
              cd build/Release
          fi
          if [ "${{ matrix.arch }}" = "x86_64" ]; then
              suffix=linux64
              prefix=x86_64
          else
              suffix=linux-aarch64
              prefix=aarch64
          fi
          python ../../repo/tools/linux/bundle_ART.py \
            -o ../../${ART_NAME}-${suffix} -v -E -I ${DBG}
          cd ../..
          pushd ${ART_NAME}-${suffix}/lib
          for l in libgmodule-2.0.so.0 libglib-2.0.so.0 libgio-2.0.so.0; do
            rm -f ${l}
            cp /opt/glib/lib/${prefix}-linux-gnu/${l} .
          done
          popd
          tar cJf ${ART_NAME}-${suffix}.tar.xz ${ART_NAME}-${suffix}
          echo "ART_BUNDLE_NAME=${ART_NAME}-${suffix}" >> $GITHUB_ENV

      - name: Prepare artifact name
        run: |
          ARTIFACT_NAME="${ART_BUNDLE_NAME}.tar.xz"
          echo "ARTIFACT_NAME=$ARTIFACT_NAME" >> $GITHUB_ENV
          if [ "$GITHUB_REF_TYPE" = "tag" ]; then
              echo "RELEASE_TAG=${ART_VERSION}" >> $GITHUB_ENV
              echo "RELEASE_MAKE_LATEST=true" >> $GITHUB_ENV
          else
              echo "RELEASE_TAG=nightly" >> $GITHUB_ENV
              echo "RELEASE_MAKE_LATEST=false" >> $GITHUB_ENV
          fi

      - name: Create AppImage
        run: |
          if [ "${{ matrix.arch }}" = "x86_64" ]; then
              arch=x86_64
          else
              arch=aarch64
          fi
          wget https://github.com/AppImage/appimagetool/releases/download/1.9.1/appimagetool-${arch}.AppImage
          chmod a+x appimagetool-${arch}.AppImage
          pushd "${ART_BUNDLE_NAME}"
          ln -s share/icons/hicolor/128x128/apps/ART.png
          echo '#!/bin/sh' > AppRun
          echo 'export ART_MKDESKTOP=no' >> AppRun
          echo 'd=$(dirname "$0")' >> AppRun
          echo 'if [ "$1" = "--cli" ]; then' >> AppRun
          echo -e '  shift\n  exec "${d}/ART-cli" "$@"' >> AppRun
          echo -e 'else\n  exec "${d}/ART" "$@"\nfi' >> AppRun
          chmod a+x AppRun
          echo '[Desktop Entry]' > ART.desktop
          echo "Name=ART-${ART_VERSION}" >> ART.desktop
          echo -e 'Type=Application\nExec=ART' >> ART.desktop
          echo 'Comment=ART is a free RAW image processor' >> ART.desktop
          echo -e 'Icon=ART\nCategories=Graphics;' >> ART.desktop
          popd
          ARCH=${arch} ./appimagetool-${arch}.AppImage -n "${ART_BUNDLE_NAME}"
          echo "ARTIFACT_APPIMAGE_NAME=ART-${ART_VERSION}-${arch}.AppImage" >> $GITHUB_ENV

      - name: Publish release
        uses: ncipollo/release-action@v1
        with:
          tag: ${{ env.RELEASE_TAG }}
          body: ${{ env.RELEASE_TAG }}
          allowUpdates: true
          makeLatest: ${{ env.RELEASE_MAKE_LATEST }}
          artifacts: ${{ env.ARTIFACT_NAME }},${{ env.ARTIFACT_APPIMAGE_NAME }}