Add multi-compiler support and cross-platform build automation

[Scanframe]

Description

This pull request adds comprehensive multi-compiler and cross-platform build support to enable building the Piper library and a CLI test application with various toolchains across different platforms.
This allows developers to test builds across all supported toolchains from a single Linux machine native or via Wine, Docker, Docker+Wine and when needed on Windows.
Minor changes have been made to the C++ source fixing some shortcomings for other toolchains and a serious MSVC only bug.

See it in action on YouTube
The repository Piper TTS Qt-Plugin is depending on these PR's changes.

How To

Simply run this in Linux with docker installed:

Build and Test Linux using its host architecture

./build.py docker -- --build --test gnu-debug

Build and Test Linux using architecture aarch64 (cross-compiled)

./build.py docker -- --build --test ga-debug

Build and Test for Windows using GNU for Windows (cross-compiled)

The test is executed in Wine.

./build.py docker -- --build --test gw-debug

Build and Test for Windows using MSVC-2022 compiler

Compiler and the test are running in Linux/Wine.

./build.py docker -- wine -- --build --test msvc-debug

The output.wav is the testresult located the bin/lnx64-<compiler> or bin/win64-<compiler> directory.

Toolchains Available for Building

This a list of all available toolchains and how they are referenced in the CMake configuration.:

• gnu - GNU GCC Linux x86_64 or aarch64 which depends on the build host
• mingw - MinGW-w64 (GNU GCC for Windows x86_64)
• gw - GNU GCC cross-compiler for Windows on Linux x86_64
• ga - Aarch64 GNU GCC cross-compiler on Linux x86_64
• msvc - Microsoft Visual C++ 2022 x86_64

Platform Support:

• Linux Native - Direct execution on the host OS (x86_64 or aarch64)
• Windows Native - Direct execution on the host OS (x86_64)
• Linux Wine - Windows emulation layer on Linux (x86_64)
• Linux Docker - Containerized build environment (x86_64)
• Linux Docker + Wine - Wine running inside Docker (x86_64)

Key Changes

• Fixed MSVC-specific issues as byte packing and global instance declaration in a header that caused a segmentation fault.
• Added CMakePresets.json with toolchain-specific configurations and separate build directories
• Added build.py automation script with build.ini configuration supporting all 11 tool/platform combinations
• Added toolchain-specific CMake files for each compiler
• Implemented run-executable.cmake helper script for cross-platform test execution
  using the environment and variables set in the CMakePresets.json file.
• Added a test application using a piper-cli application with CTest.
• The main CMakeLists.txt with CMakePresets.json suitable for working with JetBrains/CLion or VSCode.

CLion Autmatic Toolchain Selection

To have the correct toolchain selected in JetBrain's CLion the vendor section is used.
When there is not GNU tool-chain in CLion available the preset is not listed and cannot be selected.
In the current CMakePresets.json file uses tool-chains GNU , GW, GA, MinGW and MSVC.
Build presets are also prevented from builds and listing from the command-line with a condition section.

{
  "version": 6,
  "cmakeMinimumRequired": {
    "major": 3,
    "minor": 25,
    "patch": 0
  },
  "configurePresets": [
    {
      "name": ".tc-gnu",
      "description": "Toolchain for generic GNU",
      "hidden": true,
      "toolchainFile": "${sourceDir}/libpiper/cmake/toolchain-gnu.cmake",
      "cacheVariables": {
        "SF_COMPILER": {
          "type": "STRING",
          "value": "gnu"
        }
      },
      "vendor": {
        "jetbrains.com/clion": {
          "toolchain": "GNU"
        }
      }
    },
  ],
  "buildPresets": [
    {
      "name": ".build",
      "hidden": true,
      "cleanFirst": false,
      "verbose": false
    },
    {
      "name": ".lnx-only",
      "hidden": true,
      "condition": {
        "type": "equals",
        "lhs": "${hostSystemName}",
        "rhs": "Linux"
      }
    }
  ]
}

Build Automation

The build.py script with build.ini and CMakePresets.json enables building across:

• 5 toolchains (msvc, gnu, mingw, gw, ga)
• 4 platform modes (native, wine, docker, docker+wine)
• 11 total combinations with proper environment isolation

On the YouTube channel the workings of the Python script is shown for Linux and Windows.
The build.py is originally from my repository sf-cmake.

Below a list of configured toolchain and platform combinations where the Docker image (Ubuntu 24.04 baed)
has all toolchains on board (except mingw since it is superfluous since the gw cross compiler).
Docker needs running the image with special options to allow using fuse-zip (mounting zip-files).

1. msvc (native Windows)
2. msvc.wine (MSVC in Wine on Linux)
3. msvc.wine.docker (MSVC in Wine inside Docker)
4. gnu (native Linux GCC x86_64 or aarch64)
5. gnu.docker (GCC in Docker)
6. mingw (native Windows MinGW)
7. mingw.wine (MinGW in Wine on Linux)
8. gw (cross-compile Windows on Linux)
9. gw.docker (cross-compile Windows in Docker)
10. ga (native Linux GCC alternate)
11. ga.docker (GCC alternate in Docker)

Note: Windows contains an older version of the onnxruntime.dll which is part of the OS.
Directing the PATH to the location in the project is not working since the Windows\system32 directory
has a higher priority so the DLL must be copied into the executable directory. :(
Wine does not have this problem :)