Merge remote-tracking branch 'upstream/master' into metadata-pipe

Author: iVolt1

.github/workflows/build_test.yml

@@ -8,7 +8,10 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        runner: [ ubuntu-24.04, macos-15 ]
+    runs-on: ${{ matrix.runner }}
     steps:
       - uses: actions/checkout@v3
 
@@ -17,14 +20,24 @@ jobs:
         with:
           go-version: '1.22.2'
 
-      - name: Install dependencies
-        run: sudo apt-get update && sudo apt-get install -y libasound2-dev libvorbis-dev libogg-dev
+      - name: Install Linux dependencies
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install -y libasound2-dev libvorbis-dev libogg-dev libflac-dev
 
-      - name: Build daemon
-        run: go build -v ./cmd/daemon
+      - name: Install macOS dependencies
+        if: runner.os == 'macOS'
+        run: brew install libogg libvorbis flac
+
+      - name: Check dependencies
+        run: |
+          go mod tidy
+          git diff --exit-code go.mod go.sum
 
       - name: Format
         run: test -z "$(gofmt -l .)"
 
+      - name: Build daemon
+        run: go build -v ./cmd/daemon
+
       - name: Test
-        run: go test -v ./...
+        run: go test -v -tags "test_unit test_integration" ./...

.github/workflows/docker.yml

@@ -30,6 +30,10 @@ jobs:
         with:
           cosign-release: 'v2.2.4'
 
+      # Setup QEMU to be able to build images for multiple platforms
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
       # Set up BuildKit Docker container builder to be able to build
       # multi-platform images and export cache
       - name: Set up Docker Buildx
@@ -57,6 +61,7 @@ jobs:
         uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # v5.0.0
         with:
           context: .
+          platforms: linux/amd64,linux/arm64
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}

.github/workflows/release.yml

@@ -15,59 +15,22 @@ jobs:
     runs-on: ubuntu-24.04
     strategy:
       matrix:
-        include:
-          - target: x86-64-linux-gnu
-            goarch: amd64
-            goamd64: v1
-            cc: gcc
-            tar: linux_x86_64
-          - target: arm-rpi-linux-gnueabihf
-            goarch: arm
-            goarm: 6
-            cc: arm-rpi-linux-gnueabihf-gcc
-            tar: linux_armv6_rpi
-          - target: arm-linux-gnueabihf
-            goarch: arm
-            goarm: 6
-            cc: arm-linux-gnueabihf-gcc
-            tar: linux_armv6
-          - target: aarch64-linux-gnu
-            goarch: arm64
-            cc: aarch64-linux-gnu-gcc
-            tar: linux_arm64
+        variant: [ 'x86_64', 'arm64', 'armv6', 'armv6_rpi' ]
     steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - run: git fetch --force --tags
-
-      - name: Build image
-        run: |
-          docker build \
-            --build-arg TARGET=${{ matrix.target }} \
-            --build-arg GOARCH=${{ matrix.goarch }} \
-            --build-arg GOARM=${{ matrix.goarm }} \
-            --build-arg GOAMD64=${{ matrix.goamd64 }} \
-            --build-arg CC=${{ matrix.cc }} \
-            -t go-librespot-build-${{ matrix.target }} \
-            -f Dockerfile.build \
-            .
+      - name: Checkout
+        uses: actions/checkout@v3
 
       - name: Compile binary
         run: |
           mkdir -p /tmp/out
-          docker run --rm \
-            --env COMMIT=${{ github.sha }} \
-            --env VERSION=${{ startsWith(github.ref_name, 'v') && github.ref_name || '' }} \
-            -v $PWD:/src \
-            go-librespot-build-${{ matrix.target }}
-          tar -zcvf /tmp/out/go-librespot_${{ matrix.tar }}.tar.gz go-librespot README.md
+          ./crosscompile.sh ${{ matrix.variant }}
+          mv go-librespot-${{ matrix.variant }} go-librespot
+          tar -zcvf /tmp/out/go-librespot_linux_${{ matrix.variant }}.tar.gz go-librespot README.md
 
       - name: Upload compiled binary
         uses: actions/upload-artifact@v4
         with:
