Fix invalid task warning with 'clearfail'.

Update
Merge pull request #35 from chrober/fix/case-sensitive-path-reconciliation
2026-10-27 01:16:10 +03:00 · 2026-08-28 18:50:37 +01:00 · 2026-07-29 17:15:03 +01:00 · 2026-07-29 17:13:33 +01:00 · 2026-07-29 14:35:29 +02:00 · 2026-01-04 11:57:53 +00:00
21 changed files with 3453 additions and 1010 deletions
@@ -7,19 +7,55 @@ env:
  CARGO_TERM_COLOR: always

 jobs:
-  Linux:
-    runs-on: ubuntu-20.04
+  Linux_x86_symphonia:
+    runs-on: ubuntu-latest

    steps:
    - name: Checkout
      uses: actions/checkout@v1

-    - name: Packages
-      run: sudo apt-get update && sudo apt-get install build-essential yasm libavutil-dev libavcodec-dev libavformat-dev libavfilter-dev libavfilter-dev libavdevice-dev libswresample-dev libfftw3-dev ffmpeg
-      
-    - name: Build
+    - name: Build x86
      run: |
-        cargo build --release
+        docker build -t bliss-analyser-x86-symphonia - < docker/Dockerfile_x86_symphonia
+        docker run --rm -v $PWD/target:/build -v $PWD:/src bliss-analyser-x86-symphonia
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: bliss-analyser-linux-x86-symphonia
+        path: releases/
+
+#  Linux_x86_ffmpeg:
+#    runs-on: ubuntu-latest
+#
+#    steps:
+#    - name: Checkout
+#      uses: actions/checkout@v1
+#
+#    - name: Build x86
+#      run: |
+#        docker build -t bliss-analyser-x86-ffmpeg - < docker/Dockerfile_x86_ffmpeg
+#        docker run --rm -v $PWD/target:/build -v $PWD:/src bliss-analyser-x86-ffmpeg
+#
+#    - name: Upload artifacts
+#      uses: actions/upload-artifact@v4
+#      with:
+#        name: bliss-analyser-linux-x86-ffmpeg
+#        path: releases/
+
+  Linux_x86_ffmpeg:
+    runs-on: ubuntu-22.04
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Packages
+      run: sudo apt-get update && sudo apt-get install build-essential yasm -y
+
+    - name: Build x86 static-ffmpeg version
+      run: |
+        cargo build --release --features=libav,staticlibav
        strip target/release/bliss-analyser
        mkdir releases
        cp target/release/bliss-analyser releases/bliss-analyser
@@ -28,13 +64,49 @@ jobs:
        cp configs/linux.ini releases/config.ini

    - name: Upload artifacts
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
      with:
-        name: bliss-analyser-linux
+        name: bliss-analyser-linux-x86-ffmpeg
        path: releases/

-  macOS:
-    runs-on: macos-11.0
+  Linux_arm_symphonia:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v1
+
+    - name: Build ARM
+      run: |
+        docker build -t bliss-analyser-arm-symphonia - < docker/Dockerfile_arm_symphonia
+        docker run --rm -v $PWD/target:/build -v $PWD:/src bliss-analyser-arm-symphonia
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: bliss-analyser-linux-arm-symphonia
+        path: releases/
+
+  Linux_arm_ffmpeg:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v1
+
+    - name: Build ARM
+      run: |
+        docker build -t bliss-analyser-arm-ffmpeg - < docker/Dockerfile_arm_ffmpeg
+        docker run --rm -v $PWD/target:/build -v $PWD:/src bliss-analyser-arm-ffmpeg
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: bliss-analyser-linux-arm-ffmpeg
+        path: releases/
+
+  macOS_symphonia:
+    runs-on: macos-15

    steps:
    - name: Install Rust
@@ -47,26 +119,70 @@ jobs:

    - name: Install deps
      run: |
-          brew install ffmpeg@5
+        brew install pkg-config
+
+    - name: Install Rust support for ARM64 & prepare environment
+      run: |
+        rustup target add x86_64-apple-darwin
+        rustup target add aarch64-apple-darwin
+        mkdir releases

    - name: Build
      run: |
-        mkdir releases
-        cargo build --release
-        strip target/release/bliss-analyser
-        cp target/release/bliss-analyser releases/bliss-analyser
+        cargo build --target=x86_64-apple-darwin --release --features update-aubio-bindings,symphonia
+        cargo build --target=aarch64-apple-darwin --release --features update-aubio-bindings,symphonia
        cp UserGuide.md releases/README.md
        cp LICENSE releases/
        cp configs/macos.ini releases/config.ini

+    - name: Build fat binary
+      run: |
+        lipo -create \
+          -arch x86_64 target/x86_64-apple-darwin/release/bliss-analyser \
+          -arch arm64 target/aarch64-apple-darwin/release/bliss-analyser \
+          -output releases/bliss-analyser
+
    - name: Upload artifacts
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
      with:
-        name: bliss-analyser-mac
+        name: bliss-analyser-mac-symphonia
        path: releases/

-  Windows:
-    runs-on: windows-2019
+
+  Windows_symphonia:
+    runs-on: windows-2022
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        override: true
+        components: rustfmt, clippy
+
+    - name: Build
+      run: |
+        cargo build --release --features=symphonia
+        strip target/release/bliss-analyser.exe
+        mkdir releases
+        cp target/release/bliss-analyser.exe releases/bliss-analyser.exe
+        cp UserGuide.md releases/README.md
+        cp LICENSE releases/
+        cp configs/windows.ini releases/config.ini
+        cp c:\Windows\system32\vcruntime140.dll releases
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: bliss-analyser-windows-symphonia
+        path: releases/
+
+
+  Windows_ffmpeg:
+    runs-on: windows-2022

    steps:
    - name: Checkout
@@ -76,7 +192,7 @@ jobs:
      run: |
        $VCINSTALLDIR = $(& "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe" -latest -property installationPath)
        Add-Content $env:GITHUB_ENV "LIBCLANG_PATH=${VCINSTALLDIR}\VC\Tools\LLVM\x64\bin`n"
-        Invoke-WebRequest "https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-full-shared.7z" -OutFile ffmpeg-shared.7z
+        Invoke-WebRequest "https://www.gyan.dev/ffmpeg/builds/packages/ffmpeg-7.1.1-full_build-shared.7z" -OutFile ffmpeg-shared.7z
        7z x ffmpeg-shared.7z
        mkdir deps
        mv ffmpeg-*/* deps/
@@ -92,7 +208,8 @@ jobs:

    - name: Build
      run: |
-        cargo build --release
+        cargo build --release --features=libav
+        strip target/release/bliss-analyser.exe
        mkdir releases
        cp target/release/bliss-analyser.exe releases/bliss-analyser.exe
        cp deps/bin/*.dll releases/
@@ -102,7 +219,7 @@ jobs:
        cp c:\Windows\system32\vcruntime140.dll releases

    - name: Upload artifacts
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
      with:
-        name: bliss-analyser-windows
+        name: bliss-analyser-windows-ffmpeg
        path: releases/
@@ -1,26 +1,50 @@
 [package]
 name = "bliss-analyser"
-version = "0.0.2"
+version = "0.5.3"
 authors = ["Craig Drummond <craig.p.drummond@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "GPL-3.0-only"
 description = "Analyse audio files with bliss-rs"
 repository = "https://github.com/CDrummond/bliss-analyser"
 keywords = ["audio", "song", "similarity"]
 readme = "README.md"

+[profile.release]
+strip=true
+
 [dependencies]
-bliss-audio =  { git = "https://github.com/Polochon-street/bliss-rs", rev = "5f366b0" }
 argparse = "0.2.2"
 anyhow = "1.0.40"
-rusqlite = { version = "0.25.0", features = ["bundled"] }
+rusqlite = { version = "0.34.0", features = ["bundled"] }
 log = "0.4.14"
-env_logger = "0.8.4"
+env_logger = "0.11.7"
 indicatif = "0.16.2"
-lofty = "0.5.3"
+lofty = "0.22.2"
+filetime = "0.2"
 dirs = "1"
-chrono = "0.4.19"
+chrono = "0.4.40"
 regex = "1"
 substring = "1.4.5"
 ureq = "2.4.0"
 configparser = "3.0.0"
+if_chain = "1.0.2"
+num_cpus = "1.13.0"
+which = { version = "7.0.2", optional = true }
+rcue = { version = "0.1.3", optional = true }
+hhmmss = { version = "0.1.0", optional = true }
+ctrlc = "3.4"
+serde_json = "1.0.145"
+
+[features]
+libav = ["bliss-audio/ffmpeg"]
+update-aubio-bindings = ["bliss-audio/update-aubio-bindings"]
+staticlibav = ["bliss-audio/build-ffmpeg", "bliss-audio/ffmpeg-static"]
+symphonia = ["bliss-audio/symphonia-all", "bliss-audio/symphonia-aiff", "bliss-audio/symphonia-alac"]
+rpi = ["bliss-audio/rpi"]
+
+[dependencies.bliss-audio]
+default-features = false
+features = ["aubio-static"]
+version = "0.11.1"
+#git = "https://github.com/Polochon-street/bliss-rs.git"
+#rev = "006927ac16752ff2e00bfe0d6b7756f67fa822c0"
@@ -1,3 +1,90 @@
+0.5.3
+-----
+1. Fix stale case-only paths on case-insensitive filesystems - thanks to
+   chrober for implementation.
+2. Fix invalid task warning with 'clearfail'.
+
+0.5.2
+-----
+1. Fix Linux builds.
+
+0.5.1
+-----
+1. Use serde_json to build JSONRPC notification strings.
+
+0.5.0
+-----
+1. Update to bliss-rs 0.11.1
+2. Only build static-libav and symphonia by default.
+3. Don't crash if file has no tags.
+4. Set log level for tag reader library.
+5. Multi-threaded read of existing analysis tags.
+6. Store file failures in DB so don't re-analyse unless timestamp of file
+   changes.
+7. Drop support for using ffmpeg via commandline.
+
+0.4.0
+-----
+1. Add action to export results from DB to files.
+2. Add option to preserve file modification time when writing tags.
+3. Store analysis in BLISS_ANALYSIS tag, not in a COMMENT tag.
+4. Fix reading of tags during analysis phase.
+5. Check for multiple genre tags, and if found add as semi-colon separated
+   list to DB.
+6. When analysing files, always read tags (if present), but only write tags
+   if '--tags' is specified on commandline.
+7. Use max of 16 significant digits (trailing zeros stripped) when writing
+   analysis results to file tags.
+8. Strip symbols from release binaries.
+9. Gracefully handle Ctrl-C.
+
+0.3.0
+-----
+1. Add support for (DSD) WavPack - thanks to Bart Lauret
+2. Update version of tag reader library.
+3. Update version of bliss library.
+4. Allow builds to either use dynamic ffmpeg libraries, static ffmpeg
+   libraries, symphonia, or ffmpeg on commandline.
+5. Add ability to specify LMS JSONRPC port.
+6. If new files analysed and 'ignore' file exists then update DB's 'ignore'
+   flags.
+7. Add option to write analysis results to files, and use for future scans.
+8. If log level set to 'trace' then set this level for the bliss library too.
+9. Enable support for '.dsf' files.
+
+0.2.3
+-----
+1. Add option to limit number of concurrent threads.
+2. Update version of tag reader library.
+3. Update version of bliss library.
+
+0.2.2
+-----
+1. Update version of tag reader library.
+2. Update version of bliss library.
+
+0.2.1
+-----
+1. Update version of tag reader library.
+2. Fix checking if CUE already analysed.
+
+0.2.0
+-----
+1. Tidy up code, thanks to Serial-ATA
+2. Update version of tag reader library, should now support ID3v2 in FLAC.
+3. Show error message if can't open, or create, DB file.
+4. Update version of bliss-rs, this now handles CUE processing internally.
+
+0.1.0
+-----
+1. Add support for analysing CUE files.
+2. Output list of (up to 100) tracks that failed to analyse.
+3. When performing a dry-run analysis (--dry-run) print paths of all tracks to
+   be analysed and to be removed.
+4. Use git version of tag reader library.
+5. Support up to 5 music folders (music, music_1, music_2, music_3, and
+   music_4).
+
 0.0.2
 -----
 1. Package vcruntime140.dll with Windows ZIP.
@@ -7,16 +7,90 @@ bliss analysis. This is then intended to be used by [Bliss Mixer](https://github

 # Building

-clang, pkg-config, and ffmpeg are required to build, as well as
+This application can be built in 4 variants:
+
+1. Using `libavcodec`, etc, to decode files.
+2. Using `libavcodec`, etc, to decode files, but statically linked to `libavcodec`, etc.
+3. Using `symphonia` to decode files.
+
+
+`libavcodec` is the fastest (~15% faster than `symphonia`), but might have issues with
+library, versioning, etc., unless these libraries are statically linked in. `libavcodec`
+statically linked may reduce supported file formats, but is more portable.
+file formats, but is more portable.
+
+`symphonia` also produces a more portable application, is only slightly slower to decode
+files, but has more limited codec support, and can fail on more files.
+
+
+## Build for 'libavcodec' library usage
+
+`clang`, `pkg-config`, and `ffmpeg` are required to build, as well as
 [Rust](https://www.rust-lang.org/tools/install)

 To install dependencies on a Debian system:

 ```
-apt install -y clang libavcodec-dev libavformat-dev libavutil-dev libavfilter-dev libavdevice-dev pkg-config
+apt install -y clang libavcodec-dev libavformat-dev libavutil-dev libavfilter-dev libavdevice-dev pkg-config yasm
 ```

-Build with `cargo build --release`
+To install dependencies on a Fedora system:
+```
+dnf install ffmpeg-devel clang pkg-config
+```
+
+Build with `cargo build --release --features=libav`
+
+If building on a Raspberry Pi, then `rpi` also needs to be passed to `--features`, e.g.
+`cargo build --release --features=libav,rpi`
+
+The resultant application will be less portable, due to dependencies on `libavcodec` libraries (and
+their dependencies).
+
+
+
+## Build for 'libavcodec' library usage, statically linked
+
+`clang`, `pkg-config`, and `ffmpeg` are required to build, as well as
+[Rust](https://www.rust-lang.org/tools/install)
+
+To install dependencies on a Debian system:
+
+```
+apt install -y clang libavcodec-dev libavformat-dev libavutil-dev libavfilter-dev libavdevice-dev pkg-config yasm
+```
+
+To install dependencies on a Fedora system:
+```
+dnf install ffmpeg-devel clang pkg-config
+```
+
+Build with `cargo build --release --features=libav,staticlibav`
+
+If building on a Raspberry Pi, then `rpi` also needs to be passed to `--features`, e.g.
+`cargo build --release --features=libav,staticlibav,rpi`
+
+
+
+## Build for 'symphonia'
+
+`clang`, and `pkg-config` are required to build, as well as
+[Rust](https://www.rust-lang.org/tools/install)
+
+To install dependencies on a Debian system:
+
+```
+apt install -y clang pkg-config
+```
+
+To install dependencies on a Fedora system:
+```
+dnf install clang pkg-config
+```
+
+Build with `cargo build --release --features=symphonia`
+
+


 # Usage
@@ -6,6 +6,9 @@ upload its database of music analysis to LMS. The `Bliss Mixer` LMS plugin can
 then use this information to provide music mixes for LMS's `Don't Stop the Music`
 feature.

+**NOTE:** You must run this application from a terminal window (e.g. cmd.com or
+PowerShell for Windows), as there is no graphical user interface.
+


 Quick guide
@@ -13,9 +16,7 @@ Quick guide

 1. Install the `Bliss Mixer` LMS plugin.

-2. Install ffmpeg if using Linux or macOS.
-
-3. Edit the supplied `config.ini` in the current folder to set appropiate values
+2. Edit the supplied `config.ini` in the current folder to set appropriate values
 for `music` and `lms` - e.g.:
 ```
 [Bliss]
@@ -23,65 +24,19 @@ music=/home/user/Music
 lms=127.0.0.1
 ```

-4. Analyse your tracks:
+3. Analyse your tracks:
 ```
 ./bliss-analyser analyse
 ```

-5. Upload analysis database to LMS:
+4. Upload analysis database to LMS:
 ```
 ./bliss-analyser upload
 ```

-6. Set LMS to use `Bliss` in `Don't Stop the Music`
-
-7. Play some music!
-
-
-
-Installation
-============
-
-For Windows no extra installation steps are required, as all dependencies are
-bundled within its ZIP file. However, both the Linux and macOS versions require
-that `ffmpeg` be installed.
-
-
-Linux
-----
-
-Debian based systems (e.g. Ubuntu):
-```
-sudo apt install ffmpeg
-```
-
-RedHat based systems (e.g. Fedora):
-```
-sudo yum install ffmpeg
-```
-
-
-macOS
-----
-
-First install `HomeBrew`
-
-High Sierra, Sierra, El Capitan, or earlier:
-```
-/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-```
-
-Otherwise:
-```
-/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-```
-
-Then install `ffmpeg`:
-```
-brew install ffmpeg@5
-brew link ffmpeg@5
-```
+5. Set LMS to use `Bliss` in `Don't Stop the Music`

+6. Play some music!


 Configuration
@@ -98,18 +53,29 @@ music=/home/user/Music
 db=bliss.db
 lms=127.0.0.1
 ignore=ignore.txt
+readtags=true
+writetags=true
 ```

 The following items are supported:
 * `music` specifies the location of your music collection - e.g. `c:\Users\user\Music`
-for windows. This default to `Music` within the user's home folder.
+for windows. This default to `Music` within the user's home folder. Up to 4 other
+music folders may be specified via `music_1`, `music_2`, `music_3`, and `music_4`
 * `db` specifies the name and location of the database file used to store the
 analysis results. This will default to `bliss.db` in the current folder.
 * `lms` specifies the hostname, or IP address, of your LMS server. This is used
-when uploading the database file to LMS. This defaults to `127.0.0.1`
+when uploading the database file to LMS. This defaults to `127.0.0.1` If your LMS is
+password protected then use `user:pass@server` - e.g. `lms=pi:abc123@127.0.0.1`
+* `json` specifies the JSONRPC port number of your LMS server. This will default
+to `9000`.
 * `ignore` specifies the name and location of a file containing items to ignore
 in mixes. See the `Ignore` section later on for more details.
-
+* `readtags` specifies whether analysis results should be read from files whe
+analysing.
+* `writetags` specifies whether analysis results should be written to files when
+analysed.
+* `preserve` specifies whether file modification time should be preserved when
+writing tags. Set to `true` or `false`.


 Command-line parameters
@@ -122,30 +88,44 @@ Command-line parameters
 * `-d` / `--db` Name and location of the database file.
 * `-l` / `--logging` Logging level; `trace`, `debug`, `info`, `warn`, `error`.
 Default is `info`.
-* `-k` / `--keep-old` When analysing tracks, `bliss-analyser` will remove any
-tracks specified in its database that are no-longer on the file-system. This
-parameter is used to prevent this.
+* `-k` / `--keep-old` When analysing tracks, `bliss-analyser` will remove database
+rows for tracks that are no longer on the filesystem. It also reconciles stored
+case-only path differences with the filesystem's exact spelling, preserving the
+existing analysis, and removes stale case-only duplicates. This option prevents
+all of those cleanup actions.
 * `-r` / `--dry-run` If this is supplied when analysing tracks, then no actual
-analysis will be performed, instead the logging will inform you how many new
-tracks are to be analysed and how many old tracks are left in the database.
+analysis or database cleanup will be performed, instead the logging will inform
+you how many new tracks are to be analysed, how many old tracks are left in the
+database, and which stored paths would have their filename casing corrected.
 * `-i` / `--ignore` Name and location of the file containing items to ignore.
 * `-L` / `--lms` Hostname, or IP address, of your LMS server.
+* `-J` / `--json` JSONRPC port number of your LMS server.
 * `-n` / `--numtracks` Specify maximum number of tracks to analyse.
+* `-R` / `--readtags` When using the `analyse` task, read analysis results from a
+files a `BLISS_ANALYSIS` tag (it present) in files.
+* `-W` / `--writetags` When using the `analyse` task, write analysis results to files
+within a `BLISS_ANALYSIS` tag.
+* `-p` / `--preserve` Attempt to preserve file modification time when writing tags.
+* `-t` / `--threads` Maximum number of threads to use for analysis.

-Equivalent items specied in the INI config file (detailed above) will override
-any specified on the commandline.
+Equivalent items specified in the INI config file (detailed above) will override
+any specified on the command-line.

 `bliss-analyser` requires one extra parameter, which is used to determine the
 required task. This takes the following values:

 * `analyse` Performs analysis of tracks.
 * `upload` Uploads the database to LMS.
-* `stopmixer` Asks LMS plugin to stop it instance of `bliss-mixer`
+* `stopmixer` Asks LMS plugin to stop its instance of `bliss-mixer`
 * `tags` Re-reads tags from your music collection, and updates the database for
 any changes.
 * `ignore` Reads the `ignore` file and updates the database to flag tracks as
 to be ignored for mixes.
-
+* `export` Exports tags from database and stores within the audio files.
+* `clearfail` If analysis fails for a track then the track path and its modification
+time is stored in the database, so that running analysis again ignores these files.
+This action clears this information, so that an analysis run will attempt to analyse
+these files.


 Analysing tracks
@@ -173,6 +153,31 @@ is shown.
 As a rough guide, a 2015-era i7 8-core laptop with SSD analyses around 14000
 tracks/hour.

+If analysis fails for a track, then the track's path and timestamp are stored
+within the database so that subsquent analysis calls will skip these tracks.
+
+
+Tags
+----
+When analysing tracks, the analyser will first check for a `BLISS_ANALYSIS` tag
+within the file, and if found this will be used instead of re-analysing the file.
+
+If `--writetags` is passed, the analysis results will be stored within a
+`BLISS_ANALYSIS` tag in the file itself. Note, however, that only tracks that are
+not currently in the database will be analysed - therefore any such tracks would
+not have the `BLISS_ANALYSIS` tag updated. To export analysis results from the
+database to files themselves use the `export` task.
+
+*NOTE* Use of the `BLISS_ANALYSIS` tag is not supported for CUE files.
+
+
+CUE files
+---------
+
+If the analyser encounters an audio file with a matching CUE file (e.g.
+`album.flac` and `album.cue` in same folder) then it will attempt to analyse the
+individual tracks contained within.
+

 Exclude folders
 ---------------
@@ -244,6 +249,10 @@ entries):
 .\bliss-analyser.exe tags
 ```

+*NOTE* Tag re-reading is not implemented for CUE tracks. Therefore if you update
+your CUE files you will need to remove these from the database and re-analyse,
+or manually edit the meta-data in `bliss.db` using an SQLite GUI.
+


 Ignoring tracks in mixes
@@ -286,7 +295,7 @@ The SQL LIKE lines do sub-string matching. So '%Dance%' will match any genre
 string that contains 'Dance' - e.g. 'Classical Dance'. The 4 lines with 'Rock'
 show how you can explicitly look for an exact match. The 1st line means 'Rock'
 is the only genre, 2nd means 'Rock' is the first genre, 3rd means 'Rock' is the
-last genre, and 4th means 'Rock' is amongs other genres.
+last genre, and 4th means 'Rock' is amongst other genres.

 Assuming `config.ini` is in the current folder and contains valid entries, this
 is accomplished as follows:
@@ -303,6 +312,50 @@ is accomplished as follows:



+Exporting Analysis
+==================
+
+If you have analysis results stored within the database, and not within
+the files themselves, then you can use the `export` action to copy these
+analysis results from the database and into the files.
+
+(Linux / macOS)
+```
+./bliss-analyser export
+```
+
+(Windows)
+```
+.\bliss-analyser.exe export
+```
+
+*NOTE* Exporting of analysis results is not implemented for CUE tracks.
+
+
+
+Clearing Failed Tracks
+======================
+
+Any tracks that could not be analysed are stored in the database so that
+subsequent analysis runs ignore such files - unless the files themselves
+have been updated.
+
+You can remove this list of failed tracks, from database, via the
+following command:
+
+
+(Linux / macOS)
+```
+./bliss-analyser clearfail
+```
+
+(Windows)
+```
+.\bliss-analyser.exe clearfail
+```
+
+
+
 Credits
 =======

@@ -0,0 +1,34 @@
+FROM debian:bullseye
+
+RUN dpkg --add-architecture arm64 && \
+    dpkg --add-architecture armhf
+RUN apt-get update
+
+RUN apt-get install -y curl git pkg-config yasm
+RUN apt-get install -y build-essential clang
+RUN apt-get install -y crossbuild-essential-armhf crossbuild-essential-arm64
+
+RUN apt-get install -y libavutil-dev:arm64 libavcodec-dev:arm64 libavformat-dev:arm64 \
+                       libavfilter-dev:arm64 libavdevice-dev:arm64 libswresample-dev:arm64 libfftw3-dev:arm64
+
+RUN apt-get install -y libavutil-dev:armhf libavcodec-dev:armhf libavformat-dev:armhf \
+                       libavfilter-dev:armhf libavdevice-dev:armhf libswresample-dev:armhf libfftw3-dev:armhf
+
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y
+ENV PATH="/root/.cargo/bin/:${PATH}"
+RUN rustup target add aarch64-unknown-linux-gnu && \
+    rustup target add arm-unknown-linux-gnueabihf
+
+RUN mkdir /.cargo && \
+    echo '[target.aarch64-unknown-linux-gnu]\nlinker = "aarch64-linux-gnu-gcc"' > /.cargo/config && \
+    echo '[target.arm-unknown-linux-gnueabihf]\nlinker = "arm-linux-gnueabihf-gcc"' >> /.cargo/config
+
+RUN mkdir /build
+ENV CARGO_TARGET_DIR /build
+ENV CARGO_HOME /build/cache
+
+RUN mkdir /src
+
+WORKDIR /src
+CMD ["/src/docker/docker-build-arm-ffmpeg.sh"]
+
@@ -0,0 +1,28 @@
+FROM debian:bullseye
+
+RUN dpkg --add-architecture arm64 && \
+    dpkg --add-architecture armhf
+RUN apt-get update
+
+RUN apt-get install -y curl git pkg-config yasm
+RUN apt-get install -y build-essential clang
+RUN apt-get install -y crossbuild-essential-armhf crossbuild-essential-arm64
+
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y
+ENV PATH="/root/.cargo/bin/:${PATH}"
+RUN rustup target add aarch64-unknown-linux-gnu && \
+    rustup target add arm-unknown-linux-gnueabihf
+
+RUN mkdir /.cargo && \
+    echo '[target.aarch64-unknown-linux-gnu]\nlinker = "aarch64-linux-gnu-gcc"' > /.cargo/config && \
+    echo '[target.arm-unknown-linux-gnueabihf]\nlinker = "arm-linux-gnueabihf-gcc"' >> /.cargo/config
+
+RUN mkdir /build
+ENV CARGO_TARGET_DIR /build
+ENV CARGO_HOME /build/cache
+
+RUN mkdir /src
+
+WORKDIR /src
+CMD ["/src/docker/docker-build-arm-symphonia.sh"]
+
@@ -0,0 +1,30 @@
+FROM debian:bullseye
+
+RUN dpkg --add-architecture amd64
+RUN apt-get update
+
+RUN apt-get install -y curl git pkg-config yasm
+RUN apt-get install -y build-essential clang
+
+# Download and extract musl-cross toolchain for x86_64
+RUN curl -LO https://musl.cc/x86_64-linux-musl-cross.tgz \
+    && tar -xzf x86_64-linux-musl-cross.tgz \
+    && mv x86_64-linux-musl-cross /opt/musl-toolchain \
+    && rm x86_64-linux-musl-cross.tgz
+
+ENV PATH="/opt/musl-toolchain/bin:/root/.cargo/bin:${PATH}"
+
+# Optionally, still install musl-tools (for musl-gcc wrapper, not strictly needed now)
+RUN apt-get install -y musl-tools musl-dev musl
+
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y
+RUN rustup target add x86_64-unknown-linux-musl
+
+RUN mkdir /build
+ENV CARGO_TARGET_DIR /build
+ENV CARGO_HOME /build/cache
+
+RUN mkdir /src
+
+WORKDIR /src
+CMD ["/src/docker/docker-build-x86-ffmpeg.sh"]
@@ -0,0 +1,22 @@
+FROM debian:bullseye
+
+RUN dpkg --add-architecture amd64
+RUN apt-get update
+
+RUN apt-get install -y curl git pkg-config yasm
+RUN apt-get install -y build-essential clang
+RUN apt-get install -y musl-tools musl-dev musl
+
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y
+ENV PATH="/root/.cargo/bin/:${PATH}"
+RUN rustup target add x86_64-unknown-linux-musl
+
+RUN mkdir /build
+ENV CARGO_TARGET_DIR /build
+ENV CARGO_HOME /build/cache
+
+RUN mkdir /src
+
+WORKDIR /src
+CMD ["/src/docker/docker-build-x86-symphonia.sh"]
+
@@ -0,0 +1,29 @@
+#!/bin/bash
+## #!/usr/bin/env bash
+set -eux
+
+uname -a
+DESTDIR=/src/releases
+
+mkdir -p $DESTDIR/bin
+rm -rf $DESTDIR/bin/*
+
+function build {
+    echo Building for $1 to $3...
+
+    if [[ ! -f /build/$1/release/bliss-analyser ]]; then
+        export RUST_BACKTRACE=full
+        export PKG_CONFIG=${1//unknown-/}-pkg-config
+        BINDGEN_EXTRA_CLANG_ARGS="--sysroot /usr/${1//unknown-/}" cargo build --release --features=libav,staticlibav --target $1
+    fi
+
+    $2 /build/$1/release/bliss-analyser && cp /build/$1/release/bliss-analyser $DESTDIR/$3
+}
+
+build arm-unknown-linux-gnueabihf arm-linux-gnueabihf-strip bin/bliss-analyser-armhf
+build aarch64-unknown-linux-gnu aarch64-linux-gnu-strip bin/bliss-analyser-aarch64
+
+cp UserGuide.md $DESTDIR/README.md
+cp LICENSE $DESTDIR/
+cp configs/linux.ini $DESTDIR/config.ini
+cp scripts/bliss-analyser-arm $DESTDIR/bliss-analyser
@@ -0,0 +1,27 @@
+#!/bin/bash
+## #!/usr/bin/env bash
+set -eux
+
+uname -a
+DESTDIR=/src/releases
+
+mkdir -p $DESTDIR/bin
+rm -rf $DESTDIR/bin/*
+
+function build {
+	echo Building for $1 to $3...
+
+    if [[ ! -f /build/$1/release/bliss-analyser ]]; then
+        cargo build --release --features=symphonia --target $1
+    fi
+
+    $2 /build/$1/release/bliss-analyser && cp /build/$1/release/bliss-analyser $DESTDIR/$3
+}
+
+build arm-unknown-linux-gnueabihf arm-linux-gnueabihf-strip bin/bliss-analyser-armhf
+build aarch64-unknown-linux-gnu aarch64-linux-gnu-strip bin/bliss-analyser-aarch64
+
+cp UserGuide.md $DESTDIR/README.md
+cp LICENSE $DESTDIR/
+cp configs/linux.ini $DESTDIR/config.ini
+cp scripts/bliss-analyser-arm $DESTDIR/bliss-analyser
@@ -0,0 +1,22 @@
+#!/bin/ash
+set -eux
+
+uname -a
+DESTDIR=/src/releases
+mkdir -p $DESTDIR
+
+function build {
+	echo Building for $1 to $3...
+
+    if [[ ! -f /build/$1/release/bliss-analyser ]]; then
+        cargo build --release --features=update-aubio-bindings,libav,staticlibav --target $1
+    fi
+
+    $2 /build/$1/release/bliss-analyser && cp /build/$1/release/bliss-analyser $DESTDIR/$3
+}
+
+build x86_64-unknown-linux-musl strip bliss-analyser
+
+cp UserGuide.md $DESTDIR/README.md
+cp LICENSE $DESTDIR/
+cp configs/linux.ini $DESTDIR/config.ini
@@ -0,0 +1,23 @@
+#!/bin/bash
+## #!/usr/bin/env bash
+set -eux
+
+uname -a
+DESTDIR=/src/releases
+mkdir -p $DESTDIR
+
+function build {
+	echo Building for $1 to $3...
+
+    if [[ ! -f /build/$1/release/bliss-analyser ]]; then
+        cargo build --release --features update-aubio-bindings,symphonia --target $1
+    fi
+
+    $2 /build/$1/release/bliss-analyser && cp /build/$1/release/bliss-analyser $DESTDIR/$3
+}
+
+build x86_64-unknown-linux-musl strip bliss-analyser
+
+cp UserGuide.md $DESTDIR/README.md
+cp LICENSE $DESTDIR/
+cp configs/linux.ini $DESTDIR/config.ini
@@ -3,15 +3,21 @@
 #
 # LMS-BlissMixer
 #
-# Copyright (c) 2022 Craig Drummond <craig.p.drummond@gmail.com>
+# Copyright (c) 2022-2026 Craig Drummond <craig.p.drummond@gmail.com>
 # MIT license.
 #

-import datetime, os, requests, sys, time
+import datetime, os, requests, shutil, subprocess, sys, tempfile, time

 GITHUB_TOKEN_FILE = "%s/.config/github-token" % os.path.expanduser('~')
 GITHUB_REPO = "CDrummond/bliss-analyser"
-GITHUB_ARTIFACTS = ["bliss-analyser-linux", "bliss-analyser-mac", "bliss-analyser-windows"]
+LINUX_ARM_ARTIFACTS = ["bliss-analyser-linux-arm-ffmpeg", "bliss-analyser-linux-arm-symphonia"]
+LINUX_X86_ARTIFACTS = ["bliss-analyser-linux-x86-ffmpeg", "bliss-analyser-linux-x86-symphonia"]
+MAC_ARTIFACTS =       ["bliss-analyser-mac-symphonia"]
+WINDOWS_ARTIFACTS =   ["bliss-analyser-windows-ffmpeg", "bliss-analyser-windows-symphonia"]
+UNIX_ARTIFACTS = LINUX_ARM_ARTIFACTS + LINUX_X86_ARTIFACTS + MAC_ARTIFACTS
+GITHUB_ARTIFACTS = UNIX_ARTIFACTS + WINDOWS_ARTIFACTS
+

 def info(s):
    print("INFO: %s" %s)
@@ -64,7 +70,24 @@ def download_artifacts(version):
                    f.write(chunk)
        if not os.path.exists(dest):
            info("Failed to download %s" % item)
-            break
+
+
+def make_executable(version):
+    cwd = os.getcwd()
+    for a in UNIX_ARTIFACTS:
+        archive = "%s-%s.zip" % (a, version)
+        info("Making analyser executable in %s" % archive)
+        with tempfile.TemporaryDirectory() as td:
+            subprocess.call(["unzip", archive, "-d", td], shell=False)
+            os.remove(archive)
+            os.chdir(td)
+            subprocess.call(["chmod", "a+x", "%s/bliss-analyser" % td], shell=False)
+            bindir = os.path.join(td, "bin")
+            if os.path.isdir(bindir):
+                for e in os.listdir(bindir):
+                    subprocess.call(["chmod", "a+x", os.path.join(bindir, e)], shell=False)
+            shutil.make_archive("%s/%s-%s" % (cwd, a, version), "zip")
+            os.chdir(cwd)


 def checkVersion(version):
@@ -85,4 +108,4 @@ if version!="test":
    checkVersion(version)

 download_artifacts(version)
-
+make_executable(version)
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+ARCH=`arch`
+SCRIPT_DIR="$( cd -- "$( dirname -- "${BASH_SOURCE[0]:-$0}"; )" &> /dev/null && pwd 2> /dev/null; )";
+
+if [ "$ARCH" = "aarch64" ] ; then
+    $SCRIPT_DIR/bin/bliss-analyser-aarch64 $*
+else
+    $SCRIPT_DIR/bin/bliss-analyser-armhf $*
+fi
@@ -1,181 +1,452 @@
 /**
 * Analyse music with Bliss
 *
- * Copyright (c) 2022 Craig Drummond <craig.p.drummond@gmail.com>
+ * Copyright (c) 2022-2026 Craig Drummond <craig.p.drummond@gmail.com>
 * GPLv3 license.
 *
 **/