-          name: binaries-${{ matrix.target }}
+          name: binaries-${{ matrix.variant }}
           path: /tmp/out
           retention-days: 7
 

.gitignore

@@ -1,9 +1,15 @@
+# IDE files
 *.iml
 /.idea
 
+# Configuration files
 /config.yml
 /credentials.json
 /state.json
 /lockfile
 
+# Build files
+/.gocache
+/vcpkg
+/vcpkg_installed
 /dist

.mockery.yaml

@@ -0,0 +1,13 @@
+dir: '{{.InterfaceDir}}'
+structname: Mock{{.InterfaceName}}
+pkgname: '{{.SrcPackageName}}'
+filename: "mock_{{.InterfaceName}}.go"
+template: testify
+template-data:
+  mock-build-tags: test_unit || test_integration
+  unroll-variadic: true
+packages:
+  github.com/devgianlu/go-librespot:
+    interfaces:
+      Logger:
+      PageResolver:

CROSS_COMPILE.md

@@ -1,82 +1,26 @@
 # Cross Compiling
 
-Cross compilation is currently described for Linux only. All the commands below rely on the host platform being
-`linux/amd64`: this is currently enforced by the Dockerfile. If you are not on a `linux/amd64` system, have a look
-at [Multi-platform builds](https://docs.docker.com/build/building/multi-platform/).
+The cross compilation helper script uses Docker to build the project for different architectures with the respective
+toolchains.
 
-## Create Docker images for (cross-)compiling
+Currently, cross compilation is available only for Linux x64 hosts. This is enforced by Docker with the `--platform`
+flag set to `linux/amd64`. You can still use this helper on other platforms, but you will need to set up
+[Multi-platform builds](https://docs.docker.com/build/building/multi-platform/).
 
-### Target Linux x86_64
+## How To
 
-```bash
-docker build \
-  --build-arg TARGET=x86-64-linux-gnu \
-  --build-arg GOARCH=amd64 \
-  --build-arg GOAMD64=v1 \
-  --build-arg CC=gcc \
-  -f Dockerfile.build \
-  -t go-librespot-build-x86_64 .
-```
-
-### Target Linux on Raspberry Pi 1 / Zero
+A handy script to build the project for multiple platforms is provided [here](./crosscompile.sh). To use it simply
+specify the target variant you want to build for.
 
 ```bash
-docker build \
-  --build-arg TARGET=arm-rpi-linux-gnueabihf \
-  --build-arg GOARCH=arm \
-  --build-arg GOARM=6 \
-  --build-arg CC=arm-rpi-linux-gnueabihf-gcc \
-  -f Dockerfile.build \
-  -t go-librespot-build-armv6_rpi .
+./crosscompile.sh <variant>
 ```
 
-### Target Linux ARM32 (Raspberry Pi 2 and above)
+The currently supported variants are `x86_64`, `armv6`, `armv6_rpi` and `arm64`.
 
-```bash
-docker build \
-  --build-arg TARGET=arm-linux-gnueabihf \
-  --build-arg GOARCH=arm \
-  --build-arg GOARM=6 \
-  --build-arg CC=arm-linux-gnueabihf-gcc \
-  -f Dockerfile.build \
-  -t go-librespot-build-armv6 .
-```
+## `armv6` vs `armv6_rpi`
 
-### Target Linux ARM64
+The `armv6` variant is a generic armv6 build. It should work on most armv6 devices that support thumb instructions.
 
-```bash
-docker build \
-  --build-arg TARGET=aarch64-linux-gnu \
-  --build-arg GOARCH=arm64 \
-  --build-arg CC=aarch64-linux-gnu-gcc \
-  -f Dockerfile.build \
-  -t go-librespot-build-arm64 .
-```
-
-## Use the images built above to (cross-)compile
-
-`cd` into the root of the `go-librespot` source code and run on of the following statements.
-
-### Target Linux x86_64
-
-```bash
-docker run --rm -u $(id -u):$(id -g) -v $PWD:/src -e GOOUTSUFFIX=-x86_64 go-librespot-build-x86_64
-```
-
-### Target Linux on Raspberry Pi 1 / Zero
-
-```bash
-docker run --rm -u $(id -u):$(id -g) -v $PWD:/src -e GOOUTSUFFIX=-armv6_rpi go-librespot-build-armv6_rpi
-```
-
-### Target Linux ARM32 (Raspberry Pi 2 and above)
-
-```bash
-docker run --rm -u $(id -u):$(id -g) -v $PWD:/src -e GOOUTSUFFIX=-armv6 go-librespot-build-armv6
-```
-
-### Target Linux ARM64
-
-```bash
-docker run --rm -u $(id -u):$(id -g) -v $PWD:/src -e GOOUTSUFFIX=-arm64 go-librespot-build-arm64
-```
+The `armv6_rpi` variant is specifically built for the Raspberry Pi 1 and Zero, which do not support thumb instructions.
+The toolchain used for this build can be found [here](https://github.com/devgianlu/rpi-toolchain).

Dockerfile

@@ -1,14 +1,14 @@
 FROM alpine:3.20 AS build
 
-RUN apk -U --no-cache add go alsa-lib-dev libogg-dev libvorbis-dev
+RUN apk -U --no-cache add go alsa-lib-dev libogg-dev libvorbis-dev flac-dev gcc musl-dev
 
 WORKDIR /src
 
 COPY go.mod go.sum ./
 RUN go mod download
 
 COPY . .
-RUN go build -v ./cmd/daemon
+RUN CGO_ENABLED=1 go build -v ./cmd/daemon
 
 FROM alpine:3.20
 

Dockerfile.build

@@ -1,60 +1,43 @@
-FROM --platform=linux/amd64 docker.io/golang:1.22.2-bullseye
+FROM --platform=linux/amd64 docker.io/golang:1.22.2
 
-ENV COMMIT=dev
-ENV VERSION=0.0.0
+# Build tools
+RUN apt-get update && apt-get install -y zip autoconf autopoint libtool
 
-# Preparations
-RUN apt-get update && apt-get install -y wget build-essential
-
-# Download and extract dependency sources
-RUN cd /tmp && \
-    wget http://www.alsa-project.org/files/pub/lib/alsa-lib-1.2.10.tar.bz2 && \
-    tar -xvf alsa-lib-1.2.10.tar.bz2
-RUN cd /tmp && \
-    wget https://downloads.xiph.org/releases/ogg/libogg-1.3.5.tar.xz && \
-    tar -xvf libogg-1.3.5.tar.xz
-RUN cd /tmp && \
-    wget https://downloads.xiph.org/releases/vorbis/libvorbis-1.3.7.tar.xz && \
-    tar -xvf libvorbis-1.3.7.tar.xz
-
-# Depencies arguments
+# Install toolchain
 ARG TARGET
-ARG CC
-
-# Install toolchain for anything besides arm-rpi-linux-gnueabihf
-RUN if [ ${TARGET} != arm-rpi-linux-gnueabihf ]; then \
-        apt-get install -y gcc-${TARGET} ; \
-    fi
-
-# Install custom toolchain for arm-rpi-linux-gnueabihf
-RUN if [ ${TARGET} = arm-rpi-linux-gnueabihf ]; then \
+RUN if [ "$TARGET" = "arm-rpi-linux-gnueabihf" ]; then \
         cd /tmp && \
         wget https://github.com/devgianlu/rpi-toolchain/releases/download/v1/arm-rpi-linux-gnueabihf.tar.gz && \
         tar -C /usr --strip-components=1 -xzf arm-rpi-linux-gnueabihf.tar.gz ; \
+    else \
+        apt-get install -y "gcc-$TARGET" ; \
     fi
 
-# Compile dependency sources
-RUN cd /tmp/alsa-lib-1.2.10 && \
-    ./configure --enable-shared=yes --enable-static=no --with-pic --host=${TARGET} --prefix=/tmp/deps/${TARGET} && \
-    make -j $(nproc) && make install
-RUN cd /tmp/libogg-1.3.5 && \
-    ./configure --host=${TARGET} --prefix=/tmp/deps/${TARGET} && \
-    make -j $(nproc) && make install
-RUN cd /tmp/libvorbis-1.3.7 && \
-    ./configure --host=${TARGET} --prefix=/tmp/deps/${TARGET} && \
-    make -j $(nproc) && make install
-
-# Golang arguments
+# Move to build directory
+WORKDIR /build
+
+# Setup vcpkg
+ADD https://github.com/microsoft/vcpkg.git#2025.09.17 vcpkg
+RUN cd vcpkg && ./bootstrap-vcpkg.sh
+ENV VCPKG_ROOT=/build/vcpkg
+ENV PATH="$VCPKG_ROOT:$PATH"
+
+# Compile dependencies
+ARG TRIPLET
+COPY vcpkg.json vcpkg-configuration.json ./
+COPY vcpkg-triplets ./vcpkg-triplets
+RUN --mount=type=cache,target=/build/vcpkg/downloads \
+    --mount=type=cache,target=/build/vcpkg/buildtrees \
+    vcpkg install --triplet "$TRIPLET"
+
+# Go compilation setup
+ARG GOCC
 ARG GOARCH
 ARG GOAMD64
 ARG GOARM
 
-# Compile
 WORKDIR /src
-ENV CGO_ENABLED=1 PKG_CONFIG_PATH=/tmp/deps/${TARGET}/lib/pkgconfig/ CC=${CC} \
-    GOARCH=${GOARCH} GOAMD64=${GOAMD64} GOARM=${GOARM} GOOUTSUFFIX='' \
+ENV CGO_ENABLED=1 PKG_CONFIG_PATH="/build/vcpkg_installed/$TRIPLET/lib/pkgconfig" CC="$GOCC" \
+    GOARCH="$GOARCH" GOAMD64="$GOAMD64" GOARM="$GOARM" \
     GOCACHE=/src/.gocache/go-build GOMODCACHE=/src/.gocache/mod
-CMD go build \
-    -buildvcs=false \
-    -ldflags="-X github.com/devgianlu/go-librespot.commit=${COMMIT} -X github.com/devgianlu/go-librespot.version=${VERSION}" \
-    -o ./go-librespot${GOOUTSUFFIX} -a ./cmd/daemon
+CMD ["go", "build", "-o", "./go-librespot", "-a", "-ldflags", "-s -w", "./cmd/daemon"]

README.md

@@ -40,14 +40,14 @@ brew install go-librespot
 To build from source the following prerequisites are necessary:
 
 - Go 1.22 or higher
-- Libraries: `libogg`, `libvorbis`, `libasound2`
+- Libraries: `libogg`, `libvorbis`, `flac`, `libasound2`
 
 To install Go, download it from the [Go website](https://go.dev/dl/).
 
 To install the required libraries on Debian-based systems (Debian, Ubuntu, Raspbian), use:
 
 ```shell
-sudo apt-get install libogg-dev libvorbis-dev libasound2-dev
+sudo apt-get install libogg-dev libvorbis-dev libflac-dev libasound2-dev
 ```
 
 Once prerequisites are installed you can clone the repository and run the daemon with:
@@ -153,6 +153,7 @@ The following options are also available:
 
 ```yaml
 log_level: info # Log level configuration (trace, debug, info, warn, error)
+log_disable_timestamp: false # Whether to disable timestamps in log output
 device_id: '' # Spotify device ID (auto-generated)
 device_name: '' # Spotify device name
 device_type: computer # Spotify device type (icon)