-use anyhow::{Result};
-use bliss_audio::{library::analyze_paths_streaming};
-use indicatif::{ProgressBar, ProgressStyle};
-use std::convert::TryInto;
-use std::fs::File;
-use std::io::{BufRead, BufReader};
-use std::path::PathBuf;
 use crate::db;
 use crate::tags;
+use anyhow::Result;
+use if_chain::if_chain;
+use indicatif::{ProgressBar, ProgressStyle};
+use std::collections::HashSet;
+use std::convert::TryInto;
+use filetime::FileTime;
+use std::fs;
+use std::fs::DirEntry;
+use std::num::NonZero;
+use std::path::{Path, PathBuf};
+#[cfg(feature = "libav")]
+use bliss_audio::decoder::ffmpeg::FFmpegDecoder as SongDecoder;
+#[cfg(feature = "symphonia")]
+use bliss_audio::decoder::symphonia::SymphoniaDecoder as SongDecoder;
+use bliss_audio::{AnalysisOptions, decoder::Decoder};
+use ureq;
+use std::time::{SystemTime, UNIX_EPOCH};
+use std::thread;
+use std::sync::mpsc;
+use std::sync::mpsc::{Receiver, Sender};
+use serde_json::json;

-const DONT_ANALYSE:&str = ".notmusic";
-const MAX_TAG_ERRORS_TO_SHOW:usize = 25;
+const DONT_ANALYSE: &str = ".notmusic";
+const MAX_ERRORS_TO_SHOW: usize = 100;
+const MAX_TAG_ERRORS_TO_SHOW: usize = 50;
+const MIN_NOTIF_TIME:u64 = 2;
+const VALID_EXTENSIONS: [&str; 7] = ["m4a", "mp3", "ogg", "flac", "opus", "wv", "dsf"];

-fn get_file_list(db:&mut db::Db, mpath:&PathBuf, path:&PathBuf, track_paths:&mut Vec<String>) {
-    if path.is_dir() {
-        match path.read_dir() {
-            Ok(items) => {
-                for item in items {
-                    match item {
-                        Ok(entry) => {
-                            let pb = entry.path().to_path_buf();
-                            if entry.path().is_dir() {
-                                let mut check = pb.clone();
-                                check.push(PathBuf::from(DONT_ANALYSE));
-                                if check.exists() {
-                                    log::info!("Skipping '{}', found '{}'", pb.to_string_lossy(), DONT_ANALYSE);
-                                } else {
-                                    get_file_list(db, mpath, &entry.path(), track_paths);
-                                }
-                            } else if entry.path().is_file() {
-                                let e = pb.extension();
-                                if e.is_some() {
-                                    let ext = e.unwrap().to_string_lossy();
-                                    if ext=="m4a" || ext=="mp3" || ext=="ogg" || ext=="flac" || ext=="opus" {
-                                        match pb.strip_prefix(mpath) {
-                                            Ok(stripped) => {
-                                                let mut cue = pb.clone();
-                                                cue.set_extension("cue");
-                                                if cue.exists() {
-                                                    log::warn!("Found CUE album '{}' - not currently handled!", pb.to_string_lossy());
-                                                } else {
-                                                    let spb = stripped.to_path_buf();
-                                                    let sname = String::from(spb.to_string_lossy());
-                                                    match db.get_rowid(&sname) {
-                                                        Ok(id) => {
-                                                            if id<=0 {
-                                                                track_paths.push(String::from(pb.to_string_lossy()));
-                                                            }
-                                                        },
-                                                        Err(_) => { }
-                                                    }
-                                                }
-                                            },
-                                            Err(_) => { }
-                                        }
-                                    }
-                                }
-                            }
-                        },
-                        Err(_) => { }
-                    }
-                }
-            },
-            Err(_) => { }
+static mut TERMINATE_ANALYSIS_FLAG: bool = false;
+
+struct NotifInfo {
+    pub enabled: bool,
+    pub address: String,
+    pub last_send: u64,
+    pub start_time: u64
+}
+
+fn terminate_analysis() -> bool {
+    unsafe {
+        return TERMINATE_ANALYSIS_FLAG
+    }
+}
+
+fn handle_ctrl_c() {
+    unsafe {
+        TERMINATE_ANALYSIS_FLAG = true;
+    }
+}
+
+fn send_notif_msg(notifs: &mut NotifInfo, text: &str) {
+    let js = json!({"id":"1", "method":"slim.request", "params":["", ["blissmixer", "analyser", "act:update", format!("msg:{}", text)]]});
+    log::info!("Sending notif to LMS: {}", text);
+    let _ = ureq::post(&notifs.address).send_string(&js.to_string());
+}
+
+fn send_notif(notifs: &mut NotifInfo, text: &str) {
+    if notifs.enabled {
+        let now = SystemTime::now().duration_since(UNIX_EPOCH).expect("time should go forward").as_secs();
+        if now>=notifs.last_send+MIN_NOTIF_TIME {
+            let dur = now - notifs.start_time;
+            let msg = format!("[{:02}:{:02}:{:02}] {}", (dur/60)/60, (dur/60)%60, dur%60, text);
+            send_notif_msg(notifs, &msg);
+            notifs.last_send = now;
        }
    }
 }

-pub fn analyse_new_files(db:&db::Db, mpath: &PathBuf, track_paths:Vec<String>) -> Result<()> {
-    let total = track_paths.len();
-    let pb = ProgressBar::new(total.try_into().unwrap());
-    let style = ProgressStyle::default_bar()
-        .template("[{elapsed_precise}] [{bar:25}] {percent:>3}% {pos:>6}/{len:6} {wide_msg}")
-        .progress_chars("=> ");
-    pb.set_style(style);
+fn get_file_list(db: &mut db::Db, mpath: &Path, path: &Path, track_paths: &mut Vec<String>, file_count:&mut usize, max_num_files: usize,
+                 dry_run: bool, notifs: &mut NotifInfo) {
+    if !path.is_dir() {
+        return;
+    }

-    let results = analyze_paths_streaming(track_paths)?;
-    let mut analysed = 0;
-    let mut failed = 0;
-    let mut tag_error:Vec<String> = Vec::new();
+    send_notif(notifs, &format!("SCAN DIR {}", path.to_string_lossy()));
+    let mut items: Vec<_> = path.read_dir().unwrap().map(|r| r.unwrap()).collect();
+    items.sort_by_key(|dir| dir.path());

-    log::info!("Analysing new tracks");
-    for (path, result) in results {
-        let pbuff = PathBuf::from(&path);
-        let stripped = pbuff.strip_prefix(mpath).unwrap();
-        let spbuff = stripped.to_path_buf();
-        let sname = String::from(spbuff.to_string_lossy());
-        pb.set_message(format!("{}", sname));
-        match result {
-            Ok(track) => {
-                let cpath = String::from(path);
-                let meta = tags::read(&cpath);
-                if meta.title.is_empty() && meta.artist.is_empty() && meta.album.is_empty() && meta.genre.is_empty() {
-                    tag_error.push(sname.clone());
+    for item in items {
+        check_dir_entry(db, mpath, item, track_paths, file_count, max_num_files, dry_run, notifs);
+        if max_num_files>0 && *file_count>=max_num_files {
+            break;
+        }
+    }
+}
+
+fn check_dir_entry(db: &mut db::Db, mpath: &Path, entry: DirEntry, track_paths: &mut Vec<String>, file_count:&mut usize, max_num_files: usize,
+                   dry_run: bool, notifs: &mut NotifInfo) {
+    let pb = entry.path();
+    if pb.is_dir() {
+        let check = pb.join(DONT_ANALYSE);
+        if check.exists() {
+            log::info!("Skipping '{}', found '{}'", pb.to_string_lossy(), DONT_ANALYSE);
+        } else if max_num_files<=0 || *file_count<max_num_files {
+            get_file_list(db, mpath, &pb, track_paths, file_count, max_num_files, dry_run, notifs);
+        }
+    } else if pb.is_file() && (max_num_files<=0 || *file_count<max_num_files) {
+        if_chain! {
+            if let Some(ext) = pb.extension();
+            let ext = ext.to_string_lossy();
+            if VALID_EXTENSIONS.contains(&&*ext);
+            if let Ok(stripped) = pb.strip_prefix(mpath);
+            then {
+                let sname = String::from(stripped.to_string_lossy());
+                let mut cue_file = pb.clone();
+                cue_file.set_extension("cue");
+                if cue_file.exists() {
+                    // For cue files, check if first track is in DB
+                    let mut cue_track_path = pb.clone();
+                    let ext = pb.extension().unwrap().to_string_lossy();
+                    cue_track_path.set_extension(format!("{}{}1", ext, db::CUE_MARKER));
+                    if let Ok(cue_track_stripped) = cue_track_path.strip_prefix(mpath) {
+                        let cue_track_sname = String::from(cue_track_stripped.to_string_lossy());
+                        if let Ok(id) = db.get_rowid(&cue_track_sname) {
+                            if id<=0 {
+                                track_paths.push(String::from(cue_file.to_string_lossy()));
+                                *file_count+=1;
+                            }
+                        }
+                    }
+                } else {
+                    if let Ok(id) = db.get_rowid(&sname) {
+                        if id<=0 {
+                            // Check this file is not in Failures table
+                            let ts = db.get_failure_timestamp(&sname);
+                            if ts<=0 {
+                                // ...nope, not in there so analyse
+                                track_paths.push(String::from(pb.to_string_lossy()));
+                                *file_count+=1;
+                            } else {
+                                let path = String::from(pb.to_string_lossy());
+                                let metadata = fs::metadata(&path).unwrap();
+                                let mtime = FileTime::from_last_modification_time(&metadata).unix_seconds();
+                                if mtime!=ts {
+                                    // ...was in failures table, but timestamp has changed
+                                    db.remove_from_failures(&sname);
+                                    track_paths.push(path);
+                                    *file_count+=1;
+                                }
+                            }
+                        }
+                    }
                }
+            }
+        }
+    }
+}

-                db.add_track(&sname, &meta, &track.analysis);
-                analysed += 1;
-            },
-            Err(_) => {
-                failed += 1;
-            }
-        };
-        pb.inc(1);
+fn show_errors(failed: &mut Vec<String>, tag_error: &mut Vec<String>) {
+    if !failed.is_empty() {
+        let total = failed.len();
+        failed.truncate(MAX_ERRORS_TO_SHOW);
+
+        log::error!("Failed to analyse the following file(s):");
+        for err in failed {
+            log::error!("  {}", err);
+        }
+        if total > MAX_ERRORS_TO_SHOW {
+            log::error!("  + {} other(s)", total - MAX_ERRORS_TO_SHOW);
+        }
    }
-    pb.finish_with_message(format!("{} Analysed. {} Failure(s).", analysed, failed));
    if !tag_error.is_empty() {
        let total = tag_error.len();
        tag_error.truncate(MAX_TAG_ERRORS_TO_SHOW);

-        log::error!("Failed to read tags of the folling track(s):");
+        log::error!("Failed to read tags of the following file(s):");
        for err in tag_error {
            log::error!("  {}", err);
        }
-        if total>MAX_TAG_ERRORS_TO_SHOW {
+        if total > MAX_TAG_ERRORS_TO_SHOW {
            log::error!("  + {} other(s)", total - MAX_TAG_ERRORS_TO_SHOW);
        }
    }
+}
+
+#[derive(Clone, Default, PartialEq)]
+pub struct Meta {
+    pub file: String,
+    pub meta: db::Metadata
+}
+
+fn read_tags(tracks: Vec<String>, max_threads: usize) -> Receiver<Meta> {
+    #[allow(clippy::type_complexity)]
+    let (tx, rx): (
+        Sender<Meta>,
+        Receiver<Meta>,
+    ) = mpsc::channel();
+    if tracks.is_empty() {
+        return rx;
+    }
+
+    let mut handles = Vec::new();
+    let mut chunk_length = tracks.len() / max_threads;
+    if chunk_length == 0 {
+        chunk_length = tracks.len();
+    } else if chunk_length == 1 && tracks.len() > max_threads {
+        chunk_length = 2;
+    }
+
+    for chunk in tracks.chunks(chunk_length) {
+        let tx_thread = tx.clone();
+        let owned_chunk = chunk.to_owned();
+        let child = thread::spawn(move || {
+            for track in owned_chunk {
+                let _ = tx_thread.send(Meta {
+                    file:track.clone(),
+                    meta: tags::read(&track, true),
+                });
+            }
+        });
+        handles.push(child);
+    }
+
+    rx
+}
+
+fn check_for_tags(db: &db::Db, mpath: &PathBuf, track_paths: Vec<String>, max_threads: usize, notifs: &mut NotifInfo) -> Vec<String> {
+    let mut untagged_paths:Vec<String> = Vec::new();
+    let total = track_paths.len();
+    let results = read_tags(track_paths, max_threads);
+    let progress = ProgressBar::new(total.try_into().unwrap()).with_style(
+        ProgressStyle::default_bar()
+            .template("[{elapsed_precise}] [{bar:25}] {percent:>3}% {pos:>6}/{len:6} {wide_msg}")
+            .progress_chars("=> "),
+    );
+
+    log::info!("Reading any existing analysis tags");
+    send_notif(notifs, "Reading any existing analysis tags");
+    for res in results {
+        let path = PathBuf::from(&res.file);
+        let stripped = path.strip_prefix(mpath).unwrap();
+        let spbuff = stripped.to_path_buf();
+        let sname = String::from(spbuff.to_string_lossy());
+        progress.set_message(format!("{}", sname));
+        if !res.meta.is_empty() && !res.meta.analysis.is_none() {
+            db.add_track(&sname, &res.meta.clone(), &res.meta.analysis.unwrap());
+        } else {
+            untagged_paths.push(res.file);
+        }
+        if terminate_analysis() {
+            break
+        }
+        progress.inc(1);
+        if notifs.enabled {
+            let pc = (progress.position() as f64 * 100.0)/total as f64;
+            send_notif(notifs, &format!("READ TAGS {:8.2}% {}", pc, sname));
+        }
+    }
+    if terminate_analysis() {
+        progress.abandon_with_message("Terminated!");
+    } else {
+        progress.finish_with_message("Finished!");
+    }
+    untagged_paths
+}
+
+fn analyse_new_files(db: &db::Db, mpath: &PathBuf, track_paths: Vec<String>, max_threads: usize, write_tags: bool,
+                     preserve_mod_times: bool, notifs: &mut NotifInfo) -> Result<()> {
+    let total = track_paths.len();
+    let progress = ProgressBar::new(total.try_into().unwrap()).with_style(
+        ProgressStyle::default_bar()
+            .template("[{elapsed_precise}] [{bar:25}] {percent:>3}% {pos:>6}/{len:6} {wide_msg}")
+            .progress_chars("=> "),
+    );
+    let mut analysed = 0;
+    let mut failed: Vec<String> = Vec::new();
+    let mut tag_error: Vec<String> = Vec::new();
+    let mut reported_cue:HashSet<String> = HashSet::new();
+    let mut options:AnalysisOptions = AnalysisOptions::default();
+    options.number_cores = NonZero::new(max_threads).unwrap();
+
+    send_notif(notifs, "Analysing new files");
+    log::info!("Analysing new files");
+
+    for (path, result) in SongDecoder::analyze_paths_with_options(track_paths, options) {
+        let stripped = path.strip_prefix(mpath).unwrap();
+        let spbuff = stripped.to_path_buf();
+        let sname = String::from(spbuff.to_string_lossy());
+        progress.set_message(format!("{}", sname));
+        let mut inc_progress = true; // Only want to increment progress once for cue tracks
+        match result {
+            Ok(track) => {
+                let cpath = String::from(path.to_string_lossy());
+                match track.cue_info {
+                    Some(cue) => {
+                        match track.track_number {
+                            Some(track_num) => {
+                                if reported_cue.contains(&cpath) {
+                                    inc_progress = false;
+                                } else {
+                                    analysed += 1;
+                                    reported_cue.insert(cpath);
+                                }
+                                let meta = db::Metadata {
+                                    title: track.title.unwrap_or_default().to_string(),
+                                    artist: track.artist.unwrap_or_default().to_string(),
+                                    album: track.album.unwrap_or_default().to_string(),
+                                    album_artist: track.album_artist.unwrap_or_default().to_string(),
+                                    genre: track.genre.unwrap_or_default().to_string(),
+                                    duration: track.duration.as_secs() as u32,
+                                    analysis: None
+                                };
+
+                                // Remove prefix from audio_file_path
+                                let pbuff = PathBuf::from(&cue.audio_file_path);
+                                let stripped = pbuff.strip_prefix(mpath).unwrap();
+                                let spbuff = stripped.to_path_buf();
+                                let sname = String::from(spbuff.to_string_lossy());
+
+                                let db_path = format!("{}{}{}", sname, db::CUE_MARKER, track_num);
+                                db.add_track(&db_path, &meta, &track.analysis);
+                            }
+                            None => { failed.push(format!("{} - No track number?", sname)); }
+                        }
+                    }
+                    None => {
+                        // Use lofty to read tags here, and not bliss's, so that if update
+                        // tags is ever used they are from the same source.
+                        let mut meta = tags::read(&cpath, false);
+                        if meta.is_empty() {
+                            // Lofty failed? Try from bliss...
+                            meta.title = track.title.unwrap_or_default().to_string();
+                            meta.artist = track.artist.unwrap_or_default().to_string();
+                            meta.album = track.album.unwrap_or_default().to_string();
+                            meta.album_artist = track.album_artist.unwrap_or_default().to_string();
+                            meta.genre = track.genre.unwrap_or_default().to_string();
+                            meta.duration = track.duration.as_secs() as u32;
+                        }
+                        if meta.is_empty() {
+                            tag_error.push(sname.clone());
+                        }
+                        if write_tags {
+                            tags::write_analysis(&cpath, &track.analysis, preserve_mod_times);
+                        }
+                        db.add_track(&sname, &meta, &track.analysis);
+                    }
+                }
+                analysed += 1;
+            }
+            Err(e) => {
+                failed.push(format!("{} - {}", sname, e));
+                let metadata = fs::metadata(path).unwrap();
+                let mtime = FileTime::from_last_modification_time(&metadata);
+                db.add_to_failures(&sname, mtime.unix_seconds(), &format!("{}", e));
+            }
+        };
+
+        if inc_progress {
+            progress.inc(1);
+            if notifs.enabled {
+                let pc = (progress.position() as f64 * 100.0)/total as f64;
+                send_notif(notifs, &format!("ANALYSE {:8.2}% {}", pc, sname));
+            }
+        }
+        if terminate_analysis() {
+            break
+        }
+    }
+
+    if terminate_analysis() {
+        progress.abandon_with_message("Terminated!");
+    } else {
+        progress.finish_with_message("Finished!");
+    }
+    log::info!("{} Analysed. {} Failed.", analysed, failed.len());
+    show_errors(&mut failed, &mut tag_error);
    Ok(())
 }

-pub fn analyse_files(db_path: &str, mpath: &PathBuf, dry_run:bool, keep_old:bool, max_num_tracks:usize) {
-    let mut track_paths:Vec<String> = Vec::new();
+pub fn analyse_files(db_path: &str, mpaths: &Vec<PathBuf>, dry_run: bool, keep_old: bool, max_num_files: usize, 
+                     max_threads: usize, ignore_path: &PathBuf, read_tags: bool, write_tags: bool, preserve_mod_times: bool,
+                     lms_host: &String, json_port: u16, send_notifs: bool) -> bool {
    let mut db = db::Db::new(&String::from(db_path));
-    let cur = PathBuf::from(mpath);
+    let mut notifs = NotifInfo {
+        enabled: send_notifs,
+        address: format!("http://{}:{}/jsonrpc.js", lms_host, json_port),
+        last_send: 0,
+        start_time: SystemTime::now().duration_since(UNIX_EPOCH).expect("time should go forward").as_secs(),
+    };
+
+    ctrlc::set_handler(move || {
+        handle_ctrl_c();
+    }).expect("Error setting Ctrl-C handler");

    db.init();
-    log::info!("Looking for new tracks");
-    get_file_list(&mut db, mpath, &cur, &mut track_paths);
-    log::info!("Num new tracks: {}", track_paths.len());
-    if !dry_run && max_num_tracks>0 && track_paths.len()>max_num_tracks {
-        log::info!("Only analysing {} tracks", max_num_tracks);
-        track_paths.truncate(max_num_tracks);
-    }
+
+    let mut changes_made = false;
    if !keep_old {
-        db.remove_old(mpath, dry_run);
+        send_notif(&mut notifs, "Removing old files from DB");
+        changes_made = db.remove_old(mpaths, dry_run);
    }
-    if !dry_run {
-        if track_paths.len()>0 {
-            match analyse_new_files(&db, mpath, track_paths) {
-                Ok(_) => { },
-                Err(_) => { }
+
+    for path in mpaths {
+        let mpath = path.clone();
+        let cur = path.clone();
+        let mut track_paths: Vec<String> = Vec::new();
+        let mut file_count:usize = 0;
+
+        log::info!("Looking for new files in {}", mpath.to_string_lossy());
+        send_notif(&mut notifs, &format!("Looking for new files in {}", mpath.to_string_lossy()));
+
+        get_file_list(&mut db, &mpath, &cur, &mut track_paths, &mut file_count, max_num_files, dry_run, &mut notifs);
+        track_paths.sort();
+        log::info!("New files: {}", track_paths.len());
+
+        if !terminate_analysis() {
+            if dry_run {
+                if !track_paths.is_empty() {
+                    log::info!("The following need to be analysed (or tags read):");
+                    for track in track_paths {
+                        log::info!("  {}", track);
+                    }
+                }
+            } else {
+                if !track_paths.is_empty() {
+                    let untagged_paths = if read_tags { check_for_tags(&db, &mpath, track_paths, max_threads, &mut notifs) } else { track_paths };
+
+                    if !untagged_paths.is_empty() {
+                        log::info!("New untagged files: {}", untagged_paths.len());
+                        match analyse_new_files(&db, &mpath, untagged_paths, max_threads, write_tags, preserve_mod_times, &mut notifs) {
+                            Ok(_) => { changes_made = true; }
+                            Err(e) => { log::error!("Analysis returned error: {}", e); }
+                        }
+                    } else {
+                        log::info!("No new untagged files to analyse");
+                        send_notif(&mut notifs, "No new files to analyse");
+                    }
+                }
            }
-        } else {
-            log::info!("No new tracks to analyse");
        }
    }

    db.close();
-}
-
-pub fn read_tags(db_path: &str, mpath: &PathBuf) {
-    let db = db::Db::new(&String::from(db_path));
-    db.init();
-    db.update_tags(&mpath);
-    db.close();
-}
-
-pub fn update_ignore(db_path: &str, ignore_path: &PathBuf) {
-    let file = File::open(ignore_path).unwrap();
-    let reader = BufReader::new(file);
-    let db = db::Db::new(&String::from(db_path));
-    db.init();
-
-    db.clear_ignore();
-    for (_index, line) in reader.lines().enumerate() {
-        let line = line.unwrap();
-        if !line.is_empty() && !line.starts_with("#") {
-            db.set_ignore(&line);
-        }
+    if changes_made && ignore_path.exists() && ignore_path.is_file() {
+        log::info!("Updating 'ignore' flags");
+        send_notif(&mut notifs, "Updating ignore");
+        db::update_ignore(&db_path, &ignore_path);
    }
-    db.close();
+    if send_notifs {
+        send_notif_msg(&mut notifs, "FINISHED");
+    }
+    changes_made
 }
@@ -1,10 +1,11 @@
 /**
 * Analyse music with Bliss
 *
- * Copyright (c) 2022 Craig Drummond <craig.p.drummond@gmail.com>
+ * Copyright (c) 2022-2026 Craig Drummond <craig.p.drummond@gmail.com>
 * GPLv3 license.
 *
 **/
+
 use argparse::{ArgumentParser, Store, StoreTrue};
 use chrono::Local;
 use configparser::ini::Ini;
@@ -13,39 +14,54 @@ use log::LevelFilter;
 use std::io::Write;
 use std::path::PathBuf;
 use std::process;
+use num_cpus;
 mod analyse;
 mod db;
 mod tags;
 mod upload;

-
 const VERSION: &'static str = env!("CARGO_PKG_VERSION");
-const TOP_LEVEL_INI_TAG:&str = "Bliss";
+const TOP_LEVEL_INI_TAG: &str = "Bliss";

 fn main() {
    let mut config_file = "config.ini".to_string();
    let mut db_path = "bliss.db".to_string();
    let mut logging = "info".to_string();
    let mut music_path = ".".to_string();
+    let mut music_1_path = "".to_string();
+    let mut music_2_path = "".to_string();
+    let mut music_3_path = "".to_string();
+    let mut music_4_path = "".to_string();
    let mut ignore_file = "ignore.txt".to_string();
-    let mut keep_old:bool = false;
-    let mut dry_run:bool = false;
+    let mut keep_old: bool = false;
+    let mut dry_run: bool = false;
    let mut task = "".to_string();
    let mut lms_host = "127.0.0.1".to_string();
-    let mut max_num_tracks:usize = 0;
+    let mut lms_json_port:u16 = 9000;
+    let mut max_num_files: usize = 0;
+    let mut music_paths: Vec<PathBuf> = Vec::new();
+    let mut max_threads: i16 = 0;
+    let mut write_tags = false;
+    let mut read_tags = false;
+    let mut preserve_mod_times = false;
+    let mut send_notifs = false;

    match dirs::home_dir() {
-        Some(path) => { music_path = String::from(path.join("Music").to_string_lossy()); }
-        None => { }
+        Some(path) => {
+            music_path = String::from(path.join("Music").to_string_lossy());
+        }
+        None => {}
    }

    {
        let config_file_help = format!("config file (default: {})", &config_file);
        let music_path_help = format!("Music folder (default: {})", &music_path);
+        let alt_music_path_help = format!("Other music folder");
        let db_path_help = format!("Database location (default: {})", &db_path);
        let logging_help = format!("Log level; trace, debug, info, warn, error. (default: {})", logging);
-        let ignore_file_help = format!("File containg items to mark as ignored. (default: {})", ignore_file);
+        let ignore_file_help = format!("File contains items to mark as ignored. (default: {})", ignore_file);
        let lms_host_help = format!("LMS hostname or IP address (default: {})", &lms_host);
+        let lms_json_port_help = format!("LMS JSONRPC port (default: {})", &lms_json_port);
        let description = format!("Bliss Analyser v{}", VERSION);

        // arg_parse.refer 'borrows' db_path, etc, and can only have one
@@ -54,31 +70,49 @@ fn main() {
        arg_parse.set_description(&description);
        arg_parse.refer(&mut config_file).add_option(&["-c", "--config"], Store, &config_file_help);
        arg_parse.refer(&mut music_path).add_option(&["-m", "--music"], Store, &music_path_help);
+        arg_parse.refer(&mut music_1_path).add_option(&["--music_1"], Store, &alt_music_path_help);
+        arg_parse.refer(&mut music_2_path).add_option(&["--music_2"], Store, &alt_music_path_help);
+        arg_parse.refer(&mut music_3_path).add_option(&["--music_3"], Store, &alt_music_path_help);
+        arg_parse.refer(&mut music_4_path).add_option(&["--music_4"], Store, &alt_music_path_help);
        arg_parse.refer(&mut db_path).add_option(&["-d", "--db"], Store, &db_path_help);
        arg_parse.refer(&mut logging).add_option(&["-l", "--logging"], Store, &logging_help);
-        arg_parse.refer(&mut keep_old).add_option(&["-k", "--keep-old"], StoreTrue, "Don't remove tracks from DB if they don't exist (used with analyse task)");
+        arg_parse.refer(&mut keep_old).add_option(&["-k", "--keep-old"], StoreTrue, "Don't remove files from DB if they don't exist (used with analyse task)");
        arg_parse.refer(&mut dry_run).add_option(&["-r", "--dry-run"], StoreTrue, "Dry run, only show what needs to be done (used with analyse task)");
        arg_parse.refer(&mut ignore_file).add_option(&["-i", "--ignore"], Store, &ignore_file_help);
        arg_parse.refer(&mut lms_host).add_option(&["-L", "--lms"], Store, &lms_host_help);
-        arg_parse.refer(&mut max_num_tracks).add_option(&["-n", "--numtracks"], Store, "Maximum number of tracks to analyse");
-        arg_parse.refer(&mut task).add_argument("task", Store, "Task to perform; analyse, tags, ignore, upload, stopmixer.");
+        arg_parse.refer(&mut lms_json_port).add_option(&["-J", "--json"], Store, &lms_json_port_help);
+        arg_parse.refer(&mut max_num_files).add_option(&["-n", "--numfiles"], Store, "Maximum number of files to analyse");
+        arg_parse.refer(&mut max_threads).add_option(&["-t", "--threads"], Store, "Maximum number of threads to use for analysis");
+        arg_parse.refer(&mut write_tags).add_option(&["-W", "--writetags"], StoreTrue, "When analysing files, also store results within files themselves");
+        arg_parse.refer(&mut read_tags).add_option(&["-R", "--readtags"], StoreTrue, "When analysing files, attempt to read results from tags");
+        arg_parse.refer(&mut preserve_mod_times).add_option(&["-p", "--preserve"], StoreTrue, "Preserve modification time when writing results to files");
+        arg_parse.refer(&mut send_notifs).add_option(&["-N", "--notifs"], StoreTrue, "Periodically send notification messages to LMS");
+        arg_parse.refer(&mut task).add_argument("task", Store, "Task to perform; analyse, tags, ignore, upload, export, clearfail, stopmixer.");
        arg_parse.parse_args_or_exit();
    }

-    if !(logging.eq_ignore_ascii_case("trace") || logging.eq_ignore_ascii_case("debug") || logging.eq_ignore_ascii_case("info") || logging.eq_ignore_ascii_case("warn") || logging.eq_ignore_ascii_case("error")) {
+    if !(logging.eq_ignore_ascii_case("trace") || logging.eq_ignore_ascii_case("debug") || logging.eq_ignore_ascii_case("info")
+        || logging.eq_ignore_ascii_case("warn") || logging.eq_ignore_ascii_case("error")) {
        logging = String::from("info");
    }
+    let other_level = if logging.eq_ignore_ascii_case("trace") { LevelFilter::Trace } else { LevelFilter::Error };
    let mut builder = env_logger::Builder::from_env(env_logger::Env::default().filter_or("XXXXXXXX", logging));
-    builder.filter(Some("bliss_audio"), LevelFilter::Error);
-    builder.format(|buf, record| writeln!(buf, "[{} {:.1}] {}", Local::now().format("%Y-%m-%d %H:%M:%S"), record.level(), record.args()));
+    builder.filter(Some("bliss_audio"), other_level);
+    builder.filter(Some("symphonia"), other_level);
+    builder.filter(Some("lofty"), other_level);
+    builder.format(|buf, record| {
+        writeln!(buf, "[{} {:.1}] {}", Local::now().format("%Y-%m-%d %H:%M:%S"), record.level(), record.args())
+    });
    builder.init();

-    if task.is_empty()  {
-        log::error!("No task specified, please choose from; analyse, tags, ignore, upload");
+    if task.is_empty() {
+        log::error!("No task specified, please choose from; analyse, tags, ignore, upload, export, clearfail, stopmixer");
        process::exit(-1);
    }

-    if !task.eq_ignore_ascii_case("analyse") && !task.eq_ignore_ascii_case("tags") && !task.eq_ignore_ascii_case("ignore") && !task.eq_ignore_ascii_case("upload")  && !task.eq_ignore_ascii_case("stopmixer") {
+    if !task.eq_ignore_ascii_case("analyse") && !task.eq_ignore_ascii_case("tags") && !task.eq_ignore_ascii_case("ignore")
+        && !task.eq_ignore_ascii_case("upload") && !task.eq_ignore_ascii_case("export") && !task.eq_ignore_ascii_case("clearfail")
+        && !task.eq_ignore_ascii_case("stopmixer") && !task.eq_ignore_ascii_case("analyse-lms") {
        log::error!("Invalid task ({}) supplied", task);
        process::exit(-1);
    }
@@ -89,23 +123,42 @@ fn main() {
            let mut config = Ini::new();
            match config.load(&config_file) {
                Ok(_) => {
-                    match config.get(TOP_LEVEL_INI_TAG, "music") {
-                        Some(val) => {  music_path = val; },
-                        None => { }
+                    let path_keys: [&str; 5] = ["music", "music_1", "music_2", "music_3", "music_4"];
+                    for key in &path_keys {
+                        match config.get(TOP_LEVEL_INI_TAG, key) {
+                            Some(val) => { music_paths.push(PathBuf::from(&val)); }
+                            None => { }
+                        }
                    }
                    match config.get(TOP_LEVEL_INI_TAG, "db") {
-                        Some(val) => {  db_path = val; },
+                        Some(val) => { db_path = val; }
                        None => { }
                    }
                    match config.get(TOP_LEVEL_INI_TAG, "lms") {
-                        Some(val) => {  lms_host = val; },
+                        Some(val) => { lms_host = val; }
+                        None => { }
+                    }
+                    match config.get(TOP_LEVEL_INI_TAG, "json") {
+                        Some(val) => { lms_json_port = val.parse::<u16>().unwrap(); }
                        None => { }
                    }
                    match config.get(TOP_LEVEL_INI_TAG, "ignore") {
-                        Some(val) => {  ignore_file = val; },
+                        Some(val) => { ignore_file = val; }
                        None => { }
                    }
-                },
+                    match config.get(TOP_LEVEL_INI_TAG, "writetags") {
+                        Some(val) => { write_tags = val.eq("true"); }
+                        None => { }
+                    }
+                    match config.get(TOP_LEVEL_INI_TAG, "readtags") {
+                        Some(val) => { read_tags = val.eq("true"); }
+                        None => { }
+                    }
+                    match config.get(TOP_LEVEL_INI_TAG, "preserve") {
+                        Some(val) => { preserve_mod_times = val.eq("true"); }
+                        None => { }
+                    }
+                }
                Err(e) => {
                    log::error!("Failed to load config file. {}", e);
                    process::exit(-1);
@@ -114,8 +167,31 @@ fn main() {
        }
    }

+    if music_paths.is_empty() {
+        music_paths.push(PathBuf::from(&music_path));
+        if !music_1_path.is_empty() {
+            music_paths.push(PathBuf::from(&music_1_path));
+        }
+        if !music_2_path.is_empty() {
+            music_paths.push(PathBuf::from(&music_2_path));
+        }
+        if !music_3_path.is_empty() {
+            music_paths.push(PathBuf::from(&music_3_path));
+        }
+        if !music_4_path.is_empty() {
+            music_paths.push(PathBuf::from(&music_4_path));
+        }
+    }
+
+    let mut thread_limit:usize = num_cpus::get() as usize;
+    if max_threads<0 && (max_threads.abs() as usize) < thread_limit-1 {
+        thread_limit = thread_limit - (max_threads.abs() as usize)
+    } else if max_threads>0 && (max_threads as usize) < thread_limit {
+        thread_limit = max_threads as usize;
+    }
+
    if task.eq_ignore_ascii_case("stopmixer") {
-        upload::stop_mixer(&lms_host);
+        upload::stop_mixer(&lms_host, lms_json_port);
    } else {
        if db_path.len() < 3 {
            log::error!("Invalid DB path ({}) supplied", db_path);
@@ -130,24 +206,25 @@ fn main() {

        if task.eq_ignore_ascii_case("upload") {
            if path.exists() {
-                upload::upload_db(&db_path, &lms_host);
+                upload::upload_db(&db_path, &lms_host, lms_json_port);
            } else {
                log::error!("DB ({}) does not exist", db_path);
                process::exit(-1);
            }
        } else {
-            let mpath = PathBuf::from(&music_path);
-            if !mpath.exists() {
-                log::error!("Music path ({}) does not exist", music_path);
-                process::exit(-1);
-            }
-            if !mpath.is_dir() {
-                log::error!("Music path ({}) is not a directory", music_path);
-                process::exit(-1);
+            for mpath in &music_paths {
+                if !mpath.exists() {
+                    log::error!("Music path ({}) does not exist", mpath.to_string_lossy());
+                    process::exit(-1);
+                }
+                if !mpath.is_dir() {
+                    log::error!("Music path ({}) is not a directory", mpath.to_string_lossy());
+                    process::exit(-1);
+                }
            }

            if task.eq_ignore_ascii_case("tags") {
-                analyse::read_tags(&db_path, &mpath);
+                db::read_tags(&db_path, &music_paths);
            } else if task.eq_ignore_ascii_case("ignore") {
                let ignore_path = PathBuf::from(&ignore_file);
                if !ignore_path.exists() {
@@ -158,9 +235,19 @@ fn main() {
                    log::error!("Ignore file ({}) is not a file", ignore_file);
                    process::exit(-1);
                }
-                analyse::update_ignore(&db_path, &ignore_path);
+                db::update_ignore(&db_path, &ignore_path);
+            } else if task.eq_ignore_ascii_case("export") {
+                db::export(&db_path, &music_paths, thread_limit, preserve_mod_times);
+            } else if task.eq_ignore_ascii_case("clearfail") {
+                db::clear_failures(&db_path);
            } else {
-                analyse::analyse_files(&db_path, &mpath, dry_run, keep_old, max_num_tracks);
+                let ignore_path = PathBuf::from(&ignore_file);
+                let modified = analyse::analyse_files(&db_path, &music_paths, dry_run, keep_old, max_num_files, thread_limit, 
+                                                      &ignore_path, read_tags, write_tags, preserve_mod_times, &lms_host, lms_json_port,
+                                                      send_notifs);
+                if modified && task.eq_ignore_ascii_case("analyse-lms") && path.exists() {
+                    upload::stop_mixer(&lms_host, lms_json_port);
+                }
            }
        }
    }
@@ -1,87 +1,268 @@
 /**
 * Analyse music with Bliss
 *
- * Copyright (c) 2022 Craig Drummond <craig.p.drummond@gmail.com>
+ * Copyright (c) 2022-2026 Craig Drummond <craig.p.drummond@gmail.com>
 * GPLv3 license.
 *
 **/

-use lofty::{Accessor, ItemKey, Probe};
+use crate::db;
+use lofty::config::WriteOptions;
+use lofty::file::FileType;
+use lofty::prelude::{Accessor, AudioFile, ItemKey, TagExt, TaggedFileExt};
+use lofty::tag::{ItemValue, Tag, TagItem};
 use regex::Regex;
+use std::fs::File;
+use std::fs;
 use std::path::Path;
 use substring::Substring;
-use crate::db;
+use std::time::SystemTime;
+use bliss_audio::{Analysis, AnalysisIndex, FeaturesVersion};

-const MAX_GENRE_VAL:usize = 192;
+const MAX_GENRE_VAL: usize = 192;
+const NUM_ANALYSIS_VALS: usize = 23;
+const ANALYSIS_TAG: &str = "BLISS_ANALYSIS";
+const ANALYSIS_TAG_FORMAT_VER: u16 = 2;

-pub fn read(track:&String) -> db::Metadata {
-    let mut meta = db::Metadata{
-        title:String::new(),
-        artist:String::new(),
-        album:String::new(),
-        album_artist:String::new(),
-        genre:String::new(),
-        duration:180
+fn fmt(val: f32) -> String {
+    format!("{:.16}", val).trim_end_matches("0").to_string()
+}
+
+pub fn write_analysis(track: &String, analysis: &Analysis, preserve_mod_times: bool) -> bool {
+    let value = format!("{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}", ANALYSIS_TAG_FORMAT_VER,
+                        fmt(analysis[AnalysisIndex::Tempo]), fmt(analysis[AnalysisIndex::Zcr]), fmt(analysis[AnalysisIndex::MeanSpectralCentroid]), fmt(analysis[AnalysisIndex::StdDeviationSpectralCentroid]), fmt(analysis[AnalysisIndex::MeanSpectralRolloff]),
+                        fmt(analysis[AnalysisIndex::StdDeviationSpectralRolloff]), fmt(analysis[AnalysisIndex::MeanSpectralFlatness]), fmt(analysis[AnalysisIndex::StdDeviationSpectralFlatness]), fmt(analysis[AnalysisIndex::MeanLoudness]), fmt(analysis[AnalysisIndex::StdDeviationLoudness]),
+                        fmt(analysis[AnalysisIndex::Chroma1]), fmt(analysis[AnalysisIndex::Chroma2]), fmt(analysis[AnalysisIndex::Chroma3]), fmt(analysis[AnalysisIndex::Chroma4]), fmt(analysis[AnalysisIndex::Chroma5]),
+                        fmt(analysis[AnalysisIndex::Chroma6]), fmt(analysis[AnalysisIndex::Chroma7]), fmt(analysis[AnalysisIndex::Chroma8]), fmt(analysis[AnalysisIndex::Chroma9]), fmt(analysis[AnalysisIndex::Chroma10]),
+                        fmt(analysis[AnalysisIndex::Chroma11]), fmt(analysis[AnalysisIndex::Chroma12]), fmt(analysis[AnalysisIndex::Chroma13]));
+
+    let mut written = false;
+    if let Ok(mut file) = lofty::read_from_path(Path::new(track)) {
+        let tag = match file.primary_tag_mut() {
+            Some(primary_tag) => primary_tag,
+            None => {
+                if let Some(first_tag) = file.first_tag_mut() {
+                    first_tag
+                } else {
+                    let tag_type = file.primary_tag_type();
+                    file.insert_tag(Tag::new(tag_type));
+                    file.primary_tag_mut().unwrap()
+                }
+            },
+        };
+
+        // Store analysis results
+        let tag_key = ItemKey::Unknown(ANALYSIS_TAG.to_string());
+        tag.remove_key(&tag_key);
+        let lower_tag_key = ItemKey::Unknown(ANALYSIS_TAG.to_lowercase().to_string());
+        tag.remove_key(&lower_tag_key);
+        tag.insert_unchecked(TagItem::new(tag_key, ItemValue::Text(value)));
+
+        // If we have any of the older analysis-in-comment tags, then remove these
+        let entries = tag.get_strings(&ItemKey::Comment);
+        let mut keep: Vec<ItemValue> = Vec::new();
+        let mut have_old = false;
+        for entry in entries {
+            if entry.starts_with(ANALYSIS_TAG) {
+                have_old = true;
+            } else {
+                keep.push(ItemValue::Text(entry.to_string()));
+            }
+        }
+        if have_old {
+            tag.remove_key(&ItemKey::Comment);
+            for k in keep {
+                tag.push(TagItem::new(ItemKey::Comment, k));
+            }
+        }
+
+        let now = SystemTime::now();
+        let mut mod_time = now;
+
+        if preserve_mod_times {
+            if let Ok(fmeta) = fs::metadata(track) {
+                if let Ok(time) = fmeta.modified() {
+                    mod_time = time;
+                }
+            }
+        }
+        if let Ok(_) = tag.save_to_path(Path::new(track), WriteOptions::default()) {
+            if preserve_mod_times {
+                if mod_time<now {
+                    if let Ok(f) = File::open(track) {
+                        let _ = f.set_modified(mod_time);
+                    }
+                }
+            }
+            written = true;
+        }
+    }
+    written
+}
+
+fn read_analysis_string(tag_str: &str, start_tag_pos:usize, version_pos:usize) -> Option<Analysis> {
+    let parts = tag_str.split(",");
+    let mut index = 0;
+    let mut num_read_vals = 0;
+    let mut vals = [0.; NUM_ANALYSIS_VALS];
+    let val_start_pos = version_pos+1;
+    for part in parts {
+        if index==start_tag_pos && start_tag_pos<version_pos {
+            if part!=ANALYSIS_TAG {
+                break;
+            }
+        } else if index==version_pos {
+            match part.parse::<u16>() {
+                Ok(ver) => {
+                    if ver!=ANALYSIS_TAG_FORMAT_VER {
+                        break;
+                    }
+                },
+                Err(_) => {
+                    break;
+                }
+            }
+        } else if (index - val_start_pos) < NUM_ANALYSIS_VALS {
+            match part.parse::<f32>() {
+                Ok(val) => {
+                    num_read_vals += 1;
+                    vals[index - val_start_pos] = val;
+                },
+                Err(_) => {
+                    break;
+                }
+            }
+        } else {
+            break;
+        }
+        index += 1;
+    }
+    if num_read_vals == NUM_ANALYSIS_VALS {
+        return Some(Analysis::new(vals.to_vec(), FeaturesVersion::LATEST).expect("number of vals should be 23"));
+    }
+    None
+}
+
+pub fn read(track: &String, read_analysis: bool) -> db::Metadata {
+    let mut meta = db::Metadata {
+        duration: 180,
+        ..db::Metadata::default()
    };
-    let path = Path::new(track);
-    match Probe::open(path) {
-        Ok(probe) => {
-            match probe.read(true) {
-                Ok(file) => {
-                    let tag = match file.primary_tag() {
-                        Some(primary_tag) => primary_tag,
-                        None => file.first_tag().expect("Error: No tags found!"),
-                    };

-                    meta.title=tag.title().unwrap_or("").to_string();
-                    meta.artist=tag.artist().unwrap_or("").to_string();
-                    meta.album=tag.album().unwrap_or("").to_string();
-                    meta.album_artist=tag.get_string(&ItemKey::AlbumArtist).unwrap_or("").to_string();
-                    meta.genre=tag.genre().unwrap_or("").to_string();
-                    // Check whether MP3 as numeric genre, and if so covert to text
-                    if file.file_type().eq(&lofty::FileType::MP3) {
-                        match tag.genre() {
-                            Some(genre) => {
-                                let test = &genre.parse::<u8>();
-                                match test {
-                                    Ok(val) => {
-                                        let idx:usize = *val as usize;
-                                        if idx<MAX_GENRE_VAL {
-                                            meta.genre=lofty::id3::v1::GENRES[idx].to_string();
-                                        }
-                                    },
-                                    Err(_) => {
-                                        // Check for "(number)text"
-                                        let re = Regex::new(r"^\([0-9]+\)").unwrap();
-                                        if re.is_match(&genre) {
-                                            match genre.find(")") {
-                                                Some(end) => {
-                                                    let test = &genre.to_string().substring(1, end).parse::<u8>();
-                                                    match test {
-                                                        Ok(val) => {
-                                                            let idx:usize = *val as usize;
-                                                            if idx<MAX_GENRE_VAL {
-                                                                meta.genre=lofty::id3::v1::GENRES[idx].to_string();
-                                                            }
-                                                        },
-                                                        Err(_) => { }
-                                                    }
-                                                },
-                                                None => { }
+    if let Ok(file) = lofty::read_from_path(Path::new(track)) {
+        let tag = match file.primary_tag() {
+            Some(primary_tag) => primary_tag,
+            None => {
+                if let Some(first_tag) = file.first_tag() {
+                    first_tag
+                } else {
+                    return meta;
+                }
+            }
+        };
+
+        meta.title = tag.title().unwrap_or_default().to_string();
+        meta.artist = tag.artist().unwrap_or_default().to_string();
+        meta.album = tag.album().unwrap_or_default().to_string();
+        meta.album_artist = tag.get_string(&ItemKey::AlbumArtist).unwrap_or_default().to_string();
+
+        // If file has multiple genre tags then read all.
+        let genres = tag.get_strings(&ItemKey::Genre);
+        let mut genre_list:Vec<String> = Vec::new();
+
+        for genre in genres {
+            genre_list.push(genre.to_string());
+        }
+        if genre_list.len()>1 {
+            meta.genre = genre_list.join(";");
+        } else {
+            meta.genre = tag.genre().unwrap_or_default().to_string();
+        }
+
+        // Check whether MP3 has numeric genre, and if so covert to text
+        if file.file_type().eq(&FileType::Mpeg) {
+            match tag.genre() {
+                Some(genre) => {
+                    let test = genre.parse::<u8>();
+                    match test {
+                        Ok(val) => {
+                            let idx: usize = val as usize;
+                            if idx < MAX_GENRE_VAL {
+                                meta.genre = lofty::id3::v1::GENRES[idx].to_string();
+                            }
+                        }
+                        Err(_) => {
+                            // Check for "(number)text"
+                            let re = Regex::new(r"^\([0-9]+\)").unwrap();
+                            if re.is_match(&genre) {
+                                match genre.find(")") {
+                                    Some(end) => {
+                                        let test = genre.to_string().substring(1, end).parse::<u8>();
+
+                                        if let Ok(val) = test {
+                                            let idx: usize = val as usize;
+                                            if idx < MAX_GENRE_VAL {
+                                                meta.genre = lofty::id3::v1::GENRES[idx].to_string();
                                            }
                                        }
                                    }
+                                    None => { }
                                }
-                            },
-                            None => {}
+                            }
                        }
                    }
-                    meta.duration=file.properties().duration().as_secs() as u32;
-                },
-                Err(_) => { }
+                }
+                None => { }
            }
-        },
-        Err(_) => { }
+        }
+
+        meta.duration = file.properties().duration().as_secs() as u32;
+
+        if read_analysis {
+            match tag.get_string(&ItemKey::Unknown(ANALYSIS_TAG.to_string())) {
+                Some(tag_str) => {
+                    match read_analysis_string(tag_str, 100, 0) {
+                        Some(analysis) => {
+                            meta.analysis = Some(analysis);
+                        }
+                        None => { }
+                    }
+                }
+                None => { }
+            }
+
+            if meta.analysis.is_none() {
+                // Try lowercase
+                match tag.get_string(&ItemKey::Unknown(ANALYSIS_TAG.to_lowercase().to_string())) {
+                    Some(tag_str) => {
+                        match read_analysis_string(tag_str, 100, 0) {
+                            Some(analysis) => {
+                                meta.analysis = Some(analysis);
+                            }
+                            None => { }
+                        }
+                    }
+                    None => { }
+                }
+            }
+
+            if meta.analysis.is_none() {
+                // Try old, stored in comment
+                let entries = tag.get_strings(&ItemKey::Comment);
+                for entry in entries {
+                    if entry.len()>(ANALYSIS_TAG.len()+(NUM_ANALYSIS_VALS*8)) && entry.starts_with(ANALYSIS_TAG) {
+                        match read_analysis_string(entry, 0, 1) {
+                            Some(analysis) => {
+                                meta.analysis = Some(analysis);
+                                break;
+                            }
+                            None => { }
+                        }
+                    }
+                }
+            }
+        }
    }
+
    meta
-}
+}
@@ -1,7 +1,7 @@
 /**
 * Analyse music with Bliss
 *
- * Copyright (c) 2022 Craig Drummond <craig.p.drummond@gmail.com>
+ * Copyright (c) 2022-2026 Craig Drummond <craig.p.drummond@gmail.com>
 * GPLv3 license.
 *
 **/
@@ -12,93 +12,76 @@ use std::process;
 use substring::Substring;
 use ureq;

-
-fn fail(msg:&str) {
+fn fail(msg: &str) {
    log::error!("{}", msg);
    process::exit(-1);
 }

-pub fn stop_mixer(lms:&String) {
+pub fn stop_mixer(lms_host: &String, json_port: u16) {
    let stop_req = "{\"id\":1, \"method\":\"slim.request\",\"params\":[\"\",[\"blissmixer\",\"stop\"]]}";

    log::info!("Asking plugin to stop mixer");
-    match ureq::post(&format!("http://{}:9000/jsonrpc.js", lms)).send_string(&stop_req) {
-        Ok(_) => { },
-        Err(e) => { log::error!("Failed to ask plugin to stop mixer. {}", e); }
+    let req = ureq::post(&format!("http://{}:{}/jsonrpc.js", lms_host, json_port)).send_string(&stop_req);
+    if let Err(e) = req {
+        log::error!("Failed to ask plugin to stop mixer. {}", e);
    }
 }

-pub fn upload_db(db_path:&String, lms:&String) {
+pub fn upload_db(db_path: &String, lms_host: &String, json_port: u16) {
    // First tell LMS to restart the mixer in upload mode
    let start_req = "{\"id\":1, \"method\":\"slim.request\",\"params\":[\"\",[\"blissmixer\",\"start-upload\"]]}";
-    let mut port:u16 = 0;
+    let mut port: u16 = 0;

    log::info!("Requesting LMS plugin to allow uploads");

-    match ureq::post(&format!("http://{}:9000/jsonrpc.js", lms)).send_string(&start_req) {
-        Ok(resp) => {
-            match resp.into_string() {
-                Ok(text) => {
-                    match text.find("\"port\":") {
-                        Some(s) => {
-                            let txt = text.to_string().substring(s+7, text.len()).to_string();
-                            match txt.find("}") {
-                                Some(e) => {
-                                    let p = txt.substring(0, e);
-                                    let test = p.parse::<u16>();
-                                    match test {
-                                        Ok(val) => {
-                                            port = val;
-                                        },
-                                        Err(_) => { fail("Could not parse resp (cast)"); }
-                                    }
-                                },
-                                None => { fail("Could not parse resp (closing)"); }
+    match ureq::post(&format!("http://{}:{}/jsonrpc.js", lms_host, json_port)).send_string(&start_req) {
+        Ok(resp) => match resp.into_string() {
+            Ok(text) => match text.find("\"port\":") {
+                Some(s) => {
+                    let txt = text.to_string().substring(s + 7, text.len()).to_string();
+                    match txt.find("}") {
+                        Some(e) => {
+                            let p = txt.substring(0, e);
+                            let test = p.parse::<u16>();
+                            match test {
+                                Ok(val) => { port = val; }
+                                Err(_) => { fail("Could not parse resp (cast)"); }
                            }
-                        },
-                        None => { fail("Could not parse resp (no port)"); }
+                        }
+                        None => { fail("Could not parse resp (closing)"); }
                    }
-                },
-                Err(_) => { fail("No text?")}
+                }
+                None => { fail("Could not parse resp (no port)"); }
            }
-        },
-        Err(e) => {
-            fail(&format!("Failed to ask LMS plugin to allow upload. {}", e));
+            Err(_) => fail("No text?"),
        }
+        Err(e) => { fail(&format!("Failed to ask LMS plugin to allow upload. {}", e)); }
    }

-    if port<=0 {
+    if port == 0 {
        fail("Invalid port");
    }

    // Now we have port number, do the actual upload...
    log::info!("Uploading {}", db_path);
    match File::open(db_path) {
-        Ok(file) => {
-            match file.metadata() {
-                Ok(meta) => {
-                    let buffered_reader = BufReader::new(file);
-                    log::info!("Length: {}", meta.len());
-                    match ureq::put(&format!("http://{}:{}/upload", lms, port))
-                                .set("Content-Length", &meta.len().to_string())
-                                .set("Content-Type", "application/octet-stream")
-                                .send(buffered_reader) {
-                        Ok(_) => {
-                            log::info!("Database uploaded");
-                            stop_mixer(lms);
-                        },
-                        Err(e) => {
-                            fail(&format!("Failed to upload database. {}", e));
-                        }
+        Ok(file) => match file.metadata() {
+            Ok(meta) => {
+                let buffered_reader = BufReader::new(file);
+                log::info!("Length: {}", meta.len());
+                match ureq::put(&format!("http://{}:{}/upload", lms_host, port))
+                    .set("Content-Length", &meta.len().to_string())
+                    .set("Content-Type", "application/octet-stream")
+                    .send(buffered_reader) {
+                    Ok(_) => {
+                        log::info!("Database uploaded");
+                        stop_mixer(lms_host, json_port);
                    }
-                },
-                Err(e) => {
-                    fail(&format!("Failed to open database. {}", e));
+                    Err(e) => { fail(&format!("Failed to upload database. {}", e)); }
                }
            }
-        },
-        Err(e) => {
-            fail(&format!("Failed to open database. {}", e));
+            Err(e) => { fail(&format!("Failed to open database. {}", e)); }
        }
+        Err(e) => { fail(&format!("Failed to open database. {}", e)); }
    }
- }
+}