naomi: add pjustic (rev b) and pjustica. fix gunsur2 and gunsur2j

Issue #716
cheat to allow The Next Tetris online features
2026-11-08 08:06:48 -10:00 · 2025-05-06 20:04:11 +02:00 · 2025-05-04 19:31:09 +02:00 · 2025-05-04 19:26:21 +02:00 · 2025-05-03 11:05:59 +02:00 · 2025-05-03 11:05:49 +02:00
4529 changed files with 409932 additions and 891734 deletions
@@ -1,14 +0,0 @@
-freebsd_instance:
-  image_family: freebsd-13-0
-
-env:
-  CCACHE_DIR: /tmp/ccache
-  CIRRUS_CLONE_SUBMODULES: true
-
-task:
-  install_script: pkg install -y alsa-lib ccache cmake evdev-proto git libao libevdev libudev-devd libzip mesa-libs miniupnpc ninja pkgconf png pulseaudio sdl2
-  ccache_cache:
-    folder: /tmp/ccache
-  script:
-    - cmake -B build -DCMAKE_BUILD_TYPE=Release -G Ninja
-    - cmake --build build --config Release
@@ -1 +1,2 @@
-custom: ['https://utip.io/flyinghead', 'https://www.paypal.com/paypalme/FlycastEmu']
+buy_me_a_coffee: hhwtpernwq
+custom: ['https://www.paypal.com/paypalme/FlycastEmu']
@@ -12,7 +12,7 @@ assignees: ''

 Platform / OS / Hardware: 

-Github hash: 
+Flycast version: 

 Hardware: 

@@ -4,6 +4,7 @@ on: [push, pull_request]

 jobs:
  build:
+    name: Android
    runs-on: ubuntu-latest

    steps:
@@ -12,30 +13,41 @@ jobs:
          sudo apt-get update
          sudo apt-get -y install ccache libcurl4-openssl-dev ninja-build

-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
-          submodules: true
+          submodules: recursive

-      - uses: actions/cache@v3
+      - uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: 'gradle'
+
+      - uses: actions/cache@v4
        with:
          path: ~/.ccache
          key: android-ccache-${{ github.sha }}
          restore-keys: android-ccache-
+            
+      - name: Disable release signing
+        run: sed -i 's/signingConfig signingConfigs.release/signingConfig signingConfigs.debug/g' shell/android-studio/flycast/build.gradle
+        if: github.repository != 'flyinghead/flycast' || github.event_name != 'push'

-      - uses: actions/cache@v3
+      - name: Bump version code
+        uses: chkfung/[email protected]
        with:
-          path: |
-            ~/.gradle/caches
-            ~/.gradle/wrapper
-          key: android-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
-          restore-keys: android-gradle-
+          gradlePath: shell/android-studio/flycast/build.gradle 
+          versionCode: ${{ github.run_number }}

      - name: Gradle
        working-directory: shell/android-studio
-        run: ./gradlew assembleRelease --parallel
+        run: ./gradlew assembleRelease bundleRelease --parallel
+        env:
+          SENTRY_UPLOAD_URL: ${{ secrets.SENTRY_UPLOAD_URL }}
+          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}

-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
        with:
          name: flycast-release.apk
          path: shell/android-studio/flycast/build/outputs/apk/release/flycast-release.apk
@@ -50,7 +62,7 @@ jobs:
      - name: Extract symbols
        run: |
          DUMP_SYMS=./core/deps/breakpad/bin/dump_syms
-          SO_DIR=shell/android-studio/flycast/build/intermediates/cmake/release/obj
+          SO_DIR=shell/android-studio/flycast/build/intermediates/merged_native_libs/release/mergeReleaseNativeLibs/out/lib
          for arch in arm64-v8a armeabi-v7a x86 x86_64 ; do
            $DUMP_SYMS $SO_DIR/$arch/libflycast.so > libflycast.so.sym
            BUILD_ID=`head -1 libflycast.so.sym | awk '{ print $4 }'`
@@ -58,19 +70,36 @@ jobs:
            mv libflycast.so.sym symbols/libflycast.so/$BUILD_ID
          done

-      - name: Configure AWS Credentials
-        id: aws-credentials
-        uses: aws-actions/configure-aws-credentials@v1
+      - name: Setup Rclone
+        uses: AnimMouse/setup-rclone@v1
        with:
-          aws-access-key-id: AKIAJOZQS4H2PHQWYFCA
-          aws-secret-access-key: ${{ secrets.S3_SECRET_KEY }}
-          aws-region: us-east-2
-        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push'
+          rclone_config: ${{ secrets.RCLONE_CONFIG }}

      - name: Upload to S3
-        run: aws s3 sync shell/android-studio/flycast/build/outputs/apk/release s3://flycast-builds/android/${GITHUB_REF#refs/}-$GITHUB_SHA --acl public-read --exclude='*.json' --follow-symlinks
-        if: ${{ steps.aws-credentials.outputs.aws-account-id != '' }}
+        run: |
+          cp shell/android-studio/flycast/build/outputs/bundle/release/*.aab shell/android-studio/flycast/build/outputs/apk/release/
+          rclone copy shell/android-studio/flycast/build/outputs/apk/release scaleway:flycast-builds/android/${GITHUB_REF#refs/}-$GITHUB_SHA --exclude '*.json'
+        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push'

-      - name: Upload to S3 (symbols)
-        run: aws s3 sync symbols s3://flycast-symbols/android --follow-symlinks
-        if: ${{ steps.aws-credentials.outputs.aws-account-id != '' }}
+      - name: Setup Sentry CLI
+        uses: mathieu-bour/setup-sentry-cli@v2
+        env:
+          SENTRY_TOKEN: ${{ secrets.SENTRY_TOKEN }}
+        with:
+          url: https://sentry.io
+          token: ${{ env.SENTRY_TOKEN }}
+          organization: flycast
+          project: minidump
+          version: 2.21.2
+        if: ${{ env.SENTRY_TOKEN != '' }}
+      
+      - name: Upload symbols to Sentry
+        run: |
+          VERSION=$(git describe --tags --always)
+          sentry-cli releases new "$VERSION"
+          sentry-cli releases set-commits "$VERSION" --auto
+          sentry-cli debug-files upload symbols
+        shell: bash
+        env:
+          SENTRY_TOKEN: ${{ secrets.SENTRY_TOKEN }}
+        if: ${{ env.SENTRY_TOKEN != '' }}
@@ -0,0 +1,48 @@
+name: BSD CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    env:
+      CCACHE_DIR: ${{ github.workspace }}/.ccache
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        operating_system: [ freebsd, netbsd, openbsd ]
+        architecture: [ arm64, x86-64 ]
+        include:
+          - operating_system: freebsd
+            version: '14.2'
+            pkginstall: sudo pkg install -y alsa-lib ccache cmake evdev-proto git libao libevdev libudev-devd libzip lua54 miniupnpc ninja pkgconf pulseaudio sdl2 libcdio
+          - operating_system: netbsd
+            version: '10.1'
+            pkginstall: sudo pkgin update && sudo pkgin -y install alsa-lib ccache cmake gcc12 git libao libzip lua54 miniupnpc ninja-build pkgconf pulseaudio SDL2 libcdio && export PATH=/usr/pkg/gcc12/bin:$PATH
+          - operating_system: openbsd
+            version: '7.6'
+            pkginstall: sudo pkg_add ccache cmake git libao libzip miniupnpc ninja pkgconf pulseaudio sdl2 libcdio
+        exclude:
+          - architecture: arm64
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - uses: actions/cache@v4
+        with:
+          path: ${{ env.CCACHE_DIR }}
+          key: ccache-${{ matrix.operating_system }}-${{ matrix.architecture }}-${{ github.sha }}
+          restore-keys: ccache-${{ matrix.operating_system }}-${{ matrix.architecture }}-
+
+      - uses: cross-platform-actions/[email protected]
+        with:
+          operating_system: ${{ matrix.operating_system }}
+          architecture: ${{ matrix.architecture }}
+          version: ${{ matrix.version }}
+          environment_variables: CCACHE_DIR
+          run: |
+            ${{ matrix.pkginstall }}
+            cmake -B build -DUSE_LIBCDIO=ON -DCMAKE_BUILD_TYPE=Release -G Ninja
+            cmake --build build --config Release
@@ -18,37 +18,42 @@ jobs:
      matrix:
        config:
          - {name: i686-pc-windows-msvc, os: windows-latest, shell: cmd, arch: x86, cmakeArgs: -G Ninja, buildType: Release}
-          - {name: apple-darwin, os: macos-latest, shell: sh, cmakeArgs: -G Xcode, destDir: osx, buildType: Release}
+          - {name: apple-darwin, os: macos-latest, shell: sh, cmakeArgs: -G Xcode -DUSE_DISCORD=ON, destDir: osx, buildType: RelWithDebInfo}
          - {name: apple-ios, os: macos-latest, shell: sh, cmakeArgs: -DCMAKE_SYSTEM_NAME=iOS -G Xcode, destDir: ios, buildType: Release}
-          - {name: x86_64-pc-linux-gnu, os: ubuntu-latest, shell: sh, cmakeArgs: -G Ninja, buildType: Release}
-          - {name: x86_64-pc-windows-msvc, os: windows-latest, shell: cmd, arch: x64, cmakeArgs: -G Ninja, buildType: Release}
-          - {name: x86_64-w64-mingw32, os: windows-latest, shell: 'msys2 {0}', cmakeArgs: -G Ninja, destDir: win, buildType: RelWithDebInfo}
-          - {name: libretro-x86_64-pc-linux-gnu, os: ubuntu-latest, shell: sh, cmakeArgs: -DLIBRETRO=ON -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE -G Ninja, buildType: Release}
-          - {name: libretro-x86_64-w64-mingw32, os: windows-latest, shell: 'msys2 {0}', cmakeArgs: -DLIBRETRO=ON -G Ninja, buildType: Release}
+          - {name: x86_64-pc-linux-gnu, os: ubuntu-22.04, shell: sh, cmakeArgs: -G Ninja -DUSE_DISCORD=ON -DUSE_LIBCDIO=ON, destDir: linux, buildType: RelWithDebInfo}
+          - {name: x86_64-pc-windows-msvc, os: windows-latest, shell: cmd, arch: x64, cmakeArgs: -G Ninja -DUSE_DISCORD=ON, buildType: Release}
+          - {name: x86_64-w64-mingw32, os: windows-latest, shell: 'msys2 {0}', cmakeArgs: -G Ninja -DUSE_DISCORD=ON -DUSE_LIBCDIO=ON, destDir: win, buildType: RelWithDebInfo}
+          - {name: libretro-x86_64-pc-linux-gnu, os: ubuntu-22.04, shell: sh, cmakeArgs: -DLIBRETRO=ON -DUSE_LIBCDIO=ON -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE -G Ninja, buildType: Release}
+          - {name: libretro-x86_64-w64-mingw32, os: windows-latest, shell: 'msys2 {0}', cmakeArgs: -DLIBRETRO=ON -DUSE_LIBCDIO=ON -G Ninja, buildType: Release}

    steps:
      - name: Set up build environment (macOS)
        run: |
-          brew update
-          brew install libao ldid libomp ninja pulseaudio
-          wget https://sdk.lunarg.com/sdk/download/1.3.204.1/mac/vulkansdk-macos-1.3.204.1.dmg
-          hdiutil attach ./vulkansdk-macos-*.dmg
-          sudo /Volumes/vulkansdk-macos-*/InstallVulkan.app/Contents/MacOS/InstallVulkan --root $HOME/VulkanSDK --accept-licenses --default-answer --confirm-command install
-          hdiutil detach /Volumes/vulkansdk-macos-*
+          # Unlink and re-link to prevent errors when github mac runner images install python outside of brew. See https://github.com/actions/setup-python/issues/577
+          brew list -1 | grep python | while read formula; do brew unlink $formula; brew link --overwrite $formula; done
+          brew update || :
+          brew install libao ldid pulseaudio
+          brew uninstall --ignore-dependencies zstd
+          VULKAN_VER=1.3.261.1 && aria2c https://sdk.lunarg.com/sdk/download/$VULKAN_VER/mac/vulkansdk-macos-$VULKAN_VER.dmg
+          hdiutil attach ./vulkansdk-macos-*.dmg -mountpoint /Volumes/VulkanSDK
+          sudo /Volumes/VulkanSDK/InstallVulkan.app/Contents/MacOS/InstallVulkan --root $HOME/VulkanSDK --accept-licenses --default-answer --confirm-command install
+          hdiutil detach /Volumes/VulkanSDK
          echo "VULKAN_SDK=$HOME/VulkanSDK/macOS" >> $GITHUB_ENV
        if: runner.os == 'macOS'

      - name: Set up build environment (Linux)
        run: |
+          sudo add-apt-repository ppa:christianrauch/libdecoration
          sudo apt-get update
-          sudo apt-get -y install ccache libao-dev libasound2-dev libevdev-dev libgl1-mesa-dev liblua5.3-dev libminiupnpc-dev libpulse-dev libsdl2-dev libudev-dev libzip-dev ninja-build
+          sudo apt-get -y install ccache libao-dev libasound2-dev libevdev-dev libgl1-mesa-dev liblua5.3-dev libminiupnpc-dev libpulse-dev libsdl2-dev libudev-dev libzip-dev ninja-build libcurl4-openssl-dev libcdio-dev libfuse2
+          sudo apt-get -y install libwayland-dev libdecor-0-dev libaudio-dev libjack-dev libsndio-dev libsamplerate0-dev libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev libxkbcommon-dev libdrm-dev libgbm-dev libgles2-mesa-dev libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev libudev-dev fcitx-libs-dev
        if: runner.os == 'Linux'

      - name: Set up build environment (Windows, MinGW)
        uses: msys2/setup-msys2@v2
        with:
          msystem: MINGW64
-          install: git make mingw-w64-x86_64-ccache mingw-w64-x86_64-cmake mingw-w64-x86_64-lua mingw-w64-x86_64-ninja mingw-w64-x86_64-SDL2 mingw-w64-x86_64-toolchain
+          install: git make mingw-w64-x86_64-ccache mingw-w64-x86_64-cmake mingw-w64-x86_64-lua mingw-w64-x86_64-ninja mingw-w64-x86_64-SDL2 mingw-w64-x86_64-toolchain mingw-w64-x86_64-libcdio
        if: matrix.config.shell == 'msys2 {0}'

      - name: Set up build environment (Windows, Visual Studio)
@@ -62,12 +67,20 @@ jobs:
          arch: ${{ matrix.config.arch }}
        if: matrix.config.shell == 'cmd'

-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
-          submodules: true
+          submodules: recursive

-      - uses: actions/cache@v3
+      - name: Compile a universal OpenMP (macOS)
+        run: HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew reinstall --build-from-source --formula ./shell/apple/libomp.rb
+        if: matrix.config.name == 'apple-darwin'
+
+      - name: Compile OpenMP.xcframework (iOS)
+        run: ./shell/apple/emulator-ios/OpenMP/build_ios_openmp.sh --disableSimulator
+        if: matrix.config.name == 'apple-ios'
+
+      - uses: actions/cache@v4
        with:
          path: ${{ env.CCACHE_DIR }}
          key: ccache-${{ matrix.config.name }}-${{ github.sha }}
@@ -76,8 +89,10 @@ jobs:

      - name: CMake
        run: |
-          cmake -B build -DCMAKE_BUILD_TYPE=${{ matrix.config.buildType }} -DCMAKE_INSTALL_PREFIX=artifact ${{ matrix.config.cmakeArgs }}
+          cmake -B build -DCMAKE_BUILD_TYPE=${{ matrix.config.buildType }} -DCMAKE_INSTALL_PREFIX=artifact ${{ matrix.config.cmakeArgs }} -DSENTRY_UPLOAD_URL=${{ env.SENTRY_UPLOAD_URL }}
          cmake --build build --config ${{ matrix.config.buildType }} --target install
+        env:
+          SENTRY_UPLOAD_URL: ${{ secrets.SENTRY_UPLOAD_URL }}

      - name: Unit Tests
        run: |
@@ -88,17 +103,35 @@ jobs:

      - name: Dump symbols
        run: |
-          core/deps/breakpad/bin/dump_syms artifact/bin/flycast.exe > flycast.exe.sym 2>/dev/null
-          BUILD_ID=`head -1 flycast.exe.sym | awk '{ print $4 }'`
-          mkdir -p symbols/flycast.exe/$BUILD_ID
-          mv flycast.exe.sym symbols/flycast.exe/$BUILD_ID
+          mkdir -p symbols
+          core/deps/breakpad/bin/dump_syms artifact/bin/flycast.exe > symbols/flycast.sym 2>/dev/null
          strip artifact/bin/flycast.exe
        if: matrix.config.name == 'x86_64-w64-mingw32'

-      - uses: actions/upload-artifact@v3
+      - name: Build breakpad (linux)
+        working-directory: core/deps/breakpad
+        run: |
+          ./configure
+          make
+          sudo make install
+        if: matrix.config.name == 'x86_64-pc-linux-gnu'
+
+      - name: Dump symbols and make AppImage (linux)
+        run: |
+          mkdir -p symbols
+          dump_syms artifact/bin/flycast > symbols/flycast.sym 2>/dev/null
+          strip artifact/bin/flycast
+          shell/linux/make-appimage.sh . artifact/bin appimage
+          mv flycast-x86_64.AppImage artifact/bin
+          rm artifact/bin/flycast
+        if: matrix.config.name == 'x86_64-pc-linux-gnu'
+
+      - uses: actions/upload-artifact@v4
        with:
          name: flycast-${{ matrix.config.name }}
-          path: artifact/bin
+          path: |
+            artifact/bin
+            artifact/lib/libretro

      - name: Package app (macos)
        run: |
@@ -112,21 +145,36 @@ jobs:
          rm artifact/bin/flycast.exe
        if: matrix.config.name == 'x86_64-w64-mingw32'

-      - name: Configure AWS Credentials
-        id: aws-credentials
-        uses: aws-actions/configure-aws-credentials@v1
+      - name: Setup Rclone
+        uses: AnimMouse/setup-rclone@v1
        with:
-          aws-access-key-id: AKIAJOZQS4H2PHQWYFCA
-          aws-secret-access-key: ${{ secrets.S3_SECRET_KEY }}
-          aws-region: us-east-2
-        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push' && matrix.config.destDir != ''
+          rclone_config: ${{ secrets.RCLONE_CONFIG }}

      - name: Upload to S3
-        run: aws s3 sync artifact/bin s3://flycast-builds/${{ matrix.config.destDir }}/${GITHUB_REF#refs/}-$GITHUB_SHA --acl public-read --follow-symlinks
+        run: rclone copy artifact/bin scaleway:flycast-builds/${{ matrix.config.destDir }}/${GITHUB_REF#refs/}-$GITHUB_SHA
        shell: bash
-        if: ${{ steps.aws-credentials.outputs.aws-account-id != '' }}
+        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push' && matrix.config.destDir != ''

-      - name: Upload symbols to S3
-        run: aws s3 sync symbols s3://flycast-symbols/${{ matrix.config.destDir }} --follow-symlinks
+      - name: Setup Sentry CLI
+        uses: mathieu-bour/setup-sentry-cli@v2
+        env:
+          SENTRY_TOKEN: ${{ secrets.SENTRY_TOKEN }}
+        with:
+          url: https://sentry.io
+          token: ${{ env.SENTRY_TOKEN }}
+          organization: flycast
+          project: minidump
+          version: 2.21.2
+        if: ${{ env.SENTRY_TOKEN != '' }}
+      
+      - name: Upload symbols to Sentry (Windows, macOS, Linux)
+        run: |
+          VERSION=$(git describe --tags --always)
+          sentry-cli releases new "$VERSION"
+          sentry-cli releases set-commits "$VERSION" --auto
+          sentry-cli debug-files upload symbols
        shell: bash
-        if: ${{ steps.aws-credentials.outputs.aws-account-id != '' && matrix.config.name == 'x86_64-w64-mingw32' }}
+        env:
+          SENTRY_TOKEN: ${{ secrets.SENTRY_TOKEN }}
+        if: ${{ env.SENTRY_TOKEN != '' && (matrix.config.name == 'x86_64-w64-mingw32' || matrix.config.name == 'apple-darwin' || matrix.config.name == 'x86_64-pc-linux-gnu') }}
+        
@@ -15,15 +15,18 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Setup Java JDK
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v4
        with:
-          java-version: 1.8
+          java-version: 18
+          distribution: zulu

      - name: Setup Python
-        uses: actions/setup-python@v3
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'

      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4

      - name: Upload Source
        shell: bash
@@ -12,15 +12,18 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Setup Java JDK
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v4
        with:
-          java-version: 1.8
+          java-version: 18
+          distribution: zulu

      - name: Setup Python
-        uses: actions/setup-python@v3
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'

      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
        with:
          persist-credentials: false # otherwise, the token used is the GITHUB_TOKEN, instead of your personal access token.
          fetch-depth: 0 # otherwise, there would be errors pushing refs to the destination repository.
@@ -40,7 +43,7 @@ jobs:
          git commit -m "Fetch translations & Recreate libretro_core_options_intl.h"

      - name: GitHub Push
-        uses: ad-m/github-push-action@v0.6.0
+        uses: ad-m/github-push-action@v0.8.0
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          branch: ${{ github.ref }}
@@ -4,9 +4,9 @@ on: [push, pull_request]

 jobs:
  build:
-    name: ${{ matrix.config.name }}
+    name: Switch ${{ matrix.config.name }}
    runs-on: ubuntu-latest
-    container: devkitpro/devkita64:20220128
+    container: devkitpro/devkita64:latest

    strategy:
      matrix:
@@ -18,14 +18,17 @@ jobs:
      - name: Set up build environment
        run: |
          sudo apt-get update
-          sudo apt-get -y install awscli ccache ninja-build
+          sudo apt-get -y install ccache

-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
          submodules: true

-      - uses: actions/cache@v3
+      - name: Mark git repository as safe
+        run: git config --global --add safe.directory $PWD
+
+      - uses: actions/cache@v4
        with:
          path: ~/.ccache
          key: ccache-switch-${{ matrix.config.name }}-${{ github.sha }}
@@ -36,7 +39,7 @@ jobs:
          $DEVKITPRO/portlibs/switch/bin/aarch64-none-elf-cmake -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=artifact -G Ninja ${{ matrix.config.cmakeArgs }}
          cmake --build build --config Release --target install

-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
        with:
          name: flycast-switch-${{ matrix.config.name }}
          path: artifact/bin
@@ -45,15 +48,12 @@ jobs:
        run: zip -m artifact/bin/flycast.nro.zip artifact/bin/flycast.nro
        if: hashFiles('artifact/bin/flycast.nro') != ''

-      - name: Configure AWS Credentials
-        id: aws-credentials
-        uses: aws-actions/configure-aws-credentials@v1
+      - name: Setup Rclone
+        uses: AnimMouse/setup-rclone@v1
        with:
-          aws-access-key-id: AKIAJOZQS4H2PHQWYFCA
-          aws-secret-access-key: ${{ secrets.S3_SECRET_KEY }}
-          aws-region: us-east-2
-        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push' && matrix.config.destDir != ''
+          rclone_config: ${{ secrets.RCLONE_CONFIG }}
+          version: v1.69.1

      - name: Upload to S3
-        run: aws s3 sync artifact/bin s3://flycast-builds/${{ matrix.config.destDir }}/${GITHUB_REF#refs/}-$GITHUB_SHA --acl public-read --follow-symlinks
-        if: ${{ steps.aws-credentials.outputs.aws-account-id != '' }}
+        run: rclone copy artifact/bin scaleway:flycast-builds/${{ matrix.config.destDir }}/${GITHUB_REF#refs/}-$GITHUB_SHA
+        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push' && matrix.config.destDir != ''
@@ -4,33 +4,19 @@ on: [push, pull_request]

 jobs:
  build:
+    name: UWP
    runs-on: windows-latest

-    env:
-      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
-      VCPKG_DEFAULT_BINARY_CACHE: ${{ github.workspace }}/vcpkg/bincache
-
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
          submodules: true

-      - name: bootstrap vcpkg
-        run: |
-          git clone https://github.com/microsoft/vcpkg
-          mkdir vcpkg\bincache
-          vcpkg\bootstrap-vcpkg.bat
-
-      - uses: actions/cache@v3
-        with:
-          path: ${{ env.VCPKG_DEFAULT_BINARY_CACHE }}
-          key: vcpkg-${{ hashFiles( 'vcpkg.json' ) }}
-
      - name: CMake
        run: |
-          cmake -B build -DCMAKE_BUILD_TYPE=Release -G "Visual Studio 17 2022" -A x64 -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0 -DCMAKE_SYSTEM_PROCESSOR=AMD64 -DCMAKE_CROSSCOMPILING=OFF -DUSE_VULKAN=OFF -DCMAKE_TOOLCHAIN_FILE=%VCPKG_ROOT%\scripts\buildsystems\vcpkg.cmake
-          cmake --build build --config Release --parallel 2
+          cmake -B build -DCMAKE_BUILD_TYPE=Release -G "Visual Studio 17 2022" -A x64 -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0.22000.0
+          cmake --build build --config Release -- /m
        shell: cmd

      - uses: ilammy/msvc-dev-cmd@v1
@@ -49,21 +35,17 @@ jobs:
        run: signtool sign /f shell\uwp\sign_cert.pfx /p '${{ secrets.SIGN_CERT_PWD }}' /v /fd SHA256 build\artifact\flycast.appx
        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push'

-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
        with:
          name: flycast-uwp
          path: build/artifact

-      - name: Configure AWS Credentials
-        id: aws-credentials
-        uses: aws-actions/configure-aws-credentials@v1
+      - name: Setup Rclone
+        uses: AnimMouse/setup-rclone@v1
        with:
-          aws-access-key-id: AKIAJOZQS4H2PHQWYFCA
-          aws-secret-access-key: ${{ secrets.S3_SECRET_KEY }}
-          aws-region: us-east-2
-        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push'
+          rclone_config: ${{ secrets.RCLONE_CONFIG }}

      - name: Upload to S3
-        run: aws s3 sync build/artifact s3://flycast-builds/xbox/${GITHUB_REF#refs/}-$GITHUB_SHA --acl public-read --follow-symlinks
+        run: rclone copy build/artifact scaleway:flycast-builds/xbox/${GITHUB_REF#refs/}-$GITHUB_SHA
        shell: bash
-        if: ${{ steps.aws-credentials.outputs.aws-account-id != '' }}
+        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push'
@@ -1,12 +1,22 @@
 build/
+artifact/

 # macOS
 .DS_Store
+shell/apple/emulator-ios/OpenMP/OpenMP.xcframework

 # Visual Studio
 .vs/
+.vscode/
 out/

 # JetBrains IDES
 .idea/
 cmake-build-*/
+
+# Dependencies from .gitmodules
+core/deps/breakpad/
+core/deps/glslang/
+.cache/
+compile_commands.json
+CMakeUserPresets.json
@@ -9,23 +9,34 @@
  variables:
    GIT_SUBMODULE_STRATEGY: recursive
    CORENAME: flycast
-    CORE_ARGS: -DLIBRETRO=ON -DCMAKE_BUILD_TYPE=Release
+    CORE_ARGS: -DLIBRETRO=ON -DUSE_LIBCDIO=ON -DCMAKE_BUILD_TYPE=Release

 .core-defs-linux:
  extends: .core-defs
  variables:
-    CORE_ARGS: -DLIBRETRO=ON -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE -DCMAKE_BUILD_TYPE=Release
+    CORE_ARGS: -DLIBRETRO=ON -DUSE_LIBCDIO=ON -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE -DCMAKE_BUILD_TYPE=Release

 .core-defs-osx-x64:
+  extends: .core-defs
+  variables:
+    CORE_ARGS: -DLIBRETRO=ON -G Xcode -DCMAKE_BUILD_TYPE=Release -DCMAKE_OSX_ARCHITECTURES=x86_64
+    EXTRA_PATH: Release
+
+.core-defs-osx-arm64:
  extends: .core-defs
  variables:
    CORE_ARGS: -DLIBRETRO=ON -G Xcode -DCMAKE_BUILD_TYPE=Release
    EXTRA_PATH: Release

+.core-defs-ios-arm64:
+  extends: .core-defs
+  variables:
+    CORE_ARGS: -DLIBRETRO=ON -DCMAKE_BUILD_TYPE=Release
+
 .core-defs-android:
  extends: .core-defs
  script:
-    - cmake $CORE_ARGS -DANDROID_PLATFORM=android-$API_LEVEL -DCMAKE_TOOLCHAIN_FILE=$NDK_ROOT/build/cmake/android.toolchain.cmake -DANDROID_STL=c++_static -DANDROID_ABI=$ANDROID_ABI -DANDROID_ARM_MODE=arm "$CMAKE_SOURCE_ROOT" -B$BUILD_DIR
+    - cmake -DLIBRETRO=ON -DCMAKE_BUILD_TYPE=Release -DANDROID_PLATFORM=android-$API_LEVEL -DCMAKE_TOOLCHAIN_FILE=$NDK_ROOT/build/cmake/android.toolchain.cmake -DANDROID_STL=c++_static -DANDROID_ABI=$ANDROID_ABI -DANDROID_ARM_MODE=arm "$CMAKE_SOURCE_ROOT" -B$BUILD_DIR
    - cmake --build $BUILD_DIR --target ${CORENAME}_libretro --config Release -- -j $NUMPROC
    - mv $BUILD_DIR/${CORENAME}_libretro.so $LIBNAME
    - if [ $STRIP_CORE_LIB -eq 1 ]; then $NDK_ROOT/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-strip $LIBNAME; fi
@@ -43,6 +54,10 @@ include:
  - project: 'libretro-infrastructure/ci-templates'
    file: 'osx-cmake-x86.yml'

+  # MacOS arm64
+  - project: 'libretro-infrastructure/ci-templates'
+    file: 'osx-cmake-arm64.yml'
+
  # Linux
  - project: 'libretro-infrastructure/ci-templates'
    file: '/linux-cmake.yml'
@@ -52,10 +67,24 @@ include:
  - project: 'libretro-infrastructure/ci-templates'
    file: '/android-cmake.yml'

+  # iOS arm64
+  - project: 'libretro-infrastructure/ci-templates'
+    file: '/ios-cmake.yml'
+
+  ################################## CONSOLES ################################  
+  # Nintendo Switch
+#  - project: 'libretro-infrastructure/ci-templates'
+#    file: '/libnx-static.yml'
+
+  # tvOS arm64
+  - project: 'libretro-infrastructure/ci-templates'
+    file: '/tvos-cmake.yml'
+
 # Stages for building
 stages:
  - build-prepare
  - build-shared
+#  - build-static

 ##############################################################################
 #################################### STAGES ##################################
@@ -91,6 +120,14 @@ libretro-build-osx-x64:
  extends:
    - .libretro-osx-cmake-x86
    - .core-defs-osx-x64
+  tags:
+    - mac-apple-silicon
+
+# MacOS arm 64-bit
+libretro-build-osx-arm64:
+  extends:
+    - .libretro-osx-cmake-arm64
+    - .core-defs-osx-arm64

 ################################### CELLULAR #################################
 # Android ARMv7a
@@ -116,3 +153,21 @@ android-x86:
  extends:
    - .libretro-android-cmake-x86
    - .core-defs-android
+
+libretro-build-ios-arm64:
+  extends:
+    - .libretro-ios-cmake-arm64
+    - .core-defs-ios-arm64
+
+################################### CONSOLES #################################
+# Nintendo Switch
+#libretro-build-libnx-aarch64:
+#  extends:
+#    - .libretro-libnx-static-retroarch-master
+#    - .core-defs
+
+# tvOS arm64
+libretro-build-tvos-arm64:
+  extends:
+    - .libretro-tvos-cmake-arm64
+    - .core-defs-ios-arm64
@@ -3,10 +3,44 @@
 	url = https://github.com/libsdl-org/SDL.git
 [submodule "core/deps/libchdr"]
 	path = core/deps/libchdr
-	url = https://github.com/rtissera/libchdr.git
+	url = https://github.com/flyinghead/libchdr.git
+	ignore = dirty
 [submodule "core/deps/luabridge"]
 	path = core/deps/luabridge
 	url = https://github.com/vinniefalco/LuaBridge.git
 [submodule "core/deps/breakpad"]
 	path = core/deps/breakpad
 	url = https://github.com/flyinghead/mingw-breakpad
+[submodule "core/deps/Vulkan-Headers"]
+	path = core/deps/Vulkan-Headers
+	url = https://github.com/KhronosGroup/Vulkan-Headers.git
+[submodule "core/deps/VulkanMemoryAllocator"]
+	path = core/deps/VulkanMemoryAllocator
+	url = https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
+[submodule "core/deps/glslang"]
+	path = core/deps/glslang
+	url = https://github.com/KhronosGroup/glslang.git
+[submodule "core/deps/oboe"]
+	path = core/deps/oboe
+	url = https://github.com/google/oboe.git
+[submodule "core/deps/Syphon"]
+	path = core/deps/Syphon
+	url = https://github.com/vkedwardli/Syphon-Framework.git
+[submodule "core/deps/Spout"]
+	path = core/deps/Spout
+	url = https://github.com/vkedwardli/Spout2.git
+[submodule "core/deps/discord-rpc"]
+	path = core/deps/discord-rpc
+	url = https://github.com/harmonytf/discord-rpc
+[submodule "core/deps/libadrenotools"]
+	path = core/deps/libadrenotools
+	url = https://github.com/bylaws/libadrenotools
+[submodule "core/deps/rcheevos"]
+	path = core/deps/rcheevos
+	url = https://github.com/RetroAchievements/rcheevos.git
+[submodule "core/deps/googletest"]
+	path = core/deps/googletest
+	url = https://github.com/google/googletest.git
+[submodule "core/deps/asio"]
+	path = core/deps/asio
+	url = https://github.com/flyinghead/asio.git
@@ -0,0 +1,23 @@
+{
+    "version": 2,
+    "configurePresets": [
+        {
+            "name": "clang",
+            "generator": "Ninja",
+            "binaryDir": "build-clang",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug",
+                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
+            }
+        },
+        {
+            "name": "gcc",
+            "generator": "Ninja",
+            "binaryDir": "build-gcc",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug",
+                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
+            }
+        }
+    ]
+}
@@ -4,10 +4,11 @@
 [![C/C++ CI](https://github.com/flyinghead/flycast/actions/workflows/c-cpp.yml/badge.svg)](https://github.com/flyinghead/flycast/actions/workflows/c-cpp.yml)
 [![Nintendo Switch CI](https://github.com/flyinghead/flycast/actions/workflows/switch.yml/badge.svg)](https://github.com/flyinghead/flycast/actions/workflows/switch.yml)
 [![Windows UWP CI](https://github.com/flyinghead/flycast/actions/workflows/uwp.yml/badge.svg)](https://github.com/flyinghead/flycast/actions/workflows/uwp.yml)
+[![BSD CI](https://github.com/flyinghead/flycast/actions/workflows/bsd.yml/badge.svg)](https://github.com/flyinghead/flycast/actions/workflows/bsd.yml)

-![flycast logo](https://github.com/flyinghead/flycast/raw/master/shell/linux/flycast.png)
+<img src="shell/linux/flycast.png" alt="flycast logo" width="150"/>

-**Flycast** is a multi-platform Sega Dreamcast, Naomi and Atomiswave emulator derived from [**reicast**](https://reicast.com/).
+**Flycast** is a multi-platform Sega Dreamcast, Naomi, Naomi 2, and Atomiswave emulator derived from [**reicast**](https://github.com/skmp/reicast-emulator).

 Information about configuration and supported features can be found on [**TheArcadeStriker's flycast wiki**](https://github.com/TheArcadeStriker/flycast-wiki/wiki).

@@ -15,32 +16,43 @@ Join us on our [**Discord server**](https://discord.gg/X8YWP8w) for a chat.

 ## Install

-### Flatpak (Linux)
+### Android ![android](https://flyinghead.github.io/flycast-builds/android.jpg)
+Install Flycast from [**Google Play**](https://play.google.com/store/apps/details?id=com.flycast.emulator).
+### Flatpak (Linux ![ubuntu logo](https://flyinghead.github.io/flycast-builds/ubuntu.png))

-1. [Set up Flatpak](https://www.flatpak.org/setup/)
+1. [Set up Flatpak](https://www.flatpak.org/setup/).

-2. Install Flycast from [Flathub](https://flathub.org/apps/details/org.flycast.Flycast)
+2. Install Flycast from [Flathub](https://flathub.org/apps/details/org.flycast.Flycast):

 `flatpak install -y org.flycast.Flycast`

-3. Run Flycast
+3. Run Flycast:

 `flatpak run org.flycast.Flycast`

-### Homebrew (MacOS)
+### Homebrew (MacOS ![apple logo](https://flyinghead.github.io/flycast-builds/apple.png))

-1. [Set up Homebrew](https://brew.sh)
+1. [Set up Homebrew](https://brew.sh).

-2. Install Flycast via Homebrew
+2. Install Flycast via Homebrew:

 `brew install --cask flycast`

-### Xbox One
+### Xbox One/Series ![xbox logo](https://flyinghead.github.io/flycast-builds/xbox.png)

-Open [**gamr13's github page**](https://gamr13.github.io/) from your console.
+Grab the latest build from [**the builds page**](https://flyinghead.github.io/flycast-builds/), or the [**GitHub Actions**](https://github.com/flyinghead/flycast/actions/workflows/uwp.yml). Then install it using the **Xbox Device Portal**.

-### Binaries
+### Binaries ![android](https://flyinghead.github.io/flycast-builds/android.jpg) ![windows](https://flyinghead.github.io/flycast-builds/windows.png) ![linux](https://flyinghead.github.io/flycast-builds/ubuntu.png) ![apple](https://flyinghead.github.io/flycast-builds/apple.png) ![switch](https://flyinghead.github.io/flycast-builds/switch.png) ![xbox](https://flyinghead.github.io/flycast-builds/xbox.png)

 Get fresh builds for your system [**on the builds page**](https://flyinghead.github.io/flycast-builds/).

-**New:** Now automated test results are available as well.
+**New:** Now automated test results are available as well. 
+
+### Build instructions:
+```
+$ git clone --recursive https://github.com/flyinghead/flycast.git
+$ cd flycast
+$ mkdir build && cd build
+$ cmake ..
+$ make
+```
@@ -7,11 +7,10 @@ Here lies the core of our codebase. Everything that's OS inspecific rests here.
 ### Some rudimentary categories are:
 - hw				  -- DC Hardware Components Implementation
 - nullDC.cpp	-- Main entry points
- khronos			-- OpenGL and Vulkan headers
 - oslib				-- Audio drivers
 - cfg				  -- Configuration backend structure
 - reios				-- (Our) Implementation of the DreamCast BIOS
 - deps				-- External dependencies
 - imgread			-- Content drivers
 - rec-*				-- Recompilers
- rend				-- OpenGL and Vulkan renderers
+- rend				-- Graphics renderers and UI
@@ -0,0 +1,72 @@
+/*
+	This file is part of Flycast.
+
+    Flycast is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    Flycast is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Flycast.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#pragma once
+#include "types.h"
+#include <future>
+#include <vector>
+
+namespace achievements
+{
+#ifdef USE_RACHIEVEMENTS
+
+struct Game
+{
+	std::string image;
+	std::string title;
+	u32 unlockedAchievements;
+	u32 totalAchievements;
+	u32 points;
+	u32 totalPoints;
+};
+
+struct Achievement
+{
+	Achievement() = default;
+	Achievement(const std::string& image, const std::string& title, const std::string& description, const std::string& category, const std::string& status)
+		: image(image), title(title), description(description), category(category), status(status) {}
+	std::string image;
+	std::string title;
+	std::string description;
+	std::string category;
+	std::string status;
+};
+
+bool init();
+void term();
+std::future<void> login(const char *username, const char *password);
+void logout();
+bool isLoggedOn();
+bool isActive();
+Game getCurrentGame();
+std::vector<Achievement> getAchievementList();
+bool canPause();
+
+#else
+
+static inline bool isActive() {
+	return false;
+}
+static inline bool canPause() {
+	return true;
+}
+
+#endif
+
+void serialize(Serializer& ser);
+void deserialize(Deserializer& deser);
+
+}
@@ -23,19 +23,19 @@
 #include "deps/lzma/7zCrc.h"
 #include "deps/lzma/Alloc.h"

+#include <cstring>
+
 #define kInputBufSize ((size_t)1 << 18)

 static bool crc_tables_generated;

-bool SzArchive::Open(const char* path)
+bool SzArchive::Open(FILE *file)
 {
 	SzArEx_Init(&szarchive);

 	File_Close(&archiveStream.file);
 	File_Construct(&archiveStream.file);
-	archiveStream.file.file = nowide::fopen(path, "rb");
-	if (archiveStream.file.file == nullptr)
-		return false;
+	archiveStream.file.file = file;

 	FileInStream_CreateVTable(&archiveStream);
 	LookToRead2_CreateVTable(&lookStream, 0);
@@ -25,6 +25,7 @@
 #include "deps/lzma/7zFile.h"

 #include <algorithm>
+#include <cstring>

 class SzArchive : public Archive
 {
@@ -38,9 +39,10 @@ public:
 	ArchiveFile* OpenFile(const char* name) override;
 	ArchiveFile *OpenFileByCrc(u32 crc) override;

-private:
-	bool Open(const char* path) override;
+protected:
+	bool Open(FILE *file) override;

+private:
 	CSzArEx szarchive;
 	UInt32 block_idx;				/* it can have any value before first call (if outBuffer = 0) */
 	Byte *out_buffer;				/* it must be 0 before first call for each new archive. */
@@ -53,16 +55,21 @@ private:
 class SzArchiveFile : public ArchiveFile
 {
 public:
-	SzArchiveFile(u8 *data, u32 offset, u32 length) : data(data), offset(offset), length(length) {}
+	SzArchiveFile(u8 *data, u32 offset, u32 length)
+		: data(data), offset(offset), _length(length) {}
 	u32 Read(void *buffer, u32 length) override
 	{
-		length = std::min(length, this->length);
+		length = std::min(length, this->_length);
 		memcpy(buffer, data + offset, length);
 		return length;
 	}

+	size_t length() override {
+		return _length;
+	}
+
 private:
 	u8 *data;
 	u32 offset;
-	u32 length;
+	u32 _length;
 };
@@ -25,11 +25,8 @@ ZipArchive::~ZipArchive()
 	zip_close(zip);
 }

-bool ZipArchive::Open(const char* path)
+bool ZipArchive::Open(FILE *file)
 {
-	FILE *file = nowide::fopen(path, "rb");
-	if (file == nullptr)
-		return false;
 	zip_error_t error;
 	zip_source_t *source = zip_source_filep_create(file, 0, -1, &error);
 	if (source == nullptr)
@@ -37,7 +34,7 @@ bool ZipArchive::Open(const char* path)
 		std::fclose(file);
 		return false;
 	}
-	zip = zip_open_from_source(source, 0, NULL);
+	zip = zip_open_from_source(source, 0, nullptr);
 	if (zip == nullptr)
 		zip_source_free(source);
 	return zip != nullptr;
@@ -45,46 +42,77 @@ bool ZipArchive::Open(const char* path)

 ArchiveFile* ZipArchive::OpenFile(const char* name)
 {
-	zip_file *zip_file = zip_fopen(zip, name, 0);
-	if (zip_file == NULL)
-		return NULL;
-
-	return new ZipArchiveFile(zip_file);
+	zip_file_t *zip_file = zip_fopen(zip, name, 0);
+	if (zip_file == nullptr)
+		return nullptr;
+	zip_stat_t stat;
+	zip_stat(zip, name, 0, &stat);
+	return new ZipArchiveFile(zip_file, stat.size, stat.name);
 }

-struct zip_file *zip_fopen_by_crc(struct zip *za, u32 crc, int flags)
+static zip_file *zip_fopen_by_crc(zip_t *za, u32 crc, int flags, zip_uint64_t& index)
 {
-    int i, n;
-    struct zip_stat stat;
+	if (crc == 0)
+		return nullptr;

-    if (crc == 0) {
-        return NULL;
-    }
+	zip_int64_t n = zip_get_num_entries(za, 0);
+	for (index = 0; index < (zip_uint64_t)n; index++)
+	{
+		zip_stat_t stat;
+		if (zip_stat_index(za, index, flags, &stat) < -1)
+			return nullptr;
+		if (stat.crc == crc)
+			return zip_fopen_index(za, index, flags);
+	}

-    n = zip_get_num_files(za);
-    for (i = 0; i < n; i++) {
-        if (zip_stat_index(za, i, flags, &stat) < -1) {
-            return NULL;
-        }
-
-        if (stat.crc == crc) {
-            return zip_fopen_index(za, i, flags);
-        }
-    }
-
-    return NULL;
+	return nullptr;
 }

 ArchiveFile* ZipArchive::OpenFileByCrc(u32 crc)
 {
-	zip_file *zip_file = zip_fopen_by_crc(zip, crc, 0);
-	if (zip_file == NULL)
-		return NULL;
+	zip_uint64_t index;
+	zip_file_t *zip_file = zip_fopen_by_crc(zip, crc, 0, index);
+	if (zip_file == nullptr)
+		return nullptr;
+	zip_stat_t stat;
+	zip_stat_index(zip, index, 0, &stat);

-	return new ZipArchiveFile(zip_file);
+	return new ZipArchiveFile(zip_file, stat.size, stat.name);
 }

 u32 ZipArchiveFile::Read(void* buffer, u32 length)
 {
 	return zip_fread(zip_file, buffer, length);
 }
+
+bool ZipArchive::Open(const void *data, size_t size)
+{
+	zip_error_t error;
+	zip_source_t *source = zip_source_buffer_create(data, size, 0, &error);
+	if (source == nullptr)
+		return false;
+	zip = zip_open_from_source(source, 0, nullptr);
+	if (zip == nullptr)
+		zip_source_free(source);
+	return zip != nullptr;
+}
+
+ArchiveFile *ZipArchive::OpenFirstFile()
+{
+	zip_file_t *zipFile = zip_fopen_index(zip, 0, 0);
+	if (zipFile == nullptr)
+		return nullptr;
+	zip_stat_t stat;
+	zip_stat_index(zip, 0, 0, &stat);
+	return new ZipArchiveFile(zipFile, stat.size, stat.name);
+}
+
+ArchiveFile *ZipArchive::OpenFileByIndex(size_t index)
+{
+	zip_file_t *zipFile = zip_fopen_index(zip, index, 0);
+	if (zipFile == nullptr)
+		return nullptr;
+	zip_stat_t stat;
+	zip_stat_index(zip, index, 0, &stat);
+	return new ZipArchiveFile(zipFile, stat.size, stat.name);
+}
@@ -26,25 +26,39 @@
 class ZipArchive : public Archive
 {
 public:
-	ZipArchive() : zip(NULL) {}
 	~ZipArchive() override;

 	ArchiveFile* OpenFile(const char* name) override;
 	ArchiveFile* OpenFileByCrc(u32 crc) override;

-private:
-	bool Open(const char* path) override;
+	bool Open(FILE *file) override;
+	bool Open(const void *data, size_t size);

-	struct zip *zip;
+	ArchiveFile *OpenFirstFile();
+	ArchiveFile *OpenFileByIndex(size_t index);
+
+private:
+	zip_t *zip = nullptr;
 };

 class ZipArchiveFile : public ArchiveFile
 {
 public:
-	ZipArchiveFile(struct zip_file *zip_file) : zip_file(zip_file) {}
-	~ZipArchiveFile() override { zip_fclose(zip_file); }
+	ZipArchiveFile(zip_file_t *zip_file, size_t length, const char *name)
+		: zip_file(zip_file), _length(length), name(name) {}
+	~ZipArchiveFile() override {
+		zip_fclose(zip_file);
+	}
 	u32 Read(void* buffer, u32 length) override;
+	size_t length() override {
+		return _length;
+	}
+	const char *getName() override {
+		return name;
+	}

 private:
-	struct zip_file *zip_file;
+	zip_file_t *zip_file;
+	size_t _length;
+	const char *name;
 };
@@ -22,24 +22,61 @@
 #include "archive.h"
 #include "7zArchive.h"
 #include "ZipArchive.h"
+#include "oslib/storage.h"

-Archive *OpenArchive(const char *path)
+Archive *OpenArchive(const std::string& path)
 {
-	std::string base_path(path);
-
-	Archive *sz_archive = new SzArchive();
-	if (sz_archive->Open(base_path.c_str()) || sz_archive->Open((base_path + ".7z").c_str()) || sz_archive->Open((base_path + ".7Z").c_str()))
-		return sz_archive;
-	delete sz_archive;
-
+	FILE *file = nullptr;
+	hostfs::FileInfo fileInfo;
+	try {
+		fileInfo = hostfs::storage().getFileInfo(path);
+		if (!fileInfo.isDirectory)
+			file = hostfs::storage().openFile(path, "rb");
+	} catch (const hostfs::StorageException& e) {
+	}
+	if (file == nullptr)
+	{
+		file = hostfs::storage().openFile(path + ".7z", "rb");
+		if (file == nullptr)
+			file = hostfs::storage().openFile(path + ".7Z", "rb");
+	}
+	if (file != nullptr)
+	{
+		Archive *sz_archive = new SzArchive();
+		if (sz_archive->Open(file))
+			return sz_archive;
+		delete sz_archive;
+		file = nullptr;
+	}
+	// Retry as a zip file
+	try {
+		if (!fileInfo.isDirectory)
+			file = hostfs::storage().openFile(path, "rb");
+	} catch (const hostfs::StorageException& e) {
+	}
+	if (file == nullptr)
+	{
+		file = hostfs::storage().openFile(path + ".zip", "rb");
+		if (file == nullptr)
+		{
+			file = hostfs::storage().openFile(path + ".ZIP", "rb");
+			if (file == nullptr)
+				return nullptr;
+		}
+	}
 	Archive *zip_archive = new ZipArchive();
-	if (zip_archive->Open(base_path.c_str()) || zip_archive->Open((base_path + ".zip").c_str()) || zip_archive->Open((base_path + ".ZIP").c_str()))
+	if (zip_archive->Open(file))
 		return zip_archive;
 	delete zip_archive;

-	return NULL;
+	return nullptr;
 }

-
-
+bool Archive::Open(const char* path)
+{
+	FILE *file = nowide::fopen(path, "rb");
+	if (file == nullptr)
+		return false;
+	return Open(file);
+}

@@ -27,6 +27,8 @@ class ArchiveFile
 public:
 	virtual ~ArchiveFile() = default;
 	virtual u32 Read(void *buffer, u32 length) = 0;
+	virtual size_t length() = 0;
+	virtual const char *getName() { return nullptr; }
 };

 class Archive
@@ -36,10 +38,13 @@ public:
 	virtual ArchiveFile *OpenFile(const char *name) = 0;
 	virtual ArchiveFile *OpenFileByCrc(u32 crc) = 0;

-	friend Archive *OpenArchive(const char *path);
+protected:
+	virtual bool Open(FILE *file) = 0;

 private:
-	virtual bool Open(const char *name) = 0;
+	bool Open(const char *name);
+
+	friend Archive *OpenArchive(const std::string& path);
 };

-Archive *OpenArchive(const char *path);
+Archive *OpenArchive(const std::string& path);
@@ -19,15 +19,15 @@
 #include "rzip.h"
 #include <zlib.h>

+#include <cstring>
+
 const u8 RZipHeader[8] = { '#', 'R', 'Z', 'I', 'P', 'v', 1, '#' };

-bool RZipFile::Open(const std::string& path, bool write)
+bool RZipFile::Open(FILE *file, bool write)
 {
-	verify(file == nullptr);
-
-	file = nowide::fopen(path.c_str(), write ? "wb" : "rb");
-	if (file == nullptr)
-		return false;
+	verify(this->file == nullptr);
+	verify(file != nullptr);
+	startOffset = std::ftell(file);
 	if (!write)
 	{
 		u8 header[sizeof(RZipHeader)];
@@ -36,7 +36,7 @@ bool RZipFile::Open(const std::string& path, bool write)
 			|| std::fread(&maxChunkSize, sizeof(maxChunkSize), 1, file) != 1
 			|| std::fread(&size, sizeof(size), 1, file) != 1)
 		{
-			Close();
+			std::fseek(file, startOffset, SEEK_SET);
 			return false;
 		}
 		// savestates created on 32-bit platforms used to have a 32-bit size
@@ -49,7 +49,31 @@ bool RZipFile::Open(const std::string& path, bool write)
 		chunkIndex = 0;
 		chunkSize = 0;
 	}
+	else
+	{
+		maxChunkSize = 1_MB;
+		if (std::fwrite(RZipHeader, sizeof(RZipHeader), 1, file) != 1
+			|| std::fwrite(&maxChunkSize, sizeof(maxChunkSize), 1, file) != 1
+			|| std::fwrite(&size, sizeof(size), 1, file) != 1)
+		{
+			std::fseek(file, startOffset, SEEK_SET);
+			return false;
+		}
+	}
+	this->write = write;
+	this->file = file;
+	return true;
+}

+bool RZipFile::Open(const std::string& path, bool write)
+{
+	FILE *f = nowide::fopen(path.c_str(), write ? "wb" : "rb");
+	if (f == nullptr)
+		return false;
+	if (!Open(f, write)) {
+		Close();
+		return false;
+	}
 	return true;
 }

@@ -57,6 +81,11 @@ void RZipFile::Close()
 {
 	if (file != nullptr)
 	{
+		if (write)
+		{
+			std::fseek(file, startOffset + sizeof(RZipHeader) + sizeof(maxChunkSize), SEEK_SET);
+			std::fwrite(&size, sizeof(size), 1, file);
+		}
 		std::fclose(file);
 		file = nullptr;
 		if (chunk != nullptr)
@@ -70,6 +99,7 @@ void RZipFile::Close()
 size_t RZipFile::Read(void *data, size_t length)
 {
 	verify(file != nullptr);
+	verify(!write);

 	u8 *p = (u8 *)data;
 	size_t rv = 0;
@@ -99,7 +129,7 @@ size_t RZipFile::Read(void *data, size_t length)
 			delete [] zipped;
 			chunkSize = (u32)tl;
 		}
-		u32 l = std::min(chunkSize - chunkIndex, (u32)length);
+		u32 l = std::min(chunkSize - chunkIndex, (u32)(length - rv));
 		memcpy(p, chunk + chunkIndex, l);
 		p += l;
 		chunkIndex += l;
@@ -112,14 +142,9 @@ size_t RZipFile::Read(void *data, size_t length)
 size_t RZipFile::Write(const void *data, size_t length)
 {
 	verify(file != nullptr);
-	verify(std::ftell(file) == 0);
+	verify(write);

-	maxChunkSize = 1024 * 1024;
-	size = length;
-	if (std::fwrite(RZipHeader, sizeof(RZipHeader), 1, file) != 1
-		|| std::fwrite(&maxChunkSize, sizeof(maxChunkSize), 1, file) != 1
-		|| std::fwrite(&size, sizeof(size), 1, file) != 1)
-		return 0;
+	size += length;
 	const u8 *p = (const u8 *)data;
 	// compression output buffer must be 0.1% larger + 12 bytes
 	uLongf maxZippedSize = maxChunkSize + maxChunkSize / 1000 + 12;
@@ -28,6 +28,7 @@ public:
 	~RZipFile() { Close(); }

 	bool Open(const std::string& path, bool write);
+	bool Open(FILE *file, bool write);
 	void Close();
 	size_t Size() const { return size; }
 	size_t Read(void *data, size_t length);
@@ -41,4 +42,6 @@ private:
 	u8 *chunk = nullptr;
 	u32 chunkSize = 0;
 	u32 chunkIndex = 0;
+	bool write = false;
+	long startOffset = 0;
 };
@@ -0,0 +1,358 @@
+#if USE_ALSA
+#include "audiostream.h"
+#include <alsa/asoundlib.h>
+#include "cfg/cfg.h"
+#include "cfg/option.h"
+
+class AlsaAudioBackend : public AudioBackend
+{
+	snd_pcm_t *handle = nullptr;
+	bool pcm_blocking = true;
+	snd_pcm_uframes_t buffer_size = 0;
+	snd_pcm_uframes_t period_size = 0;
+	snd_pcm_t *handle_record = nullptr;
+
+public:
+	AlsaAudioBackend()
+		: AudioBackend("alsa", "Advanced Linux Sound Architecture") {}
+
+	bool init() override
+	{
+		snd_pcm_hw_params_t *params;
+
+		std::string device = cfgLoadStr("alsa", "device", "");
+
+		int rc = -1;
+		if (!device.empty() && device != "auto") {
+			rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
+			if (rc < 0)
+				WARN_LOG(AUDIO, "ALSA: Cannot open device %s. Trying auto", device.c_str());
+		}
+		if (rc < 0)
+		{
+			INFO_LOG(AUDIO, "ALSA: trying to determine audio device");
+
+			// trying default device
+			device = "default";
+			rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
+
+			// "default" didn't work, try first device
+			if (rc < 0)
+			{
+				device = "plughw:0,0,0";
+				rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
+
+				if (rc < 0)
+				{
+					device = "plughw:0,0";
+					rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
+				}
+			}
+
+			// first didn't work, try second
+			if (rc < 0)
+			{
+				device = "plughw:1,0";
+				rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
+			}
+
+			// try pulse audio backend
+			if (rc < 0)
+			{
+				device = "pulse";
+				rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
+			}
+
+			if (rc < 0)
+				INFO_LOG(AUDIO, "ALSA: unable to automatically determine audio device.");
+		}
+
+		if (rc < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: unable to open PCM device %s: %s", device.c_str(), snd_strerror(rc));
+			return false;
+		}
+
+		INFO_LOG(AUDIO, "ALSA: Successfully initialized \"%s\"", device.c_str());
+
+		/* Allocate a hardware parameters object. */
+		snd_pcm_hw_params_alloca(&params);
+
+		/* Fill it in with default values. */
+		rc=snd_pcm_hw_params_any(handle, params);
+		if (rc < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_any %s", snd_strerror(rc));
+			term();
+			return false;
+		}
+
+		/* Set the desired hardware parameters. */
+
+		/* Interleaved mode */
+		rc=snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
+		if (rc < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_access %s", snd_strerror(rc));
+			term();
+			return false;
+		}
+
+		/* Signed 16-bit little-endian format */
+		rc=snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);
+		if (rc < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_format %s", snd_strerror(rc));
+			term();
+			return false;
+		}
+
+		/* Two channels (stereo) */
+		rc=snd_pcm_hw_params_set_channels(handle, params, 2);
+		if (rc < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_channels %s", snd_strerror(rc));
+			term();
+			return false;
+		}
+
+		// 44100 samples/second
+		rc = snd_pcm_hw_params_set_rate(handle, params, 44100, 0);
+		if (rc < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_rate %s", snd_strerror(rc));
+			term();
+			return false;
+		}
+
+		// Period size (512)
+		period_size = std::min(SAMPLE_COUNT, (u32)config::AudioBufferSize / 4);
+		rc = snd_pcm_hw_params_set_period_size_near(handle, params, &period_size, nullptr);
+		if (rc < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_periods_near %s", snd_strerror(rc));
+			term();
+			return false;
+		}
+		INFO_LOG(AUDIO, "ALSA: period size set to %zd", (size_t)period_size);
+
+		// Sample buffer size
+		buffer_size = config::AudioBufferSize;
+		rc = snd_pcm_hw_params_set_buffer_size_near(handle, params, &buffer_size);
+		if (rc < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_buffer_size_near %s", snd_strerror(rc));
+			term();
+			return false;
+		}
+		INFO_LOG(AUDIO, "ALSA: buffer size set to %ld", buffer_size);
+
+		/* Write the parameters to the driver */
+		rc = snd_pcm_hw_params(handle, params);
+		if (rc < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Unable to set hw parameters: %s", snd_strerror(rc));
+			term();
+			return false;
+		}
+
+		return true;
+	}
+
+	bool initRecord(u32 sampling_freq) override
+	{
+		int err;
+		if ((err = snd_pcm_open(&handle_record, "default", SND_PCM_STREAM_CAPTURE, 0)) < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Cannot open default audio capture device: %s", snd_strerror(err));
+			return false;
+		}
+		snd_pcm_hw_params_t *hw_params;
+		if ((err = snd_pcm_hw_params_malloc(&hw_params)) < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Cannot allocate hardware parameter structure: %s", snd_strerror(err));
+			snd_pcm_close(handle_record);
+			return false;
+		}
+		if ((err = snd_pcm_hw_params_any(handle_record, hw_params)) < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Cannot initialize hardware parameter structure: %s", snd_strerror(err));
+			snd_pcm_hw_params_free(hw_params);
+			snd_pcm_close(handle_record);
+			return false;
+		}
+		if ((err = snd_pcm_hw_params_set_access(handle_record, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Cannot set access type: %s\n", snd_strerror(err));
+			snd_pcm_hw_params_free(hw_params);
+			snd_pcm_close(handle_record);
+			return false;
+		}
+		if ((err = snd_pcm_hw_params_set_format(handle_record, hw_params, SND_PCM_FORMAT_S16_LE)) < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Cannot set sample format: %s", snd_strerror(err));
+			snd_pcm_hw_params_free(hw_params);
+			snd_pcm_close(handle_record);
+			return false;
+		}
+		if ((err = snd_pcm_hw_params_set_rate(handle_record, hw_params, sampling_freq, 0)) < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Cannot set sample rate to %d Hz: %s", sampling_freq, snd_strerror(err));
+			snd_pcm_hw_params_free(hw_params);
+			snd_pcm_close(handle_record);
+			return false;
+		}
+		if ((err = snd_pcm_hw_params_set_channels(handle_record, hw_params, 1)) < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Cannot set channel count: %s", snd_strerror(err));
+			snd_pcm_hw_params_free(hw_params);
+			snd_pcm_close(handle_record);
+			return false;
+		}
+		if ((err = snd_pcm_hw_params(handle_record, hw_params)) < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Cannot set parameters: %s", snd_strerror(err));
+			snd_pcm_hw_params_free(hw_params);
+			snd_pcm_close(handle_record);
+			return false;
+		}
+		snd_pcm_hw_params_free(hw_params);
+		snd_pcm_nonblock(handle_record, 1);
+		if ((err = snd_pcm_prepare(handle_record)) < 0)
+		{
+			ERROR_LOG(AUDIO, "ALSA: Cannot prepare device: %s", snd_strerror(err));
+			snd_pcm_close(handle_record);
+			return false;
+		}
+		INFO_LOG(AUDIO, "ALSA: Successfully initialized capture device");
+
+		return true;
+	}
+
+	void termRecord() override
+	{
+		snd_pcm_close(handle_record);
+	}
+
+	u32 record(void* frame, u32 samples) override
+	{
+		int err = snd_pcm_readi(handle_record, frame, samples);
+		if (err < (int)samples)
+		{
+			if (err < 0)
+			{
+				DEBUG_LOG(AUDIO, "ALSA: Recording error: %s", snd_strerror(err));
+				err = 0;
+				err = snd_pcm_prepare(handle_record);
+			}
+			u8 *buffer = (u8 *)frame + err;
+			memset(buffer, 0, (samples - err) * 2);
+		}
+
+		return err;
+	}
+
+	u32 push(const void* frame, u32 samples, bool wait) override
+	{
+		if (wait != pcm_blocking) {
+			snd_pcm_nonblock(handle, wait ? 0 : 1);
+			pcm_blocking = wait;
+		}
+
+		int rc = snd_pcm_writei(handle, frame, samples);
+		if (rc < 0)
+		{
+			snd_pcm_recover(handle, rc, 1);
+			if (rc == -EPIPE)
+			{
+				// EPIPE means underrun
+				// Write some silence then our samples
+				const size_t silence_size = buffer_size - samples;
+				void *silence = alloca(silence_size * 4);
+				memset(silence, 0, silence_size * 4);
+				snd_pcm_writei(handle, silence, silence_size);
+				snd_pcm_writei(handle, frame, samples);
+			}
+		}
+		return 1;
+	}
+
+	void term() override
+	{
+		snd_pcm_drop(handle);
+		snd_pcm_close(handle);
+	}
+
+	std::vector<std::string> getDeviceList()
+	{
+		std::vector<std::string> result;
+
+		char **hints;
+		int err = snd_device_name_hint(-1, "pcm", (void***)&hints);
+
+		// Error initializing ALSA
+		if (err != 0)
+			return result;
+
+		// special value to automatically detect on initialization
+		result.emplace_back("auto");
+
+		char** n = hints;
+		while (*n != NULL)
+		{
+			// Get the type (NULL/Input/Output)
+			char *type = snd_device_name_get_hint(*n, "IOID");
+			char *name = snd_device_name_get_hint(*n, "NAME");
+
+			if (name != NULL)
+			{
+				// We only want output or special devices (like "default" or "pulse")
+				// TODO Only those with type == NULL?
+				if (type == NULL || strcmp(type, "Output") == 0)
+				{
+					// TODO Check if device works (however we need to hash the resulting list then)
+					/*snd_pcm_t *handle;
+					int rc = snd_pcm_open(&handle, name, SND_PCM_STREAM_PLAYBACK, 0);
+
+					if (rc == 0)
+					{
+						result.push_back(name);
+						snd_pcm_close(handle);
+					}
+					*/
+
+					result.emplace_back(name);
+				}
+
+			}
+
+			if (type != NULL)
+				free(type);
+
+			if (name != NULL)
+				free(name);
+
+			n++;
+		}
+
+		snd_device_name_free_hint((void**)hints);
+
+		return result;
+	}
+
+	Option* getOptions(int *count) override
+	{
+		*count = 1;
+		static Option result;
+
+		result.name = "device";
+		result.caption = "Device";
+		result.type = Option::list;
+		result.values = getDeviceList();
+
+		return &result;
+	}
+};
+static AlsaAudioBackend alsaBackend;
+
+#endif
@@ -0,0 +1,308 @@
+/*
+    Simple Core Audio backend for osx (and maybe ios?)
+    Based off various audio core samples and dolphin's code
+
+    This is part of the Reicast project, please consult the
+    LICENSE file for licensing & related information
+
+    This could do with some locking logic to avoid
+    race conditions, and some variable length buffer
+    logic to support chunk sizes other than 512 bytes
+
+    It does work on my macmini though
+ */
+#if defined(__APPLE__)
+#include "audiostream.h"
+#include "cfg/option.h"
+#include "stdclass.h"
+
+#include <atomic>
+
+#include <AudioUnit/AudioUnit.h>
+#include <AudioToolbox/AudioQueue.h>
+
+class CoreAudioBackend : public AudioBackend
+{
+	AudioUnit audioUnit;
+
+	u32 BUFSIZE = 0;
+	u8 *samples_temp = nullptr;
+
+	std::atomic<int> samples_wptr;
+	std::atomic<int> samples_rptr;
+	cResetEvent bufferEmpty;
+
+	// input buffer and indexes
+	u8 samples_input[2400];
+	static constexpr size_t InputBufSize = sizeof(samples_input);
+	std::atomic<int> input_wptr;
+	std::atomic<int> input_rptr;
+	AudioQueueRef recordQueue;
+
+	static OSStatus renderCallback(void* ctx, AudioUnitRenderActionFlags* flags, const AudioTimeStamp* ts,
+								UInt32 bus, UInt32 frames, AudioBufferList* abl)
+	{
+		CoreAudioBackend *backend = (CoreAudioBackend *)ctx;
+		for (int i = 0; i < abl->mNumberBuffers; i++)
+		{
+			int size = abl->mBuffers[i].mDataByteSize;
+			u8 *outBuffer = (u8 *)abl->mBuffers[i].mData;
+			while (size != 0)
+			{
+				int avail = (backend->samples_wptr - backend->samples_rptr + backend->BUFSIZE) % backend->BUFSIZE;
+				if (avail == 0)
+				{
+					//printf("Core Audio: buffer underrun %d bytes (%d)", size, abl->mBuffers[i].mDataByteSize);
+					memset(outBuffer, '\0', size);
+					return noErr;
+				}
+				avail = std::min(avail, size);
+				avail = std::min(avail, (int)backend->BUFSIZE - backend->samples_rptr);
+				memcpy(outBuffer, backend->samples_temp + backend->samples_rptr, avail);
+				backend->samples_rptr = (backend->samples_rptr + avail) % backend->BUFSIZE;
+				size -= avail;
+				outBuffer += avail;
+				// Set the mutex to allow writing
+				backend->bufferEmpty.Set();
+			}
+		}
+
+		return noErr;
+	}
+
+public:
+	CoreAudioBackend()
+		: AudioBackend("coreaudio", "Core Audio") {}
+
+	bool init() override
+	{
+		OSStatus err;
+		AURenderCallbackStruct callback_struct;
+		AudioStreamBasicDescription format;
+		AudioComponentDescription desc;
+		AudioComponent component;
+
+		desc.componentType = kAudioUnitType_Output;
+#if !defined(TARGET_IPHONE)
+		desc.componentSubType = kAudioUnitSubType_DefaultOutput;
+#else
+		desc.componentSubType = kAudioUnitSubType_RemoteIO;
+#endif
+		desc.componentFlags = 0;
+		desc.componentFlagsMask = 0;
+		desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+		component = AudioComponentFindNext(nullptr, &desc);
+
+		if (component == nullptr) {
+			ERROR_LOG(AUDIO, "coreaudio: AudioComponentFindNext failed");
+			return false;
+		}
+
+		err = AudioComponentInstanceNew(component, &audioUnit);
+		if (err != noErr) {
+			ERROR_LOG(AUDIO, "coreaudio: AudioComponentInstanceNew failed");
+			return false;
+		}
+
+		FillOutASBDForLPCM(format, 44100,
+						   2, 16, 16, false, false, false);
+		err = AudioUnitSetProperty(audioUnit,
+								   kAudioUnitProperty_StreamFormat,
+								   kAudioUnitScope_Input, 0, &format,
+								   sizeof(AudioStreamBasicDescription));
+		if (err != noErr)
+		{
+			ERROR_LOG(AUDIO, "coreaudio: AudioUnitSetProperty(kAudioUnitProperty_StreamFormat) failed");
+			AudioComponentInstanceDispose(audioUnit);
+			return false;
+		}
+
+		callback_struct.inputProc = renderCallback;
+		callback_struct.inputProcRefCon = this;
+		err = AudioUnitSetProperty(audioUnit,
+								   kAudioUnitProperty_SetRenderCallback,
+								   kAudioUnitScope_Input, 0, &callback_struct,
+								   sizeof callback_struct);
+		if (err != noErr)
+		{
+			ERROR_LOG(AUDIO, "coreaudio: AudioUnitSetProperty(kAudioUnitProperty_SetRenderCallback) failed");
+			AudioComponentInstanceDispose(audioUnit);
+			return false;
+		}
+
+		/*
+		err = AudioUnitSetParameter(audioUnit,
+									kHALOutputParam_Volume,
+									kAudioUnitParameterFlag_Output, 0,
+									1, 0);
+		verify(err == noErr);
+		*/
+
+		err = AudioUnitInitialize(audioUnit);
+		if (err != noErr)
+		{
+			ERROR_LOG(AUDIO, "coreaudio: AudioUnitInitialize failed");
+			AudioComponentInstanceDispose(audioUnit);
+			return false;
+		}
+
+		BUFSIZE = config::AudioBufferSize * 4;
+		samples_temp = new u8[BUFSIZE]();
+		samples_rptr = 0;
+		samples_wptr = 0;
+
+		err = AudioOutputUnitStart(audioUnit);
+		if (err != noErr)
+		{
+			ERROR_LOG(AUDIO, "coreaudio: AudioOutputUnitStart failed");
+			AudioUnitUninitialize(audioUnit);
+			AudioComponentInstanceDispose(audioUnit);
+			return false;
+		}
+
+		bufferEmpty.Set();
+
+		return true;
+	}
+
+	u32 push(const void* frame, u32 samples, bool wait) override
+	{
+		int size = samples * 4;
+		while (size != 0)
+		{
+			int avail = (samples_rptr - samples_wptr - 4 + BUFSIZE) % BUFSIZE;
+			if (avail == 0)
+			{
+				if (!wait)
+					break;
+				bufferEmpty.Wait();
+				continue;
+			}
+			avail = std::min(avail, size);
+			avail = std::min(avail, (int)BUFSIZE - samples_wptr);
+			memcpy(&samples_temp[samples_wptr], frame, avail);
+			samples_wptr = (samples_wptr + avail) % BUFSIZE;
+			frame = (u8 *)frame + avail;
+			size -= avail;
+		}
+	
+		return 1;
+	}
+
+	void term() override
+	{
+		AudioOutputUnitStop(audioUnit);
+		AudioUnitUninitialize(audioUnit);
+		AudioComponentInstanceDispose(audioUnit);
+		bufferEmpty.Set();
+		delete [] samples_temp;
+		samples_temp = nullptr;
+	}
+
+	static void recordCallback(void *inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer,
+			const AudioTimeStamp *inStartTime, UInt32 frameSize, const AudioStreamPacketDescription *dataFormat)
+	{
+		//DEBUG_LOG(AUDIO, "AudioQueue callback: wptr %d rptr %d bytes %d", (int)input_wptr, (int)input_rptr, inBuffer->mAudioDataByteSize);
+		CoreAudioBackend *backend = (CoreAudioBackend *)inUserData;
+		UInt32 size = inBuffer->mAudioDataByteSize;
+		UInt32 freeSpace = (backend->input_rptr - backend->input_wptr - 2 + InputBufSize) % InputBufSize;
+		if (size > freeSpace)
+		{
+			DEBUG_LOG(AUDIO, "coreaudio: record overrun %d bytes", size - freeSpace);
+			size = freeSpace;
+		}
+		while (size != 0)
+		{
+			UInt32 chunk = std::min(size, (UInt32)(InputBufSize - backend->input_wptr));
+			memcpy(backend->samples_input + backend->input_wptr, inBuffer->mAudioData, chunk);
+			backend->input_wptr = (backend->input_wptr + chunk) % InputBufSize;
+			size -= chunk;
+		}
+		AudioQueueEnqueueBuffer(backend->recordQueue, inBuffer, 0, nullptr);
+	}
+
+	void termRecord() override
+	{
+		if (recordQueue != nullptr)
+		{
+			AudioQueueStop(recordQueue, true);
+			AudioQueueDispose(recordQueue, true);
+			recordQueue = nullptr;
+		}
+	}
+
+	bool initRecord(u32 sampling_freq) override
+	{
+		AudioStreamBasicDescription desc{};
+		desc.mFormatID = kAudioFormatLinearPCM;
+		desc.mSampleRate = (double)sampling_freq;
+		desc.mChannelsPerFrame = 1;
+		desc.mBitsPerChannel = 16;
+		desc.mBytesPerPacket = desc.mBytesPerFrame = 2;
+		desc.mFramesPerPacket = 1;
+		desc.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked;
+		desc.mReserved = 0;
+	
+		OSStatus err = AudioQueueNewInput(&desc,
+						   recordCallback,
+						   this,
+						   nullptr,
+						   kCFRunLoopCommonModes,
+						   0,
+						   &recordQueue);
+		if (err != noErr)
+		{
+			ERROR_LOG(AUDIO, "AudioQueueNewInput failed: %d", err);
+			return false;
+		}
+
+		AudioQueueBufferRef buffers[2];
+		for (UInt32 i = 0; i < std::size(buffers) && err == noErr; i++)
+		{
+			err = AudioQueueAllocateBuffer(recordQueue, 480, &buffers[i]);
+			if (err == noErr)
+				err = AudioQueueEnqueueBuffer(recordQueue, buffers[i], 0, nullptr);
+		}
+		input_wptr = 0;
+		input_rptr = 0;
+		if (err == noErr)
+			err = AudioQueueStart(recordQueue, nullptr);
+		if (err != noErr)
+		{
+			ERROR_LOG(AUDIO, "AudioQueue init failed: %d", err);
+			termRecord();
+			return false;
+		}
+		INFO_LOG(AUDIO, "AudioQueue initialized - sample rate %f", desc.mSampleRate);
+
+		return true;
+	}
+
+	u32 record(void* frame, u32 samples) override
+	{
+	//	DEBUG_LOG(AUDIO, "coreaudio_record: wptr %d rptr %d", (int)input_wptr, (int)input_rptr);
+		u32 size = samples * 2;
+		while (size != 0)
+		{
+			u32 avail = (input_wptr - input_rptr + InputBufSize) % InputBufSize;
+			if (avail == 0)
+			{
+				DEBUG_LOG(AUDIO, "coreaudio: record underrun %d bytes", size);
+				break;
+			}
+			avail = std::min(avail, size);
+			avail = std::min(avail, (u32)(InputBufSize - input_rptr));
+
+			memcpy(frame, &samples_input[input_rptr], avail);
+			frame = (u8 *)frame + avail;
+			input_rptr = (input_rptr + avail) % InputBufSize;
+			size -= avail;
+		}
+
+		return samples - size / 2;
+	}
+};
+static CoreAudioBackend coreAudioBackend;
+
+
+#endif
@@ -0,0 +1,242 @@
+#include "build.h"
+#if defined(_WIN32) && !defined(TARGET_UWP)
+#include "audiostream.h"
+#include "cfg/option.h"
+#include <initguid.h>
+#include <dsound.h>
+#include <vector>
+#include <atomic>
+#include <thread>
+#include "stdclass.h"
+#include "windows/comptr.h"
+#include "oslib/oslib.h"
+
+HWND getNativeHwnd();
+#define verifyc(x) verify(!FAILED(x))
+
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(IDirectSoundBuffer8, 0x6825A449,0x7524,0x4D82,0x92,0x0F,0x50,0xE3,0x6A,0xB3,0xAB,0x1E);
+__CRT_UUID_DECL(IDirectSoundNotify,	0xB0210783,0x89cd,0x11d0,0xAF,0x08,0x00,0xA0,0xC9,0x25,0xCD,0x16);
+__CRT_UUID_DECL(IDirectSoundCaptureBuffer8, 0x00990DF4,0x0DBB,0x4872,0x83,0x3E,0x6D,0x30,0x3E,0x80,0xAE,0xB6);
+#else
+struct __declspec(uuid("{6825A449-7524-4D82-920F-50E36AB3AB1E}")) IDirectSoundBuffer8;
+struct __declspec(uuid("{B0210783-89cd-11d0-AF08-00A0C925CD16}")) IDirectSoundNotify;
+struct __declspec(uuid("{00990DF4-0DBB-4872-833E-6D303E80AEB6}")) IDirectSoundCaptureBuffer8;
+#endif
+
+class DirectSoundBackend : public AudioBackend
+{
+	ComPtr<IDirectSound8> dsound;
+	ComPtr<IDirectSoundBuffer8> buffer;
+	std::vector<HANDLE> notificationEvents;
+
+	ComPtr<IDirectSoundCapture8> dcapture;
+	ComPtr<IDirectSoundCaptureBuffer8> capture_buffer;
+
+	std::atomic_bool audioThreadRunning;
+	std::thread audioThread;
+	cResetEvent pushWait;
+
+	static constexpr u32 SAMPLE_BYTES = SAMPLE_COUNT * 4;
+
+	RingBuffer ringBuffer;
+
+	u32 notificationOffset(int index) {
+		return index * SAMPLE_BYTES;
+	}
+
+	void audioThreadMain()
+	{
+		ThreadName _("FlyDirectSound");
+		audioThreadRunning = true;
+		while (true)
+		{
+			u32 rv = WaitForMultipleObjects(notificationEvents.size(), &notificationEvents[0], false, 100);
+
+			if (!audioThreadRunning)
+				break;
+			if (rv == WAIT_TIMEOUT || rv == WAIT_FAILED)
+				continue;
+			rv -= WAIT_OBJECT_0;
+
+			void *p1, *p2;
+			DWORD sz1, sz2;
+
+			if (SUCCEEDED(buffer->Lock(notificationOffset(rv), SAMPLE_BYTES, &p1, &sz1, &p2, &sz2, 0)))
+			{
+				if (!ringBuffer.read((u8*)p1, sz1))
+					memset(p1, 0, sz1);
+				if (sz2 != 0)
+				{
+					if (!ringBuffer.read((u8*)p2, sz2))
+						memset(p2, 0, sz2);
+				}
+				buffer->Unlock(p1, sz1, p2, sz2);
+				pushWait.Set();
+			}
+		}
+	}
+
+public:
+	DirectSoundBackend()
+		: AudioBackend("directsound", "Microsoft DirectSound") {}
+
+	bool init() override
+	{
+		if (FAILED(DirectSoundCreate8(NULL, &dsound.get(), NULL))) {
+			ERROR_LOG(AUDIO, "DirectSound8 initialization failed");
+			return false;
+		}
+		if (FAILED(dsound->SetCooperativeLevel(getNativeHwnd(), DSSCL_PRIORITY))) {
+			ERROR_LOG(AUDIO, "DirectSound8 SetCooperativeLevel failed");
+			dsound.reset();
+			return false;
+		}
+
+		// Set up WAV format structure.
+		WAVEFORMATEX wfx;
+		memset(&wfx, 0, sizeof(WAVEFORMATEX));
+		wfx.wFormatTag = WAVE_FORMAT_PCM;
+		wfx.nChannels = 2;
+		wfx.nSamplesPerSec = 44100;
+		wfx.nBlockAlign = 4;
+		wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
+		wfx.wBitsPerSample = 16;
+
+		// Set up DSBUFFERDESC structure.
+		DSBUFFERDESC desc;
+		memset(&desc, 0, sizeof(DSBUFFERDESC));
+		desc.dwSize = sizeof(DSBUFFERDESC);
+		desc.dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_CTRLPOSITIONNOTIFY | DSBCAPS_GLOBALFOCUS;
+		desc.dwBufferBytes = SAMPLE_BYTES * 2;
+		desc.lpwfxFormat = &wfx;
+
+		// Create the buffer
+		ComPtr<IDirectSoundBuffer> buffer_;
+		if (FAILED(dsound->CreateSoundBuffer(&desc, &buffer_.get(), 0))
+				|| FAILED(buffer_.as(buffer)))
+		{
+			ERROR_LOG(AUDIO, "DirectSound8 CreateSoundBuffer failed");
+			dsound.reset();
+			return false;
+		}
+
+		// Set up notifications
+		ComPtr<IDirectSoundNotify> bufferNotify;
+		verifyc(buffer.as(bufferNotify));
+		notificationEvents.clear();
+		std::vector<DSBPOSITIONNOTIFY> posNotify;
+		for (int i = 0; notificationOffset(i) < desc.dwBufferBytes; i++)
+		{
+			notificationEvents.push_back(CreateEvent(nullptr, false, false, nullptr));
+			posNotify.push_back({ notificationOffset(i), notificationEvents.back() });
+		}
+		bufferNotify->SetNotificationPositions(posNotify.size(), &posNotify[0]);
+
+		// Clear the buffers
+		void *p1, *p2;
+		DWORD sz1, sz2;
+		verifyc(buffer->Lock(0, desc.dwBufferBytes, &p1, &sz1, &p2, &sz2, 0));
+		verify(p2 == nullptr);
+		memset(p1, 0, sz1);
+		verifyc(buffer->Unlock(p1, sz1, p2, sz2));
+		ringBuffer.setCapacity(config::AudioBufferSize * 4);
+
+		// Start the thread
+		audioThread = std::thread(&DirectSoundBackend::audioThreadMain, this);
+
+		// Play the buffer !
+		if (FAILED(buffer->Play(0, 0, DSBPLAY_LOOPING)))
+		{
+			ERROR_LOG(AUDIO, "DirectSound8 Play failed");
+			term();
+			return false;
+		}
+		INFO_LOG(AUDIO, "DirectSound playback started");
+
+		return true;
+	}
+
+	u32 push(const void* frame, u32 samples, bool wait) override
+	{
+		while (!ringBuffer.write((const u8 *)frame, samples * 4) && wait)
+			pushWait.Wait();
+
+		return 1;
+	}
+
+	void term() override
+	{
+		audioThreadRunning = false;
+		audioThread.join();
+		buffer->Stop();
+
+		for (HANDLE event : notificationEvents)
+			CloseHandle(event);
+		buffer.reset();
+		dsound.reset();
+		INFO_LOG(AUDIO, "DirectSound playback stopped");
+	}
+
+	bool initRecord(u32 sampling_freq) override
+	{
+		if (FAILED(DirectSoundCaptureCreate8(&DSDEVID_DefaultVoiceCapture, &dcapture.get(), NULL)))
+		{
+			ERROR_LOG(AUDIO, "DirectSound capture device creation failed");
+			return false;
+		}
+		HRESULT hr;
+		WAVEFORMATEX wfx =
+		{ WAVE_FORMAT_PCM, 1, sampling_freq, sampling_freq * 2, 2, 16, 0 };
+		// wFormatTag, nChannels, nSamplesPerSec, nAvgBytesPerSec,
+		// nBlockAlign, wBitsPerSample, cbSize
+
+		DSCBUFFERDESC dscbd;
+		dscbd.dwSize = sizeof(DSCBUFFERDESC);
+		dscbd.dwFlags = 0;
+		dscbd.dwBufferBytes = 480 * 2;
+		dscbd.dwReserved = 0;
+		dscbd.lpwfxFormat = &wfx;
+		dscbd.dwFXCount = 0;
+		dscbd.lpDSCFXDesc = NULL;
+
+		ComPtr<IDirectSoundCaptureBuffer> pDSCB;
+		if (FAILED(hr = dcapture->CreateCaptureBuffer(&dscbd, &pDSCB.get(), NULL)))
+		{
+			ERROR_LOG(AUDIO, "DirectSound capture buffer creation failed");
+			dcapture.reset();
+			return false;
+		}
+		pDSCB.as(capture_buffer);
+		capture_buffer->Start(DSCBSTART_LOOPING);
+		INFO_LOG(AUDIO, "DirectSound capture device and buffer created");
+
+		return true;
+	}
+
+	u32 record(void *buffer, u32 samples) override
+	{
+		DWORD readPos;
+		capture_buffer->GetCurrentPosition(NULL, &readPos);
+		void *p1, *p2;
+		DWORD p1bytes, p2bytes;
+		capture_buffer->Lock(readPos, samples * 2, &p1, &p1bytes, &p2, &p2bytes, 0);
+		memcpy(buffer, p1, p1bytes);
+		if (p2bytes > 0)
+			memcpy((u8 *)buffer + p1bytes, p2, p2bytes);
+		capture_buffer->Unlock(p1, p1bytes, p2, p2bytes);
+		return (p1bytes + p2bytes) / 2;
+	}
+
+	void termRecord() override
+	{
+		if (!dcapture)
+			return;
+		capture_buffer->Stop();
+		capture_buffer.reset();
+		dcapture.reset();
+	}
+};
+static DirectSoundBackend directSoundBackend;
+
+#endif
@@ -0,0 +1,54 @@
+#ifdef USE_LIBAO
+#include "audiostream.h"
+#include <ao/ao.h>
+
+class LibAOBackend : public AudioBackend
+{
+	ao_device *aodevice = nullptr;
+
+public:
+	LibAOBackend()
+		: AudioBackend("libao", "libao") {}
+
+	bool init() override
+	{
+		ao_initialize();
+
+		ao_sample_format aoformat {};
+		aoformat.bits = 16;
+		aoformat.channels = 2;
+		aoformat.rate = 44100;
+		aoformat.byte_format = AO_FMT_LITTLE;
+
+		aodevice = ao_open_live(ao_default_driver_id(), &aoformat, NULL); // Live output
+		if (aodevice == nullptr)
+			aodevice = ao_open_live(ao_driver_id("null"), &aoformat, NULL);
+		if (aodevice == nullptr) {
+			ERROR_LOG(AUDIO, "Cannot open libao driver");
+			ao_shutdown();
+		}
+
+		return aodevice != nullptr;
+	}
+
+	u32 push(const void* frame, u32 samples, bool wait) override
+	{
+		if (aodevice != nullptr)
+			ao_play(aodevice, (char*)frame, samples * 4);
+
+		return 1;
+	}
+
+	void term() override
+	{
+		if (aodevice != nullptr)
+		{
+			ao_close(aodevice);
+			aodevice = nullptr;
+			ao_shutdown();
+		}
+	}
+};
+static LibAOBackend libAOBackend;
+
+#endif
@@ -0,0 +1,54 @@
+#include "audiostream.h"
+
+#include <chrono>
+#include <thread>
+
+class NullAudioBackend : public AudioBackend
+{
+	using the_clock = std::chrono::high_resolution_clock;
+
+public:
+	NullAudioBackend()
+		: AudioBackend("null", "No Audio") {}
+
+	bool init() override
+	{
+		last_time = the_clock::time_point();
+		return true;
+	}
+
+	u32 push(const void* frame, u32 samples, bool wait) override
+	{
+		if (wait && last_time.time_since_epoch() != the_clock::duration::zero())
+		{
+			auto fduration = std::chrono::nanoseconds(1'000'000'000LL * samples / 44100);
+			auto duration = fduration - (the_clock::now() - last_time);
+			if (duration > std::chrono::nanoseconds::zero())
+				std::this_thread::sleep_for(duration);
+			if (duration < -std::chrono::milliseconds(67))
+				// if ~4 frames ahead, reset time (fast forward detection)
+				last_time = the_clock::now();
+			else
+				last_time += fduration;
+		}
+		else {
+			last_time = the_clock::now();
+		}
+		return 1;
+	}
+
+	bool initRecord(u32 sampling_freq) override
+	{
+		return true;
+	}
+
+	u32 record(void *buffer, u32 samples) override
+	{
+		memset(buffer, 0, samples * 2);
+		return samples;
+	}
+
+private:
+	the_clock::time_point last_time;
+};
+static NullAudioBackend nullBackend;
@@ -0,0 +1,201 @@
+/*
+	Copyright 2021 flyinghead
+
+	This file is part of Flycast.
+
+    Flycast is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    Flycast is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Flycast.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#ifdef USE_OBOE
+#include "audiostream.h"
+#include "cfg/option.h"
+#include <oboe/Oboe.h>
+#include <vector>
+#include <algorithm>
+#include <atomic>
+#include <memory>
+#include "stdclass.h"
+
+class OboeBackend : AudioBackend
+{
+	RingBuffer ringBuffer;
+	cResetEvent pushWait;
+
+	std::shared_ptr<oboe::AudioStream> stream;
+	std::shared_ptr<oboe::AudioStream> recordStream;
+
+	class AudioCallback : public oboe::AudioStreamDataCallback
+	{
+	public:
+		AudioCallback(OboeBackend *backend) : backend(backend) {}
+
+		oboe::DataCallbackResult onAudioReady(oboe::AudioStream *audioStream, void *audioData, int32_t numFrames) override
+		{
+			if (!backend->ringBuffer.read((u8 *)audioData, numFrames * 4))
+				// underrun
+				memset(audioData, 0, numFrames * 4);
+			backend->pushWait.Set();
+
+			return oboe::DataCallbackResult::Continue;
+		}
+
+		OboeBackend *backend;
+	};
+	AudioCallback audioCallback;
+
+	class AudioErrorCallback : public oboe::AudioStreamErrorCallback
+	{
+	public:
+		AudioErrorCallback(OboeBackend *backend) : backend(backend) {}
+
+		void onErrorAfterClose(oboe::AudioStream *stream, oboe::Result error) override
+		{
+			// Only attempt to recover if init was successful
+			if (backend->stream != nullptr)
+			{
+				WARN_LOG(AUDIO, "Audio device lost. Attempting to reopen the audio stream");
+				// the oboe stream is already closed so make sure we don't close it twice
+				backend->stream.reset();
+				backend->term();
+				backend->init();
+			}
+		}
+
+		OboeBackend *backend;
+	};
+	AudioErrorCallback errorCallback;
+
+public:
+	OboeBackend()
+		: AudioBackend("Oboe", "Automatic AAudio / OpenSL selection"), audioCallback(this), errorCallback(this) {}
+
+	bool init() override
+	{
+		// Actual capacity is size-1 to avoid overrun so add one buffer
+		ringBuffer.setCapacity((config::AudioBufferSize + SAMPLE_COUNT) * 4);
+
+		oboe::AudioStreamBuilder builder;
+		oboe::Result result = builder.setDirection(oboe::Direction::Output)
+				->setPerformanceMode(oboe::PerformanceMode::LowLatency)
+				->setSharingMode(oboe::SharingMode::Exclusive)
+				->setFormat(oboe::AudioFormat::I16)
+				->setChannelCount(oboe::ChannelCount::Stereo)
+				->setSampleRate(44100)
+				->setSampleRateConversionQuality(oboe::SampleRateConversionQuality::High)
+				->setFramesPerCallback(SAMPLE_COUNT)
+				->setDataCallback(&audioCallback)
+				->setErrorCallback(&errorCallback)
+				->setUsage(oboe::Usage::Game)
+				->openStream(stream);
+		if (result != oboe::Result::OK)
+		{
+			ERROR_LOG(AUDIO, "Oboe open stream failed: %s", oboe::convertToText(result));
+			return false;
+		}
+
+		if (stream->getAudioApi() == oboe::AudioApi::AAudio && config::AudioBufferSize < 1764)
+		{
+			// Reduce internal buffer for low latency (< 40 ms)
+			int bufSize = stream->getBufferSizeInFrames();
+			int burst = stream->getFramesPerBurst();
+			if (bufSize - burst > SAMPLE_COUNT)
+			{
+				while (bufSize - burst > SAMPLE_COUNT)
+					bufSize -= burst;
+				stream->setBufferSizeInFrames(bufSize);
+			}
+		}
+
+		stream->requestStart();
+		NOTICE_LOG(AUDIO, "Oboe driver started. stream capacity: %d frames, size: %d frames, frames/callback: %d, frames/burst: %d",
+				stream->getBufferCapacityInFrames(), stream->getBufferSizeInFrames(),
+				stream->getFramesPerCallback(), stream->getFramesPerBurst());
+
+		return true;
+	}
+
+	void term() override
+	{
+		NOTICE_LOG(AUDIO, "Oboe driver stopping");
+		if (stream != nullptr)
+		{
+			// Don't let the AudioErrorCallback term/reinit while we are stopping
+			// This won't prevent shit to hit the fan if it's already in the process
+			// of doing so but this is a pretty rare event and happens on devices
+			// that have audio issues already.
+			auto localStream = stream;
+			stream.reset();
+			localStream->stop();
+			localStream->close();
+		}
+	}
+
+	u32 push(const void* frame, u32 samples, bool wait) override
+	{
+		while (!ringBuffer.write((const u8 *)frame, samples * 4) && wait)
+			pushWait.Wait();
+
+		return 1;
+	}
+
+	void termRecord() override
+	{
+		if (recordStream != nullptr)
+		{
+			recordStream->stop();
+			recordStream->close();
+			recordStream.reset();
+		}
+		NOTICE_LOG(AUDIO, "Oboe recorder stopped");
+	}
+
+	bool initRecord(u32 sampling_freq) override
+	{
+		oboe::AudioStreamBuilder builder;
+		oboe::Result result = builder.setDirection(oboe::Direction::Input)
+			->setPerformanceMode(oboe::PerformanceMode::None)
+			->setSharingMode(oboe::SharingMode::Exclusive)
+			->setFormat(oboe::AudioFormat::I16)
+			->setChannelCount(oboe::ChannelCount::Mono)
+			->setSampleRate(sampling_freq)
+			->openStream(recordStream);
+		if (result != oboe::Result::OK)
+		{
+			ERROR_LOG(AUDIO, "Oboe open record stream failed: %s", oboe::convertToText(result));
+			return false;
+		}
+		recordStream->requestStart();
+		NOTICE_LOG(AUDIO, "Oboe recorder started. stream capacity: %d frames",
+				recordStream->getBufferCapacityInFrames());
+
+		return true;
+	}
+
+	u32 record(void *data, u32 samples) override
+	{
+		if (recordStream == nullptr)
+			return 0;
+		oboe::ResultWithValue<int32_t> result = recordStream->read(data, samples, 0);
+		if (result == oboe::Result::ErrorDisconnected)
+		{
+			WARN_LOG(AUDIO, "Recording device lost. Attempting to reopen the audio stream");
+			u32 sampleRate = recordStream->getSampleRate();
+			termRecord();
+			initRecord(sampleRate);
+		}
+		return std::max(0, result.value());
+	}
+};
+static OboeBackend oboeBackend;
+
+#endif
@@ -0,0 +1,337 @@
+#if USE_OMX
+#include "audiostream.h"
+#include "cfg/option.h"
+#include <IL/OMX_Broadcom.h>
+#include <unistd.h>
+
+#define PORT_INDEX 100
+#define OUTPUT_FREQ 44100
+
+class OMXAudioBackend : public AudioBackend
+{
+	OMX_HANDLETYPE omx_handle = nullptr;
+	OMX_STATETYPE omx_state = OMX_StateInvalid;
+	size_t audio_buffer_idx = 0;
+	OMX_BUFFERHEADERTYPE** audio_buffers = nullptr;
+	u32 latency_max = 0;
+	u32 buffer_count = 0;
+	u32 buffer_size = 0;
+	u32 buffer_length = 0;
+	pthread_mutex_t audio_lock;
+	pthread_cond_t omx_state_cond;
+
+	static OMX_ERRORTYPE eventHandler(
+			OMX_IN OMX_HANDLETYPE hComponent,
+			OMX_IN OMX_PTR pAppData,
+			OMX_IN OMX_EVENTTYPE eEvent,
+			OMX_IN OMX_U32 nData1,
+			OMX_IN OMX_U32 nData2,
+			OMX_IN OMX_PTR pEventData)
+	{
+		OMXAudioBackend *backend = (OMXAudioBackend *)pAddData;
+		pthread_mutex_lock(&backend->audio_lock);
+		if(eEvent == OMX_EventCmdComplete && nData1 == OMX_CommandStateSet)
+		{
+			backend->omx_state = (OMX_STATETYPE)nData2;
+			pthread_cond_signal(&backend->omx_state_cond);
+		}
+		pthread_mutex_unlock(&backend->audio_lock);
+		return OMX_ErrorNone;
+	}
+
+	static OMX_ERRORTYPE emptyBufferDone(
+			OMX_IN OMX_HANDLETYPE hComponent,
+			OMX_IN OMX_PTR pAppData,
+			OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
+	{
+		return OMX_ErrorNone;
+	}
+
+	static OMX_ERRORTYPE fillBufferDone(
+			OMX_OUT OMX_HANDLETYPE hComponent,
+			OMX_OUT OMX_PTR pAppData,
+			OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
+	{
+		return OMX_ErrorNone;
+	}
+
+	void waitForState(OMX_STATETYPE state)
+	{
+		pthread_mutex_lock(&audio_lock);
+		while(omx_state != state)
+			pthread_cond_wait(&omx_state_cond, &audio_lock);
+		pthread_mutex_unlock(&audio_lock);
+	}
+
+	u32 getLatency()
+	{
+		OMX_PARAM_U32TYPE param;
+		memset(&param, 0, sizeof(OMX_PARAM_U32TYPE));
+		param.nSize = sizeof(OMX_PARAM_U32TYPE);
+		param.nVersion.nVersion = OMX_VERSION;
+		param.nPortIndex = PORT_INDEX;
+
+		OMX_ERRORTYPE error = OMX_GetConfig(omx_handle, OMX_IndexConfigAudioRenderingLatency, &param);
+		if(error != OMX_ErrorNone)
+			WARN_LOG(AUDIO, "OMX: failed to get OMX configuration (OMX_IndexConfigAudioRenderingLatency). Error 0x%X", error);
+
+		return param.nU32 * 1000 / OUTPUT_FREQ;
+	}
+
+public:
+	OMXAudioBackend()
+		: AudioBackend("omx", "OpenMAX IL") {}
+
+	bool init() override
+	{
+		OMX_ERRORTYPE error;
+
+		error = OMX_Init();
+		if (error != OMX_ErrorNone)
+		{
+			WARN_LOG(AUDIO, "OMX: OMX_Init() failed. Error 0x%X", error);
+			return false;
+		}
+
+		// Initialize settings
+		latency_max = config::OmxAudioLatency;
+		buffer_size = config::AudioBufferSize * 4;
+		buffer_count = 2 + OUTPUT_FREQ * latency_max / (buffer_size * 1000);
+
+		OMX_CALLBACKTYPE callbacks;
+		callbacks.EventHandler = eventHandler;
+		callbacks.EmptyBufferDone = emptyBufferDone;
+		callbacks.FillBufferDone = fillBufferDone;
+
+		error = OMX_GetHandle(&omx_handle, (OMX_STRING)"OMX.broadcom.audio_render", this, &callbacks);
+		if (error != OMX_ErrorNone)
+		{
+			WARN_LOG(AUDIO, "OMX: OMX_GetHandle() failed. Error 0x%X", error);
+			OMX_Deinit();
+			return false;
+		}
+
+		OMX_PARAM_PORTDEFINITIONTYPE param;
+		memset(&param, 0, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
+		param.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
+		param.nVersion.nVersion = OMX_VERSION;
+		param.nPortIndex = PORT_INDEX;
+		param.nBufferSize = buffer_size;
+		param.nBufferCountActual = buffer_count;
+		param.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
+
+		error = OMX_SetParameter(omx_handle, OMX_IndexParamPortDefinition, &param);
+		if (error != OMX_ErrorNone)
+		{
+			WARN_LOG(AUDIO, "OMX: failed to set OMX_IndexParamPortDefinition. Error 0x%X", error);
+			OMX_Deinit();
+			return false;
+		}
+
+		OMX_AUDIO_PARAM_PCMMODETYPE pcm;
+		memset(&pcm, 0, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
+		pcm.nSize = sizeof(OMX_AUDIO_PARAM_PCMMODETYPE);
+		pcm.nVersion.nVersion = OMX_VERSION;
+		pcm.nPortIndex = PORT_INDEX;
+		pcm.nChannels = 2;
+		pcm.eNumData = OMX_NumericalDataSigned;
+		pcm.eEndian = OMX_EndianLittle;
+		pcm.nSamplingRate = OUTPUT_FREQ;
+		pcm.bInterleaved = OMX_TRUE;
+		pcm.nBitPerSample = 16;
+		pcm.ePCMMode = OMX_AUDIO_PCMModeLinear;
+		pcm.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
+		pcm.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
+
+		error = OMX_SetParameter(omx_handle, OMX_IndexParamAudioPcm, &pcm);
+		if (error != OMX_ErrorNone)
+		{
+			WARN_LOG(AUDIO, "OMX: failed to set OMX_IndexParamAudioPcm. Error 0x%X", error);
+			OMX_Deinit();
+			return false;
+		}
+
+		// Disable all ports
+		error = OMX_SendCommand(omx_handle, OMX_CommandPortDisable, PORT_INDEX, NULL);
+		if (error != OMX_ErrorNone)
+			WARN_LOG(AUDIO, "OMX: failed to do OMX_CommandPortDisable. Error 0x%X", error);
+
+		OMX_PORT_PARAM_TYPE param2;
+		memset(&param2, 0, sizeof(OMX_PORT_PARAM_TYPE));
+		param2.nSize = sizeof(OMX_PORT_PARAM_TYPE);
+		param2.nVersion.nVersion = OMX_VERSION;
+		error = OMX_GetParameter(omx_handle, OMX_IndexParamOtherInit, &param2);
+		if (error != OMX_ErrorNone)
+		{
+			WARN_LOG(AUDIO, "OMX: failed to get OMX_IndexParamOtherInit. Error 0x%X", error);
+		}
+		else
+		{
+			for(u32 i = 0; i < param2.nPorts; i++)
+			{
+				u32 port = param2.nStartPortNumber + i;
+				error = OMX_SendCommand(omx_handle, OMX_CommandPortDisable, port, NULL);
+				if(error != OMX_ErrorNone)
+					WARN_LOG(AUDIO, "OMX: failed to do OMX_CommandPortDisable on port %u. Error 0x%X", port, error);
+			}
+		}
+
+		// Go into idle state
+		error = OMX_SendCommand(omx_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
+		if (error != OMX_ErrorNone)
+		{
+			WARN_LOG(AUDIO, "OMX: failed to set OMX_CommandStateSet. Error 0x%X", error);
+			OMX_Deinit();
+			return false;
+		}
+		waitForState(OMX_StateIdle);
+
+		// Check if we're in a state able to recieve buffers
+		OMX_STATETYPE state;
+		error = OMX_GetState(omx_handle, &state);
+		if (error != OMX_ErrorNone || !(state == OMX_StateIdle || state == OMX_StateExecuting || state == OMX_StatePause))
+		{
+			WARN_LOG(AUDIO, "OMX: state is incorrect. State 0x%X; Error 0x%X", state, error);
+			OMX_Deinit();
+			return false;
+		}
+
+		// Create audio buffers
+		INFO_LOG(AUDIO, "OMX: creating %u buffers", buffer_count);
+
+		// Enable port
+		error = OMX_SendCommand(omx_handle, OMX_CommandPortEnable, PORT_INDEX, NULL);
+		if (error != OMX_ErrorNone)
+			WARN_LOG(AUDIO, "OMX: failed to do OMX_CommandPortEnable. Error 0x%X", error);
+
+		// Free audio buffers if they're allocated
+		if (audio_buffers != NULL)
+			delete[] audio_buffers;
+
+		// Allocate buffers
+		audio_buffers = new OMX_BUFFERHEADERTYPE*[buffer_count];
+		for (size_t i = 0; i < buffer_count; i++)
+		{
+			error = OMX_AllocateBuffer(omx_handle, &audio_buffers[i], PORT_INDEX, NULL, buffer_size);
+			if (error != OMX_ErrorNone)
+			{
+				WARN_LOG(AUDIO, "OMX: failed to allocate buffer[%u]. Error 0x%X", i, error);
+				OMX_Deinit();
+				return false;
+			}
+		}
+
+		// Set state to executing
+		error = OMX_SendCommand(omx_handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
+		if (error != OMX_ErrorNone)
+		{
+			WARN_LOG(AUDIO, "OMX: failed to do OMX_CommandStateSet. Error 0x%X", error);
+			OMX_Deinit();
+			return false;
+		}
+		waitForState(OMX_StateExecuting);
+
+		// Empty buffers
+		for (size_t i = 0; i < buffer_count; i++)
+		{
+			memset(audio_buffers[i]->pBuffer, 0, buffer_size);
+			audio_buffers[i]->nOffset = 0;
+			audio_buffers[i]->nFilledLen = buffer_size;
+
+			error = OMX_EmptyThisBuffer(omx_handle, audio_buffers[i]);
+			if(error != OMX_ErrorNone)
+				WARN_LOG(AUDIO, "OMX: failed to empty buffer[%u]. Error 0x%X", i, error);
+		}
+
+		const char* output_device = "local";
+		if (config::OmxAudioHdmi)
+			output_device = (const char*)"hdmi";
+
+		// Set audio destination
+		OMX_CONFIG_BRCMAUDIODESTINATIONTYPE ar_dest;
+		memset(&ar_dest, 0, sizeof(ar_dest));
+		ar_dest.nSize = sizeof(OMX_CONFIG_BRCMAUDIODESTINATIONTYPE);
+		ar_dest.nVersion.nVersion = OMX_VERSION;
+		strcpy((char *)ar_dest.sName, output_device);
+		error = OMX_SetConfig(omx_handle, OMX_IndexConfigBrcmAudioDestination, &ar_dest);
+		if (error != OMX_ErrorNone)
+		{
+			WARN_LOG(AUDIO, "OMX: failed to set OMX configuration (OMX_IndexConfigBrcmAudioDestination). Error 0x%X", error);
+			OMX_Deinit();
+			return false;
+		}
+
+		audio_buffer_idx = 0;
+		buffer_length = 0;
+
+		INFO_LOG(AUDIO, "OMX: audio output to '%s'", ar_dest.sName);
+
+		return true;
+	}
+
+	u32 push(const void* frame, u32 samples, bool wait) override
+	{
+		if(audio_buffers == NULL)
+			return 1;
+
+		size_t data_size = samples * 4;
+
+		while(data_size > 0)
+		{
+			size_t copy_size = std::min(buffer_size - buffer_length, data_size);
+
+			// Don't have more than maximum audio latency
+			u32 latency = getLatency();
+			if(latency > latency_max)
+			{
+				usleep((latency - latency_max) * 1000);
+			}
+			else if(latency == 0)
+			{
+				INFO_LOG(AUDIO, "OMX: underrun occurred");
+			}
+
+			memcpy(audio_buffers[audio_buffer_idx]->pBuffer + buffer_length, frame, copy_size);
+			buffer_length += copy_size;
+			frame = (char *)frame + copy_size;
+
+			// Flush buffer and swap
+			if(buffer_length >= buffer_size)
+			{
+				audio_buffers[audio_buffer_idx]->nOffset = 0;
+				audio_buffers[audio_buffer_idx]->nFilledLen = buffer_size;
+
+				OMX_ERRORTYPE error = OMX_EmptyThisBuffer(omx_handle, audio_buffers[audio_buffer_idx]);
+				if(error != OMX_ErrorNone)
+					INFO_LOG(AUDIO, "OMX: failed to empty buffer[%u]. Error 0x%X", audio_buffer_idx, error);
+
+				audio_buffer_idx = (audio_buffer_idx + 1) % buffer_count;
+				buffer_length = 0;
+			}
+
+			data_size -= copy_size;
+		}
+
+		return 1;
+	}
+
+	void term() override
+	{
+		OMX_ERRORTYPE error;
+
+		// Is there anything else that needs to be done for omx?
+
+		error = OMX_Deinit();
+		if(error != OMX_ErrorNone)
+			WARN_LOG(AUDIO, "OMX: OMX_Deinit() failed. Error 0x%X", error);
+
+		if(audio_buffers != NULL)
+		{
+			delete[] audio_buffers;
+			audio_buffers = NULL;
+		}
+	}
+};
+static OMXAudioBackend omxAudioBackend;
+
+#endif
@@ -0,0 +1,151 @@
+#ifdef USE_OSS
+#include "audiostream.h"
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/soundcard.h>
+#include <unistd.h>
+
+class OSSAudioBackend : public AudioBackend
+{
+	int audioFD = -1;
+	int recordFD = -1;
+
+	static int openDevice(int flags)
+	{
+		const char* path = "/dev/dsp";
+		int fd = open(path, flags);
+
+		if (fd < 0)
+			ERROR_LOG(AUDIO, "OSS: open(%s) failed: %s", path, strerror(errno));
+
+		return fd;
+	}
+
+	static bool setRate(int fd, int rate)
+	{
+		int tmp = rate;
+
+		if (ioctl(fd, SNDCTL_DSP_SPEED, &tmp) < 0)
+		{
+			ERROR_LOG(AUDIO, "OSS: ioctl(SNDCTL_DSP_SPEED) failed: %s", strerror(errno));
+			return false;
+		}
+
+		if (tmp != rate)
+		{
+			ERROR_LOG(AUDIO, "OSS: sample rate unsupported: %d => %d", rate, tmp);
+			return false;
+		}
+
+		return true;
+	}
+
+	static bool setChannels(int fd, int channels)
+	{
+		int tmp = channels;
+
+		if (ioctl(fd, SNDCTL_DSP_CHANNELS, &tmp) < 0)
+		{
+			ERROR_LOG(AUDIO, "OSS: ioctl(SNDCTL_DSP_CHANNELS) failed: %s", strerror(errno));
+			return false;
+		}
+
+		if (tmp != channels)
+		{
+			ERROR_LOG(AUDIO, "OSS: channels unsupported: %d => %d", channels, tmp);
+			return false;
+		}
+
+		return true;
+	}
+
+	static bool setFormat(int fd, int format)
+	{
+		int tmp = format;
+
+		if (ioctl(fd, SNDCTL_DSP_SETFMT, &tmp) < 0)
+		{
+			ERROR_LOG(AUDIO, "OSS: ioctl(SNDCTL_DSP_SETFMT) failed: %s", strerror(errno));
+			return false;
+		}
+
+		if (tmp != format)
+		{
+			ERROR_LOG(AUDIO, "OSS: sample format unsupported: %#.8x => %#.8x", format, tmp);
+			return false;
+		}
+
+		return true;
+	}
+
+public:
+	OSSAudioBackend()
+		: AudioBackend("oss", "Open Sound System") {}
+
+	bool init() override
+	{
+		audioFD = openDevice(O_WRONLY);
+
+		if (audioFD < 0 || !setRate(audioFD, 44100) || !setChannels(audioFD, 2) || !setFormat(audioFD, AFMT_S16_LE))
+		{
+			term();
+			return false;
+		}
+
+		return true;
+	}
+
+	u32 push(const void* frame, u32 samples, bool wait) override
+	{
+		write(audioFD, frame, samples * 4);
+		return 1;
+	}
+
+	void term() override
+	{
+		if (audioFD >= 0)
+			close(audioFD);
+		audioFD = -1;
+	}
+
+	// recording untested
+
+	bool initRecord(u32 sampling_freq) override
+	{
+		recordFD = openDevice(O_RDONLY);
+
+		if (recordFD < 0 || !setRate(recordFD, sampling_freq) || !setChannels(recordFD, 1) || !setFormat(recordFD, AFMT_S16_NE /* Native 16 bits */ ))
+		{
+			termRecord();
+			return false;
+		}
+
+		return true;
+	}
+
+	void termRecord() override
+	{
+		if (recordFD >= 0)
+			close(recordFD);
+		recordFD = -1;
+	}
+
+	u32 record(void *buffer, u32 samples) override
+	{
+		samples *= 2;
+		int l = read(recordFD, buffer, samples);
+		if (l < (int)samples)
+		{
+			if (l < 0)
+			{
+				INFO_LOG(AUDIO, "OSS: Recording error");
+				l = 0;
+			}
+			memset((u8 *)buffer + l, 0, samples - l);
+		}
+		return l / 2;
+	}
+};
+static OSSAudioBackend ossAudioBackend;
+
+#endif
@@ -0,0 +1,252 @@
+#ifdef USE_PULSEAUDIO
+#include "audiostream.h"
+#include "cfg/option.h"
+#include <pulse/pulseaudio.h>
+
+class PulseAudioBackend : public AudioBackend
+{
+	pa_threaded_mainloop *mainloop = nullptr;
+	pa_context *context = nullptr;
+	pa_stream *stream = nullptr;
+	pa_stream *record_stream = nullptr;
+
+	static void context_state_cb(pa_context *c, void *userdata)
+	{
+		PulseAudioBackend *backend = (PulseAudioBackend *)userdata;
+		switch (pa_context_get_state(c))
+		{
+		case PA_CONTEXT_READY:
+		case PA_CONTEXT_TERMINATED:
+		case PA_CONTEXT_FAILED:
+			pa_threaded_mainloop_signal(backend->mainloop, 0);
+			break;
+		default:
+			break;
+		}
+	}
+
+	static void stream_request_cb(pa_stream *s, size_t length, void *userdata)
+	{
+		PulseAudioBackend *backend = (PulseAudioBackend *)userdata;
+		pa_threaded_mainloop_signal(backend->mainloop, 0);
+	}
+
+public:
+	PulseAudioBackend()
+		: AudioBackend("pulse", "PulseAudio") {}
+
+	bool init() override
+	{
+		mainloop = pa_threaded_mainloop_new();
+		if (!mainloop)
+		{
+			WARN_LOG(AUDIO, "PulseAudio: pa_threaded_mainloop_new failed");
+			return false;
+		}
+		context = pa_context_new(pa_threaded_mainloop_get_api(mainloop), "flycast");
+		if (!context)
+		{
+			WARN_LOG(AUDIO, "PulseAudio: pa_context_new failed");
+			term();
+			return false;
+		}
+		pa_context_set_state_callback(context, context_state_cb, this);
+
+		if (pa_context_connect(context, nullptr, PA_CONTEXT_NOFLAGS, nullptr) < 0)
+		{
+			WARN_LOG(AUDIO, "PulseAudio: pa_context_connect failed");
+			term();
+			return false;
+		}
+
+		pa_threaded_mainloop_lock(mainloop);
+		if (pa_threaded_mainloop_start(mainloop) < 0)
+		{
+			WARN_LOG(AUDIO, "PulseAudio: pa_threaded_mainloop_start failed");
+			pa_threaded_mainloop_unlock(mainloop);
+			term();
+			return false;
+		}
+		pa_threaded_mainloop_wait(mainloop);
+
+		if (pa_context_get_state(context) != PA_CONTEXT_READY)
+		{
+			WARN_LOG(AUDIO, "PulseAudio: context isn't ready");
+			pa_threaded_mainloop_unlock(mainloop);
+			term();
+			return false;
+		}
+		pa_sample_spec spec{ PA_SAMPLE_S16LE, 44100, 2 };
+
+		stream = pa_stream_new(context, "audio", &spec, NULL);
+		if (!stream)
+		{
+			WARN_LOG(AUDIO, "PulseAudio: pa_stream_new failed");
+			pa_threaded_mainloop_unlock(mainloop);
+			term();
+			return false;
+		}
+
+		//pa_stream_set_state_callback(stream, stream_state_cb, this);
+		pa_stream_set_write_callback(stream, stream_request_cb, this);
+		//pa_stream_set_latency_update_callback(stream, stream_latency_update_cb, this);
+		//pa_stream_set_underflow_callback(stream, underrun_update_cb, this);
+		//pa_stream_set_buffer_attr_callback(stream, buffer_attr_cb, this);
+
+		pa_buffer_attr buffer_attr;
+		buffer_attr.maxlength = -1;
+		buffer_attr.tlength = pa_usec_to_bytes(config::AudioBufferSize * PA_USEC_PER_SEC / 44100, &spec);
+		buffer_attr.prebuf = -1;
+		buffer_attr.minreq = -1;
+		buffer_attr.fragsize = -1;
+
+		if (pa_stream_connect_playback(stream, nullptr, &buffer_attr, PA_STREAM_ADJUST_LATENCY, nullptr, nullptr) < 0)
+		{
+			WARN_LOG(AUDIO, "PulseAudio: pa_stream_connect_playback failed");
+			pa_threaded_mainloop_unlock(mainloop);
+			term();
+			return false;
+		}
+
+		pa_threaded_mainloop_wait(mainloop);
+
+		if (pa_stream_get_state(stream) != PA_STREAM_READY)
+		{
+			WARN_LOG(AUDIO, "PulseAudio: stream isn't ready");
+			pa_threaded_mainloop_unlock(mainloop);
+			term();
+			return false;
+		}
+
+		const pa_buffer_attr *server_attr = pa_stream_get_buffer_attr(stream);
+		if (server_attr)
+			DEBUG_LOG(AUDIO, "PulseAudio: requested %d samples buffer, got %d", buffer_attr.tlength / 4, server_attr->tlength / 4);
+
+		pa_threaded_mainloop_unlock(mainloop);
+
+		return true;
+	}
+
+	u32 push(const void* frame, u32 samples, bool wait) override
+	{
+		const u8 *buf = (const u8 *)frame;
+		size_t size = samples * 4;
+
+		pa_threaded_mainloop_lock(mainloop);
+		while (size)
+		{
+			size_t writable = std::min(size, pa_stream_writable_size(stream));
+
+			if (writable)
+			{
+				pa_stream_write(stream, buf, writable, NULL, 0, PA_SEEK_RELATIVE);
+				buf += writable;
+				size -= writable;
+			}
+			else if (wait)
+				pa_threaded_mainloop_wait(mainloop);
+			else
+				break;
+		}
+		pa_threaded_mainloop_unlock(mainloop);
+
+		return 0;
+	}
+
+	void term() override
+	{
+		if (mainloop)
+			pa_threaded_mainloop_stop(mainloop);
+
+		if (stream)
+		{
+			pa_stream_disconnect(stream);
+			pa_stream_unref(stream);
+			stream = nullptr;
+		}
+		if (context)
+		{
+			pa_context_disconnect(context);
+			pa_context_unref(context);
+			context = nullptr;
+		}
+
+		if (mainloop)
+			pa_threaded_mainloop_free(mainloop);
+		mainloop = nullptr;
+	}
+
+	bool initRecord(u32 sampling_freq) override
+	{
+		pa_sample_spec spec{ PA_SAMPLE_S16LE, sampling_freq, 1 };
+
+		record_stream = pa_stream_new(context, "record", &spec, NULL);
+		if (!record_stream)
+		{
+			INFO_LOG(AUDIO, "PulseAudio: pa_stream_new failed");
+			return false;
+		}
+
+		pa_threaded_mainloop_lock(mainloop);
+
+		pa_buffer_attr buffer_attr;
+		buffer_attr.fragsize = 240 * 2;
+		buffer_attr.maxlength = buffer_attr.fragsize * 2;
+
+		if (pa_stream_connect_record(record_stream, nullptr, &buffer_attr, PA_STREAM_NOFLAGS) < 0)
+		{
+			INFO_LOG(AUDIO, "PulseAudio: pa_stream_connect_record failed");
+			pa_stream_unref(record_stream);
+			record_stream = nullptr;
+			return false;
+		}
+		pa_threaded_mainloop_unlock(mainloop);
+		INFO_LOG(AUDIO, "PulseAudio: Successfully initialized capture device");
+
+		return true;
+	}
+
+	void termRecord() override
+	{
+		if (record_stream != nullptr)
+		{
+			pa_threaded_mainloop_lock(mainloop);
+			pa_stream_disconnect(record_stream);
+			pa_stream_unref(record_stream);
+			record_stream = nullptr;
+			pa_threaded_mainloop_unlock(mainloop);
+		}
+	}
+
+	u32 record(void *buffer, u32 samples) override
+	{
+		if (record_stream == nullptr)
+			return 0;
+		pa_threaded_mainloop_lock(mainloop);
+		const void *data;
+		size_t size;
+		if (pa_stream_peek(record_stream, &data, &size) < 0)
+		{
+			pa_threaded_mainloop_unlock(mainloop);
+			DEBUG_LOG(AUDIO, "PulseAudio: pa_stream_peek error");
+			return 0;
+		}
+		if (size == 0)
+		{
+			pa_threaded_mainloop_unlock(mainloop);
+			return 0;
+		}
+		size = std::min((size_t)samples * 2, size);
+		if (data != nullptr)
+			memcpy(buffer, data, size);
+		else
+			memset(buffer, 0, size);
+		pa_stream_drop(record_stream);
+		pa_threaded_mainloop_unlock(mainloop);
+
+		return size / 2;
+	}
+};
+static PulseAudioBackend pulseAudioBackend;
+
+#endif
@@ -0,0 +1,243 @@
+#if defined(USE_SDL_AUDIO)
+
+#include <SDL.h>
+#include "audiostream.h"
+#include "cfg/option.h"
+#include "stdclass.h"
+
+#include <algorithm>
+#include <atomic>
+#include <mutex>
+
+class SDLAudioBackend : AudioBackend
+{
+	SDL_AudioDeviceID audiodev {};
+	bool needs_resampling = false;
+	cResetEvent read_wait;
+	std::mutex stream_mutex;
+	uint32_t *sample_buffer;
+	unsigned sample_buffer_size = 0;
+	unsigned sample_count = 0;
+	SDL_AudioCVT audioCvt;
+
+	SDL_AudioDeviceID recorddev {};
+	u8 recordbuf[480 * 4];
+	std::atomic<size_t> rec_read;
+	std::atomic<size_t> rec_write;
+
+	static void audioCallback(void* userdata, Uint8* stream, int len)
+	{
+		SDLAudioBackend *backend = (SDLAudioBackend *)userdata;
+
+		backend->stream_mutex.lock();
+		// Wait until there's enough samples to feed the kraken
+		unsigned oslen = len / sizeof(uint32_t);
+		unsigned islen = backend->needs_resampling ? std::ceil(oslen / backend->audioCvt.len_ratio) : oslen;
+
+		if (backend->sample_count < islen)
+		{
+			// No data, just output a bit of silence for the underrun
+			memset(stream, 0, len);
+			backend->stream_mutex.unlock();
+			backend->read_wait.Set();
+			return;
+		}
+
+		if (!backend->needs_resampling) {
+			// Just copy bytes for this case.
+			memcpy(stream, &backend->sample_buffer[0], len);
+		}
+		else
+		{
+			SDL_AudioCVT& cvt = backend->audioCvt;
+			cvt.len = islen * sizeof(uint32_t);
+			memcpy(cvt.buf, &backend->sample_buffer[0], cvt.len);
+			SDL_ConvertAudio(&cvt);
+			memcpy(stream, cvt.buf, cvt.len_cvt);
+		}
+
+		// Move samples in the buffer and consume them
+		memmove(&backend->sample_buffer[0], &backend->sample_buffer[islen], (backend->sample_count - islen) * sizeof(uint32_t));
+		backend->sample_count -= islen;
+
+		backend->stream_mutex.unlock();
+		backend->read_wait.Set();
+	}
+
+public:
+	SDLAudioBackend()
+		: AudioBackend("sdl2", "Simple DirectMedia Layer 2 Audio") {}
+
+	bool init() override
+	{
+		if (!SDL_WasInit(SDL_INIT_AUDIO))
+		{
+			if (SDL_InitSubSystem(SDL_INIT_AUDIO)) {
+				ERROR_LOG(AUDIO, "SDL2 error initializing audio subsystem: %s", SDL_GetError());
+				return false;
+			}
+		}
+	
+		sample_buffer_size = std::max<u32>(SAMPLE_COUNT * 2, config::AudioBufferSize);
+		sample_buffer = new uint32_t[sample_buffer_size]();
+		sample_count = 0;
+
+		// Support 44.1KHz (native) but also upsampling to 48KHz
+		SDL_AudioSpec wav_spec, out_spec;
+		memset(&wav_spec, 0, sizeof(wav_spec));
+		wav_spec.freq = 44100;
+		wav_spec.format = AUDIO_S16;
+		wav_spec.channels = 2;
+		wav_spec.samples = SAMPLE_COUNT * 2;  // Must be power of two
+		wav_spec.callback = audioCallback;
+		wav_spec.userdata = this;
+		needs_resampling = false;
+
+		// Try 44.1KHz which should be faster since it's native.
+		audiodev = SDL_OpenAudioDevice(NULL, 0, &wav_spec, &out_spec, 0);
+		if (audiodev == 0)
+		{
+			INFO_LOG(AUDIO, "SDL2: SDL_OpenAudioDevice failed: %s", SDL_GetError());
+			needs_resampling = true;
+			wav_spec.freq = 48000;
+			audiodev = SDL_OpenAudioDevice(NULL, 0, &wav_spec, &out_spec, 0);
+			if (audiodev == 0)
+				ERROR_LOG(AUDIO, "SDL2: SDL_OpenAudioDevice failed: %s", SDL_GetError());
+			else
+			{
+				INFO_LOG(AUDIO, "SDL2: Using resampling to 48 KHz");
+				int ret = SDL_BuildAudioCVT(&audioCvt, AUDIO_S16, 2, 44100, AUDIO_S16, 2, 48000);
+				if (ret != 1 || audioCvt.needed == 0)
+				{
+					ERROR_LOG(AUDIO, "SDL2: can't build audio converter: %s", SDL_GetError());
+					SDL_CloseAudioDevice(audiodev);
+					audiodev = 0;
+				}
+				else
+				{
+					audioCvt.buf = new u8[SAMPLE_COUNT * 2 * sizeof(uint32_t) * audioCvt.len_mult];
+				}
+			}
+		}
+
+		return audiodev != 0;
+	}
+
+	u32 push(const void* frame, u32 samples, bool wait) override
+	{
+		// Unpause the device shall it be paused.
+		if (SDL_GetAudioDeviceStatus(audiodev) != SDL_AUDIO_PLAYING)
+			SDL_PauseAudioDevice(audiodev, 0);
+
+		// If wait, then wait for the buffer to be smaller than a certain size.
+		stream_mutex.lock();
+		if (wait) {
+			while (sample_count + samples > sample_buffer_size) {
+				stream_mutex.unlock();
+				read_wait.Wait();
+				stream_mutex.lock();
+			}
+		}
+
+		// Copy as many samples as possible, drop any remaining (this should not happen usually)
+		unsigned free_samples = sample_buffer_size - sample_count;
+		unsigned tocopy = samples < free_samples ? samples : free_samples;
+		memcpy(&sample_buffer[sample_count], frame, tocopy * sizeof(uint32_t));
+		sample_count += tocopy;
+		stream_mutex.unlock();
+
+		return 1;
+	}
+
+	void term() override
+	{
+		if (audiodev)
+		{
+			// Stop audio playback.
+			SDL_PauseAudioDevice(audiodev, 1);
+			read_wait.Set();
+			SDL_CloseAudioDevice(audiodev);
+			audiodev = SDL_AudioDeviceID();
+		}
+		delete [] sample_buffer;
+		sample_buffer = nullptr;
+		if (needs_resampling)
+		{
+			delete [] audioCvt.buf;
+			audioCvt.buf = nullptr;
+		}
+	}
+
+	static void recordCallback(void *userdata, u8 *stream, int len)
+	{
+		SDLAudioBackend *backend = (SDLAudioBackend *)userdata;
+		DEBUG_LOG(AUDIO, "SDL2: sdl2_record_cb len %d write %zd read %zd", len, (size_t)backend->rec_write, (size_t)backend->rec_read);
+		while (len > 0)
+		{
+			size_t plen = std::min((size_t)len, sizeof(backend->recordbuf) - backend->rec_write);
+			memcpy(&backend->recordbuf[backend->rec_write], stream, plen);
+			len -= plen;
+			backend->rec_write = (backend->rec_write + plen) % sizeof(backend->recordbuf);
+			stream += plen;
+		}
+	}
+
+	bool initRecord(u32 sampling_freq) override
+	{
+		rec_write = 0;
+		rec_read = 0;
+
+		SDL_AudioSpec wav_spec, out_spec;
+		memset(&wav_spec, 0, sizeof(wav_spec));
+		wav_spec.freq = sampling_freq;
+		wav_spec.format = AUDIO_S16;
+		wav_spec.channels = 1;
+		wav_spec.samples = 256;  // Must be power of two
+		wav_spec.callback = recordCallback;
+		wav_spec.userdata = this;
+		recorddev = SDL_OpenAudioDevice(NULL, 1, &wav_spec, &out_spec, 0);
+		if (recorddev == 0)
+		{
+			ERROR_LOG(AUDIO, "SDL2: Cannot open audio capture device: %s", SDL_GetError());
+			return false;
+		}
+		SDL_PauseAudioDevice(recorddev, 0);
+		INFO_LOG(AUDIO, "SDL2: opened audio capture device");
+
+		return true;
+	}
+
+	void termRecord() override
+	{
+		if (recorddev != 0)
+		{
+			SDL_PauseAudioDevice(recorddev, 1);
+			SDL_CloseAudioDevice(recorddev);
+			recorddev = 0;
+		}
+	}
+
+	u32 record(void* frame, u32 samples) override
+	{
+		u32 count = 0;
+		samples *= 2;
+		while (samples > 0)
+		{
+			u32 avail = std::min(rec_write - rec_read, sizeof(recordbuf) - rec_read);
+			if (avail == 0)
+				break;
+			avail = std::min(avail, samples);
+			memcpy((u8 *)frame + count, &recordbuf[rec_read], avail);
+			rec_read = (rec_read + avail) % sizeof(recordbuf);
+			samples -= avail;
+			count += avail;
+		}
+		DEBUG_LOG(AUDIO, "SDL2: sdl2_record len %d ret %d write %zd read %zd", samples * 2, count, (size_t)rec_write, (size_t)rec_read);
+
+		return count / 2;
+	}
+};
+static SDLAudioBackend sdlAudioBackend;
+
+#endif
+
@@ -0,0 +1,160 @@
+#include "audiostream.h"
+#include "cfg/option.h"
+#include "emulator.h"
+
+static void registerForEvents();
+
+struct SoundFrame { s16 l; s16 r; };
+
+static SoundFrame Buffer[SAMPLE_COUNT];
+static u32 writePtr;  // next sample index
+
+static AudioBackend *currentBackend;
+std::vector<AudioBackend *> *AudioBackend::backends;
+
+static bool audio_recording_started;
+static bool eight_khz;
+
+AudioBackend *AudioBackend::getBackend(const std::string& slug)
+{
+	if (backends == nullptr)
+		return nullptr;
+	if (slug == "auto")
+	{
+		// Prefer sdl2 if available and avoid the null driver
+		AudioBackend *sdlBackend = nullptr;
+		AudioBackend *autoBackend = nullptr;
+		for (auto backend : *backends)
+		{
+			if (backend->slug == "sdl2")
+				sdlBackend = backend;
+			if (backend->slug != "null" && autoBackend == nullptr)
+				autoBackend = backend;
+		}
+		if (sdlBackend != nullptr)
+			autoBackend = sdlBackend;
+		if (autoBackend == nullptr)
+			autoBackend = backends->front();
+		INFO_LOG(AUDIO, "Auto-selected audio backend \"%s\" (%s).", autoBackend->slug.c_str(), autoBackend->name.c_str());
+
+		return autoBackend;
+	}
+	for (auto backend : *backends)
+	{
+		if (backend->slug == slug)
+			return backend;
+	}
+	WARN_LOG(AUDIO, "WARNING: Audio backend \"%s\" not found!", slug.c_str());
+	return nullptr;
+}
+
+void WriteSample(s16 r, s16 l)
+{
+	Buffer[writePtr].r = r * config::AudioVolume.dbPower();
+	Buffer[writePtr].l = l * config::AudioVolume.dbPower();
+
+	if (++writePtr == SAMPLE_COUNT)
+	{
+		if (currentBackend != nullptr)
+			currentBackend->push(Buffer, SAMPLE_COUNT, config::LimitFPS);
+		writePtr = 0;
+	}
+}
+
+void InitAudio()
+{
+	registerForEvents();
+	TermAudio();
+
+	std::string slug = config::AudioBackend;
+	currentBackend = AudioBackend::getBackend(slug);
+	if (currentBackend == nullptr && slug != "auto")
+	{
+		slug = "auto";
+		currentBackend = AudioBackend::getBackend(slug);
+	}
+	if (currentBackend != nullptr)
+	{
+		INFO_LOG(AUDIO, "Initializing audio backend \"%s\" (%s)...", currentBackend->slug.c_str(), currentBackend->name.c_str());
+		if (!currentBackend->init())
+		{
+			currentBackend = nullptr;
+			if (slug != "auto")
+			{
+				WARN_LOG(AUDIO, "Audio driver %s failed to initialize. Defaulting to 'auto'", slug.c_str());
+				slug = "auto";
+				currentBackend = AudioBackend::getBackend(slug);
+				if (!currentBackend->init())
+					currentBackend = nullptr;
+			}
+		}
+	}
+
+	if (currentBackend == nullptr)
+	{
+		WARN_LOG(AUDIO, "Running without audio!");
+		return;
+	}
+
+	if (audio_recording_started)
+	{
+		// Restart recording
+		audio_recording_started = false;
+		StartAudioRecording(eight_khz);
+	}
+}
+
+void TermAudio()
+{
+	if (currentBackend == nullptr)
+		return;
+
+	// Save recording state before stopping
+	bool rec_started = audio_recording_started;
+	StopAudioRecording();
+	audio_recording_started = rec_started;
+	currentBackend->term();
+	INFO_LOG(AUDIO, "Terminating audio backend \"%s\" (%s)...", currentBackend->slug.c_str(), currentBackend->name.c_str());
+	currentBackend = nullptr;
+}
+
+void StartAudioRecording(bool eight_khz)
+{
+	::eight_khz = eight_khz;
+	if (currentBackend != nullptr)
+		audio_recording_started = currentBackend->initRecord(eight_khz ? 8000 : 11025);
+	else
+		// might be called between TermAudio/InitAudio
+		audio_recording_started = true;
+}
+
+u32 RecordAudio(void *buffer, u32 samples)
+{
+	if (!audio_recording_started || currentBackend == nullptr)
+		return 0;
+	return currentBackend->record(buffer, samples);
+}
+
+void StopAudioRecording()
+{
+	// might be called between TermAudio/InitAudio
+	if (audio_recording_started && currentBackend != nullptr)
+		currentBackend->termRecord();
+	audio_recording_started = false;
+}
+
+static void registerForEvents()
+{
+	static bool done;
+	if (done)
+		return;
+	done = true;
+	// Empty the audio buffer when loading a state or terminating the game
+	const auto& callback = [](Event, void *) {
+		writePtr = 0;
+	};
+	EventManager::listen(Event::Terminate, callback);
+	EventManager::listen(Event::LoadState, callback);
+}
+
+
@@ -0,0 +1,131 @@
+#pragma once
+#include "types.h"
+
+#include <algorithm>
+#include <atomic>
+#include <cstring>
+#include <string>
+#include <vector>
+
+class AudioBackend
+{
+public:
+	virtual ~AudioBackend() = default;
+
+	virtual bool init() = 0;
+	virtual u32 push(const void *data, u32 frames, bool wait) = 0;
+	virtual void term() {}
+
+	struct Option {
+		std::string name;
+		std::string caption;
+		enum { integer, checkbox, list } type;
+
+		int minValue;
+		int maxValue;
+		std::vector<std::string> values;
+	};
+	virtual const Option *getOptions(int *count) {
+		*count = 0;
+		return nullptr;
+	}
+
+	virtual bool initRecord(u32 sampling_freq) { return false; }
+	virtual u32 record(void *, u32) { return 0; }
+	virtual void termRecord() {}
+
+	std::string slug;
+	std::string name;
+
+	static size_t getCount() { return backends == nullptr ? 0 : backends->size(); }
+	static AudioBackend *getBackend(size_t index) { return backends == nullptr ? nullptr : (*backends)[index]; }
+	static AudioBackend *getBackend(const std::string& slug);
+
+protected:
+	AudioBackend(const std::string& slug, const std::string& name)
+		: slug(slug), name(name) {
+		registerAudioBackend(this);
+	}
+
+private:
+	static void registerAudioBackend(AudioBackend *backend)
+	{
+		if (backends == nullptr)
+			backends = new std::vector<AudioBackend *>();
+		backends->push_back(backend);
+		std::sort(backends->begin(), backends->end(), [](AudioBackend *b1, AudioBackend *b2) { return b1->slug < b2->slug; });
+	}
+
+	static std::vector<AudioBackend *> *backends;
+};
+
+void InitAudio();
+void TermAudio();
+void WriteSample(s16 right, s16 left);
+
+void StartAudioRecording(bool eight_khz);
+u32 RecordAudio(void *buffer, u32 samples);
+void StopAudioRecording();
+
+constexpr u32 SAMPLE_COUNT = 512;	// AudioBackend::push() is always called with that many frames
+
+class RingBuffer
+{
+	std::vector<u8> buffer;
+	std::atomic_int readCursor { 0 };
+	std::atomic_int writeCursor { 0 };
+
+	u32 readSize() {
+		return (u32)((writeCursor - readCursor + buffer.size()) % buffer.size());
+	}
+	u32 writeSize() {
+		return (u32)((readCursor - writeCursor + buffer.size() - 1) % buffer.size());
+	}
+
+public:
+	bool write(const u8 *data, u32 size)
+	{
+		if (size > writeSize())
+			return false;
+		u32 wc = writeCursor;
+		u32 chunkSize = std::min<u32>(size, (u32)buffer.size() - wc);
+		memcpy(&buffer[wc], data, chunkSize);
+		wc = (wc + chunkSize) % buffer.size();
+		size -= chunkSize;
+		if (size > 0)
+		{
+			data += chunkSize;
+			memcpy(&buffer[wc], data, size);
+			wc = (wc + size) % buffer.size();
+		}
+		writeCursor = wc;
+		return true;
+	}
+
+	bool read(u8 *data, u32 size)
+	{
+		if (size > readSize())
+			return false;
+		u32 rc = readCursor;
+		u32 chunkSize = std::min<u32>(size, (u32)buffer.size() - rc);
+		memcpy(data, &buffer[rc], chunkSize);
+		rc = (rc + chunkSize) % buffer.size();
+		size -= chunkSize;
+		if (size > 0)
+		{
+			data += chunkSize;
+			memcpy(data, &buffer[rc], size);
+			rc = (rc + size) % buffer.size();
+		}
+		readCursor = rc;
+		return true;
+	}
+
+	void setCapacity(size_t size)
+	{
+		std::fill(buffer.begin(), buffer.end(), 0);
+		buffer.resize(size);
+		readCursor = 0;
+		writeCursor = 0;
+	}
+};
@@ -1,151 +1,26 @@
-/*
-	reicast build options
-
-		Reicast can support a lot of stuff, and this is an attempt
-		to organize the build time options
-
-		Option categories
-
-			BUILD_* - BUILD_COMPILER, etc...
-				definitions about the build machine
-
-			HOST_*	
-				definitions about the host machine
-
-			FEAT_*
-				definitions about the features that this build targets
-				This is higly related to HOST_*, but it's for options that might
-				or might not be avaiable depending on the target host, or that 
-				features that are irrelevant of	the host
-
-				Eg, Alsa, Pulse Audio and OSS might sense as HOST dedinitions
-				but it usually makes more sense to detect them as runtime. In
-				that context, HOST_ALSA makes no sense because the host might
-				or might not have alsa installed/ running
-
-				MMU makes no sense as a HOST definition at all, so it should
-				be FEAT_HAS_MMU
-
-			TARGET_*
-				A preconfigured default. Eg TARGET_WIN86. 
-
-		Naming of options, option values, and how to use them
-			
-			for options that makes sense to have a list of values
-				{CATEGORY}_{OPTION} 
-				{OPTION}_{VALUE}
-
-				eg.
-				BUILD_COMPILER == COMPILER_GCC, HOST_CPU != CPU_X64, ...
-
-			for options that are boolean
-				{CATEGORY}_IS_{OPTION} or {CATEGORY}_HAS_{OPTION} 
-				
-				Evaluates to 0 or 1
-
-			If an configuration cannot be neatly split into a set of
-			of orthogonal options, then it makes sense to break things
-			to "sets" or have a hierarchy of options. 
-
-			Example
-			-------
-			
-			In the beggining it made sense to have an audio backend
-			per operating system. It made sense to have it depend 
-			on HOST_OS and seleect DirectSound or alsa. 
-
-				// no option needed
-
-			Then, as android was introduced, which also uses OS_LINUX
-			atm, the audio could have been made an option. It could be
-			a HOST_* option, or FEAT_* one. I'd prefer FEAT_*. 
-			FEAT_* makes more sense as future wise we might want
-			to support multiple backends.
-				
-				FEAT_AUDIO_BACKEND
-					AUDIO_BACKEND_NONE
-					AUDIO_BACKEND_DS
-					AUDIO_BACKEND_ALSA
-					AUDIO_BACKEND_ANDROID
-
-				Used like
-					#if FEAT_AUDIO_BACKEND == AUDIO_BACKEND_DS ....
-			
-			At some point, we might have multiple audio backends that
-			can be compiled in and autodetected/selected at runtime.
-			In that case, it might make sense to have the options like
-
-					FEAT_HAS_ALSA
-					FEAT_HAS_DIRECTSOUND
-					FEAT_HAS_ANDROID_AUDIO
-
-				or 
-					FEAT_HAS_AUDIO_ALSA
-					FEAT_HAS_AUDIO_DS
-					FEAT_HAS_AUDIO_ANDROID
-
-				The none option might or might not make sense. In this
-				case it can be removed, as it should always be avaiable.
-
-			Guidelines
-			----------
-
-			General rule of thumb, don't overcomplicate things. Start
-			with a simple option, and then make it more complicated
-			as new uses apply (see the example above)
-
-			Don't use too long names, don't use too cryptic names. 
-			Most team developers should be able to understand or
-			figure out most of the acronyms used. 
-
-			Try to be consistent on the acronyms across all definitions
-
-			Code shouldn't depend on build level options whenever possible
-
-			Generally, the file should compile even if the option/module is
-			disabled. This makes makefiles etc much easier to write
-
-			TARGET_* options should generally only be used in this file
-
-			The current source is *not* good example of these guidelines
-
-		We'll try to be smart and figure out some options/defaults on this file
-		but this shouldn't get too complicated
-
-
-*/
-
+#pragma once
 //#define STRICT_MODE
 #ifndef STRICT_MODE
 #define FAST_MMU
 #define USE_WINCE_HACK
 #endif

-#define DC_PLATFORM_MASK        7
-#define DC_PLATFORM_DREAMCAST   0   /* Works, for the most part */
-#define DC_PLATFORM_DEV_UNIT    1   /* This is missing hardware */
-#define DC_PLATFORM_NAOMI       2   /* Works, for the most part */ 
-#define DC_PLATFORM_NAOMI2      3   /* Needs to be done, 2xsh4 + 2xpvr + custom TNL */
-#define DC_PLATFORM_ATOMISWAVE  4   /* Works, for the most part */
-#define DC_PLATFORM_HIKARU      5   /* Needs to be done, 2xsh4, 2x aica , custom vpu */
-#define DC_PLATFORM_AURORA      6   /* Needs to be done, Uses newer 300 mhz sh4 + 150 mhz pvr mbx SoC */
+#define DC_PLATFORM_DREAMCAST   0
+#define DC_PLATFORM_DEV_UNIT    1
+#define DC_PLATFORM_NAOMI       2
+#define DC_PLATFORM_NAOMI2      3
+#define DC_PLATFORM_ATOMISWAVE  4
+#define DC_PLATFORM_SYSTEMSP    5

 //HOST_CPU
 #define CPU_X86      0x20000001
 #define CPU_ARM      0x20000002
-#define CPU_MIPS     0x20000003
+#define CPU_ARM64    0x20000003
 #define CPU_X64      0x20000004
-#define CPU_GENERIC  0x20000005 //used for pnacl, emscripten, etc
-#define CPU_PPC      0x20000006
-#define CPU_PPC64    0x20000007
-#define CPU_ARM64    0x20000008
-#define CPU_MIPS64   0x20000009

 //FEAT_SHREC, FEAT_AREC, FEAT_DSPREC
 #define DYNAREC_NONE	0x40000001
 #define DYNAREC_JIT		0x40000002
-#define DYNAREC_CPP		0x40000003
-

 //automatic

@@ -157,10 +32,19 @@
 	#define HOST_CPU CPU_ARM
 #elif defined(__aarch64__) || defined(_M_ARM64)
 	#define HOST_CPU CPU_ARM64
-#elif defined(__mips__)
-	#define HOST_CPU CPU_MIPS
 #else
-	#define HOST_CPU CPU_GENERIC
+	#error Unsupported architecture
+#endif
+
+#if defined(__APPLE__)
+#include "TargetConditionals.h"
+#if TARGET_OS_SIMULATOR
+// iOS simulator
+#define TARGET_NO_REC
+#endif
+#if defined(TARGET_MAC) && HOST_CPU == CPU_ARM64
+#define TARGET_ARM_MAC
+#endif
 #endif

 #if defined(TARGET_NO_REC)
@@ -175,12 +59,6 @@
 #define FEAT_DSPREC DYNAREC_NONE
 #endif

-#if defined(TARGET_NO_JIT)
-#define FEAT_SHREC DYNAREC_CPP
-#define FEAT_AREC DYNAREC_NONE
-#define FEAT_DSPREC DYNAREC_NONE
-#endif
-
 #ifdef __SWITCH__
 #define FEAT_NO_RWX_PAGES
 #endif
@@ -222,31 +100,26 @@
 #if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
 #define TARGET_UWP
 #endif
-#if !defined(LIBRETRO) && !defined(TARGET_UWP)
-#define USE_DX9
+#ifdef HAVE_D3D11
+#define USE_DX11
 #endif
 #endif

-
-#if !defined(LIBRETRO) && !defined(TARGET_NO_EXCEPTIONS)
+#if !defined(LIBRETRO)
 #define USE_GGPO
 #endif

+#if !defined(__ANDROID__) && !defined(TARGET_IPHONE) && !defined(TARGET_UWP) \
+	&& !defined(__SWITCH__) && !defined(LIBRETRO) && !defined(__NetBSD__) && !defined(__OpenBSD__)
+#define NAOMI_MULTIBOARD
+#endif
+
 // TARGET PLATFORM
-
-#define RAM_SIZE_MAX (32*1024*1024)
-#define VRAM_SIZE_MAX (16*1024*1024)
-#define ARAM_SIZE_MAX (8*1024*1024)
-
-#define GD_CLOCK 33868800				//GDROM XTAL -- 768fs
-
-#define AICA_CORE_CLOCK (GD_CLOCK*4/3)		//[45158400]  GD->PLL 3:4 -> AICA CORE	 -- 1024fs
-#define ADAC_CLOCK (AICA_CORE_CLOCK/4)		//[11289600]  44100*256, AICA CORE -> PLL 4:1 -> ADAC -- 256fs
-#define AICA_ARM_CLOCK (AICA_CORE_CLOCK/2)	//[22579200]  AICA CORE -> PLL 2:1 -> ARM
-#define AICA_SDRAM_CLOCK (GD_CLOCK*2)		//[67737600]  GD-> PLL 2 -> SDRAM
-#define SH4_MAIN_CLOCK (200*1000*1000)		//[200000000] XTal(13.5) -> PLL (33.3) -> PLL 1:6 (200)
-#define SH4_RAM_CLOCK (100*1000*1000)		//[100000000] XTal(13.5) -> PLL (33.3) -> PLL 1:3 (100)	, also suplied to HOLLY chip
-#define G2_BUS_CLOCK (25*1000*1000)			//[25000000]  from Holly, from SH4_RAM_CLOCK w/ 2 2:1 plls
+#define GD_CLOCK 33868800						//GDROM XTAL -- 768fs
+#define AICA_CORE_CLOCK (GD_CLOCK * 4 / 3)		//[45158400]  GD->PLL 3:4 -> AICA CORE	 -- 1024fs
+#define AICA_ARM_CLOCK (AICA_CORE_CLOCK / 2)	//[22579200]  AICA CORE -> PLL 2:1 -> ARM
+#define SH4_MAIN_CLOCK (200 * 1000 * 1000)		//[200000000] XTal(13.5) -> PLL (33.3) -> PLL 1:6 (200)
+#define G2_BUS_CLOCK (25 * 1000 * 1000)			//[25000000]  from Holly, from SH4_RAM_CLOCK w/ 2 2:1 plls

 #if defined(GLES) && !defined(GLES3) && !defined(GLES2)
 // Only use GL ES 2.0 API functions
@@ -82,6 +82,13 @@ s32 cfgLoadInt(const std::string& section, const std::string& key, s32 def)
 	return cfgdb.get_int(section, key, def);
 }

+int64_t cfgLoadInt64(const std::string& section, const std::string& key, int64_t def) {
+	return cfgdb.get_int64(section, key, def);
+}
+void cfgSaveInt64(const std::string& section, const std::string& key, int64_t value) {
+	cfgdb.set_int64(section, key, value);
+}
+
 void  cfgSaveBool(const std::string& section, const std::string& key, bool value)
 {
 	cfgSaveStr(section, key, value ? "yes" : "no");
@@ -112,9 +119,23 @@ void cfgDeleteSection(const std::string& section)
 	cfgdb.delete_section(section);
 }

+void cfgDeleteEntry(const std::string& section, const std::string& key)
+{
+	cfgdb.delete_entry(section, key);
+}
+
 void cfgSetAutoSave(bool autoSave)
 {
 	::autoSave = autoSave;
 	if (autoSave)
 		saveConfigFile();
 }
+
+void cfgSaveFloat(const std::string& section, const std::string& key, float value)
+{
+	cfgdb.set_float(section, key, value);
+}
+float cfgLoadFloat(const std::string& section, const std::string& key, float def)
+{
+	return cfgdb.get_float(section, key, def);
+}
@@ -5,15 +5,20 @@
 bool cfgOpen();
 s32 cfgLoadInt(const std::string& section, const std::string& key, s32 def);
 void cfgSaveInt(const std::string& section, const std::string& key, s32 value);
+int64_t cfgLoadInt64(const std::string& section, const std::string& key, int64_t def);
+void cfgSaveInt64(const std::string& section, const std::string& key, int64_t value);
 std::string cfgLoadStr(const std::string& section, const std::string& key, const std::string& def);
 void cfgSaveStr(const std::string& section, const std::string& key, const std::string& value);
 void cfgSaveBool(const std::string& section, const std::string& key, bool value);
 bool cfgLoadBool(const std::string& section, const std::string& key, bool def);
+void cfgSaveFloat(const std::string& section, const std::string& key, float value);
+float cfgLoadFloat(const std::string& section, const std::string& key, float def);
 void cfgSetVirtual(const std::string& section, const std::string& key, const std::string& value);
 bool cfgIsVirtual(const std::string& section, const std::string& key);

-bool ParseCommandLine(int argc, char *argv[]);
+void ParseCommandLine(int argc, char *argv[]);

 void cfgSetAutoSave(bool autoSave);
 bool cfgHasSection(const std::string& section);
 void cfgDeleteSection(const std::string& section);
+void cfgDeleteEntry(const std::string& section, const std::string& key);
@@ -3,7 +3,6 @@
 */

 #include <cstdio>
-#include <cctype>
 #include <cstring>

 #include "cfg/cfg.h"
@@ -12,43 +11,56 @@
 static int setconfig(char *arg[], int cl)
 {
 	int rv=0;
-	for(;;)
+
+	if (cl < 1)
 	{
-		if (cl<1)
-		{
-			WARN_LOG(COMMON, "-config : invalid number of parameters, format is section:key=value");
-			break;
-		}
-		std::string value(arg[1]);
+		WARN_LOG(COMMON, "-config : invalid number of parameters, format is section:key=value,section:key=value,...");
+		return rv;
+	}
+
+	std::string value(arg[1]);
+	for(;;)
+	{		
 		auto seppos = value.find(':');
 		if (seppos == std::string::npos)
 		{
-			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value", value.c_str());
+			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value,section:key=value,...", value.c_str());
 			break;
 		}
 		auto eqpos = value.find('=', seppos);
 		if (eqpos == std::string::npos)
 		{
-			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value", value.c_str());
+			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value,section:key=value,...", value.c_str());
 			break;
 		}

+		auto commapos = value.find(',', eqpos);
+
 		std::string sect = trim_ws(value.substr(0, seppos));
 		std::string key = trim_ws(value.substr(seppos + 1, eqpos - seppos - 1));
-		value = trim_ws(value.substr(eqpos + 1));
+		auto endofcurrent = (commapos == std::string::npos) ? value.size() : commapos;
+		std::string next = (commapos == std::string::npos) ? "" : trim_ws(value.substr(endofcurrent + 1, value.size() - endofcurrent));
+		value = trim_ws(value.substr(eqpos + 1, endofcurrent - eqpos - 1));

 		if (sect.empty() || key.empty())
 		{
-			WARN_LOG(COMMON, "-config : invalid parameter, format is section:key=value");
+			WARN_LOG(COMMON, "-config : invalid parameter, format is section:key=value,section:key=value,...");
 			break;
 		}

 		INFO_LOG(COMMON, "Virtual cfg %s:%s=%s", sect.c_str(), key.c_str(), value.c_str());

 		cfgSetVirtual(sect, key, value);
-		rv++;

-		if (cl>=3 && strcmp(arg[2],",")==0)
+		if (commapos == std::string::npos)
+			rv++;
+
+		if (commapos != std::string::npos)
+		{
+			value = next;
+			continue;
+		}
+		else if (cl>=3 && strcmp(arg[2],",")==0)
 		{
 			cl-=2;
 			arg+=2;
@@ -74,7 +86,7 @@ static int showhelp()
 	return 0;
 }

-bool ParseCommandLine(int argc,char* argv[])
+void ParseCommandLine(int argc,char* argv[])
 {
 	settings.content.path.clear();
 	int cl=argc-2;
@@ -128,5 +140,4 @@ bool ParseCommandLine(int argc,char* argv[])
 		arg++;
 		cl--;
 	}
-	return false;
 }
@@ -24,6 +24,14 @@ int ConfigEntry::get_int()
 	}
 }

+int64_t ConfigEntry::get_int64()
+{
+	int base = 10;
+	if (strstr(this->value.c_str(), "0x") != nullptr)
+		base = 16;
+	return (int64_t)strtoll(this->value.c_str(), nullptr, base);
+}
+
 bool ConfigEntry::get_bool()
 {
 	if (stricmp(this->value.c_str(), "yes") == 0 ||
@@ -39,6 +47,11 @@ bool ConfigEntry::get_bool()
 	}
 }

+float ConfigEntry::get_float()
+{
+	return atof(this->value.c_str());
+}
+
 /* ConfigSection */

 bool ConfigSection::has_entry(const std::string& name)
@@ -158,6 +171,19 @@ int ConfigFile::get_int(const std::string& section_name, const std::string& entr
 	}
 }

+int64_t ConfigFile::get_int64(const std::string& section_name, const std::string& entry_name, int64_t default_value)
+{
+	ConfigEntry* entry = this->get_entry(section_name, entry_name);
+	if (entry == NULL)
+	{
+		return default_value;
+	}
+	else
+	{
+		return entry->get_int64();
+	}
+}
+
 bool ConfigFile::get_bool(const std::string& section_name, const std::string& entry_name, bool default_value)
 {
 	ConfigEntry* entry = this->get_entry(section_name, entry_name);
@@ -171,6 +197,15 @@ bool ConfigFile::get_bool(const std::string& section_name, const std::string& en
 	}
 }

+float ConfigFile::get_float(const std::string& section_name, const std::string& entry_name, float default_value)
+{
+	ConfigEntry* entry = get_entry(section_name, entry_name);
+	if (entry == nullptr)
+		return default_value;
+	else
+		return entry->get_float();
+}
+
 void ConfigFile::set(const std::string& section_name, const std::string& entry_name, const std::string& value, bool is_virtual)
 {
 	ConfigSection* section = this->get_section(section_name, is_virtual);
@@ -188,12 +223,26 @@ void ConfigFile::set_int(const std::string& section_name, const std::string& ent
 	this->set(section_name, entry_name, str_value.str(), is_virtual);
 }

+void ConfigFile::set_int64(const std::string& section_name, const std::string& entry_name, int64_t value, bool is_virtual)
+{
+	std::stringstream str_value;
+	str_value << value;
+	this->set(section_name, entry_name, str_value.str(), is_virtual);
+}
+
 void ConfigFile::set_bool(const std::string& section_name, const std::string& entry_name, bool value, bool is_virtual)
 {
 	std::string str_value = (value ? "yes" : "no");
 	this->set(section_name, entry_name, str_value, is_virtual);
 }

+void ConfigFile::set_float(const std::string& section_name, const std::string& entry_name, float value, bool is_virtual)
+{
+	std::stringstream str_value;
+	str_value << value;
+	this->set(section_name, entry_name, str_value.str(), is_virtual);
+}
+
 void ConfigFile::parse(FILE* file)
 {
 	if (file == nullptr)
@@ -232,18 +281,13 @@ void ConfigFile::parse(FILE* file)

 void ConfigFile::save(FILE* file)
 {
-	for (const auto& section_it : this->sections)
+	for (const auto& [section_name, section] : this->sections)
 	{
-		const std::string& section_name = section_it.first;
-		const ConfigSection& section = section_it.second;
-
 		if (!section_name.empty())
 			std::fprintf(file, "[%s]\n", section_name.c_str());

-		for (const auto& entry_it : section.entries)
+		for (const auto& [entry_name, entry] : section.entries)
 		{
-			const std::string& entry_name = entry_it.first;
-			const ConfigEntry& entry = entry_it.second;
 			std::fprintf(file, "%s = %s\n", entry_name.c_str(), entry.get_string().c_str());
 		}
 		if (!section_name.empty())
@@ -3,6 +3,7 @@
 #include <cstdio>
 #include <map>
 #include <string>
+#include <cstdint>

 namespace emucfg {

@@ -11,6 +12,8 @@ struct ConfigEntry {
 	const std::string& get_string() const;
 	int get_int();
 	bool get_bool();
+	int64_t get_int64();
+	float get_float();
 };

 struct ConfigSection {
@@ -41,11 +44,15 @@ struct ConfigFile {
 		/* getting values */
 		std::string get(const std::string& section_name, const std::string& entry_name, const std::string& default_value = "");
 		int get_int(const std::string& section_name, const std::string& entry_name, int default_value = 0);
+		int64_t get_int64(const std::string& section_name, const std::string& entry_name, int64_t default_value = 0);
 		bool get_bool(const std::string& section_name, const std::string& entry_name, bool default_value = false);
+		float get_float(const std::string& section_name, const std::string& entry_name, float default_value = 0.f);
 		/* setting values */
 		void set(const std::string& section_name, const std::string& entry_name, const std::string& value, bool is_virtual = false);
 		void set_int(const std::string& section_name, const std::string& entry_name, int value, bool is_virtual = false);
+		void set_int64(const std::string& section_name, const std::string& entry_name, int64_t value, bool is_virtual = false);
 		void set_bool(const std::string& section_name, const std::string& entry_name, bool value, bool is_virtual = false);
+		void set_float(const std::string& section_name, const std::string& entry_name, float value, bool is_virtual = false);

 		void delete_section(const std::string& section_name);
 		void delete_entry(const std::string& section_name, const std::string& entry_name);
@@ -17,13 +17,15 @@
    along with Flycast.  If not, see <https://www.gnu.org/licenses/>.
 */
 #include "option.h"
+#include "network/naomi_network.h"
+#include "debug/gdb_server.h"

 namespace config {

 // Dynarec

 Option<bool> DynarecEnabled("Dynarec.Enabled", true);
-Option<bool> DynarecIdleSkip("Dynarec.idleskip", true);
+Option<int> Sh4Clock("Sh4Clock", 200);

 // General

@@ -31,11 +33,13 @@ Option<int> Cable("Dreamcast.Cable", 3);			// TV Composite
 Option<int> Region("Dreamcast.Region", 1);			// USA
 Option<int> Broadcast("Dreamcast.Broadcast", 0);	// NTSC
 Option<int> Language("Dreamcast.Language", 1);		// English
-Option<bool> FullMMU("Dreamcast.FullMMU");
-Option<bool> ForceWindowsCE("Dreamcast.ForceWindowsCE");
 Option<bool> AutoLoadState("Dreamcast.AutoLoadState");
 Option<bool> AutoSaveState("Dreamcast.AutoSaveState");
-Option<int> SavestateSlot("Dreamcast.SavestateSlot");
+Option<int, false> SavestateSlot("Dreamcast.SavestateSlot");
+Option<bool> ForceFreePlay("ForceFreePlay", true);
+Option<bool, false> FetchBoxart("FetchBoxart", true);
+Option<bool, false> BoxartDisplayMode("BoxartDisplayMode", true);
+Option<int, false> UIScaling("UIScaling", 100);

 // Sound

@@ -55,6 +59,7 @@ Option<bool> AutoLatency("aica.AutoLatency",

 OptionString AudioBackend("backend", "auto", "audio");
 AudioVolumeOption AudioVolume;
+Option<bool> VmuSound("VmuSound", false, "audio");

 // Rendering

@@ -88,45 +93,81 @@ std::array<Option<int>, 4> CrosshairColor {
 	Option<int>("rend.CrossHairColor3"),
 	Option<int>("rend.CrossHairColor4"),
 };
+Option<int> CrosshairSize("rend.CrosshairSize", 40);
 Option<int> SkipFrame("ta.skip");
 Option<int> MaxThreads("pvr.MaxThreads", 3);
 Option<int> AutoSkipFrame("pvr.AutoSkipFrame", 0);
 Option<int> RenderResolution("rend.Resolution", 480);
 Option<bool> VSync("rend.vsync", true);
-Option<u64> PixelBufferSize("rend.PixelBufferSize", 512 * 1024 * 1024);
+Option<int64_t> PixelBufferSize("rend.PixelBufferSize", 512_MB);
 Option<int> AnisotropicFiltering("rend.AnisotropicFiltering", 1);
 Option<int> TextureFiltering("rend.TextureFiltering", 0); // Default
 Option<bool> ThreadedRendering("rend.ThreadedRendering", true);
 Option<bool> DupeFrames("rend.DupeFrames", false);
+Option<int> PerPixelLayers("rend.PerPixelLayers", 32);
+#ifdef TARGET_UWP
+Option<bool> NativeDepthInterpolation("rend.NativeDepthInterpolation", true);
+#else
+Option<bool> NativeDepthInterpolation("rend.NativeDepthInterpolation", false);
+#endif
+Option<bool> EmulateFramebuffer("rend.EmulateFramebuffer", false);
+Option<bool> FixUpscaleBleedingEdge("rend.FixUpscaleBleedingEdge", true);
+Option<bool> CustomGpuDriver("rend.CustomGpuDriver", false);
+#ifdef VIDEO_ROUTING
+Option<bool, false> VideoRouting("rend.VideoRouting", false);
+Option<bool, false> VideoRoutingScale("rend.VideoRoutingScale", false);
+Option<int, false> VideoRoutingVRes("rend.VideoRoutingVRes", 720);
+#endif

 // Misc

 Option<bool> SerialConsole("Debug.SerialConsoleEnabled");
 Option<bool> SerialPTY("Debug.SerialPTY");
+Option<bool> GDB("Debug.GDBEnabled");
+Option<int> GDBPort("Debug.GDBPort", debugger::DEFAULT_PORT);
+Option<bool> GDBWaitForConnection("Debug.GDBWaitForConnection");
 Option<bool> UseReios("UseReios");
 Option<bool> FastGDRomLoad("FastGDRomLoad", false);
+Option<bool> RamMod32MB("Dreamcast.RamMod32MB", false);

 Option<bool> OpenGlChecks("OpenGlChecks", false, "validate");

 Option<std::vector<std::string>, false> ContentPath("Dreamcast.ContentPath");
 Option<bool, false> HideLegacyNaomiRoms("Dreamcast.HideLegacyNaomiRoms", true);
+Option<bool, false> UploadCrashLogs("UploadCrashLogs", true);
+Option<bool, false> DiscordPresence("DiscordPresence", true);
+#if defined(__ANDROID__) && !defined(LIBRETRO)
+Option<bool, false> UseSafFilePicker("UseSafFilePicker", true);
+#endif
+OptionString LogServer("LogServer", "", "log");
+
+// Profiler
+Option<bool> ProfilerEnabled("Profiler.Enabled");
+Option<bool> ProfilerDrawToGUI("Profiler.DrawGUI");
+Option<bool> ProfilerOutputTTY("Profiler.OutputTTY");
+Option<float> ProfilerFrameWarningTime("Profiler.FrameWarningTime", 1.0f / 55.0f);

 // Network

 Option<bool> NetworkEnable("Enable", false, "network");
 Option<bool> ActAsServer("ActAsServer", false, "network");
-OptionString DNS("DNS", "46.101.91.123", "network");
+OptionString DNS("DNS", "dns.flyca.st", "network");
 OptionString NetworkServer("server", "", "network");
+Option<int> LocalPort("LocalPort", NaomiNetwork::SERVER_PORT, "network");
 Option<bool> EmulateBBA("EmulateBBA", false, "network");
+Option<bool> EnableUPnP("EnableUPnP", true, "network");
 Option<bool> GGPOEnable("GGPO", false, "network");
 Option<int> GGPODelay("GGPODelay", 0, "network");
 Option<bool> NetworkStats("Stats", true, "network");
 Option<int> GGPOAnalogAxes("GGPOAnalogAxes", 0, "network");
 Option<bool> GGPOChat("GGPOChat", true, "network");
-
-#ifdef SUPPORT_DISPMANX
-Option<bool> DispmanxMaintainAspect("maintain_aspect", true, "dispmanx");
-#endif
+Option<bool> GGPOChatTimeoutToggle("GGPOChatTimeoutToggle", true, "network");
+Option<int> GGPOChatTimeout("GGPOChatTimeout", 10, "network");
+Option<bool> NetworkOutput("NetworkOutput", false, "network");
+Option<int> MultiboardSlaves("MultiboardSlaves", 1, "network");
+Option<bool> BattleCableEnable("BattleCable", false, "network");
+Option<bool> UseDCNet("DCNet", false, "network");
+OptionString ISPUsername("ISPUsername", "flycast1", "network");

 #ifdef USE_OMX
 Option<int> OmxAudioLatency("audio_latency", 100, "omx");
@@ -137,6 +178,7 @@ Option<bool> OmxAudioHdmi("audio_hdmi", true, "omx");

 Option<int> MouseSensitivity("MouseSensitivity", 100, "input");
 Option<int> VirtualGamepadVibration("VirtualGamepadVibration", 20, "input");
+Option<int> VirtualGamepadTransparency("VirtualGamepadTransparency", 37, "input");

 std::array<Option<MapleDeviceType>, 4> MapleMainDevices {
 	Option<MapleDeviceType>("device1", MDT_SegaController, "input"),
@@ -144,25 +186,34 @@ std::array<Option<MapleDeviceType>, 4> MapleMainDevices {
 	Option<MapleDeviceType>("device3", MDT_None, "input"),
 	Option<MapleDeviceType>("device4", MDT_None, "input"),
 };
-std::array<std::array<Option<MapleDeviceType>, 2>, 4> MapleExpansionDevices {
-	Option<MapleDeviceType>("device1.1", MDT_SegaVMU, "input"),
-	Option<MapleDeviceType>("device1.2", MDT_SegaVMU, "input"),
+std::array<std::array<Option<MapleDeviceType>, 2>, 4> MapleExpansionDevices {{
+	{{Option<MapleDeviceType>("device1.1", MDT_SegaVMU, "input"),
+	Option<MapleDeviceType>("device1.2", MDT_SegaVMU, "input")}},

-	Option<MapleDeviceType>("device2.1", MDT_None, "input"),
-	Option<MapleDeviceType>("device2.2", MDT_None, "input"),
+	{{Option<MapleDeviceType>("device2.1", MDT_None, "input"),
+	Option<MapleDeviceType>("device2.2", MDT_None, "input")}},

-	Option<MapleDeviceType>("device3.1", MDT_None, "input"),
-	Option<MapleDeviceType>("device3.2", MDT_None, "input"),
+	{{Option<MapleDeviceType>("device3.1", MDT_None, "input"),
+	Option<MapleDeviceType>("device3.2", MDT_None, "input")}},

-	Option<MapleDeviceType>("device4.1", MDT_None, "input"),
-	Option<MapleDeviceType>("device4.2", MDT_None, "input"),
-};
+	{{Option<MapleDeviceType>("device4.1", MDT_None, "input"),
+	Option<MapleDeviceType>("device4.2", MDT_None, "input")}},
+}};
+Option<bool> PerGameVmu("PerGameVmu", false, "config");
 #ifdef _WIN32
-Option<bool> UseRawInput("RawInput", false, "input");
+Option<bool, false> UseRawInput("RawInput", false, "input");
 #endif
+Option<bool> UsePhysicalVmuMemory("UsePhysicalVmuMemory", false);

 #ifdef USE_LUA
-OptionString LuaFileName("LuaFileName", "flycast.lua");
+Option<std::string, false> LuaFileName("LuaFileName", "flycast.lua");
 #endif

+// RetroAchievements
+
+Option<bool> EnableAchievements("Enabled", false, "achievements");
+Option<bool> AchievementsHardcoreMode("HardcoreMode", false, "achievements");
+OptionString AchievementsUserName("UserName", "", "achievements");
+OptionString AchievementsToken("Token", "", "achievements");
+
 } // namespace config
@@ -21,6 +21,7 @@
 #include <vector>
 #include <array>
 #include <cmath>
+#include <type_traits>
 #include "cfg.h"
 #include "hw/maple/maple_cfg.h"
 #ifdef LIBRETRO
@@ -100,10 +101,6 @@ private:
 	friend class Option;
 };

-// Missing in C++11
-template <bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-
 template<typename T, bool PerGameOption = true>
 class Option : public BaseOption {
 public:
@@ -142,7 +139,11 @@ public:
 		else if (PerGameOption && settings.hasPerGameConfig())
 		{
 			if (value == doLoad(section, name))
+			{
+				// delete existing per-game option if any
+				cfgDeleteEntry(settings.gameId, section + "." + name);
 				return;
+			}
 		}
 		if (PerGameOption && settings.hasPerGameConfig())
 			doSave(settings.gameId, section + "." + name);
@@ -153,8 +154,8 @@ public:
 	T& get() { return value; }
 	void set(T v) { value = v; }

-	void override(T v) {
-		verify(PerGameOption);
+	void override(T v)
+	{
 		overriddenDefault = v;
 		overridden = true;
 		value = v;
@@ -169,40 +170,43 @@ public:

 protected:
 	template <typename U = T>
-	enable_if_t<std::is_same<U, bool>::value, T>
+	std::enable_if_t<std::is_same_v<U, bool>, T>
 	doLoad(const std::string& section, const std::string& name) const
 	{
 		return cfgLoadBool(section, name, value);
 	}

 	template <typename U = T>
-	enable_if_t<(std::is_integral<U>::value || std::is_enum<U>::value)
-			&& !std::is_same<U, bool>::value, T>
+	std::enable_if_t<std::is_same<U, int64_t>::value, T>
+	doLoad(const std::string& section, const std::string& name) const
+	{
+		return cfgLoadInt64(section, name, value);
+	}
+
+	template <typename U = T>
+	std::enable_if_t<(std::is_integral_v<U> || std::is_enum_v<U>)
+			&& !std::is_same_v<U, bool> && !std::is_same_v<U, int64_t>, T>
 	doLoad(const std::string& section, const std::string& name) const
 	{
 		return (T)cfgLoadInt(section, name, (int)value);
 	}

 	template <typename U = T>
-	enable_if_t<std::is_same<U, std::string>::value, T>
+	std::enable_if_t<std::is_same_v<U, std::string>, T>
 	doLoad(const std::string& section, const std::string& name) const
 	{
 		return cfgLoadStr(section, name, value);
 	}

 	template <typename U = T>
-	enable_if_t<std::is_same<float, U>::value, T>
+	std::enable_if_t<std::is_same_v<float, U>, T>
 	doLoad(const std::string& section, const std::string& name) const
 	{
-		std::string strValue = cfgLoadStr(section, name, "");
-		if (strValue.empty())
-			return value;
-		else
-			return (float)atof(strValue.c_str());
+		return cfgLoadFloat(section, name, value);
 	}

 	template <typename U = T>
-	enable_if_t<std::is_same<std::vector<std::string>, U>::value, T>
+	std::enable_if_t<std::is_same_v<std::vector<std::string>, U>, T>
 	doLoad(const std::string& section, const std::string& name) const
 	{
 		std::string paths = cfgLoadStr(section, name, "");
@@ -261,38 +265,43 @@ protected:
 	}

 	template <typename U = T>
-	enable_if_t<std::is_same<U, bool>::value>
+	std::enable_if_t<std::is_same_v<U, bool>>
 	doSave(const std::string& section, const std::string& name) const
 	{
 		cfgSaveBool(section, name, value);
 	}

 	template <typename U = T>
-	enable_if_t<(std::is_integral<U>::value || std::is_enum<U>::value)
-		&& !std::is_same<U, bool>::value>
+	std::enable_if_t<std::is_same<U, int64_t>::value>
+	doSave(const std::string& section, const std::string& name) const
+	{
+		cfgSaveInt64(section, name, value);
+	}
+
+	template <typename U = T>
+	std::enable_if_t<(std::is_integral_v<U> || std::is_enum_v<U>)
+		&& !std::is_same_v<U, bool> && !std::is_same_v<U, int64_t>>
 	doSave(const std::string& section, const std::string& name) const
 	{
 		cfgSaveInt(section, name, (int)value);
 	}

 	template <typename U = T>
-	enable_if_t<std::is_same<U, std::string>::value>
+	std::enable_if_t<std::is_same_v<U, std::string>>
 	doSave(const std::string& section, const std::string& name) const
 	{
 		cfgSaveStr(section, name, value);
 	}

 	template <typename U = T>
-	enable_if_t<std::is_same<float, U>::value>
+	std::enable_if_t<std::is_same_v<float, U>>
 	doSave(const std::string& section, const std::string& name) const
 	{
-		char buf[64];
-		snprintf(buf, sizeof(buf), "%f", value);
-		cfgSaveStr(section, name, buf);
+		cfgSaveFloat(section, name, value);
 	}

 	template <typename U = T>
-	enable_if_t<std::is_same<std::vector<std::string>, U>::value>
+	std::enable_if_t<std::is_same_v<std::vector<std::string>, U>>
 	doSave(const std::string& section, const std::string& name) const
 	{
 		std::string s;
@@ -341,8 +350,9 @@ using OptionString = Option<std::string>;
 // Dynarec

 extern Option<bool> DynarecEnabled;
-extern Option<bool> DynarecIdleSkip;
-constexpr bool DynarecSafeMode = false;
+#ifndef LIBRETRO
+extern Option<int> Sh4Clock;
+#endif

 // General

@@ -350,11 +360,13 @@ extern Option<int> Cable;		// 0 -> VGA, 1 -> VGA, 2 -> RGB, 3 -> TV Composite
 extern Option<int> Region;		// 0 -> JP, 1 -> USA, 2 -> EU, 3 -> default
 extern Option<int> Broadcast;	// 0 -> NTSC, 1 -> PAL, 2 -> PAL/M, 3 -> PAL/N, 4 -> default
 extern Option<int> Language;	// 0 -> JP, 1 -> EN, 2 -> DE, 3 -> FR, 4 -> SP, 5 -> IT, 6 -> default
-extern Option<bool> FullMMU;
-extern Option<bool> ForceWindowsCE;
 extern Option<bool> AutoLoadState;
 extern Option<bool> AutoSaveState;
-extern Option<int> SavestateSlot;
+extern Option<int, false> SavestateSlot;
+extern Option<bool> ForceFreePlay;
+extern Option<bool, false> FetchBoxart;
+extern Option<bool, false> BoxartDisplayMode;
+extern Option<int, false> UIScaling;

 // Sound

@@ -388,19 +400,27 @@ public:
 	}
 };
 extern AudioVolumeOption AudioVolume;
+extern Option<bool> VmuSound;

 // Rendering

 class RendererOption : public Option<RenderType> {
 public:
-	RendererOption()
-#ifdef USE_DX9
-		: Option<RenderType>("pvr.rend", RenderType::DirectX9) {}
-#elif defined(TARGET_UWP)
-		: Option<RenderType>("pvr.rend", RenderType::DirectX11) {}
+#ifdef LIBRETRO
+	RendererOption() : Option<RenderType>("",
 #else
-		: Option<RenderType>("pvr.rend", RenderType::OpenGL) {}
+	RendererOption() : Option<RenderType>("pvr.rend",
 #endif
+#if defined(USE_DX11)
+			RenderType::DirectX11
+#elif defined(USE_DX9)
+			RenderType::DirectX9
+#elif !defined(USE_OPENGL)
+			RenderType::Vulkan
+#else
+			RenderType::OpenGL
+#endif
+		) {}

 	RenderType& operator=(const RenderType& v) { set(v); return value; }

@@ -421,6 +441,7 @@ constexpr bool Clipping = true;
 #ifndef LIBRETRO
 extern Option<int> TextureUpscale;
 extern Option<int> MaxFilteredTextureSize;
+extern Option<int> PerPixelLayers;
 #endif
 extern Option<float> ExtraDepthScale;
 extern Option<bool> CustomTextures;
@@ -433,28 +454,54 @@ extern Option<bool> PerStripSorting;
 extern Option<bool> DelayFrameSwapping;	// Delay swapping frame until FB_R_SOF matches FB_W_SOF
 extern Option<bool> WidescreenGameHacks;
 extern std::array<Option<int>, 4> CrosshairColor;
+extern Option<int> CrosshairSize;
 extern Option<int> SkipFrame;
 extern Option<int> MaxThreads;
 extern Option<int> AutoSkipFrame;		// 0: none, 1: some, 2: more
 extern Option<int> RenderResolution;
 extern Option<bool> VSync;
-extern Option<u64> PixelBufferSize;
+extern Option<int64_t> PixelBufferSize;
 extern Option<int> AnisotropicFiltering;
 extern Option<int> TextureFiltering; // 0: default, 1: force nearest, 2: force linear
 extern Option<bool> ThreadedRendering;
 extern Option<bool> DupeFrames;
+extern Option<bool> NativeDepthInterpolation;
+extern Option<bool> EmulateFramebuffer;
+extern Option<bool> FixUpscaleBleedingEdge;
+extern Option<bool> CustomGpuDriver;
+#ifdef VIDEO_ROUTING
+extern Option<bool, false> VideoRouting;
+extern Option<bool, false> VideoRoutingScale;
+extern Option<int, false> VideoRoutingVRes;
+#endif

 // Misc

 extern Option<bool> SerialConsole;
 extern Option<bool> SerialPTY;
+extern Option<bool> GDB;
+extern Option<int> GDBPort;
+extern Option<bool> GDBWaitForConnection;
 extern Option<bool> UseReios;
 extern Option<bool> FastGDRomLoad;
+extern Option<bool> RamMod32MB;

 extern Option<bool> OpenGlChecks;

 extern Option<std::vector<std::string>, false> ContentPath;
 extern Option<bool, false> HideLegacyNaomiRoms;
+extern Option<bool, false> UploadCrashLogs;
+extern Option<bool, false> DiscordPresence;
+#if defined(__ANDROID__) && !defined(LIBRETRO)
+extern Option<bool, false> UseSafFilePicker;
+#endif
+extern OptionString LogServer;
+
+// Profiling
+extern Option<bool> ProfilerEnabled;
+extern Option<bool> ProfilerDrawToGUI;
+extern Option<bool> ProfilerOutputTTY;
+extern Option<float> ProfilerFrameWarningTime;

 // Network

@@ -462,16 +509,21 @@ extern Option<bool> NetworkEnable;
 extern Option<bool> ActAsServer;
 extern OptionString DNS;
 extern OptionString NetworkServer;
+extern Option<int> LocalPort;
 extern Option<bool> EmulateBBA;
+extern Option<bool> EnableUPnP;
 extern Option<bool> GGPOEnable;
 extern Option<int> GGPODelay;
 extern Option<bool> NetworkStats;
 extern Option<int> GGPOAnalogAxes;
 extern Option<bool> GGPOChat;
-
-#ifdef SUPPORT_DISPMANX
-extern Option<bool> DispmanxMaintainAspect;
-#endif
+extern Option<bool> GGPOChatTimeoutToggle;
+extern Option<int> GGPOChatTimeout;
+extern Option<bool> NetworkOutput;
+extern Option<int> MultiboardSlaves;
+extern Option<bool> BattleCableEnable;
+extern Option<bool> UseDCNet;
+extern OptionString ISPUsername;

 #ifdef USE_OMX
 extern Option<int> OmxAudioLatency;
@@ -482,16 +534,26 @@ extern Option<bool> OmxAudioHdmi;

 extern Option<int> MouseSensitivity;
 extern Option<int> VirtualGamepadVibration;
+extern Option<int> VirtualGamepadTransparency;
 extern std::array<Option<MapleDeviceType>, 4> MapleMainDevices;
 extern std::array<std::array<Option<MapleDeviceType>, 2>, 4> MapleExpansionDevices;
+extern Option<bool> PerGameVmu;
 #ifdef _WIN32
-extern Option<bool> UseRawInput;
+extern Option<bool, false> UseRawInput;
 #else
 constexpr bool UseRawInput = false;
 #endif
+extern Option<bool> UsePhysicalVmuMemory;

 #ifdef USE_LUA
-extern OptionString LuaFileName;
+extern Option<std::string, false> LuaFileName;
 #endif

+// RetroAchievements
+
+extern Option<bool> EnableAchievements;
+extern Option<bool> AchievementsHardcoreMode;
+extern OptionString AchievementsUserName;
+extern OptionString AchievementsToken;
+
 } // namespace config
@@ -21,12 +21,15 @@
 #pragma once
 #include "types.h"

+#include <vector>
+
 struct WidescreenCheat
 {
 	const char *game_id;
 	const char *area_or_version;
 	u32 addresses[16];
 	u32 values[16];
+	u32 origValues[16];
 };

 struct Cheat
@@ -42,17 +45,25 @@ struct Cheat
 		runNextIfLt,
 		copy
 	};
-	Type type = Type::disabled;
+	Type type;
 	std::string description;
-	bool enabled = false;
-	u32 size = 0;
-	u32 address = 0;
-	u32 value = 0;
+	bool enabled;
+	u32 size;
+	u32 address;
+	u32 value;
 	u8 valueMask = 0;
 	u32 repeatCount = 1;
 	u32 repeatValueIncrement = 0;
 	u32 repeatAddressIncrement = 0;
 	u32 destAddress = 0;
+	bool builtIn;
+
+	Cheat(Type type = Type::disabled, const std::string& description = "", bool enabled = false,
+			u32 size = 0, u32 address = 0, u32 value = 0, bool builtIn = false)
+		: type(type), description(description), enabled(enabled),
+		  size(size), address(address), value(value), builtIn(builtIn)
+	{
+	}
 };

 class CheatManager
@@ -73,6 +84,7 @@ public:
 private:
 	u32 readRam(u32 addr, u32 bits);
 	void writeRam(u32 addr, u32 value, u32 bits);
+	void setActive(bool active);

 	static const WidescreenCheat widescreen_cheats[];
 	static const WidescreenCheat naomi_widescreen_cheats[];
@@ -21,7 +21,7 @@
 #include "emulator.h"
 #include "hw/sh4/sh4_if.h"
 #include "hw/sh4/sh4_mem.h"
-#include "hw/sh4/sh4_interpreter.h"
+#include "hw/sh4/dyna/shil.h"
 #include "cfg/option.h"
 #include <array>
 #include <signal.h>
@@ -73,6 +73,24 @@ const std::array<Sh4RegType, 59> Sh4RegList {
 class DebugAgent
 {
 public:
+	struct Breakpoint {
+		enum Type
+		{
+			BP_TYPE_SOFTWARE_BREAK,
+			BP_TYPE_HARDWARE_BREAK,
+			BP_TYPE_WRITE_WATCHPOINT,
+			BP_TYPE_READ_WATCHPOINT,
+			BP_TYPE_ACCESS_WATCHPOINT,
+			BP_TYPE_COUNT
+		};
+
+		Breakpoint() = default;
+		Breakpoint(u16 type, u32 addr) : addr(addr), type(type) { }
+		u32 addr = 0;
+		u16 type = 0;
+		u16 savedOp = 0;
+	};
+
 	void doContinue(u32 pc = 1)
 	{
 		if (pc != 1)
@@ -82,11 +100,20 @@ public:

 	void step()
 	{
-		bool restoreBreakpoint = removeMatchpoint(0, Sh4cntx.pc, 2);
+		bool restoreBreakpoint = removeMatchpoint(Breakpoint::BP_TYPE_SOFTWARE_BREAK, Sh4cntx.pc, 2);
 		u32 savedPc = Sh4cntx.pc;
 		emu.step();
 		if (restoreBreakpoint)
-			insertMatchpoint(0, savedPc, 2);
+			insertMatchpoint(Breakpoint::BP_TYPE_SOFTWARE_BREAK, savedPc, 2);
+	}
+
+	void stepRange(u32 from, u32 to)
+	{
+		bool restoreBreakpoint = removeMatchpoint(Breakpoint::BP_TYPE_SOFTWARE_BREAK, Sh4cntx.pc, 2);
+		u32 savedPc = Sh4cntx.pc;
+		emu.stepRange(from, to);
+		if (restoreBreakpoint)
+			insertMatchpoint(Breakpoint::BP_TYPE_SOFTWARE_BREAK, savedPc, 2);
 	}

 	int readAllRegs(u32 **regs)
@@ -95,9 +122,9 @@ public:
 		for (u32 i = 0; i < Sh4RegList.size(); i++)
 		{
 			if (Sh4RegList[i] == reg_sr_status)
-				allregs[i] = sh4_sr_GetFull();
+				allregs[i] = Sh4cntx.sr.getFull();
 			else if (Sh4RegList[i] != NoReg)
-				allregs[i] = *GetRegPtr(Sh4RegList[i]);
+				allregs[i] = *GetRegPtr(Sh4cntx, Sh4RegList[i]);
 		}
 		*regs = &allregs[0];
 		return allregs.size();
@@ -107,7 +134,7 @@ public:
 	{
 		for (u32 i = 0; i < Sh4RegList.size(); i++)
 			if (Sh4RegList[i] != NoReg)
-				*GetRegPtr(Sh4RegList[i]) = regs[i];
+				*GetRegPtr(Sh4cntx, Sh4RegList[i]) = regs[i];
 	}

 	u32 readReg(u32 regNum)
@@ -116,9 +143,9 @@ public:
 			return 0;
 		Sh4RegType reg = Sh4RegList[regNum];
 		if (reg == reg_sr_status)
-			return sh4_sr_GetFull();
+			return Sh4cntx.sr.getFull();
 		if (reg != NoReg)
-			return *GetRegPtr(reg);
+			return *GetRegPtr(Sh4cntx, reg);
 		return 0;
 	}
 	void writeReg(u32 regNum, u32 value)
@@ -127,9 +154,9 @@ public:
 			return;
 		Sh4RegType reg = Sh4RegList[regNum];
 		if (reg == reg_sr_status)
-			sh4_sr_SetFull(value);
+			Sh4cntx.sr.setFull(value);
 		else if (reg != NoReg)
-			*GetRegPtr(reg) = value;
+			*GetRegPtr(Sh4cntx, reg) = value;
 	}

 	const u8 *readMem(u32 addr, u32 len)
@@ -190,31 +217,31 @@ public:
 			}
 		}
 	}
-	bool insertMatchpoint(char type, u32 addr, u32 len)
+	bool insertMatchpoint(Breakpoint::Type type, u32 addr, u32 len)
 	{
-		if (type == 0 && len != 2) {
+		if (type == Breakpoint::BP_TYPE_SOFTWARE_BREAK && len != 2) {
 			WARN_LOG(COMMON, "insertMatchpoint: length != 2: %d", len);
 			return false;
 		}
 		// TODO other matchpoint types
-		if (breakpoints.find(addr) != breakpoints.end())
+		if (breakpoints[type].find(addr) != breakpoints[type].end())
 			return true;
-		breakpoints[addr] = Breakpoint(type, addr);
-		breakpoints[addr].savedOp = ReadMem16_nommu(addr);
+		breakpoints[type][addr] = Breakpoint(type, addr);
+		breakpoints[type][addr].savedOp = ReadMem16_nommu(addr);
 		WriteMem16_nommu(addr, 0xC308);	// trapa #0x20
 		return true;
 	}
-	bool removeMatchpoint(char type, u32 addr, u32 len)
+	bool removeMatchpoint(Breakpoint::Type type, u32 addr, u32 len)
 	{
-		if (type == 0 && len != 2) {
+		if (type == Breakpoint::BP_TYPE_SOFTWARE_BREAK && len != 2) {
 			WARN_LOG(COMMON, "removeMatchpoint: length != 2: %d", len);
 			return false;
 		}
-		auto it = breakpoints.find(addr);
-		if (it == breakpoints.end())
+		auto it = breakpoints[type].find(addr);
+		if (it == breakpoints[type].end())
 			return false;
 		WriteMem16_nommu(addr, it->second.savedOp);
-		breakpoints.erase(it);
+		breakpoints[type].erase(it);
 		return true;
 	}

@@ -247,7 +274,7 @@ public:
 	void restart()
 	{
 		emu.unloadGame();
-		emu.loadGame(settings.content.path);
+		emu.loadGame(settings.content.path.c_str());
 		emu.start();
 	}

@@ -295,7 +322,10 @@ public:
 	{
 		verify(!Sh4cntx.CpuRunning);
 		size = stack.size() * 8;
-		return (const u32 *)&stack[0];
+		if (!stack.empty())
+			return (const u32 *)&stack[0];
+		else
+			return nullptr;
 	}

 	void subroutineCall()
@@ -312,13 +342,6 @@ public:

 	u32 exception = 0;

-	struct Breakpoint {
-		Breakpoint() = default;
-		Breakpoint(u16 type, u32 addr) : addr(addr), type(type) { }
-		u32 addr = 0;
-		u16 type = 0;
-		u16 savedOp = 0;
-	};
-	std::map<u32, Breakpoint> breakpoints;
+	std::map<u32, Breakpoint> breakpoints[Breakpoint::Type::BP_TYPE_COUNT];
 	std::vector<std::pair<u32, u32>> stack;
 };
@@ -23,9 +23,11 @@ namespace debugger {
 // exception thrown in response to trap
 struct Stop { };

+	static const int DEFAULT_PORT = 3263;
+
 #ifdef GDB_SERVER

-	void init();
+	void init(int port);
 	void term();
 	void run();
 	void debugTrap(u32 event);
@@ -33,7 +35,7 @@ struct Stop { };
 	void subroutineReturn();

 #else
-	static inline void init() {}
+	static inline void init(int port) {}
 	static inline void term() {}
 	static inline void run() {}
 	static inline void debugTrap(u32 event) {}
@@ -38,7 +38,7 @@ unsigned long track_mode;
 /////////////////////////////////////////////////////////////////////////////


-void CDI_read_track (FILE *fsource, image_s *image, track_s *track)
+bool CDI_read_track (FILE *fsource, image_s *image, track_s *track)
 {

     unsigned char TRACK_START_MARK[10] = { 0, 0, 0x01, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF };
@@ -49,10 +49,16 @@ void CDI_read_track (FILE *fsource, image_s *image, track_s *track)
            fseek(fsource, 8, SEEK_CUR); // extra data (DJ 3.00.780 and up)

         fread(&current_start_mark, 10, 1, fsource);
-         if (memcmp(TRACK_START_MARK, current_start_mark, 10)) printf( "Unsupported format: Could not find the track start mark");
+         if (memcmp(TRACK_START_MARK, current_start_mark, 10)) {
+        	 printf("CDI_read_track: Unsupported format: Could not find the track start mark\n");
+        	 return false;
+         }

         fread(&current_start_mark, 10, 1, fsource);
-         if (memcmp(TRACK_START_MARK, current_start_mark, 10)) printf(  "Unsupported format: Could not find the track start mark");
+         if (memcmp(TRACK_START_MARK, current_start_mark, 10)) {
+        	 printf("CDI_read_track: Unsupported format: Could not find the track start mark\n");
+        	 return false;
+         }

         fseek(fsource, 4, SEEK_CUR);
         fread(&track->filename_length, 1, 1, fsource);
@@ -80,20 +86,25 @@ void CDI_read_track (FILE *fsource, image_s *image, track_s *track)
               case 1 : track->sector_size = 2336; break;
               case 2 : track->sector_size = 2352; break;
               case 4 : track->sector_size = 2448; break;
-               default: printf("Unsupported sector size. value %ld\n", track->sector_size_value);
-               		break;
+               default:
+            	   printf("CDI_read_track: Unsupported sector size. value %ld\n", track->sector_size_value);
+               	   return false;
               }

-         if (track->mode > 2) printf( "Unsupported format: Track mode not supported");
+         if (track->mode > 2) {
+        	 printf("CDI_read_track: Unsupported format: Track mode not supported\n");
+        	 return false;
+         }

         fseek(fsource, 29, SEEK_CUR);
         if (image->version != CDI_V2)
-            {
+         {
            fseek(fsource, 5, SEEK_CUR);
            fread(&temp_value, 4, 1, fsource);
            if (temp_value == 0xffffffff)
                fseek(fsource, 78, SEEK_CUR); // extra data (DJ 3.00.780 and up)
-            }
+         }
+         return true;
 }


@@ -104,9 +115,9 @@ void CDI_skip_next_session (FILE *fsource, image_s *image)
     if (image->version != CDI_V2) fseek(fsource, 1, SEEK_CUR);
 }

-void CDI_get_tracks (FILE *fsource, image_s *image)
+bool CDI_get_tracks (FILE *fsource, image_s *image)
 {
-     fread(&image->tracks, 2, 1, fsource);
+     return fread(&image->tracks, 2, 1, fsource) == 1;
 }

 bool CDI_init (FILE *fsource, image_s *image, const char *fsourcename)
@@ -121,8 +132,9 @@ bool CDI_init (FILE *fsource, image_s *image, const char *fsourcename)
 	}

 	fseek(fsource, image->length-8, SEEK_SET);
-	fread(&image->version, 4, 1, fsource);
-	fread(&image->header_offset, 4, 1, fsource);
+	if (fread(&image->version, 4, 1, fsource) != 1
+			|| fread(&image->header_offset, 4, 1, fsource) != 1)
+		return false;

 	if ((image->version != CDI_V2 && image->version != CDI_V3 && image->version != CDI_V35)
 			|| image->header_offset == 0)
@@ -133,7 +145,7 @@ bool CDI_init (FILE *fsource, image_s *image, const char *fsourcename)
 	return true;
 }

-void CDI_get_sessions (FILE *fsource, image_s *image)
+bool CDI_get_sessions (FILE *fsource, image_s *image)
 {
 #ifndef DEBUG_CDI
     if (image->version == CDI_V35)
@@ -144,6 +156,6 @@ void CDI_get_sessions (FILE *fsource, image_s *image)
 #else
     fseek(fsource, 0L, SEEK_SET);
 #endif
-     fread(&image->sessions, 2, 1, fsource);
+     return fread(&image->sessions, 2, 1, fsource) == 1;
 }

@@ -38,9 +38,9 @@ typedef struct track_s

 unsigned long ask_type(FILE *fsource, long header_position);
 bool CDI_init(FILE *fsource, image_s *image, const char *fsourcename);
-void CDI_get_sessions(FILE *fsource, image_s *image);
-void CDI_get_tracks(FILE *fsource, image_s *image);
-void CDI_read_track(FILE *fsource, image_s *image, track_s *track);
+bool CDI_get_sessions(FILE *fsource, image_s *image);
+bool CDI_get_tracks(FILE *fsource, image_s *image);
+bool CDI_read_track(FILE *fsource, image_s *image, track_s *track);
 void CDI_skip_next_session(FILE *fsource, image_s *image);

 #endif
@@ -579,26 +579,6 @@ GGPO_API GGPOErrorCode __cdecl ggpo_set_disconnect_timeout(GGPOSession *,
 GGPO_API GGPOErrorCode __cdecl ggpo_set_disconnect_notify_start(GGPOSession *,
                                                                int timeout);

-/*
- * ggpo_log --
- *
- * Used to write to the ggpo.net log.  In the current versions of the
- * SDK, a log file is only generated if the "quark.log" environment
- * variable is set to 1.  This will change in future versions of the
- * SDK.
- */
-GGPO_API void __cdecl ggpo_log(GGPOSession *,
-                               const char *fmt, ...);
-/*
- * ggpo_logv --
- *
- * A varargs compatible version of ggpo_log.  See ggpo_log for
- * more details.
- */
-GGPO_API void __cdecl ggpo_logv(GGPOSession *,
-                                const char *fmt,
-                                va_list args);
-
 /*
 * ggpo_send_message --
 *
@@ -20,7 +20,6 @@ struct GGPOSession {
   virtual GGPOErrorCode IncrementFrame(void) { return GGPO_OK; }
   virtual GGPOErrorCode DisconnectPlayer(GGPOPlayerHandle handle) { return GGPO_OK; }
   virtual GGPOErrorCode GetNetworkStats(GGPONetworkStats *stats, GGPOPlayerHandle handle) { return GGPO_OK; }
-   virtual GGPOErrorCode Logv(const char *fmt, va_list list) { ::Logv(fmt, list); return GGPO_OK; }

   virtual GGPOErrorCode SetFrameDelay(GGPOPlayerHandle player, int delay) { return GGPO_ERRORCODE_UNSUPPORTED; }
   virtual GGPOErrorCode SetDisconnectTimeout(int timeout) { return GGPO_ERRORCODE_UNSUPPORTED; }
@@ -130,12 +130,12 @@ Peer2PeerBackend::DoPoll(int timeout)
            total_min_confirmed = PollNPlayers(current_frame);
         }

-         Log("last confirmed frame in p2p backend is %d.\n", total_min_confirmed);
+         Log("last confirmed frame in p2p backend is %d.", total_min_confirmed);
         if (total_min_confirmed >= 0) {
            ASSERT(total_min_confirmed != INT_MAX);
            if (_num_spectators > 0) {
               while (_next_spectator_frame <= total_min_confirmed) {
-                  Log("pushing frame %d to spectators.\n", _next_spectator_frame);
+                  Log("pushing frame %d to spectators.", _next_spectator_frame);
   
                  GameInput input;
                  input.frame = _next_spectator_frame;
@@ -147,7 +147,7 @@ Peer2PeerBackend::DoPoll(int timeout)
                  _next_spectator_frame++;
               }
            }
-            Log("setting confirmed frame in sync to %d.\n", total_min_confirmed);
+            Log("setting confirmed frame in sync to %d.", total_min_confirmed);
            _sync.SetLastConfirmedFrame(total_min_confirmed);
         }

@@ -189,12 +189,12 @@ int Peer2PeerBackend::Poll2Players(int current_frame)
      if (!_local_connect_status[i].disconnected) {
         total_min_confirmed = MIN(_local_connect_status[i].last_frame, total_min_confirmed);
      }
-      Log("  local endp: connected = %d, last_received = %d, total_min_confirmed = %d.\n", !_local_connect_status[i].disconnected, _local_connect_status[i].last_frame, total_min_confirmed);
+      Log("  local endp: connected = %d, last_received = %d, total_min_confirmed = %d.", !_local_connect_status[i].disconnected, _local_connect_status[i].last_frame, total_min_confirmed);
      if (!queue_connected && !_local_connect_status[i].disconnected) {
-         Log("disconnecting i %d by remote request.\n", i);
+         Log("disconnecting i %d by remote request.", i);
         DisconnectPlayerQueue(i, total_min_confirmed);
      }
-      Log("  total_min_confirmed = %d.\n", total_min_confirmed);
+      Log("  total_min_confirmed = %d.", total_min_confirmed);
   }
   return total_min_confirmed;
 }
@@ -208,7 +208,7 @@ int Peer2PeerBackend::PollNPlayers(int current_frame)
   for (queue = 0; queue < _num_players; queue++) {
      bool queue_connected = true;
      int queue_min_confirmed = MAX_INT;
-      Log("considering queue %d.\n", queue);
+      Log("considering queue %d.", queue);
      for (i = 0; i < _num_players; i++) {
         // we're going to do a lot of logic here in consideration of endpoint i.
         // keep accumulating the minimum confirmed point for all n*n packets and
@@ -218,16 +218,16 @@ int Peer2PeerBackend::PollNPlayers(int current_frame)

            queue_connected = queue_connected && connected;
            queue_min_confirmed = MIN(last_received, queue_min_confirmed);
-            Log("  endpoint %d: connected = %d, last_received = %d, queue_min_confirmed = %d.\n", i, connected, last_received, queue_min_confirmed);
+            Log("  endpoint %d: connected = %d, last_received = %d, queue_min_confirmed = %d.", i, connected, last_received, queue_min_confirmed);
         } else {
-            Log("  endpoint %d: ignoring... not running.\n", i);
+            Log("  endpoint %d: ignoring... not running.", i);
         }
      }
      // merge in our local status only if we're still connected!
      if (!_local_connect_status[queue].disconnected) {
         queue_min_confirmed = MIN(_local_connect_status[queue].last_frame, queue_min_confirmed);
      }
-      Log("  local endp: connected = %d, last_received = %d, queue_min_confirmed = %d.\n", !_local_connect_status[queue].disconnected, _local_connect_status[queue].last_frame, queue_min_confirmed);
+      Log("  local endp: connected = %d, last_received = %d, queue_min_confirmed = %d.", !_local_connect_status[queue].disconnected, _local_connect_status[queue].last_frame, queue_min_confirmed);

      if (queue_connected) {
         total_min_confirmed = MIN(queue_min_confirmed, total_min_confirmed);
@@ -236,11 +236,11 @@ int Peer2PeerBackend::PollNPlayers(int current_frame)
         // so, we need to re-adjust.  This can happen when we detect our own disconnect at frame n
         // and later receive a disconnect notification for frame n-1.
         if (!_local_connect_status[queue].disconnected || _local_connect_status[queue].last_frame > queue_min_confirmed) {
-            Log("disconnecting queue %d by remote request.\n", queue);
+            Log("disconnecting queue %d by remote request.", queue);
            DisconnectPlayerQueue(queue, queue_min_confirmed);
         }
      }
-      Log("  total_min_confirmed = %d.\n", total_min_confirmed);
+      Log("  total_min_confirmed = %d.", total_min_confirmed);
   }
   return total_min_confirmed;
 }
@@ -335,7 +335,7 @@ Peer2PeerBackend::SyncInput(void *values,
 GGPOErrorCode
 Peer2PeerBackend::IncrementFrame(void)
 {  
-   Log("End of frame (%d)...\n", _sync.GetFrameCount());
+   Log("End of frame (%d)...", _sync.GetFrameCount());
   _sync.IncrementFrame();
   DoPoll(0);
   PollSyncEvents();
@@ -383,7 +383,7 @@ Peer2PeerBackend::OnUdpProtocolPeerEvent(UdpProtocol::Event &evt, int queue)

            _sync.AddRemoteInput(queue, evt.u.input.input);
            // Notify the other endpoints which frame we received from a peer
-            Log("setting remote connect status for queue %d to %d\n", queue, evt.u.input.input.frame);
+            Log("setting remote connect status for queue %d to %d", queue, evt.u.input.input.frame);
            _local_connect_status[queue].last_frame = evt.u.input.input.frame;
         }
         break;
@@ -493,14 +493,14 @@ Peer2PeerBackend::DisconnectPlayer(GGPOPlayerHandle player)
      int current_frame = _sync.GetFrameCount();
      // xxx: we should be tracking who the local player is, but for now assume
      // that if the endpoint is not initalized, this must be the local player.
-      Log("Disconnecting local player %d at frame %d by user request.\n", queue, _local_connect_status[queue].last_frame);
+      Log("Disconnecting local player %d at frame %d by user request.", queue, _local_connect_status[queue].last_frame);
      for (int i = 0; i < _num_players; i++) {
         if (_endpoints[i].IsInitialized()) {
            DisconnectPlayerQueue(i, current_frame);
         }
      }
   } else {
-      Log("Disconnecting queue %d at frame %d by user request.\n", queue, _local_connect_status[queue].last_frame);
+      Log("Disconnecting queue %d at frame %d by user request.", queue, _local_connect_status[queue].last_frame);
      DisconnectPlayerQueue(queue, _local_connect_status[queue].last_frame);
   }
   return GGPO_OK;
@@ -514,16 +514,16 @@ Peer2PeerBackend::DisconnectPlayerQueue(int queue, int syncto)

   _endpoints[queue].Disconnect();

-   Log("Changing queue %d local connect status for last frame from %d to %d on disconnect request (current: %d).\n",
+   Log("Changing queue %d local connect status for last frame from %d to %d on disconnect request (current: %d).",
       queue, _local_connect_status[queue].last_frame, syncto, framecount);

   _local_connect_status[queue].disconnected = 1;
   _local_connect_status[queue].last_frame = syncto;

   if (syncto != GameInput::NullFrame && syncto < framecount) {
-      Log("adjusting simulation to account for the fact that %d disconnected @ %d.\n", queue, syncto);
+      Log("adjusting simulation to account for the fact that %d disconnected @ %d.", queue, syncto);
      _sync.AdjustSimulation(syncto);
-      Log("finished adjusting simulation.\n");
+      Log("finished adjusting simulation.");
   }

   info.code = GGPO_EVENTCODE_DISCONNECTED_FROM_PEER;
@@ -92,7 +92,7 @@ SpectatorBackend::SyncInput(void *values,
 GGPOErrorCode
 SpectatorBackend::IncrementFrame(void)
 {  
-   Log("End of frame (%d)...\n", _next_input_to_send - 1);
+   Log("End of frame (%d)...", _next_input_to_send - 1);
   DoPoll(0);
   PollUdpProtocolEvents();

@@ -83,7 +83,6 @@ SyncTestBackend::SyncInput(void *values,
                           int size,
                           int *disconnect_flags)
 {
-   BeginLog(false);
   if (_rollingback) {
      _last_input = _saved_frames.front().input;
   } else {
@@ -105,8 +104,7 @@ SyncTestBackend::IncrementFrame(void)
   _sync.IncrementFrame();
   _current_input.erase();
   
-   Log("End of frame(%d)...\n", _sync.GetFrameCount());
-   EndLog();
+   DEBUG_LOG(NETWORK, "End of frame(%d)...", _sync.GetFrameCount());

   if (_rollingback) {
      return GGPO_OK;
@@ -171,47 +169,9 @@ SyncTestBackend::RaiseSyncError(const char *fmt, ...)
 #ifdef _WIN32
   OutputDebugStringA(buf);
 #endif
-   EndLog();
 //   DebugBreak();
 }

-GGPOErrorCode
-SyncTestBackend::Logv(char *fmt, va_list list)
-{
-   if (_logfp) {
-      vfprintf(_logfp, fmt, list);
-   }
-   return GGPO_OK;
-}
-
-void
-SyncTestBackend::BeginLog(int saving)
-{
-   EndLog();
-
-   char filename[MAX_PATH];
-#ifdef _WIN32
-   CreateDirectoryA("synclogs", NULL);
-#else
-   mkdir("synclogs", 0755);
-#endif
-   snprintf(filename, ARRAY_SIZE(filename), "synclogs/%s-%04d-%s.log",
-           saving ? "state" : "log",
-           _sync.GetFrameCount(),
-           _rollingback ? "replay" : "original");
-
-    _logfp = fopen(filename, "w");
-}
-
-void
-SyncTestBackend::EndLog()
-{
-   if (_logfp) {
-      fprintf(_logfp, "Closing log file.\n");
-      fclose(_logfp);
-      _logfp = NULL;
-   }
-}
 void
 SyncTestBackend::LogSaveStates(SavedInfo &info)
 {
@@ -24,7 +24,6 @@ public:
   virtual GGPOErrorCode AddLocalInput(GGPOPlayerHandle player, void *values, int size);
   virtual GGPOErrorCode SyncInput(void *values, int size, int *disconnect_flags);
   virtual GGPOErrorCode IncrementFrame(void);
-   virtual GGPOErrorCode Logv(char *fmt, va_list list);

 protected:
   struct SavedInfo {
@@ -36,8 +35,6 @@ protected:
   };

   void RaiseSyncError(const char *fmt, ...);
-   void BeginLog(int saving);
-   void EndLog();
   void LogSaveStates(SavedInfo &info);

 protected:
@@ -8,7 +8,6 @@
 #include "game_input.h"

 #include "ggpo_types.h"
-#include "log.h"

 void
 GameInput::init(int iframe, char *ibits, int isize, int offset)
@@ -65,25 +64,23 @@ GameInput::log(char *prefix, bool show_frame) const
 	size_t c = strlen(prefix);
 	strcpy(buf, prefix);
 	desc(buf + c, ARRAY_SIZE(buf) - c, show_frame);
-	strcat(buf, "\n");
-	Log(buf);
+	Log("%s", buf);
 }

 bool
 GameInput::equal(GameInput &other, bool bitsonly)
 {
   if (!bitsonly && frame != other.frame) {
-      Log("frames don't match: %d, %d\n", frame, other.frame);
+      Log("frames don't match: %d, %d", frame, other.frame);
   }
   if (size != other.size) {
-      Log("sizes don't match: %d, %d\n", size, other.size);
-   }
-   if (memcmp(bits, other.bits, size)) {
-      Log("bits don't match\n");
+      Log("sizes don't match: %d, %d", size, other.size);
   }
+   bool match = memcmp(bits, other.bits, size) == 0;
+   if (!match)
+      Log("bits don't match");
   ASSERT(size && other.size);
   return (bitsonly || frame == other.frame) &&
-          size == other.size &&
-          memcmp(bits, other.bits, size) == 0;
+          size == other.size && match;
 }

@@ -40,6 +40,7 @@ typedef short int16;
 typedef int int32;

 #include "ggponet.h"
+#include "log/Log.h"
 #include <stdexcept>

 class GGPOException : public std::runtime_error {
@@ -61,8 +62,6 @@ public:
 #  error Unsupported platform
 #endif

-#include "log.h"
-
 /*
 * Macros
 */
@@ -70,16 +69,14 @@ public:
   do {                                                     \
      if (!(x)) {                                           \
         char assert_buf[1024];                             \
-         snprintf(assert_buf, sizeof(assert_buf) - 1, "Assertion: %s @ %s:%d (pid:%ld)", #x, __FILE__, __LINE__, (long)GGPOPlatform::GetProcessID()); \
-         Log("%s\n", assert_buf);                           \
-         Log("\n");                                         \
-         Log("\n");                                         \
-         Log("\n");                                         \
-         GGPOPlatform::AssertFailed(assert_buf);                \
-         exit(0);                                           \
+         snprintf(assert_buf, sizeof(assert_buf) - 1, "Assertion: %s @ %s:%d", #x, __FILE__, __LINE__); \
+         GGPOPlatform::AssertFailed(assert_buf);            \
+         throw GGPOException(assert_buf, GGPO_ERRORCODE_GENERAL_FAILURE); \
      }                                                     \
   } while (false)

+#define Log(...) DEBUG_LOG(NETWORK, __VA_ARGS__)
+
 #ifndef ARRAY_SIZE
 #  define ARRAY_SIZE(a)    (sizeof(a) / sizeof((a)[0]))
 #endif
@@ -48,7 +48,7 @@ InputQueue::Init(int id, int input_size)
 int
 InputQueue::GetLastConfirmedFrame()
 {
-   Log("returning last confirmed frame %d.\n", _last_added_frame);
+   Log("input q%d | returning last confirmed frame %d.", _id, _last_added_frame);
   return _last_added_frame;
 }

@@ -67,21 +67,21 @@ InputQueue::DiscardConfirmedFrames(int frame)
      frame = MIN(frame, _last_frame_requested);
   }

-   Log("discarding confirmed frames up to %d (last_added:%d length:%d [head:%d tail:%d]).\n", 
+   Log("input q%d | discarding confirmed frames up to %d (last_added:%d length:%d [head:%d tail:%d]).", _id,
       frame, _last_added_frame, _length, _head, _tail);
   if (frame >= _last_added_frame) {
      _tail = _head;
   } else {
      int offset = frame - _inputs[_tail].frame + 1;
      
-      Log("difference of %d frames.\n", offset);
+      Log("input q%d | difference of %d frames.", _id, offset);
      ASSERT(offset >= 0);

      _tail = (_tail + offset) % INPUT_QUEUE_LENGTH;
      _length -= offset;
   }

-   Log("after discarding, new tail is %d (frame:%d).\n", _tail, _inputs[_tail].frame);
+   Log("input q%d | after discarding, new tail is %d (frame:%d).", _id, _tail, _inputs[_tail].frame);
   ASSERT(_length >= 0);
 }

@@ -90,7 +90,7 @@ InputQueue::ResetPrediction(int frame)
 {
   ASSERT(_first_incorrect_frame == GameInput::NullFrame || frame <= _first_incorrect_frame);

-   Log("resetting all prediction errors back to frame %d.\n", frame);
+   Log("input q%d | resetting all prediction errors back to frame %d.", _id, frame);

   /*
    * There's nothing really to do other than reset our prediction
@@ -116,7 +116,7 @@ InputQueue::GetConfirmedInput(int requested_frame, GameInput *input)
 bool
 InputQueue::GetInput(int requested_frame, GameInput *input)
 {
-   Log("requesting input frame %d.\n", requested_frame);
+   Log("input q%d | requesting input frame %d.", _id, requested_frame);

   /*
    * No one should ever try to grab any input when we have a prediction
@@ -144,7 +144,7 @@ InputQueue::GetInput(int requested_frame, GameInput *input)
         offset = (offset + _tail) % INPUT_QUEUE_LENGTH;
         ASSERT(_inputs[offset].frame == requested_frame);
         *input = _inputs[offset];
-         Log("returning confirmed frame number %d.\n", input->frame);
+         Log("input q%d | returning confirmed frame number %d.", _id, input->frame);
         return true;
      }

@@ -154,13 +154,13 @@ InputQueue::GetInput(int requested_frame, GameInput *input)
       * same thing they did last time.
       */
      if (requested_frame == 0) {
-         Log("basing new prediction frame from nothing, you're client wants frame 0.\n");
+         Log("input q%d | basing new prediction frame from nothing, you're client wants frame 0.", _id);
         _prediction.erase();
      } else if (_last_added_frame == GameInput::NullFrame) {
-         Log("basing new prediction frame from nothing, since we have no frames yet.\n");
+         Log("input q%d | basing new prediction frame from nothing, since we have no frames yet.", _id);
         _prediction.erase();
      } else {
-         Log("basing new prediction frame from previously added frame (queue entry:%d, frame:%d).\n",
+         Log("input q%d | basing new prediction frame from previously added frame (queue entry:%d, frame:%d).", _id,
              PREVIOUS_FRAME(_head), _inputs[PREVIOUS_FRAME(_head)].frame);
         _prediction = _inputs[PREVIOUS_FRAME(_head)];
      }
@@ -176,7 +176,7 @@ InputQueue::GetInput(int requested_frame, GameInput *input)
    */
   *input = _prediction;
   input->frame = requested_frame;
-   Log("returning prediction frame number %d (%d).\n", input->frame, _prediction.frame);
+   Log("input q%d | returning prediction frame number %d (%d).", _id, input->frame, _prediction.frame);

   return false;
 }
@@ -186,7 +186,7 @@ InputQueue::AddInput(GameInput &input)
 {
   int new_frame;

-   Log("adding input frame number %d to queue.\n", input.frame);
+   Log("input q%d | adding input frame number %d to queue.", _id, input.frame);

   /*
    * These next two lines simply verify that inputs are passed in 
@@ -216,7 +216,7 @@ InputQueue::AddInput(GameInput &input)
 void
 InputQueue::AddDelayedInputToQueue(GameInput &input, int frame_number)
 {
-   Log("adding delayed input frame number %d to queue.\n", frame_number);
+   Log("input q%d | adding delayed input frame number %d to queue.", _id, frame_number);

   if (input.size != _prediction.size)
 	   throw GGPOException("Input size differs from peer", GGPO_ERRORCODE_INPUT_SIZE_DIFF);
@@ -246,7 +246,7 @@ InputQueue::AddDelayedInputToQueue(GameInput &input, int frame_number)
       * in GetFirstIncorrectFrame()
       */
      if (_first_incorrect_frame == GameInput::NullFrame && !_prediction.equal(input, true)) {
-         Log("frame %d does not match prediction.  marking error.\n", frame_number);
+         Log("input q%d | frame %d does not match prediction.  marking error.", _id, frame_number);
         _first_incorrect_frame = frame_number;
      }

@@ -257,7 +257,7 @@ InputQueue::AddDelayedInputToQueue(GameInput &input, int frame_number)
       * count up.
       */
      if (_prediction.frame == _last_frame_requested && _first_incorrect_frame == GameInput::NullFrame) {
-         Log("prediction is correct!  dumping out of prediction mode.\n");
+         Log("input q%d | prediction is correct!  dumping out of prediction mode.", _id);
         _prediction.frame = GameInput::NullFrame;
      } else {
         _prediction.frame++;
@@ -269,7 +269,7 @@ InputQueue::AddDelayedInputToQueue(GameInput &input, int frame_number)
 int
 InputQueue::AdvanceQueueHead(int frame)
 {
-   Log("advancing queue head to frame %d.\n", frame);
+   Log("input q%d | advancing queue head to frame %d.", _id, frame);

   int expected_frame = _first_frame ? 0 : _inputs[PREVIOUS_FRAME(_head)].frame + 1;

@@ -281,7 +281,7 @@ InputQueue::AdvanceQueueHead(int frame)
       * time we shoved a frame into the system.  In this case, there's
       * no room on the queue.  Toss it.
       */
-      Log("Dropping input frame %d (expected next frame to be %d).\n",
+      Log("input q%d | Dropping input frame %d (expected next frame to be %d).", _id,
          frame, expected_frame);
      return GameInput::NullFrame;
   }
@@ -293,7 +293,7 @@ InputQueue::AdvanceQueueHead(int frame)
       * last frame in the queue several times in order to fill the space
       * left.
       */
-      Log("Adding padding frame %d to account for change in frame delay.\n",
+      Log("input q%d | Adding padding frame %d to account for change in frame delay.", _id,
          expected_frame);
      GameInput &last_frame = _inputs[PREVIOUS_FRAME(_head)];     
      AddDelayedInputToQueue(last_frame, expected_frame);
@@ -303,19 +303,3 @@ InputQueue::AdvanceQueueHead(int frame)
   ASSERT(frame == 0 || frame == _inputs[PREVIOUS_FRAME(_head)].frame + 1);
   return frame;
 }
-
-
-void
-InputQueue::Log(const char *fmt, ...)
-{
-   char buf[1024];
-   size_t offset;
-   va_list args;
-
-   offset = snprintf(buf, ARRAY_SIZE(buf), "input q%d | ", _id);
-   va_start(args, fmt);
-   vsnprintf(buf + offset, ARRAY_SIZE(buf) - offset - 1, fmt, args);
-   buf[ARRAY_SIZE(buf)-1] = '\0';
-   ::Log(buf);
-   va_end(args);
-}
@@ -34,7 +34,6 @@ public:
 protected:
   int AdvanceQueueHead(int frame);
   void AddDelayedInputToQueue(GameInput &input, int i);
-   void Log(const char *fmt, ...);

 protected:
   int                  _id;
@@ -1,31 +0,0 @@
-/* -----------------------------------------------------------------------
- * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
- *
- * Use of this software is governed by the MIT license that can be found
- * in the LICENSE file.
- */
-
-#include "ggpo_types.h"
-#include "log/Log.h"
-#include "log/LogManager.h"
-#include <string>
-
-void Log(const char *fmt, ...)
-{
-   va_list args;
-   va_start(args, fmt);
-   Logv(fmt, args);
-   va_end(args);
-}
-
-void Logv(const char* fmt, va_list args)
-{
-	std::string copy;
-	if (fmt[strlen(fmt) - 1] == '\n') {
-		copy = fmt;
-		copy.pop_back();
-		fmt = copy.c_str();
-	}
-	if (LogManager::GetInstance())
-		LogManager::GetInstance()->Log(LogTypes::LDEBUG, LogTypes::NETWORK, __FILE__, __LINE__, fmt, args);
-}
@@ -1,14 +0,0 @@
-/* -----------------------------------------------------------------------
- * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
- *
- * Use of this software is governed by the MIT license that can be found
- * in the LICENSE file.
- */
-
-#ifndef _LOG_H
-#define _LOG_H
-
-extern void Log(const char *fmt, ...);
-extern void Logv(const char *fmt, va_list list);
-
-#endif
@@ -23,22 +23,6 @@ struct Init
 };
 static Init init;

-void
-ggpo_log(GGPOSession *ggpo, const char *fmt, ...)
-{
-   va_list args;
-   va_start(args, fmt);
-   ggpo_logv(ggpo, fmt, args);
-   va_end(args);
-}
-
-void
-ggpo_logv(GGPOSession *ggpo, const char *fmt, va_list args)
-{
-   if (ggpo)
-      ggpo->Logv(fmt, args);
-}
-
 GGPOErrorCode
 ggpo_start_session(GGPOSession **session,
                   GGPOSessionCallbacks *cb,
@@ -59,7 +43,7 @@ ggpo_start_session(GGPOSession **session,
 													 verification_size);
 	   return GGPO_OK;
 	} catch (const GGPOException& e) {
-	   Log("GGPOException in ggpo_start_session: %s", e.what());
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_start_session: %s", e.what());
 	   return e.ggpoError;
 	}
 }
@@ -74,7 +58,7 @@ ggpo_add_player(GGPOSession *ggpo,
   try {
 	   return ggpo->AddPlayer(player, handle);
   } catch (const GGPOException& e) {
-	   Log("GGPOException in ggpo_add_player: %s", e.what());
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_add_player: %s", e.what());
 	   return e.ggpoError;
   }
 }
@@ -93,7 +77,7 @@ ggpo_start_synctest(GGPOSession **ggpo,
 	   *ggpo = (GGPOSession *)new SyncTestBackend(cb, game, frames, num_players);
 	   return GGPO_OK;
 	} catch (const GGPOException& e) {
-	   Log("GGPOException in ggpo_start_synctest: %s", e.what());
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_start_synctest: %s", e.what());
 	   return e.ggpoError;
 	}
 }
@@ -108,7 +92,7 @@ ggpo_set_frame_delay(GGPOSession *ggpo,
   try {
 	   return ggpo->SetFrameDelay(player, frame_delay);
   } catch (const GGPOException& e) {
-	   Log("GGPOException in ggpo_set_frame_delay: %s", e.what());
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_set_frame_delay: %s", e.what());
 	   return e.ggpoError;
   }
 }
@@ -121,7 +105,7 @@ ggpo_idle(GGPOSession *ggpo, int timeout)
   try {
 	   return ggpo->DoPoll(timeout);
   } catch (const GGPOException& e) {
-	   Log("GGPOException in ggpo_idle: %s", e.what());
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_idle: %s", e.what());
 	   return e.ggpoError;
   }
 }
@@ -137,7 +121,7 @@ ggpo_add_local_input(GGPOSession *ggpo,
   try {
      return ggpo->AddLocalInput(player, values, size);
   } catch (const GGPOException& e) {
-      Log("GGPOException in ggpo_add_local_input: %s", e.what());
+	  ERROR_LOG(NETWORK, "GGPOException in ggpo_add_local_input: %s", e.what());
      return e.ggpoError;
   }
 }
@@ -153,7 +137,7 @@ ggpo_synchronize_input(GGPOSession *ggpo,
   try {
      return ggpo->SyncInput(values, size, disconnect_flags);
   } catch (const GGPOException& e) {
-      Log("GGPOException in ggpo_synchronize_input: %s", e.what());
+	  ERROR_LOG(NETWORK, "GGPOException in ggpo_synchronize_input: %s", e.what());
      return e.ggpoError;
   }
 }
@@ -166,7 +150,7 @@ GGPOErrorCode ggpo_disconnect_player(GGPOSession *ggpo,
   try {
 	   return ggpo->DisconnectPlayer(player);
   } catch (const GGPOException& e) {
-	   Log("GGPOException in ggpo_disconnect_player: %s", e.what());
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_disconnect_player: %s", e.what());
 	   return e.ggpoError;
   }
 }
@@ -179,7 +163,7 @@ ggpo_advance_frame(GGPOSession *ggpo)
   try {
 	   return ggpo->IncrementFrame();
   } catch (const GGPOException& e) {
-	   Log("GGPOException in ggpo_advance_frame: %s", e.what());
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_advance_frame: %s", e.what());
 	   return e.ggpoError;
   }
 }
@@ -194,7 +178,7 @@ ggpo_get_network_stats(GGPOSession *ggpo,
   try {
 	   return ggpo->GetNetworkStats(stats, player);
   } catch (const GGPOException& e) {
-	   Log("GGPOException in ggpo_get_network_stats: %s", e.what());
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_get_network_stats: %s", e.what());
 	   return e.ggpoError;
   }
 }
@@ -218,7 +202,7 @@ ggpo_set_disconnect_timeout(GGPOSession *ggpo, int timeout)
   try {
 	   return ggpo->SetDisconnectTimeout(timeout);
   } catch (const GGPOException& e) {
-	   Log("GGPOException in ggpo_set_disconnect_timeout: %s", e.what());
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_set_disconnect_timeout: %s", e.what());
 	   return e.ggpoError;
   }
 }
@@ -231,7 +215,7 @@ ggpo_set_disconnect_notify_start(GGPOSession *ggpo, int timeout)
   try {
 	   return ggpo->SetDisconnectNotifyStart(timeout);
   } catch (const GGPOException& e) {
-	   Log("GGPOException in ggpo_set_disconnect_notify_start: %s", e.what());
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_set_disconnect_notify_start: %s", e.what());
 	   return e.ggpoError;
   }
 }
@@ -259,7 +243,7 @@ GGPOErrorCode ggpo_start_spectating(GGPOSession **session,
 													 verification_size);
 	   return GGPO_OK;
 	} catch (const GGPOException& e) {
-	   Log("GGPOException in ggpo_start_spectating: %s", e.what());
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_start_spectating: %s", e.what());
 	   return e.ggpoError;
 	}
 }
@@ -34,7 +34,7 @@ CreateSocket(uint16 bind_port, int retries)
   for (port = bind_port; port <= bind_port + retries; port++) {
      sin.sin_port = htons(port);
      if (bind(s, (sockaddr *)&sin, sizeof sin) == 0) {
-         Log("Udp bound to port: %d.\n", port);
+         Log("Udp bound to port: %d.", port);
         return s;
      }
   }
@@ -62,7 +62,7 @@ Udp::Init(uint16 port, Poll *poll, Callbacks *callbacks)
   _callbacks = callbacks;
   poll->RegisterLoop(this);

-   Log("binding udp socket to port %d.\n", port);
+   Log("binding udp socket to port %d.", port);
   _socket = CreateSocket(port, 0);
   if (_socket == INVALID_SOCKET)
 	   throw GGPOException("Socket creation or bind failed", GGPO_ERRORCODE_NETWORK_ERROR);
@@ -76,11 +76,11 @@ Udp::SendTo(char *buffer, int len, int flags, struct sockaddr *dst, int destlen)
   int res = sendto(_socket, buffer, len, flags, dst, destlen);
   if (res == SOCKET_ERROR) {
 	  int err = WSAGetLastError();
-      Log("unknown error in sendto (erro: %d  wsaerr: %d).\n", res, err);
+      Log("unknown error in sendto (erro: %d  wsaerr: %d).", res, err);
      ASSERT(false && "Unknown error in sendto");
   }
   char dst_ip[1024];
-   Log("sent packet length %d to %s:%d (ret:%d).\n", len, inet_ntop(AF_INET, (void *)&to->sin_addr, dst_ip, ARRAY_SIZE(dst_ip)), ntohs(to->sin_port), res);
+   Log("sent packet length %d to %s:%d (ret:%d).", len, inet_ntop(AF_INET, (void *)&to->sin_addr, dst_ip, ARRAY_SIZE(dst_ip)), ntohs(to->sin_port), res);
 }

 bool
@@ -99,32 +99,15 @@ Udp::OnLoopPoll(void *cookie)
      if (len == -1) {
         int error = WSAGetLastError();
         if (error != WSAEWOULDBLOCK) {
-            Log("recvfrom WSAGetLastError returned %d (%x).\n", error, error);
+            Log("recvfrom WSAGetLastError returned %d (%x).", error, error);
         }
         break;
      } else if (len > 0) {
         char src_ip[1024];
-         Log("recvfrom returned (len:%d  from:%s:%d).\n", len, inet_ntop(AF_INET, (void*)&recv_addr.sin_addr, src_ip, ARRAY_SIZE(src_ip)), ntohs(recv_addr.sin_port) );
+         Log("recvfrom returned (len:%d  from:%s:%d).", len, inet_ntop(AF_INET, (void*)&recv_addr.sin_addr, src_ip, ARRAY_SIZE(src_ip)), ntohs(recv_addr.sin_port) );
         UdpMsg *msg = (UdpMsg *)recv_buf;
         _callbacks->OnMsg(recv_addr, msg, len);
      } 
   }
   return true;
 }
-
-
-void
-Udp::Log(const char *fmt, ...)
-{
-   char buf[1024];
-   size_t offset;
-   va_list args;
-
-   strcpy(buf, "udp | ");
-   offset = strlen(buf);
-   va_start(args, fmt);
-   vsnprintf(buf + offset, ARRAY_SIZE(buf) - offset - 1, fmt, args);
-   buf[ARRAY_SIZE(buf)-1] = '\0';
-   ::Log(buf);
-   va_end(args);
-}
@@ -31,11 +31,6 @@ public:
      virtual void OnMsg(sockaddr_in &from, UdpMsg *msg, int len) = 0;
   };

-
-protected:
-   void Log(const char *fmt, ...);
-
-public:
   Udp();

   void Init(uint16 port, Poll *p, Callbacks *callbacks);
@@ -197,7 +197,7 @@ UdpProtocol::OnLoopPoll(void *cookie)
   case Syncing:
      next_interval = (_state.sync.roundtrips_remaining == NUM_SYNC_PACKETS) ? SYNC_FIRST_RETRY_INTERVAL : SYNC_RETRY_INTERVAL;
      if (_last_send_time && _last_send_time + next_interval < now && _peer_addr.sin_addr.s_addr != 0) {
-         Log("No luck syncing after %d ms... Re-queueing sync packet.\n", next_interval);
+         Log("udpproto%d | No luck syncing after %d ms... Re-queueing sync packet.", _queue, next_interval);
         SendSyncRequest();
      }
      break;
@@ -205,7 +205,7 @@ UdpProtocol::OnLoopPoll(void *cookie)
   case Running:
      // xxx: rig all this up with a timer wrapper
      if (!_state.running.last_input_packet_recv_time || _state.running.last_input_packet_recv_time + RUNNING_RETRY_INTERVAL < now) {
-         Log("Haven't exchanged packets in a while (last received:%d  last sent:%d).  Resending.\n", _last_received_input.frame, _last_sent_input.frame);
+         Log("udpproto%d | Haven't exchanged packets in a while (last received:%d  last sent:%d).  Resending.", _queue, _last_received_input.frame, _last_sent_input.frame);
         SendPendingOutput();
         _state.running.last_input_packet_recv_time = now;
      }
@@ -224,13 +224,13 @@ UdpProtocol::OnLoopPoll(void *cookie)
      }

      if (_last_send_time && _last_send_time + KEEP_ALIVE_INTERVAL < now) {
-         Log("Sending keep alive packet\n");
+         Log("udpproto%d | Sending keep alive packet", _queue);
         SendMsg(new UdpMsg(UdpMsg::KeepAlive));
      }

      if (_disconnect_timeout && _disconnect_notify_start && 
         !_disconnect_notify_sent && (_last_recv_time + _disconnect_notify_start < now)) {
-         Log("Endpoint has stopped receiving packets for %d ms.  Sending notification.\n", _disconnect_notify_start);
+         Log("udpproto%d | Endpoint has stopped receiving packets for %d ms.  Sending notification.", _queue, _disconnect_notify_start);
         Event e(Event::NetworkInterrupted);
         e.u.network_interrupted.disconnect_timeout = _disconnect_timeout - _disconnect_notify_start;
         QueueEvent(e);
@@ -239,7 +239,7 @@ UdpProtocol::OnLoopPoll(void *cookie)

      if (_disconnect_timeout && (_last_recv_time + _disconnect_timeout < now)) {
         if (!_disconnect_event_sent) {
-            Log("Endpoint has stopped receiving packets for %d ms.  Disconnecting.\n", _disconnect_timeout);
+            Log("udpproto%d | Endpoint has stopped receiving packets for %d ms.  Disconnecting.", _queue, _disconnect_timeout);
            QueueEvent(Event(Event::Disconnected));
            _disconnect_event_sent = true;
         }
@@ -248,7 +248,7 @@ UdpProtocol::OnLoopPoll(void *cookie)

   case Disconnected:
      if (_shutdown_timeout < now) {
-         Log("Shutting down udp connection.\n");
+         Log("udpproto%d | Shutting down udp connection.", _queue);
         _udp = NULL;
         _shutdown_timeout = 0;
      }
@@ -345,9 +345,9 @@ UdpProtocol::OnMsg(UdpMsg *msg, int len)

      // filter out out-of-order packets
      uint16 skipped = (uint16)((int)seq - (int)_next_recv_seq);
-      // Log("checking sequence number -> next - seq : %d - %d = %d\n", seq, _next_recv_seq, skipped);
+      // Log("udpproto%d | checking sequence number -> next - seq : %d - %d = %d", _queue, seq, _next_recv_seq, skipped);
      if (skipped > MAX_SEQ_DISTANCE) {
-         Log("dropping out of order packet (seq: %d, last seq:%d)\n", seq, _next_recv_seq);
+         Log("udpproto%d | dropping out of order packet (seq: %d, last seq:%d)", _queue, seq, _next_recv_seq);
         return;
      }
   }
@@ -384,9 +384,9 @@ UdpProtocol::UpdateNetworkStats(void)

   _kbps_sent = int(Bps / 1024);

-   Log("Network Stats -- Bandwidth: %.2f KBps   Packets Sent: %5d (%.2f pps)   "
-       "KB Sent: %.2f    UDP Overhead: %.2f %%.\n",
-       _kbps_sent, 
+   Log("udpproto%d | Network Stats -- Bandwidth: %.2f KBps   Packets Sent: %5d (%.2f pps)   "
+       "KB Sent: %.2f    UDP Overhead: %.2f %%.", _queue,
+       (float)_kbps_sent,
       _packets_sent,
       (float)_packets_sent * 1000 / (now - _stats_start_time),
       total_bytes_sent / 1024.0,
@@ -419,51 +419,35 @@ UdpProtocol::GetPeerConnectStatus(int id, int *frame)
   return !_peer_connect_status[id].disconnected;
 }

-void
-UdpProtocol::Log(const char *fmt, ...)
-{
-   char buf[1024];
-   size_t offset;
-   va_list args;
-
-   snprintf(buf, ARRAY_SIZE(buf), "udpproto%d | ", _queue);
-   offset = strlen(buf);
-   va_start(args, fmt);
-   vsnprintf(buf + offset, ARRAY_SIZE(buf) - offset - 1, fmt, args);
-   buf[ARRAY_SIZE(buf)-1] = '\0';
-   ::Log(buf);
-   va_end(args);
-}
-
 void
 UdpProtocol::LogMsg(const char *prefix, UdpMsg *msg)
 {
   switch (msg->hdr.type) {
   case UdpMsg::SyncRequest:
-      Log("%s sync-request (%d).\n", prefix,
+      Log("udpproto%d | %s sync-request (%d).", _queue, prefix,
          msg->u.sync_request.random_request);
      break;
   case UdpMsg::SyncReply:
-      Log("%s sync-reply (%d).\n", prefix,
+      Log("udpproto%d | %s sync-reply (%d).", _queue, prefix,
          msg->u.sync_reply.random_reply);
      break;
   case UdpMsg::QualityReport:
-      Log("%s quality report.\n", prefix);
+      Log("udpproto%d | %s quality report.", _queue, prefix);
      break;
   case UdpMsg::QualityReply:
-      Log("%s quality reply.\n", prefix);
+      Log("udpproto%d | %s quality reply.", _queue, prefix);
      break;
   case UdpMsg::KeepAlive:
-      Log("%s keep alive.\n", prefix);
+      Log("udpproto%d | %s keep alive.", _queue, prefix);
      break;
   case UdpMsg::Input:
-      Log("%s game-compressed-input %d (+ %d bits).\n", prefix, msg->u.input.start_frame, msg->u.input.num_bits);
+      Log("udpproto%d | %s game-compressed-input %d (+ %d bits).", _queue, prefix, msg->u.input.start_frame, msg->u.input.num_bits);
      break;
   case UdpMsg::InputAck:
-      Log("%s input ack.\n", prefix);
+      Log("udpproto%d | %s input ack.", _queue, prefix);
      break;
   case UdpMsg::AppData:
-      Log("%s app data (%d bytes).\n", prefix, msg->u.app_data.size);
+      Log("udpproto%d | %s app data (%d bytes).", _queue, prefix, msg->u.app_data.size);
      break;
   default:
      ASSERT(false && "Unknown UdpMsg type.");
@@ -474,7 +458,7 @@ void
 UdpProtocol::LogEvent(const char *prefix, const UdpProtocol::Event &evt)
 {
   if (evt.type == UdpProtocol::Event::Synchronzied)
-      Log("%s (event: Synchronzied).\n", prefix);
+      Log("udpproto%d | %s (event: Synchronized).", _queue, prefix);
 }

 bool
@@ -488,7 +472,7 @@ bool
 UdpProtocol::OnSyncRequest(UdpMsg *msg, int len)
 {
   if (_remote_magic_number != 0 && msg->hdr.magic != _remote_magic_number) {
-      Log("Ignoring sync request from unknown endpoint (%d != %d).\n", 
+      Log("udpproto%d | Ignoring sync request from unknown endpoint (%d != %d).", _queue,
           msg->hdr.magic, _remote_magic_number);
      return false;
   }
@@ -500,14 +484,14 @@ UdpProtocol::OnSyncRequest(UdpMsg *msg, int len)
   if (msgVerifSize != (int)verification.size()
 		   || (msgVerifSize != 0 && memcmp(&msg->u.sync_request.verification[0], &verification[0], msgVerifSize)))
   {
-	   Log("Verification mismatch: size received %d expected %d", msgVerifSize, (int)verification.size());
+	   Log("udpproto%d | Verification mismatch: size received %d expected %d", _queue, msgVerifSize, (int)verification.size());
 	   reply->u.sync_reply.verification_failure = 1;
 	   SendMsg(reply);
 	   throw GGPOException("Verification mismatch", GGPO_ERRORCODE_VERIFICATION_ERROR);
   }
   // FIXME
   if (_state.sync.roundtrips_remaining == NUM_SYNC_PACKETS && msg->hdr.sequence_number == 0) {
-      Log("Sync request 0 received... Re-queueing sync packet.\n");
+      Log("udpproto%d | Sync request 0 received... Re-queueing sync packet.", _queue);
      SendSyncRequest();
   }

@@ -521,12 +505,12 @@ bool
 UdpProtocol::OnSyncReply(UdpMsg *msg, int len)
 {
   if (_current_state != Syncing) {
-      Log("Ignoring SyncReply while not synching.\n");
+      Log("udpproto%d | Ignoring SyncReply while not synching.", _queue);
      return msg->hdr.magic == _remote_magic_number;
   }

   if (msg->u.sync_reply.random_reply != _state.sync.random) {
-      Log("sync reply %d != %d.  Keep looking...\n",
+      Log("udpproto%d | sync reply %d != %d.  Keep looking...", _queue,
          msg->u.sync_reply.random_reply, _state.sync.random);
      return false;
   }
@@ -538,9 +522,9 @@ UdpProtocol::OnSyncReply(UdpMsg *msg, int len)
      _connected = true;
   }

-   Log("Checking sync state (%d round trips remaining).\n", _state.sync.roundtrips_remaining);
+   Log("udpproto%d | Checking sync state (%d round trips remaining).", _queue, _state.sync.roundtrips_remaining);
   if (--_state.sync.roundtrips_remaining == 0) {
-      Log("Synchronized!\n");
+      Log("udpproto%d | Synchronized!", _queue);
      QueueEvent(UdpProtocol::Event(UdpProtocol::Event::Synchronzied));
      _current_state = Running;
      _last_received_input.frame = -1;
@@ -564,7 +548,7 @@ UdpProtocol::OnInput(UdpMsg *msg, int len)
   bool disconnect_requested = msg->u.input.disconnect_requested;
   if (disconnect_requested) {
      if (_current_state != Disconnected && !_disconnect_event_sent) {
-         Log("Disconnecting endpoint on remote request.\n");
+         Log("udpproto%d | Disconnecting endpoint on remote request.", _queue);
         QueueEvent(Event(Event::Disconnected));
         _disconnect_event_sent = true;
      }
@@ -629,20 +613,21 @@ UdpProtocol::OnInput(UdpMsg *msg, int len)
            _last_received_input.frame = currentFrame;

            /*
-             * Send the event to the emualtor
+             * Send the event to the emulator
             */
            UdpProtocol::Event evt(UdpProtocol::Event::Input);
            evt.u.input.input = _last_received_input;

-            _last_received_input.desc(desc, ARRAY_SIZE(desc));
+            if (LogTypes::LDEBUG <= MAX_LOGLEVEL)
+            	_last_received_input.desc(desc, ARRAY_SIZE(desc));

            _state.running.last_input_packet_recv_time = GGPOPlatform::GetCurrentTimeMS();

-            Log("Sending frame %d to emu queue %d (%s).\n", _last_received_input.frame, _queue, desc);
+            Log("udpproto%d | Sending frame %d to emu queue %d (%s).", _queue, _last_received_input.frame, _queue, desc);
            QueueEvent(evt);

         } else {
-            Log("Skipping past frame:(%d) current is %d.\n", currentFrame, _last_received_input.frame);
+            Log("udpproto%d | Skipping past frame:(%d) current is %d.", _queue, currentFrame, _last_received_input.frame);
         }

         /*
@@ -657,7 +642,7 @@ UdpProtocol::OnInput(UdpMsg *msg, int len)
    * Get rid of our buffered input
    */
   while (_pending_output.size() && _pending_output.front().frame < msg->u.input.ack_frame) {
-      Log("Throwing away pending output frame %d\n", _pending_output.front().frame);
+      Log("udpproto%d | Throwing away pending output frame %d", _queue, _pending_output.front().frame);
      _last_acked_input = _pending_output.front();
      _pending_output.pop();
   }
@@ -672,7 +657,7 @@ UdpProtocol::OnInputAck(UdpMsg *msg, int len)
    * Get rid of our buffered input
    */
   while (_pending_output.size() && _pending_output.front().frame < msg->u.input_ack.ack_frame) {
-      Log("Throwing away pending output frame %d\n", _pending_output.front().frame);
+      Log("udpproto%d | Throwing away pending output frame %d", _queue, _pending_output.front().frame);
      _last_acked_input = _pending_output.front();
      _pending_output.pop();
   }
@@ -770,7 +755,7 @@ UdpProtocol::PumpSendQueue()
      }
      if (_oop_percent && !_oo_packet.msg && ((rand() % 100) < _oop_percent)) {
         int delay = rand() % (_send_latency * 10 + 1000);
-         Log("creating rogue oop (seq: %d  delay: %d)\n", entry.msg->hdr.sequence_number, delay);
+         Log("udpproto%d | creating rogue oop (seq: %d  delay: %d)", _queue, entry.msg->hdr.sequence_number, delay);
         _oo_packet.send_time = GGPOPlatform::GetCurrentTimeMS() + delay;
         _oo_packet.msg = entry.msg;
         _oo_packet.dest_addr = entry.dest_addr;
@@ -785,7 +770,7 @@ UdpProtocol::PumpSendQueue()
      _send_queue.pop();
   }
   if (_oo_packet.msg && _oo_packet.send_time < (int)GGPOPlatform::GetCurrentTimeMS()) {
-      Log("sending rogue oop!");
+      Log("udpproto%d | sending rogue oop!", _queue);
      _udp->SendTo((char *)_oo_packet.msg, _oo_packet.msg->PacketSize(), 0,
                     (struct sockaddr *)&_oo_packet.dest_addr, sizeof _oo_packet.dest_addr);

@@ -119,7 +119,6 @@ protected:
   void UpdateNetworkStats(void);
   void QueueEvent(const UdpProtocol::Event &evt);
   void ClearSendQueue(void);
-   void Log(const char *fmt, ...);
   void LogMsg(const char *prefix, UdpMsg *msg);
   void LogEvent(const char *prefix, const UdpProtocol::Event &evt);
   void SendSyncRequest();
@@ -13,7 +13,7 @@
 template<class T, int N> class RingBuffer
 {
 public:
-   RingBuffer<T, N>() : 
+   RingBuffer() : 
      _head(0),
      _tail(0),
      _size(0) {
@@ -13,7 +13,7 @@
 template<class T, int N> class StaticBuffer
 {
 public:
-   StaticBuffer<T, N>() :
+   StaticBuffer() :
      _size(0) {
   } 

@@ -59,7 +59,7 @@ Sync::AddLocalInput(int queue, GameInput &input)
 {
   int frames_behind = _framecount - _last_confirmed_frame; 
   if (_framecount >= _max_prediction_frames && frames_behind >= _max_prediction_frames) {
-      Log("Rejecting input from emulator: reached prediction barrier.\n");
+      Log("Rejecting input from emulator: reached prediction barrier.");
      return false;
   }

@@ -67,7 +67,7 @@ Sync::AddLocalInput(int queue, GameInput &input)
      SaveCurrentFrame();
   }

-   Log("Sending undelayed local frame %d to queue %d.\n", _framecount, queue);
+   Log("Sending undelayed local frame %d to queue %d.", _framecount, queue);
   input.frame = _framecount;
   _input_queues[queue].AddInput(input);

@@ -146,7 +146,7 @@ Sync::AdjustSimulation(int seek_to)
   int framecount = _framecount;
   int count = _framecount - seek_to;

-   Log("Catching up\n");
+   Log("Catching up");
   _rollingback = true;

   /*
@@ -167,7 +167,7 @@ Sync::AdjustSimulation(int seek_to)

   _rollingback = false;

-   Log("---\n");   
+   Log("---");
 }

 void
@@ -175,7 +175,7 @@ Sync::LoadFrame(int frame)
 {
   // find the frame in question
   if (frame == _framecount) {
-      Log("Skipping NOP.\n");
+      Log("Skipping NOP.");
      return;
   }

@@ -183,7 +183,7 @@ Sync::LoadFrame(int frame)
   _savedstate.head = FindSavedFrameIndex(frame);
   SavedFrame *state = _savedstate.frames + _savedstate.head;

-   Log("=== Loading frame info %d (size: %d  checksum: %08x).\n",
+   Log("=== Loading frame info %d (size: %d  checksum: %08x).",
       state->frame, state->cbuf, state->checksum);

   ASSERT(state->buf && state->cbuf);
@@ -210,7 +210,7 @@ Sync::SaveCurrentFrame()
   state->frame = _framecount;
   _callbacks.save_game_state(&state->buf, &state->cbuf, &state->checksum, state->frame);

-   Log("=== Saved frame info %d (size: %d  checksum: %08x).\n", state->frame, state->cbuf, state->checksum);
+   Log("=== Saved frame info %d (size: %d  checksum: %08x).", state->frame, state->cbuf, state->checksum);
   _savedstate.head = (_savedstate.head + 1) % ARRAY_SIZE(_savedstate.frames);
 }

@@ -259,7 +259,7 @@ Sync::CheckSimulationConsistency(int *seekTo)
   int first_incorrect = GameInput::NullFrame;
   for (int i = 0; i < _config.num_players; i++) {
      int incorrect = _input_queues[i].GetFirstIncorrectFrame();
-      Log("considering incorrect frame %d reported by queue %d.\n", incorrect, i);
+      Log("considering incorrect frame %d reported by queue %d.", incorrect, i);

      if (incorrect != GameInput::NullFrame && (first_incorrect == GameInput::NullFrame || incorrect < first_incorrect)) {
         first_incorrect = incorrect;
@@ -267,7 +267,7 @@ Sync::CheckSimulationConsistency(int *seekTo)
   }

   if (first_incorrect == GameInput::NullFrame) {
-      Log("prediction ok.  proceeding.\n");
+      Log("prediction ok.  proceeding.");
      return true;
   }
   *seekTo = first_incorrect;
@@ -59,7 +59,7 @@ TimeSync::recommend_frame_wait_duration(bool require_idle_input)
   // sleep for.
   int sleep_frames = (int)(((radvantage - advantage) / 2) + 0.5);

-   Log("iteration %d:  sleep frames is %d\n", count, sleep_frames);
+   Log("iteration %d:  sleep frames is %d", count, sleep_frames);

   // Some things just aren't worth correcting for.  Make sure
   // the difference is relevant before proceeding.
@@ -74,7 +74,7 @@ TimeSync::recommend_frame_wait_duration(bool require_idle_input)
   if (require_idle_input) {
      for (size_t i = 1; i < ARRAY_SIZE(_last_inputs); i++) {
         if (!_last_inputs[i].equal(_last_inputs[0], true)) {
-            Log("iteration %d:  rejecting due to input stuff at position %d...!!!\n", count, i);
+            Log("iteration %d:  rejecting due to input stuff at position %d...!!!", count, (int)i);
            return 0;
         }
      }
@@ -0,0 +1,175 @@
+#ifndef __eglplatform_h_
+#define __eglplatform_h_
+
+/*
+** Copyright 2007-2020 The Khronos Group Inc.
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/* Platform-specific types and definitions for egl.h
+ *
+ * Adopters may modify khrplatform.h and this file to suit their platform.
+ * You are encouraged to submit all modifications to the Khronos group so that
+ * they can be included in future versions of this file.  Please submit changes
+ * by filing an issue or pull request on the public Khronos EGL Registry, at
+ * https://www.github.com/KhronosGroup/EGL-Registry/
+ */
+
+#include <KHR/khrplatform.h>
+
+/* Macros used in EGL function prototype declarations.
+ *
+ * EGL functions should be prototyped as:
+ *
+ * EGLAPI return-type EGLAPIENTRY eglFunction(arguments);
+ * typedef return-type (EXPAPIENTRYP PFNEGLFUNCTIONPROC) (arguments);
+ *
+ * KHRONOS_APICALL and KHRONOS_APIENTRY are defined in KHR/khrplatform.h
+ */
+
+#ifndef EGLAPI
+#define EGLAPI KHRONOS_APICALL
+#endif
+
+#ifndef EGLAPIENTRY
+#define EGLAPIENTRY  KHRONOS_APIENTRY
+#endif
+#define EGLAPIENTRYP EGLAPIENTRY*
+
+/* The types NativeDisplayType, NativeWindowType, and NativePixmapType
+ * are aliases of window-system-dependent types, such as X Display * or
+ * Windows Device Context. They must be defined in platform-specific
+ * code below. The EGL-prefixed versions of Native*Type are the same
+ * types, renamed in EGL 1.3 so all types in the API start with "EGL".
+ *
+ * Khronos STRONGLY RECOMMENDS that you use the default definitions
+ * provided below, since these changes affect both binary and source
+ * portability of applications using EGL running on different EGL
+ * implementations.
+ */
+
+#if defined(EGL_NO_PLATFORM_SPECIFIC_TYPES)
+
+typedef void *EGLNativeDisplayType;
+typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+
+typedef HDC     EGLNativeDisplayType;
+typedef HBITMAP EGLNativePixmapType;
+typedef HWND    EGLNativeWindowType;
+
+#elif defined(__QNX__)
+
+typedef khronos_uintptr_t      EGLNativeDisplayType;
+typedef struct _screen_pixmap* EGLNativePixmapType;  /* screen_pixmap_t */
+typedef struct _screen_window* EGLNativeWindowType;  /* screen_window_t */
+
+#elif defined(__EMSCRIPTEN__)
+
+typedef int EGLNativeDisplayType;
+typedef int EGLNativePixmapType;
+typedef int EGLNativeWindowType;
+
+#elif defined(__WINSCW__) || defined(__SYMBIAN32__)  /* Symbian */
+
+typedef int   EGLNativeDisplayType;
+typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(WL_EGL_PLATFORM)
+
+typedef struct wl_display     *EGLNativeDisplayType;
+typedef struct wl_egl_pixmap  *EGLNativePixmapType;
+typedef struct wl_egl_window  *EGLNativeWindowType;
+
+#elif defined(__GBM__)
+
+typedef struct gbm_device  *EGLNativeDisplayType;
+typedef struct gbm_bo      *EGLNativePixmapType;
+typedef void               *EGLNativeWindowType;
+
+#elif defined(__ANDROID__) || defined(ANDROID)
+
+struct ANativeWindow;
+struct egl_native_pixmap_t;
+
+typedef void*                           EGLNativeDisplayType;
+typedef struct egl_native_pixmap_t*     EGLNativePixmapType;
+typedef struct ANativeWindow*           EGLNativeWindowType;
+
+#elif defined(USE_OZONE)
+
+typedef intptr_t EGLNativeDisplayType;
+typedef intptr_t EGLNativePixmapType;
+typedef intptr_t EGLNativeWindowType;
+
+#elif defined(USE_X11)
+
+/* X11 (tentative)  */
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+typedef Display *EGLNativeDisplayType;
+typedef Pixmap   EGLNativePixmapType;
+typedef Window   EGLNativeWindowType;
+
+#elif defined(__unix__)
+
+typedef void             *EGLNativeDisplayType;
+typedef khronos_uintptr_t EGLNativePixmapType;
+typedef khronos_uintptr_t EGLNativeWindowType;
+
+#elif defined(__APPLE__)
+
+typedef int   EGLNativeDisplayType;
+typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(__HAIKU__)
+
+#include <kernel/image.h>
+
+typedef void              *EGLNativeDisplayType;
+typedef khronos_uintptr_t  EGLNativePixmapType;
+typedef khronos_uintptr_t  EGLNativeWindowType;
+
+#elif defined(__Fuchsia__)
+
+typedef void              *EGLNativeDisplayType;
+typedef khronos_uintptr_t  EGLNativePixmapType;
+typedef khronos_uintptr_t  EGLNativeWindowType;
+
+#else
+#error "Platform not recognized"
+#endif
+
+/* EGL 1.2 types, renamed for consistency in EGL 1.3 */
+typedef EGLNativeDisplayType NativeDisplayType;
+typedef EGLNativePixmapType  NativePixmapType;
+typedef EGLNativeWindowType  NativeWindowType;
+
+
+/* Define EGLint. This must be a signed integral type large enough to contain
+ * all legal attribute names and values passed into and out of EGL, whether
+ * their type is boolean, bitmask, enumerant (symbolic constant), integer,
+ * handle, or other.  While in general a 32-bit integer will suffice, if
+ * handles are 64 bit types, then EGLint should be defined as a signed 64-bit
+ * integer type.
+ */
+typedef khronos_int32_t EGLint;
+
+
+/* C++ / C typecast macros for special EGL handle values */
+#if defined(__cplusplus)
+#define EGL_CAST(type, value) (static_cast<type>(value))
+#else
+#define EGL_CAST(type, value) ((type) (value))
+#endif
+
+#endif /* __eglplatform_h */
@@ -0,0 +1,311 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2018 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
+#   define KHRONOS_STATIC 1
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(KHRONOS_STATIC)
+    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
+     * header compatible with static linking. */
+#   define KHRONOS_APICALL
+#elif defined(_WIN32)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   define KHRONOS_APICALL __attribute__((visibility("default")))
+#else
+#   define KHRONOS_APICALL
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
+    /* Win32 but not WinCE */
+#   define KHRONOS_APIENTRY __stdcall
+#else
+#   define KHRONOS_APIENTRY
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
+#if defined (__ARMCC_2__)
+#define KHRONOS_APIATTRIBUTES __softfp
+#else
+#define KHRONOS_APIATTRIBUTES
+#endif
+
+/*-------------------------------------------------------------------------
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
+
+
+/*
+ * Using <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+/*
+ * To support platform where unsigned long cannot be used interchangeably with
+ * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
+ * Ideally, we could just use (u)intptr_t everywhere, but this could result in
+ * ABI breakage if khronos_uintptr_t is changed from unsigned long to
+ * unsigned long long or similar (this results in different C++ name mangling).
+ * To avoid changes for existing platforms, we restrict usage of intptr_t to
+ * platforms where the size of a pointer is larger than the size of long.
+ */
+#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
+#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
+#define KHRONOS_USE_INTPTR_T
+#endif
+#endif
+
+#elif defined(__VMS ) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
+
+/*
+ * Win32
+ */
+typedef __int32                 khronos_int32_t;
+typedef unsigned __int32        khronos_uint32_t;
+typedef __int64                 khronos_int64_t;
+typedef unsigned __int64        khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__sun__) || defined(__digital__)
+
+/*
+ * Sun or Digital
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#if defined(__arch64__) || defined(_LP64)
+typedef long int                khronos_int64_t;
+typedef unsigned long int       khronos_uint64_t;
+#else
+typedef long long int           khronos_int64_t;
+typedef unsigned long long int  khronos_uint64_t;
+#endif /* __arch64__ */
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif 0
+
+/*
+ * Hypothetical platform with no float or int64 support
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#define KHRONOS_SUPPORT_INT64   0
+#define KHRONOS_SUPPORT_FLOAT   0
+
+#else
+
+/*
+ * Generic fallback
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#endif
+
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+
+/*
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
+#ifdef KHRONOS_USE_INTPTR_T
+typedef intptr_t               khronos_intptr_t;
+typedef uintptr_t              khronos_uintptr_t;
+#elif defined(_WIN64)
+typedef signed   long long int khronos_intptr_t;
+typedef unsigned long long int khronos_uintptr_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
+#endif
+
+#if defined(_WIN64)
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
+typedef signed   long  int     khronos_ssize_t;
+typedef unsigned long  int     khronos_usize_t;
+#endif
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef          float         khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
+typedef khronos_int64_t        khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum {
+    KHRONOS_FALSE = 0,
+    KHRONOS_TRUE  = 1,
+    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */
@@ -0,0 +1,550 @@
+/**
+ * Loader generated by glad 2.0.4 on Sat Jan 20 11:00:00 2024
+ *
+ * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
+ *
+ * Generator: C/C++
+ * Specification: egl
+ * Extensions: 0
+ *
+ * APIs:
+ *  - egl=1.5
+ *
+ * Options:
+ *  - ALIAS = False
+ *  - DEBUG = False
+ *  - HEADER_ONLY = False
+ *  - LOADER = True
+ *  - MX = False
+ *  - ON_DEMAND = False
+ *
+ * Commandline:
+ *    --api='egl=1.5' --extensions='' c --loader
+ *
+ * Online:
+ *    http://glad.sh/#api=egl%3D1.5&extensions=&generator=c&options=LOADER
+ *
+ */
+
+#ifndef GLAD_EGL_H_
+#define GLAD_EGL_H_
+
+
+#define GLAD_EGL
+#define GLAD_OPTION_EGL_LOADER
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef GLAD_PLATFORM_H_
+#define GLAD_PLATFORM_H_
+
+#ifndef GLAD_PLATFORM_WIN32
+  #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)
+    #define GLAD_PLATFORM_WIN32 1
+  #else
+    #define GLAD_PLATFORM_WIN32 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_APPLE
+  #ifdef __APPLE__
+    #define GLAD_PLATFORM_APPLE 1
+  #else
+    #define GLAD_PLATFORM_APPLE 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_EMSCRIPTEN
+  #ifdef __EMSCRIPTEN__
+    #define GLAD_PLATFORM_EMSCRIPTEN 1
+  #else
+    #define GLAD_PLATFORM_EMSCRIPTEN 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_UWP
+  #if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY)
+    #ifdef __has_include
+      #if __has_include(<winapifamily.h>)
+        #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+      #endif
+    #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
+      #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+    #endif
+  #endif
+
+  #ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY
+    #include <winapifamily.h>
+    #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+      #define GLAD_PLATFORM_UWP 1
+    #endif
+  #endif
+
+  #ifndef GLAD_PLATFORM_UWP
+    #define GLAD_PLATFORM_UWP 0
+  #endif
+#endif
+
+#ifdef __GNUC__
+  #define GLAD_GNUC_EXTENSION __extension__
+#else
+  #define GLAD_GNUC_EXTENSION
+#endif
+
+#define GLAD_UNUSED(x) (void)(x)
+
+#ifndef GLAD_API_CALL
+  #if defined(GLAD_API_CALL_EXPORT)
+    #if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__)
+      #if defined(GLAD_API_CALL_EXPORT_BUILD)
+        #if defined(__GNUC__)
+          #define GLAD_API_CALL __attribute__ ((dllexport)) extern
+        #else
+          #define GLAD_API_CALL __declspec(dllexport) extern
+        #endif
+      #else
+        #if defined(__GNUC__)
+          #define GLAD_API_CALL __attribute__ ((dllimport)) extern
+        #else
+          #define GLAD_API_CALL __declspec(dllimport) extern
+        #endif
+      #endif
+    #elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD)
+      #define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern
+    #else
+      #define GLAD_API_CALL extern
+    #endif
+  #else
+    #define GLAD_API_CALL extern
+  #endif
+#endif
+
+#ifdef APIENTRY
+  #define GLAD_API_PTR APIENTRY
+#elif GLAD_PLATFORM_WIN32
+  #define GLAD_API_PTR __stdcall
+#else
+  #define GLAD_API_PTR
+#endif
+
+#ifndef GLAPI
+#define GLAPI GLAD_API_CALL
+#endif
+
+#ifndef GLAPIENTRY
+#define GLAPIENTRY GLAD_API_PTR
+#endif
+
+#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor)
+#define GLAD_VERSION_MAJOR(version) (version / 10000)
+#define GLAD_VERSION_MINOR(version) (version % 10000)
+
+#define GLAD_GENERATOR_VERSION "2.0.4"
+
+typedef void (*GLADapiproc)(void);
+
+typedef GLADapiproc (*GLADloadfunc)(const char *name);
+typedef GLADapiproc (*GLADuserptrloadfunc)(void *userptr, const char *name);
+
+typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...);
+typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...);
+
+#endif /* GLAD_PLATFORM_H_ */
+
+#define EGL_ALPHA_FORMAT 0x3088
+#define EGL_ALPHA_FORMAT_NONPRE 0x308B
+#define EGL_ALPHA_FORMAT_PRE 0x308C
+#define EGL_ALPHA_MASK_SIZE 0x303E
+#define EGL_ALPHA_SIZE 0x3021
+#define EGL_BACK_BUFFER 0x3084
+#define EGL_BAD_ACCESS 0x3002
+#define EGL_BAD_ALLOC 0x3003
+#define EGL_BAD_ATTRIBUTE 0x3004
+#define EGL_BAD_CONFIG 0x3005
+#define EGL_BAD_CONTEXT 0x3006
+#define EGL_BAD_CURRENT_SURFACE 0x3007
+#define EGL_BAD_DISPLAY 0x3008
+#define EGL_BAD_MATCH 0x3009
+#define EGL_BAD_NATIVE_PIXMAP 0x300A
+#define EGL_BAD_NATIVE_WINDOW 0x300B
+#define EGL_BAD_PARAMETER 0x300C
+#define EGL_BAD_SURFACE 0x300D
+#define EGL_BIND_TO_TEXTURE_RGB 0x3039
+#define EGL_BIND_TO_TEXTURE_RGBA 0x303A
+#define EGL_BLUE_SIZE 0x3022
+#define EGL_BUFFER_DESTROYED 0x3095
+#define EGL_BUFFER_PRESERVED 0x3094
+#define EGL_BUFFER_SIZE 0x3020
+#define EGL_CLIENT_APIS 0x308D
+#define EGL_CL_EVENT_HANDLE 0x309C
+#define EGL_COLORSPACE 0x3087
+#define EGL_COLORSPACE_LINEAR 0x308A
+#define EGL_COLORSPACE_sRGB 0x3089
+#define EGL_COLOR_BUFFER_TYPE 0x303F
+#define EGL_CONDITION_SATISFIED 0x30F6
+#define EGL_CONFIG_CAVEAT 0x3027
+#define EGL_CONFIG_ID 0x3028
+#define EGL_CONFORMANT 0x3042
+#define EGL_CONTEXT_CLIENT_TYPE 0x3097
+#define EGL_CONTEXT_CLIENT_VERSION 0x3098
+#define EGL_CONTEXT_LOST 0x300E
+#define EGL_CONTEXT_MAJOR_VERSION 0x3098
+#define EGL_CONTEXT_MINOR_VERSION 0x30FB
+#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001
+#define EGL_CONTEXT_OPENGL_DEBUG 0x31B0
+#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE 0x31B1
+#define EGL_CONTEXT_OPENGL_PROFILE_MASK 0x30FD
+#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY 0x31BD
+#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS 0x31B2
+#define EGL_CORE_NATIVE_ENGINE 0x305B
+#define EGL_DEFAULT_DISPLAY EGL_CAST(EGLNativeDisplayType,0)
+#define EGL_DEPTH_SIZE 0x3025
+#define EGL_DISPLAY_SCALING 10000
+#define EGL_DONT_CARE EGL_CAST(EGLint,-1)
+#define EGL_DRAW 0x3059
+#define EGL_EXTENSIONS 0x3055
+#define EGL_FALSE 0
+#define EGL_FOREVER 0xFFFFFFFFFFFFFFFF
+#define EGL_GL_COLORSPACE 0x309D
+#define EGL_GL_COLORSPACE_LINEAR 0x308A
+#define EGL_GL_COLORSPACE_SRGB 0x3089
+#define EGL_GL_RENDERBUFFER 0x30B9
+#define EGL_GL_TEXTURE_2D 0x30B1
+#define EGL_GL_TEXTURE_3D 0x30B2
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x30B4
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x30B6
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x30B3
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x30B5
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7
+#define EGL_GL_TEXTURE_LEVEL 0x30BC
+#define EGL_GL_TEXTURE_ZOFFSET 0x30BD
+#define EGL_GREEN_SIZE 0x3023
+#define EGL_HEIGHT 0x3056
+#define EGL_HORIZONTAL_RESOLUTION 0x3090
+#define EGL_IMAGE_PRESERVED 0x30D2
+#define EGL_LARGEST_PBUFFER 0x3058
+#define EGL_LEVEL 0x3029
+#define EGL_LOSE_CONTEXT_ON_RESET 0x31BF
+#define EGL_LUMINANCE_BUFFER 0x308F
+#define EGL_LUMINANCE_SIZE 0x303D
+#define EGL_MATCH_NATIVE_PIXMAP 0x3041
+#define EGL_MAX_PBUFFER_HEIGHT 0x302A
+#define EGL_MAX_PBUFFER_PIXELS 0x302B
+#define EGL_MAX_PBUFFER_WIDTH 0x302C
+#define EGL_MAX_SWAP_INTERVAL 0x303C
+#define EGL_MIN_SWAP_INTERVAL 0x303B
+#define EGL_MIPMAP_LEVEL 0x3083
+#define EGL_MIPMAP_TEXTURE 0x3082
+#define EGL_MULTISAMPLE_RESOLVE 0x3099
+#define EGL_MULTISAMPLE_RESOLVE_BOX 0x309B
+#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200
+#define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A
+#define EGL_NATIVE_RENDERABLE 0x302D
+#define EGL_NATIVE_VISUAL_ID 0x302E
+#define EGL_NATIVE_VISUAL_TYPE 0x302F
+#define EGL_NONE 0x3038
+#define EGL_NON_CONFORMANT_CONFIG 0x3051
+#define EGL_NOT_INITIALIZED 0x3001
+#define EGL_NO_CONTEXT EGL_CAST(EGLContext,0)
+#define EGL_NO_DISPLAY EGL_CAST(EGLDisplay,0)
+#define EGL_NO_IMAGE EGL_CAST(EGLImage,0)
+#define EGL_NO_RESET_NOTIFICATION 0x31BE
+#define EGL_NO_SURFACE EGL_CAST(EGLSurface,0)
+#define EGL_NO_SYNC EGL_CAST(EGLSync,0)
+#define EGL_NO_TEXTURE 0x305C
+#define EGL_OPENGL_API 0x30A2
+#define EGL_OPENGL_BIT 0x0008
+#define EGL_OPENGL_ES2_BIT 0x0004
+#define EGL_OPENGL_ES3_BIT 0x00000040
+#define EGL_OPENGL_ES_API 0x30A0
+#define EGL_OPENGL_ES_BIT 0x0001
+#define EGL_OPENVG_API 0x30A1
+#define EGL_OPENVG_BIT 0x0002
+#define EGL_OPENVG_IMAGE 0x3096
+#define EGL_PBUFFER_BIT 0x0001
+#define EGL_PIXEL_ASPECT_RATIO 0x3092
+#define EGL_PIXMAP_BIT 0x0002
+#define EGL_READ 0x305A
+#define EGL_RED_SIZE 0x3024
+#define EGL_RENDERABLE_TYPE 0x3040
+#define EGL_RENDER_BUFFER 0x3086
+#define EGL_RGB_BUFFER 0x308E
+#define EGL_SAMPLES 0x3031
+#define EGL_SAMPLE_BUFFERS 0x3032
+#define EGL_SIGNALED 0x30F2
+#define EGL_SINGLE_BUFFER 0x3085
+#define EGL_SLOW_CONFIG 0x3050
+#define EGL_STENCIL_SIZE 0x3026
+#define EGL_SUCCESS 0x3000
+#define EGL_SURFACE_TYPE 0x3033
+#define EGL_SWAP_BEHAVIOR 0x3093
+#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400
+#define EGL_SYNC_CL_EVENT 0x30FE
+#define EGL_SYNC_CL_EVENT_COMPLETE 0x30FF
+#define EGL_SYNC_CONDITION 0x30F8
+#define EGL_SYNC_FENCE 0x30F9
+#define EGL_SYNC_FLUSH_COMMANDS_BIT 0x0001
+#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE 0x30F0
+#define EGL_SYNC_STATUS 0x30F1
+#define EGL_SYNC_TYPE 0x30F7
+#define EGL_TEXTURE_2D 0x305F
+#define EGL_TEXTURE_FORMAT 0x3080
+#define EGL_TEXTURE_RGB 0x305D
+#define EGL_TEXTURE_RGBA 0x305E
+#define EGL_TEXTURE_TARGET 0x3081
+#define EGL_TIMEOUT_EXPIRED 0x30F5
+#define EGL_TRANSPARENT_BLUE_VALUE 0x3035
+#define EGL_TRANSPARENT_GREEN_VALUE 0x3036
+#define EGL_TRANSPARENT_RED_VALUE 0x3037
+#define EGL_TRANSPARENT_RGB 0x3052
+#define EGL_TRANSPARENT_TYPE 0x3034
+#define EGL_TRUE 1
+#define EGL_UNKNOWN EGL_CAST(EGLint,-1)
+#define EGL_UNSIGNALED 0x30F3
+#define EGL_VENDOR 0x3053
+#define EGL_VERSION 0x3054
+#define EGL_VERTICAL_RESOLUTION 0x3091
+#define EGL_VG_ALPHA_FORMAT 0x3088
+#define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B
+#define EGL_VG_ALPHA_FORMAT_PRE 0x308C
+#define EGL_VG_ALPHA_FORMAT_PRE_BIT 0x0040
+#define EGL_VG_COLORSPACE 0x3087
+#define EGL_VG_COLORSPACE_LINEAR 0x308A
+#define EGL_VG_COLORSPACE_LINEAR_BIT 0x0020
+#define EGL_VG_COLORSPACE_sRGB 0x3089
+#define EGL_WIDTH 0x3057
+#define EGL_WINDOW_BIT 0x0004
+
+
+#include <KHR/khrplatform.h>
+#include <EGL/eglplatform.h>
+
+
+
+
+
+
+
+
+
+
+
+struct AHardwareBuffer;
+struct wl_buffer;
+struct wl_display;
+struct wl_resource;
+
+typedef unsigned int EGLBoolean;
+typedef unsigned int EGLenum;
+typedef intptr_t EGLAttribKHR;
+typedef intptr_t EGLAttrib;
+typedef void *EGLClientBuffer;
+typedef void *EGLConfig;
+typedef void *EGLContext;
+typedef void *EGLDeviceEXT;
+typedef void *EGLDisplay;
+typedef void *EGLImage;
+typedef void *EGLImageKHR;
+typedef void *EGLLabelKHR;
+typedef void *EGLObjectKHR;
+typedef void *EGLOutputLayerEXT;
+typedef void *EGLOutputPortEXT;
+typedef void *EGLStreamKHR;
+typedef void *EGLSurface;
+typedef void *EGLSync;
+typedef void *EGLSyncKHR;
+typedef void *EGLSyncNV;
+typedef void (*__eglMustCastToProperFunctionPointerType)(void);
+typedef khronos_utime_nanoseconds_t EGLTimeKHR;
+typedef khronos_utime_nanoseconds_t EGLTime;
+typedef khronos_utime_nanoseconds_t EGLTimeNV;
+typedef khronos_utime_nanoseconds_t EGLuint64NV;
+typedef khronos_uint64_t EGLuint64KHR;
+typedef khronos_stime_nanoseconds_t EGLnsecsANDROID;
+typedef int EGLNativeFileDescriptorKHR;
+typedef khronos_ssize_t EGLsizeiANDROID;
+typedef void (*EGLSetBlobFuncANDROID) (const void *key, EGLsizeiANDROID keySize, const void *value, EGLsizeiANDROID valueSize);
+typedef EGLsizeiANDROID (*EGLGetBlobFuncANDROID) (const void *key, EGLsizeiANDROID keySize, void *value, EGLsizeiANDROID valueSize);
+struct EGLClientPixmapHI {
+    void  *pData;
+    EGLint iWidth;
+    EGLint iHeight;
+    EGLint iStride;
+};
+typedef void (GLAD_API_PTR *EGLDEBUGPROCKHR)(EGLenum error,const char *command,EGLint messageType,EGLLabelKHR threadLabel,EGLLabelKHR objectLabel,const char* message);
+#define PFNEGLBINDWAYLANDDISPLAYWL PFNEGLBINDWAYLANDDISPLAYWLPROC
+#define PFNEGLUNBINDWAYLANDDISPLAYWL PFNEGLUNBINDWAYLANDDISPLAYWLPROC
+#define PFNEGLQUERYWAYLANDBUFFERWL PFNEGLQUERYWAYLANDBUFFERWLPROC
+#define PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWL PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWLPROC
+
+
+#define EGL_VERSION_1_0 1
+GLAD_API_CALL int GLAD_EGL_VERSION_1_0;
+#define EGL_VERSION_1_1 1
+GLAD_API_CALL int GLAD_EGL_VERSION_1_1;
+#define EGL_VERSION_1_2 1
+GLAD_API_CALL int GLAD_EGL_VERSION_1_2;
+#define EGL_VERSION_1_3 1
+GLAD_API_CALL int GLAD_EGL_VERSION_1_3;
+#define EGL_VERSION_1_4 1
+GLAD_API_CALL int GLAD_EGL_VERSION_1_4;
+#define EGL_VERSION_1_5 1
+GLAD_API_CALL int GLAD_EGL_VERSION_1_5;
+
+
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLBINDAPIPROC)(EGLenum api);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLBINDTEXIMAGEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLCHOOSECONFIGPROC)(EGLDisplay dpy, const EGLint * attrib_list, EGLConfig * configs, EGLint config_size, EGLint * num_config);
+typedef EGLint (GLAD_API_PTR *PFNEGLCLIENTWAITSYNCPROC)(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLCOPYBUFFERSPROC)(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
+typedef EGLContext (GLAD_API_PTR *PFNEGLCREATECONTEXTPROC)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint * attrib_list);
+typedef EGLImage (GLAD_API_PTR *PFNEGLCREATEIMAGEPROC)(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib * attrib_list);
+typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC)(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint * attrib_list);
+typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPBUFFERSURFACEPROC)(EGLDisplay dpy, EGLConfig config, const EGLint * attrib_list);
+typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPIXMAPSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint * attrib_list);
+typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC)(EGLDisplay dpy, EGLConfig config, void * native_pixmap, const EGLAttrib * attrib_list);
+typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPLATFORMWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, void * native_window, const EGLAttrib * attrib_list);
+typedef EGLSync (GLAD_API_PTR *PFNEGLCREATESYNCPROC)(EGLDisplay dpy, EGLenum type, const EGLAttrib * attrib_list);
+typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint * attrib_list);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYIMAGEPROC)(EGLDisplay dpy, EGLImage image);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYSYNCPROC)(EGLDisplay dpy, EGLSync sync);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLGETCONFIGATTRIBPROC)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint * value);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLGETCONFIGSPROC)(EGLDisplay dpy, EGLConfig * configs, EGLint config_size, EGLint * num_config);
+typedef EGLContext (GLAD_API_PTR *PFNEGLGETCURRENTCONTEXTPROC)(void);
+typedef EGLDisplay (GLAD_API_PTR *PFNEGLGETCURRENTDISPLAYPROC)(void);
+typedef EGLSurface (GLAD_API_PTR *PFNEGLGETCURRENTSURFACEPROC)(EGLint readdraw);
+typedef EGLDisplay (GLAD_API_PTR *PFNEGLGETDISPLAYPROC)(EGLNativeDisplayType display_id);
+typedef EGLint (GLAD_API_PTR *PFNEGLGETERRORPROC)(void);
+typedef EGLDisplay (GLAD_API_PTR *PFNEGLGETPLATFORMDISPLAYPROC)(EGLenum platform, void * native_display, const EGLAttrib * attrib_list);
+typedef __eglMustCastToProperFunctionPointerType (GLAD_API_PTR *PFNEGLGETPROCADDRESSPROC)(const char * procname);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLGETSYNCATTRIBPROC)(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib * value);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLINITIALIZEPROC)(EGLDisplay dpy, EGLint * major, EGLint * minor);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLMAKECURRENTPROC)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+typedef EGLenum (GLAD_API_PTR *PFNEGLQUERYAPIPROC)(void);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint * value);
+typedef const char * (GLAD_API_PTR *PFNEGLQUERYSTRINGPROC)(EGLDisplay dpy, EGLint name);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint * value);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLRELEASETEXIMAGEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLRELEASETHREADPROC)(void);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLSURFACEATTRIBPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLSWAPBUFFERSPROC)(EGLDisplay dpy, EGLSurface surface);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLSWAPINTERVALPROC)(EGLDisplay dpy, EGLint interval);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLTERMINATEPROC)(EGLDisplay dpy);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITCLIENTPROC)(void);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITGLPROC)(void);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITNATIVEPROC)(EGLint engine);
+typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITSYNCPROC)(EGLDisplay dpy, EGLSync sync, EGLint flags);
+
+GLAD_API_CALL PFNEGLBINDAPIPROC glad_eglBindAPI;
+#define eglBindAPI glad_eglBindAPI
+GLAD_API_CALL PFNEGLBINDTEXIMAGEPROC glad_eglBindTexImage;
+#define eglBindTexImage glad_eglBindTexImage
+GLAD_API_CALL PFNEGLCHOOSECONFIGPROC glad_eglChooseConfig;
+#define eglChooseConfig glad_eglChooseConfig
+GLAD_API_CALL PFNEGLCLIENTWAITSYNCPROC glad_eglClientWaitSync;
+#define eglClientWaitSync glad_eglClientWaitSync
+GLAD_API_CALL PFNEGLCOPYBUFFERSPROC glad_eglCopyBuffers;
+#define eglCopyBuffers glad_eglCopyBuffers
+GLAD_API_CALL PFNEGLCREATECONTEXTPROC glad_eglCreateContext;
+#define eglCreateContext glad_eglCreateContext
+GLAD_API_CALL PFNEGLCREATEIMAGEPROC glad_eglCreateImage;
+#define eglCreateImage glad_eglCreateImage
+GLAD_API_CALL PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC glad_eglCreatePbufferFromClientBuffer;
+#define eglCreatePbufferFromClientBuffer glad_eglCreatePbufferFromClientBuffer
+GLAD_API_CALL PFNEGLCREATEPBUFFERSURFACEPROC glad_eglCreatePbufferSurface;
+#define eglCreatePbufferSurface glad_eglCreatePbufferSurface
+GLAD_API_CALL PFNEGLCREATEPIXMAPSURFACEPROC glad_eglCreatePixmapSurface;
+#define eglCreatePixmapSurface glad_eglCreatePixmapSurface
+GLAD_API_CALL PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC glad_eglCreatePlatformPixmapSurface;
+#define eglCreatePlatformPixmapSurface glad_eglCreatePlatformPixmapSurface
+GLAD_API_CALL PFNEGLCREATEPLATFORMWINDOWSURFACEPROC glad_eglCreatePlatformWindowSurface;
+#define eglCreatePlatformWindowSurface glad_eglCreatePlatformWindowSurface
+GLAD_API_CALL PFNEGLCREATESYNCPROC glad_eglCreateSync;
+#define eglCreateSync glad_eglCreateSync
+GLAD_API_CALL PFNEGLCREATEWINDOWSURFACEPROC glad_eglCreateWindowSurface;
+#define eglCreateWindowSurface glad_eglCreateWindowSurface
+GLAD_API_CALL PFNEGLDESTROYCONTEXTPROC glad_eglDestroyContext;
+#define eglDestroyContext glad_eglDestroyContext
+GLAD_API_CALL PFNEGLDESTROYIMAGEPROC glad_eglDestroyImage;
+#define eglDestroyImage glad_eglDestroyImage
+GLAD_API_CALL PFNEGLDESTROYSURFACEPROC glad_eglDestroySurface;
+#define eglDestroySurface glad_eglDestroySurface
+GLAD_API_CALL PFNEGLDESTROYSYNCPROC glad_eglDestroySync;
+#define eglDestroySync glad_eglDestroySync
+GLAD_API_CALL PFNEGLGETCONFIGATTRIBPROC glad_eglGetConfigAttrib;
+#define eglGetConfigAttrib glad_eglGetConfigAttrib
+GLAD_API_CALL PFNEGLGETCONFIGSPROC glad_eglGetConfigs;
+#define eglGetConfigs glad_eglGetConfigs
+GLAD_API_CALL PFNEGLGETCURRENTCONTEXTPROC glad_eglGetCurrentContext;
+#define eglGetCurrentContext glad_eglGetCurrentContext
+GLAD_API_CALL PFNEGLGETCURRENTDISPLAYPROC glad_eglGetCurrentDisplay;
+#define eglGetCurrentDisplay glad_eglGetCurrentDisplay
+GLAD_API_CALL PFNEGLGETCURRENTSURFACEPROC glad_eglGetCurrentSurface;
+#define eglGetCurrentSurface glad_eglGetCurrentSurface
+GLAD_API_CALL PFNEGLGETDISPLAYPROC glad_eglGetDisplay;
+#define eglGetDisplay glad_eglGetDisplay
+GLAD_API_CALL PFNEGLGETERRORPROC glad_eglGetError;
+#define eglGetError glad_eglGetError
+GLAD_API_CALL PFNEGLGETPLATFORMDISPLAYPROC glad_eglGetPlatformDisplay;
+#define eglGetPlatformDisplay glad_eglGetPlatformDisplay
+GLAD_API_CALL PFNEGLGETPROCADDRESSPROC glad_eglGetProcAddress;
+#define eglGetProcAddress glad_eglGetProcAddress
+GLAD_API_CALL PFNEGLGETSYNCATTRIBPROC glad_eglGetSyncAttrib;
+#define eglGetSyncAttrib glad_eglGetSyncAttrib
+GLAD_API_CALL PFNEGLINITIALIZEPROC glad_eglInitialize;
+#define eglInitialize glad_eglInitialize
+GLAD_API_CALL PFNEGLMAKECURRENTPROC glad_eglMakeCurrent;
+#define eglMakeCurrent glad_eglMakeCurrent
+GLAD_API_CALL PFNEGLQUERYAPIPROC glad_eglQueryAPI;
+#define eglQueryAPI glad_eglQueryAPI
+GLAD_API_CALL PFNEGLQUERYCONTEXTPROC glad_eglQueryContext;
+#define eglQueryContext glad_eglQueryContext
+GLAD_API_CALL PFNEGLQUERYSTRINGPROC glad_eglQueryString;
+#define eglQueryString glad_eglQueryString
+GLAD_API_CALL PFNEGLQUERYSURFACEPROC glad_eglQuerySurface;
+#define eglQuerySurface glad_eglQuerySurface
+GLAD_API_CALL PFNEGLRELEASETEXIMAGEPROC glad_eglReleaseTexImage;
+#define eglReleaseTexImage glad_eglReleaseTexImage
+GLAD_API_CALL PFNEGLRELEASETHREADPROC glad_eglReleaseThread;
+#define eglReleaseThread glad_eglReleaseThread
+GLAD_API_CALL PFNEGLSURFACEATTRIBPROC glad_eglSurfaceAttrib;
+#define eglSurfaceAttrib glad_eglSurfaceAttrib
+GLAD_API_CALL PFNEGLSWAPBUFFERSPROC glad_eglSwapBuffers;
+#define eglSwapBuffers glad_eglSwapBuffers
+GLAD_API_CALL PFNEGLSWAPINTERVALPROC glad_eglSwapInterval;
+#define eglSwapInterval glad_eglSwapInterval
+GLAD_API_CALL PFNEGLTERMINATEPROC glad_eglTerminate;
+#define eglTerminate glad_eglTerminate
+GLAD_API_CALL PFNEGLWAITCLIENTPROC glad_eglWaitClient;
+#define eglWaitClient glad_eglWaitClient
+GLAD_API_CALL PFNEGLWAITGLPROC glad_eglWaitGL;
+#define eglWaitGL glad_eglWaitGL
+GLAD_API_CALL PFNEGLWAITNATIVEPROC glad_eglWaitNative;
+#define eglWaitNative glad_eglWaitNative
+GLAD_API_CALL PFNEGLWAITSYNCPROC glad_eglWaitSync;
+#define eglWaitSync glad_eglWaitSync
+
+
+
+
+
+GLAD_API_CALL int gladLoadEGLUserPtr(EGLDisplay display, GLADuserptrloadfunc load, void *userptr);
+GLAD_API_CALL int gladLoadEGL(EGLDisplay display, GLADloadfunc load);
+
+#ifdef GLAD_EGL
+
+GLAD_API_CALL int gladLoaderLoadEGL(EGLDisplay display);
+
+GLAD_API_CALL void gladLoaderUnloadEGL(void);
+
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
@@ -0,0 +1,397 @@
+/**
+ * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glad/egl.h>
+
+#ifndef GLAD_IMPL_UTIL_C_
+#define GLAD_IMPL_UTIL_C_
+
+#ifdef _MSC_VER
+#define GLAD_IMPL_UTIL_SSCANF sscanf_s
+#else
+#define GLAD_IMPL_UTIL_SSCANF sscanf
+#endif
+
+#endif /* GLAD_IMPL_UTIL_C_ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+int GLAD_EGL_VERSION_1_0 = 0;
+int GLAD_EGL_VERSION_1_1 = 0;
+int GLAD_EGL_VERSION_1_2 = 0;
+int GLAD_EGL_VERSION_1_3 = 0;
+int GLAD_EGL_VERSION_1_4 = 0;
+int GLAD_EGL_VERSION_1_5 = 0;
+
+
+
+PFNEGLBINDAPIPROC glad_eglBindAPI = NULL;
+PFNEGLBINDTEXIMAGEPROC glad_eglBindTexImage = NULL;
+PFNEGLCHOOSECONFIGPROC glad_eglChooseConfig = NULL;
+PFNEGLCLIENTWAITSYNCPROC glad_eglClientWaitSync = NULL;
+PFNEGLCOPYBUFFERSPROC glad_eglCopyBuffers = NULL;
+PFNEGLCREATECONTEXTPROC glad_eglCreateContext = NULL;
+PFNEGLCREATEIMAGEPROC glad_eglCreateImage = NULL;
+PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC glad_eglCreatePbufferFromClientBuffer = NULL;
+PFNEGLCREATEPBUFFERSURFACEPROC glad_eglCreatePbufferSurface = NULL;
+PFNEGLCREATEPIXMAPSURFACEPROC glad_eglCreatePixmapSurface = NULL;
+PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC glad_eglCreatePlatformPixmapSurface = NULL;
+PFNEGLCREATEPLATFORMWINDOWSURFACEPROC glad_eglCreatePlatformWindowSurface = NULL;
+PFNEGLCREATESYNCPROC glad_eglCreateSync = NULL;
+PFNEGLCREATEWINDOWSURFACEPROC glad_eglCreateWindowSurface = NULL;
+PFNEGLDESTROYCONTEXTPROC glad_eglDestroyContext = NULL;
+PFNEGLDESTROYIMAGEPROC glad_eglDestroyImage = NULL;
+PFNEGLDESTROYSURFACEPROC glad_eglDestroySurface = NULL;
+PFNEGLDESTROYSYNCPROC glad_eglDestroySync = NULL;
+PFNEGLGETCONFIGATTRIBPROC glad_eglGetConfigAttrib = NULL;
+PFNEGLGETCONFIGSPROC glad_eglGetConfigs = NULL;
+PFNEGLGETCURRENTCONTEXTPROC glad_eglGetCurrentContext = NULL;
+PFNEGLGETCURRENTDISPLAYPROC glad_eglGetCurrentDisplay = NULL;
+PFNEGLGETCURRENTSURFACEPROC glad_eglGetCurrentSurface = NULL;
+PFNEGLGETDISPLAYPROC glad_eglGetDisplay = NULL;
+PFNEGLGETERRORPROC glad_eglGetError = NULL;
+PFNEGLGETPLATFORMDISPLAYPROC glad_eglGetPlatformDisplay = NULL;
+PFNEGLGETPROCADDRESSPROC glad_eglGetProcAddress = NULL;
+PFNEGLGETSYNCATTRIBPROC glad_eglGetSyncAttrib = NULL;
+PFNEGLINITIALIZEPROC glad_eglInitialize = NULL;
+PFNEGLMAKECURRENTPROC glad_eglMakeCurrent = NULL;
+PFNEGLQUERYAPIPROC glad_eglQueryAPI = NULL;
+PFNEGLQUERYCONTEXTPROC glad_eglQueryContext = NULL;
+PFNEGLQUERYSTRINGPROC glad_eglQueryString = NULL;
+PFNEGLQUERYSURFACEPROC glad_eglQuerySurface = NULL;
+PFNEGLRELEASETEXIMAGEPROC glad_eglReleaseTexImage = NULL;
+PFNEGLRELEASETHREADPROC glad_eglReleaseThread = NULL;
+PFNEGLSURFACEATTRIBPROC glad_eglSurfaceAttrib = NULL;
+PFNEGLSWAPBUFFERSPROC glad_eglSwapBuffers = NULL;
+PFNEGLSWAPINTERVALPROC glad_eglSwapInterval = NULL;
+PFNEGLTERMINATEPROC glad_eglTerminate = NULL;
+PFNEGLWAITCLIENTPROC glad_eglWaitClient = NULL;
+PFNEGLWAITGLPROC glad_eglWaitGL = NULL;
+PFNEGLWAITNATIVEPROC glad_eglWaitNative = NULL;
+PFNEGLWAITSYNCPROC glad_eglWaitSync = NULL;
+
+
+static void glad_egl_load_EGL_VERSION_1_0( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_EGL_VERSION_1_0) return;
+    glad_eglChooseConfig = (PFNEGLCHOOSECONFIGPROC) load(userptr, "eglChooseConfig");
+    glad_eglCopyBuffers = (PFNEGLCOPYBUFFERSPROC) load(userptr, "eglCopyBuffers");
+    glad_eglCreateContext = (PFNEGLCREATECONTEXTPROC) load(userptr, "eglCreateContext");
+    glad_eglCreatePbufferSurface = (PFNEGLCREATEPBUFFERSURFACEPROC) load(userptr, "eglCreatePbufferSurface");
+    glad_eglCreatePixmapSurface = (PFNEGLCREATEPIXMAPSURFACEPROC) load(userptr, "eglCreatePixmapSurface");
+    glad_eglCreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC) load(userptr, "eglCreateWindowSurface");
+    glad_eglDestroyContext = (PFNEGLDESTROYCONTEXTPROC) load(userptr, "eglDestroyContext");
+    glad_eglDestroySurface = (PFNEGLDESTROYSURFACEPROC) load(userptr, "eglDestroySurface");
+    glad_eglGetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC) load(userptr, "eglGetConfigAttrib");
+    glad_eglGetConfigs = (PFNEGLGETCONFIGSPROC) load(userptr, "eglGetConfigs");
+    glad_eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC) load(userptr, "eglGetCurrentDisplay");
+    glad_eglGetCurrentSurface = (PFNEGLGETCURRENTSURFACEPROC) load(userptr, "eglGetCurrentSurface");
+    glad_eglGetDisplay = (PFNEGLGETDISPLAYPROC) load(userptr, "eglGetDisplay");
+    glad_eglGetError = (PFNEGLGETERRORPROC) load(userptr, "eglGetError");
+    glad_eglGetProcAddress = (PFNEGLGETPROCADDRESSPROC) load(userptr, "eglGetProcAddress");
+    glad_eglInitialize = (PFNEGLINITIALIZEPROC) load(userptr, "eglInitialize");
+    glad_eglMakeCurrent = (PFNEGLMAKECURRENTPROC) load(userptr, "eglMakeCurrent");
+    glad_eglQueryContext = (PFNEGLQUERYCONTEXTPROC) load(userptr, "eglQueryContext");
+    glad_eglQueryString = (PFNEGLQUERYSTRINGPROC) load(userptr, "eglQueryString");
+    glad_eglQuerySurface = (PFNEGLQUERYSURFACEPROC) load(userptr, "eglQuerySurface");
+    glad_eglSwapBuffers = (PFNEGLSWAPBUFFERSPROC) load(userptr, "eglSwapBuffers");
+    glad_eglTerminate = (PFNEGLTERMINATEPROC) load(userptr, "eglTerminate");
+    glad_eglWaitGL = (PFNEGLWAITGLPROC) load(userptr, "eglWaitGL");
+    glad_eglWaitNative = (PFNEGLWAITNATIVEPROC) load(userptr, "eglWaitNative");
+}
+static void glad_egl_load_EGL_VERSION_1_1( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_EGL_VERSION_1_1) return;
+    glad_eglBindTexImage = (PFNEGLBINDTEXIMAGEPROC) load(userptr, "eglBindTexImage");
+    glad_eglReleaseTexImage = (PFNEGLRELEASETEXIMAGEPROC) load(userptr, "eglReleaseTexImage");
+    glad_eglSurfaceAttrib = (PFNEGLSURFACEATTRIBPROC) load(userptr, "eglSurfaceAttrib");
+    glad_eglSwapInterval = (PFNEGLSWAPINTERVALPROC) load(userptr, "eglSwapInterval");
+}
+static void glad_egl_load_EGL_VERSION_1_2( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_EGL_VERSION_1_2) return;
+    glad_eglBindAPI = (PFNEGLBINDAPIPROC) load(userptr, "eglBindAPI");
+    glad_eglCreatePbufferFromClientBuffer = (PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC) load(userptr, "eglCreatePbufferFromClientBuffer");
+    glad_eglQueryAPI = (PFNEGLQUERYAPIPROC) load(userptr, "eglQueryAPI");
+    glad_eglReleaseThread = (PFNEGLRELEASETHREADPROC) load(userptr, "eglReleaseThread");
+    glad_eglWaitClient = (PFNEGLWAITCLIENTPROC) load(userptr, "eglWaitClient");
+}
+static void glad_egl_load_EGL_VERSION_1_4( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_EGL_VERSION_1_4) return;
+    glad_eglGetCurrentContext = (PFNEGLGETCURRENTCONTEXTPROC) load(userptr, "eglGetCurrentContext");
+}
+static void glad_egl_load_EGL_VERSION_1_5( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_EGL_VERSION_1_5) return;
+    glad_eglClientWaitSync = (PFNEGLCLIENTWAITSYNCPROC) load(userptr, "eglClientWaitSync");
+    glad_eglCreateImage = (PFNEGLCREATEIMAGEPROC) load(userptr, "eglCreateImage");
+    glad_eglCreatePlatformPixmapSurface = (PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC) load(userptr, "eglCreatePlatformPixmapSurface");
+    glad_eglCreatePlatformWindowSurface = (PFNEGLCREATEPLATFORMWINDOWSURFACEPROC) load(userptr, "eglCreatePlatformWindowSurface");
+    glad_eglCreateSync = (PFNEGLCREATESYNCPROC) load(userptr, "eglCreateSync");
+    glad_eglDestroyImage = (PFNEGLDESTROYIMAGEPROC) load(userptr, "eglDestroyImage");
+    glad_eglDestroySync = (PFNEGLDESTROYSYNCPROC) load(userptr, "eglDestroySync");
+    glad_eglGetPlatformDisplay = (PFNEGLGETPLATFORMDISPLAYPROC) load(userptr, "eglGetPlatformDisplay");
+    glad_eglGetSyncAttrib = (PFNEGLGETSYNCATTRIBPROC) load(userptr, "eglGetSyncAttrib");
+    glad_eglWaitSync = (PFNEGLWAITSYNCPROC) load(userptr, "eglWaitSync");
+}
+
+
+
+static int glad_egl_get_extensions(EGLDisplay display, const char **extensions) {
+    *extensions = eglQueryString(display, EGL_EXTENSIONS);
+
+    return extensions != NULL;
+}
+
+static int glad_egl_has_extension(const char *extensions, const char *ext) {
+    const char *loc;
+    const char *terminator;
+    if(extensions == NULL) {
+        return 0;
+    }
+    while(1) {
+        loc = strstr(extensions, ext);
+        if(loc == NULL) {
+            return 0;
+        }
+        terminator = loc + strlen(ext);
+        if((loc == extensions || *(loc - 1) == ' ') &&
+            (*terminator == ' ' || *terminator == '\0')) {
+            return 1;
+        }
+        extensions = terminator;
+    }
+}
+
+static GLADapiproc glad_egl_get_proc_from_userptr(void *userptr, const char *name) {
+    return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name);
+}
+
+static int glad_egl_find_extensions_egl(EGLDisplay display) {
+    const char *extensions;
+    if (!glad_egl_get_extensions(display, &extensions)) return 0;
+
+    GLAD_UNUSED(glad_egl_has_extension);
+
+    return 1;
+}
+
+static int glad_egl_find_core_egl(EGLDisplay display) {
+    int major, minor;
+    const char *version;
+
+    if (display == NULL) {
+        display = EGL_NO_DISPLAY; /* this is usually NULL, better safe than sorry */
+    }
+    if (display == EGL_NO_DISPLAY) {
+        display = eglGetCurrentDisplay();
+    }
+#ifdef EGL_VERSION_1_4
+    if (display == EGL_NO_DISPLAY) {
+        display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    }
+#endif
+#ifndef EGL_VERSION_1_5
+    if (display == EGL_NO_DISPLAY) {
+        return 0;
+    }
+#endif
+
+    version = eglQueryString(display, EGL_VERSION);
+    (void) eglGetError();
+
+    if (version == NULL) {
+        major = 1;
+        minor = 0;
+    } else {
+        GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor);
+    }
+
+    GLAD_EGL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
+    GLAD_EGL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
+    GLAD_EGL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
+    GLAD_EGL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
+    GLAD_EGL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
+    GLAD_EGL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1;
+
+    return GLAD_MAKE_VERSION(major, minor);
+}
+
+int gladLoadEGLUserPtr(EGLDisplay display, GLADuserptrloadfunc load, void* userptr) {
+    int version;
+    eglGetDisplay = (PFNEGLGETDISPLAYPROC) load(userptr, "eglGetDisplay");
+    eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC) load(userptr, "eglGetCurrentDisplay");
+    eglQueryString = (PFNEGLQUERYSTRINGPROC) load(userptr, "eglQueryString");
+    eglGetError = (PFNEGLGETERRORPROC) load(userptr, "eglGetError");
+    if (eglGetDisplay == NULL || eglGetCurrentDisplay == NULL || eglQueryString == NULL || eglGetError == NULL) return 0;
+
+    version = glad_egl_find_core_egl(display);
+    if (!version) return 0;
+    glad_egl_load_EGL_VERSION_1_0(load, userptr);
+    glad_egl_load_EGL_VERSION_1_1(load, userptr);
+    glad_egl_load_EGL_VERSION_1_2(load, userptr);
+    glad_egl_load_EGL_VERSION_1_4(load, userptr);
+    glad_egl_load_EGL_VERSION_1_5(load, userptr);
+
+    if (!glad_egl_find_extensions_egl(display)) return 0;
+
+
+    return version;
+}
+
+int gladLoadEGL(EGLDisplay display, GLADloadfunc load) {
+    return gladLoadEGLUserPtr(display, glad_egl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
+}
+
+ 
+
+#ifdef GLAD_EGL
+
+#ifndef GLAD_LOADER_LIBRARY_C_
+#define GLAD_LOADER_LIBRARY_C_
+
+#include <stddef.h>
+#include <stdlib.h>
+
+#if GLAD_PLATFORM_WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+
+static void* glad_get_dlopen_handle(const char *lib_names[], int length) {
+    void *handle = NULL;
+    int i;
+
+    for (i = 0; i < length; ++i) {
+#if GLAD_PLATFORM_WIN32
+  #if GLAD_PLATFORM_UWP
+        size_t buffer_size = (strlen(lib_names[i]) + 1) * sizeof(WCHAR);
+        LPWSTR buffer = (LPWSTR) malloc(buffer_size);
+        if (buffer != NULL) {
+            int ret = MultiByteToWideChar(CP_ACP, 0, lib_names[i], -1, buffer, buffer_size);
+            if (ret != 0) {
+                handle = (void*) LoadPackagedLibrary(buffer, 0);
+            }
+            free((void*) buffer);
+        }
+  #else
+        handle = (void*) LoadLibraryA(lib_names[i]);
+  #endif
+#else
+        handle = dlopen(lib_names[i], RTLD_LAZY | RTLD_LOCAL);
+#endif
+        if (handle != NULL) {
+            return handle;
+        }
+    }
+
+    return NULL;
+}
+
+static void glad_close_dlopen_handle(void* handle) {
+    if (handle != NULL) {
+#if GLAD_PLATFORM_WIN32
+        FreeLibrary((HMODULE) handle);
+#else
+        dlclose(handle);
+#endif
+    }
+}
+
+static GLADapiproc glad_dlsym_handle(void* handle, const char *name) {
+    if (handle == NULL) {
+        return NULL;
+    }
+
+#if GLAD_PLATFORM_WIN32
+    return (GLADapiproc) GetProcAddress((HMODULE) handle, name);
+#else
+    return GLAD_GNUC_EXTENSION (GLADapiproc) dlsym(handle, name);
+#endif
+}
+
+#endif /* GLAD_LOADER_LIBRARY_C_ */
+
+struct _glad_egl_userptr {
+    void *handle;
+    PFNEGLGETPROCADDRESSPROC get_proc_address_ptr;
+};
+
+static GLADapiproc glad_egl_get_proc(void *vuserptr, const char* name) {
+    struct _glad_egl_userptr userptr = *(struct _glad_egl_userptr*) vuserptr;
+    GLADapiproc result = NULL;
+
+    result = glad_dlsym_handle(userptr.handle, name);
+    if (result == NULL) {
+        result = GLAD_GNUC_EXTENSION (GLADapiproc) userptr.get_proc_address_ptr(name);
+    }
+
+    return result;
+}
+
+static void* _egl_handle = NULL;
+
+static void* glad_egl_dlopen_handle(void) {
+#if GLAD_PLATFORM_APPLE
+    static const char *NAMES[] = {"libEGL.dylib"};
+#elif GLAD_PLATFORM_WIN32
+    static const char *NAMES[] = {"libEGL.dll", "EGL.dll"};
+#else
+    static const char *NAMES[] = {"libEGL.so.1", "libEGL.so"};
+#endif
+
+    if (_egl_handle == NULL) {
+        _egl_handle = glad_get_dlopen_handle(NAMES, sizeof(NAMES) / sizeof(NAMES[0]));
+    }
+
+    return _egl_handle;
+}
+
+static struct _glad_egl_userptr glad_egl_build_userptr(void *handle) {
+    struct _glad_egl_userptr userptr;
+    userptr.handle = handle;
+    userptr.get_proc_address_ptr = (PFNEGLGETPROCADDRESSPROC) glad_dlsym_handle(handle, "eglGetProcAddress");
+    return userptr;
+}
+
+int gladLoaderLoadEGL(EGLDisplay display) {
+    int version = 0;
+    void *handle = NULL;
+    int did_load = 0;
+    struct _glad_egl_userptr userptr;
+
+    did_load = _egl_handle == NULL;
+    handle = glad_egl_dlopen_handle();
+    if (handle != NULL) {
+        userptr = glad_egl_build_userptr(handle);
+
+        if (userptr.get_proc_address_ptr != NULL) {
+            version = gladLoadEGLUserPtr(display, glad_egl_get_proc, &userptr);
+        }
+
+        if (!version && did_load) {
+            gladLoaderUnloadEGL();
+        }
+    }
+
+    return version;
+}
+
+
+void gladLoaderUnloadEGL() {
+    if (_egl_handle != NULL) {
+        glad_close_dlopen_handle(_egl_handle);
+        _egl_handle = NULL;
+    }
+}
+
+#endif /* GLAD_EGL */
+
+#ifdef __cplusplus
+}
+#endif
@@ -1,5 +1,5 @@
-cmake_minimum_required(VERSION 3.2 FATAL_ERROR)
-cmake_policy(VERSION 3.2)
+cmake_minimum_required(VERSION 3.6 FATAL_ERROR)
+cmake_policy(VERSION 3.6)

 set(GLM_VERSION "0.9.9")
 project(glm VERSION ${GLM_VERSION} LANGUAGES CXX)
@@ -1,108 +0,0 @@
-# Windows Build Configuration for AppVeyor
-# http://www.appveyor.com/docs/appveyor-yml
-
-# build version format
-version: "{build}"
-
-os: Visual Studio 2013
-
-platform:
-  - x64
-
-configuration:
-  - Debug
-  - Release
-
-branches:
-  only:
-    - master
-
-# changes to these files don't need to trigger testing
-skip_commits:
-  files:
-    - README.md
-    - README-spirv-remap.txt
-    - LICENSE.txt
-    - CODE_OF_CONDUCT.md
-    - BUILD.*
-    - WORKSPACE
-    - kokoro/*
-    - make-revision
-    - Android.mk
-    - _config.yml
-
-# Travis advances the master-tot tag to current top of the tree after
-# each push into the master branch, because it relies on that tag to
-# upload build artifacts to the master-tot release. This will cause
-# double testing for each push on Appveyor: one for the push, one for
-# the tag advance. Disable testing tags.
-skip_tags: true
-
-clone_depth: 5
-
-matrix:
-  fast_finish: true # Show final status immediately if a test fails.
-
-# scripts that run after cloning repository
-install:
-  - C:/Python27/python.exe update_glslang_sources.py
-  - set PATH=C:\ninja;C:\Python36;%PATH%
-  - git clone https://github.com/google/googletest.git External/googletest
-  - cd External/googletest
-  - git checkout 440527a61e1c91188195f7de212c63c77e8f0a45
-  - cd ../..
-
-build:
-  parallel: true  # enable MSBuild parallel builds
-  verbosity: minimal
-
-build_script:
-  - mkdir build && cd build
-  - cmake -G "Visual Studio 12 2013 Win64" -DCMAKE_INSTALL_PREFIX=install ..
-  - cmake --build . --config %CONFIGURATION% --target install
-
-test_script:
-  - ctest -C %CONFIGURATION% --output-on-failure
-  - cd ../Test && bash runtests
-  - cd ../build
-
-after_test:
-  # For debug build, the generated dll has a postfix "d" in its name.
-  - ps: >-
-      If ($env:configuration -Match "Debug") {
-        $env:SUFFIX="d"
-      } Else {
-        $env:SUFFIX=""
-      }
-  - cd install
-  # Zip all glslang artifacts for uploading and deploying
-  - 7z a glslang-master-windows-"%PLATFORM%"-"%CONFIGURATION%".zip
-    bin\glslangValidator.exe
-    bin\spirv-remap.exe
-    include\glslang\*
-    lib\glslang%SUFFIX%.lib
-    lib\HLSL%SUFFIX%.lib
-    lib\OGLCompiler%SUFFIX%.lib
-    lib\OSDependent%SUFFIX%.lib
-    lib\SPIRV%SUFFIX%.lib
-    lib\SPVRemapper%SUFFIX%.lib
-    lib\SPIRV-Tools%SUFFIX%.lib
-    lib\SPIRV-Tools-opt%SUFFIX%.lib
-
-artifacts:
-  - path: build\install\*.zip
-    name: artifacts-zip
-
-deploy:
-  - provider: GitHub
-    auth_token:
-      secure: YglcSYdl0TylEa59H4K6lylBEDr586NAt2EMgZquSo+iuPrwgZQuJLPCoihSm9y6
-    release: master-tot
-    description: "Continuous build of the latest master branch by Appveyor and Travis CI"
-    artifact: artifacts-zip
-    draft: false
-    prerelease: false
-    force_update: true
-    on:
-      branch: master
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
@@ -1,13 +0,0 @@
-Language: Cpp
-IndentWidth: 4
-PointerAlignment: Left
-BreakBeforeBraces: Custom
-BraceWrapping: { AfterFunction: true, AfterControlStatement: false }
-IndentCaseLabels: false
-ReflowComments: false
-ColumnLimit: 120
-AccessModifierOffset: -4
-AlignTrailingComments: true
-AllowShortBlocksOnASingleLine: false
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLoopsOnASingleLine: false
@@ -1,17 +0,0 @@
-# test files have a mix of lf/crlf, and that's a good thing, for testing, don't mess with it
-# bash scripts need lines ending with lf, and that's correct for Windows too, e.g., under Cygwin
-# (scripts often don't have a suffix)
-* -text
-*.sh text eof=lf
-
-# txt files should be native and normalized
-*.txt text
-
-# source code can be native and normalized, but simpler if lf everywhere; will try that way
-*.h text eol=lf
-*.c text eol=lf
-*.cpp text eol=lf
-*.y text eol=lf
-*.out text eol=lf
-*.conf text eol=lf
-*.err text eol=lf
@@ -1,10 +0,0 @@
-*.o
-*.a
-*.so
-*.exe
-tags
-TAGS
-build/
-Test/localResults/
-External/googletest
-External/spirv-tools
@@ -1,128 +0,0 @@
-# Linux and Mac Build Configuration for Travis
-
-language: cpp
-
-os:
-  - linux
-  - osx
-
-# Use Ubuntu 14.04 LTS (Trusty) as the Linux testing environment.
-sudo: false
-dist: trusty
-
-env:
-  global:
-    - secure: aGFrgzyKp+84hKrGkxVWg8cHV61uqrKEHT38gfSQK6+WS4GfLOyH83p7WnsEBb7AMhzU7LMNFdvOFr6+NaMpVnqRvc40CEG1Q+lNg9Pq9mhIZLowvDrfqTL9kQ+8Nbw5Q6/dg6CTvY7fvRfpfCEmKIUZBRkoKUuHeuM1uy3IupFcdNuL5bSYn3Beo+apSJginh9DI4BLDXFUgBzTRSLLyCX5g3cpaeGGOCr8quJlYx75W6HRck5g9SZuLtUoH9GFEV3l+ZEWB8noErW+J56L03bwNwFuuAh321evw++oQk5KFa8rlDvar3SJ3b1RHB8u/eq5DBYMyaK/fS8+Q7QbGr8diF/wDe68bKO7U9IhpNfExXmczCpExjHomW5TQv4rYdGhygPMfW97aIsPRYyNKcl4fkmb7NDrM8w0Jscdq2g5c2Kz0ItyZoBri/NXLwFQQjaVCs7Pf97TjuMA7mK0GJmDTRzi6SrDYlWMt5BQL3y0CCojyfLIRcTh0CQjQI29s97bLfQrYAxt9GNNFR+HTXRLLrkaAlJkPGEPwUywlSfEThnvHLesNxYqemolAYpQT4ithoL4GehGIHmaxsW295aKVhuRf8K9eBODNqrfblvM42UHhjntT+92ZnQ/Gkq80GqaMxnxi4PO5FyPIxt0r981b54YBkWi8YA4P7w5pNI=
-  matrix:
-    - GLSLANG_BUILD_TYPE=Release
-    - GLSLANG_BUILD_TYPE=Debug
-
-compiler:
-  - clang
-  - gcc
-
-matrix:
-  fast_finish: true # Show final status immediately if a test fails.
-  exclude:
-    # Skip GCC builds on Mac OS X.
-    - os: osx
-      compiler: gcc
-  include:
-    # Additional build using Android NDK.
-    - env: BUILD_NDK=ON
-
-cache:
-  apt: true
-
-branches:
-  only:
-    - master
-
-addons:
-  apt:
-    packages:
-      - clang-3.6
-
-install:
-  # Make sure that clang-3.6 is selected on Linux.
-  - if [[ "$TRAVIS_OS_NAME" == "linux" && "$CC" == "clang" ]]; then
-      export CC=clang-3.6 CXX=clang++-3.6;
-    fi
-  # Download a recent Android NDK and use its android.toolchain.cmake file.
-  - if [[ "$BUILD_NDK" == "ON" ]]; then
-      export ANDROID_NDK=$HOME/android-ndk;
-      git init $ANDROID_NDK;
-      pushd $ANDROID_NDK;
-        git remote add dneto0 https://github.com/dneto0/android-ndk.git;
-        git fetch --depth=1 dneto0 r17b-strip;
-        git checkout FETCH_HEAD;
-      popd;
-      export TOOLCHAIN_PATH=$ANDROID_NDK/build/cmake/android.toolchain.cmake;
-    fi
-
-before_script:
-  - git clone --depth=1 https://github.com/google/googletest.git External/googletest
-  - ./update_glslang_sources.py
-
-script:
-  - mkdir build && cd build
-  # For Android, do release building using NDK without testing.
-  # Use android-14, the oldest native API level supporeted by NDK r17b.
-  # We can use newer API levels if we want.
-  # For Linux and macOS, do debug/release building with testing.
-  - if [[ "$BUILD_NDK" == "ON" ]]; then
-      cmake -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_PATH}
-            -DANDROID_NATIVE_API_LEVEL=android-14
-            -DCMAKE_BUILD_TYPE=Release
-            -DANDROID_ABI="armeabi-v7a with NEON"
-            -DBUILD_TESTING=OFF ..;
-      make -j4;
-    else
-      cmake -DCMAKE_BUILD_TYPE=${GLSLANG_BUILD_TYPE}
-            -DCMAKE_INSTALL_PREFIX=`pwd`/install ..;
-      make -j4 install;
-      ctest --output-on-failure &&
-      cd ../Test && ./runtests;
-    fi
-
-after_success:
-  # For debug build, the generated dll has a postfix "d" in its name.
-  - if [[ "${GLSLANG_BUILD_TYPE}" == "Debug" ]]; then
-      export SUFFIX="d";
-    else
-      export SUFFIX="";
-    fi
-  # Create tarball for deployment
-  - if [[ ${CC} == clang* && "${BUILD_NDK}" != "ON" ]]; then
-      cd ../build/install;
-      export TARBALL=glslang-master-${TRAVIS_OS_NAME}-${GLSLANG_BUILD_TYPE}.zip;
-      zip ${TARBALL}
-        bin/glslangValidator
-        include/glslang/*
-        lib/libglslang${SUFFIX}.a
-        lib/libHLSL${SUFFIX}.a
-        lib/libOGLCompiler${SUFFIX}.a
-        lib/libOSDependent${SUFFIX}.a
-        lib/libSPIRV${SUFFIX}.a
-        lib/libSPVRemapper${SUFFIX}.a
-        lib/libSPIRV-Tools${SUFFIX}.a
-        lib/libSPIRV-Tools-opt${SUFFIX}.a;
-    fi
-
-before_deploy:
-  # Tag the current top of the tree as "master-tot".
-  # Travis CI replies on the tag name to properly push to GitHub Releases.
-  - git config --global user.name "Travis CI"
-  - git config --global user.email "[email protected]"
-  - git tag -f master-tot
-  - git push -q -f https://${glslangtoken}@github.com/KhronosGroup/glslang --tags
-
-deploy:
-  provider: releases
-  api_key: ${glslangtoken}
-  on:
-    branch: master
-    condition: ${CC} == clang* && ${BUILD_NDK} != ON
-  file: ${TARBALL}
-  skip_cleanup: true
-  overwrite: true
@@ -1,100 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-GLSLANG_OS_FLAGS := -DGLSLANG_OSINCLUDE_UNIX
-# AMD and NV extensions are turned on by default in upstream Glslang.
-GLSLANG_DEFINES:= -DAMD_EXTENSIONS -DNV_EXTENSIONS -DENABLE_HLSL $(GLSLANG_OS_FLAGS)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE:=OSDependent
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
-LOCAL_SRC_FILES:=glslang/OSDependent/Unix/ossource.cpp
-LOCAL_C_INCLUDES:=$(LOCAL_PATH) $(LOCAL_PATH)/glslang/OSDependent/Unix/
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)/glslang/OSDependent/Unix/
-include $(BUILD_STATIC_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE:=OGLCompiler
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
-LOCAL_SRC_FILES:=OGLCompilersDLL/InitializeDll.cpp
-LOCAL_C_INCLUDES:=$(LOCAL_PATH)/OGLCompiler
-LOCAL_STATIC_LIBRARIES:=OSDependent
-include $(BUILD_STATIC_LIBRARY)
-
-# Build Glslang's HLSL parser library.
-include $(CLEAR_VARS)
-LOCAL_MODULE:=HLSL
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
-LOCAL_SRC_FILES:= \
-		hlsl/hlslAttributes.cpp \
-		hlsl/hlslGrammar.cpp \
-		hlsl/hlslOpMap.cpp \
-		hlsl/hlslParseables.cpp \
-		hlsl/hlslParseHelper.cpp \
-		hlsl/hlslScanContext.cpp \
-		hlsl/hlslTokenStream.cpp
-LOCAL_C_INCLUDES:=$(LOCAL_PATH) \
-	$(LOCAL_PATH)/hlsl
-include $(BUILD_STATIC_LIBRARY)
-
-include $(CLEAR_VARS)
-GLSLANG_OUT_PATH=$(if $(call host-path-is-absolute,$(TARGET_OUT)),$(TARGET_OUT),$(abspath $(TARGET_OUT)))
-
-LOCAL_MODULE:=glslang
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
-LOCAL_SRC_FILES:= \
-		glslang/GenericCodeGen/CodeGen.cpp \
-		glslang/GenericCodeGen/Link.cpp \
-		glslang/MachineIndependent/attribute.cpp \
-		glslang/MachineIndependent/Constant.cpp \
-		glslang/MachineIndependent/glslang_tab.cpp \
-		glslang/MachineIndependent/InfoSink.cpp \
-		glslang/MachineIndependent/Initialize.cpp \
-		glslang/MachineIndependent/Intermediate.cpp \
-		glslang/MachineIndependent/intermOut.cpp \
-		glslang/MachineIndependent/IntermTraverse.cpp \
-		glslang/MachineIndependent/iomapper.cpp \
-		glslang/MachineIndependent/limits.cpp \
-		glslang/MachineIndependent/linkValidate.cpp \
-		glslang/MachineIndependent/parseConst.cpp \
-		glslang/MachineIndependent/ParseContextBase.cpp \
-		glslang/MachineIndependent/ParseHelper.cpp \
-		glslang/MachineIndependent/PoolAlloc.cpp \
-		glslang/MachineIndependent/propagateNoContraction.cpp \
-		glslang/MachineIndependent/reflection.cpp \
-		glslang/MachineIndependent/RemoveTree.cpp \
-		glslang/MachineIndependent/Scan.cpp \
-		glslang/MachineIndependent/ShaderLang.cpp \
-		glslang/MachineIndependent/SymbolTable.cpp \
-		glslang/MachineIndependent/Versions.cpp \
-		glslang/MachineIndependent/preprocessor/PpAtom.cpp \
-		glslang/MachineIndependent/preprocessor/PpContext.cpp \
-		glslang/MachineIndependent/preprocessor/Pp.cpp \
-		glslang/MachineIndependent/preprocessor/PpScanner.cpp \
-		glslang/MachineIndependent/preprocessor/PpTokens.cpp
-LOCAL_C_INCLUDES:=$(LOCAL_PATH) \
-	$(LOCAL_PATH)/glslang/MachineIndependent \
-	$(GLSLANG_OUT_PATH)
-LOCAL_STATIC_LIBRARIES:=OSDependent OGLCompiler HLSL
-include $(BUILD_STATIC_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE:=SPIRV
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti -Werror $(GLSLANG_DEFINES)
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
-LOCAL_SRC_FILES:= \
-	SPIRV/GlslangToSpv.cpp \
-	SPIRV/InReadableOrder.cpp \
-	SPIRV/Logger.cpp \
-	SPIRV/SPVRemapper.cpp \
-	SPIRV/SpvBuilder.cpp \
-	SPIRV/SpvPostProcess.cpp \
-	SPIRV/SpvTools.cpp \
-	SPIRV/disassemble.cpp \
-	SPIRV/doc.cpp
-LOCAL_C_INCLUDES:=$(LOCAL_PATH) $(LOCAL_PATH)/glslang/SPIRV
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)/glslang/SPIRV
-LOCAL_STATIC_LIBRARIES:=glslang
-include $(BUILD_STATIC_LIBRARY)
@@ -1,247 +0,0 @@
-package(
-    default_visibility = ["//visibility:public"],
-)
-
-# Description:
-#
-# Khronos reference front-end for GLSL and ESSL, and sample SPIR-V generator.
-
-licenses(["notice"])
-
-exports_files(["LICENSE"])
-
-COMMON_COPTS = select({
-    "@bazel_tools//src/conditions:windows": [""],
-    "//conditions:default": [
-        "-Wall",
-        "-Wuninitialized",
-        "-Wunused",
-        "-Wunused-local-typedefs",
-        "-Wunused-parameter",
-        "-Wunused-value",
-        "-Wunused-variable",
-        "-Wno-reorder",
-        "-std=c++11",
-        "-fvisibility=hidden",
-        "-fvisibility-inlines-hidden",
-        "-fno-exceptions",
-        "-fno-rtti",
-    ],
-})
-
-cc_library(
-    name = "glslang",
-    srcs = glob(
-        [
-            "glslang/GenericCodeGen/*.cpp",
-            "glslang/MachineIndependent/*.cpp",
-            "glslang/MachineIndependent/preprocessor/*.cpp",
-            "hlsl/*.cpp",
-        ],
-        exclude = [
-            "glslang/MachineIndependent/pch.cpp",
-            "glslang/MachineIndependent/pch.h",
-            "hlsl/pch.cpp",
-            "hlsl/pch.h",
-        ],
-    ) + [
-        "OGLCompilersDLL/InitializeDll.cpp",
-    ] + select({
-        "@bazel_tools//src/conditions:windows":
-            ["glslang/OSDependent/Windows/ossource.cpp"],
-        "//conditions:default":
-            ["glslang/OSDependent/Unix/ossource.cpp"],
-    }),
-    hdrs = glob([
-        "glslang/Include/*.h",
-        "glslang/MachineIndependent/*.h",
-        "glslang/MachineIndependent/preprocessor/*.h",
-        "hlsl/*.h",
-    ]) + [
-        "OGLCompilersDLL/InitializeDll.h",
-        "StandAlone/DirStackFileIncluder.h",
-        "glslang/OSDependent/osinclude.h",
-        "glslang/Public/ShaderLang.h",
-    ],
-    copts = COMMON_COPTS,
-    defines = [
-        "AMD_EXTENSIONS",
-        "ENABLE_HLSL=0",
-        "ENABLE_OPT=0",
-        "NV_EXTENSIONS",
-    ],
-    linkopts = select({
-        "@bazel_tools//src/conditions:windows": [""],
-        "//conditions:default": ["-lm", "-lpthread"],
-    }),
-    linkstatic = 1,
-)
-
-genrule(
-    name = "export_spirv_headers",
-    srcs = [
-        "SPIRV/GLSL.ext.AMD.h",
-        "SPIRV/GLSL.ext.EXT.h",
-        "SPIRV/GLSL.ext.KHR.h",
-        "SPIRV/GLSL.ext.NV.h",
-        "SPIRV/GLSL.std.450.h",
-        "SPIRV/NonSemanticDebugPrintf.h",
-        "SPIRV/spirv.hpp",
-    ],
-    outs = [
-        "include/SPIRV/GLSL.ext.AMD.h",
-        "include/SPIRV/GLSL.ext.EXT.h",
-        "include/SPIRV/GLSL.ext.KHR.h",
-        "include/SPIRV/GLSL.ext.NV.h",
-        "include/SPIRV/GLSL.std.450.h",
-        "include/SPIRV/NonSemanticDebugPrintf.h",
-        "include/SPIRV/spirv.hpp",
-    ],
-    cmd = "mkdir -p $(@D)/include/SPIRV && cp $(SRCS) $(@D)/include/SPIRV/",
-)
-
-cc_library(
-    name = "SPIRV_headers",
-    hdrs = [":export_spirv_headers"],
-    copts = COMMON_COPTS,
-    includes = [
-        "include",
-        "include/SPIRV",
-    ],
-    linkstatic = 1,
-)
-
-cc_library(
-    name = "SPIRV",
-    srcs = glob(
-        ["SPIRV/*.cpp"],
-        exclude = [
-            "SPIRV/SpvTools.cpp",
-        ],
-    ),
-    hdrs = [
-        "SPIRV/GlslangToSpv.h",
-        "SPIRV/Logger.h",
-        "SPIRV/SPVRemapper.h",
-        "SPIRV/SpvBuilder.h",
-        "SPIRV/SpvTools.h",
-        "SPIRV/bitutils.h",
-        "SPIRV/disassemble.h",
-        "SPIRV/doc.h",
-        "SPIRV/hex_float.h",
-        "SPIRV/spvIR.h",
-    ],
-    copts = COMMON_COPTS,
-    includes = ["SPIRV"],
-    linkopts = select({
-        "@bazel_tools//src/conditions:windows": [""],
-        "//conditions:default": ["-lm"],
-    }),
-    linkstatic = 1,
-    deps = [
-        ":SPIRV_headers",
-        ":glslang",
-    ],
-)
-
-cc_library(
-    name = "glslang-default-resource-limits",
-    srcs = ["StandAlone/ResourceLimits.cpp"],
-    hdrs = ["StandAlone/ResourceLimits.h"],
-    copts = COMMON_COPTS,
-    linkstatic = 1,
-    deps = [":glslang"],
-)
-
-cc_binary(
-    name = "glslangValidator",
-    srcs = [
-        "StandAlone/StandAlone.cpp",
-        "StandAlone/Worklist.h",
-    ],
-    copts = COMMON_COPTS,
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang-default-resource-limits",
-    ],
-)
-
-cc_binary(
-    name = "spirv-remap",
-    srcs = ["StandAlone/spirv-remap.cpp"],
-    copts = COMMON_COPTS,
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang-default-resource-limits",
-    ],
-)
-
-filegroup(
-    name = "test_files",
-    srcs = glob(
-        ["Test/**"],
-        exclude = [
-            "Test/bump",
-            "Test/glslangValidator",
-            "Test/runtests",
-        ],
-    ),
-)
-
-cc_library(
-    name = "glslang_test_lib",
-    testonly = 1,
-    srcs = [
-        "gtests/HexFloat.cpp",
-        "gtests/Initializer.h",
-        "gtests/Settings.cpp",
-        "gtests/Settings.h",
-        "gtests/TestFixture.cpp",
-        "gtests/TestFixture.h",
-        "gtests/main.cpp",
-    ],
-    copts = COMMON_COPTS,
-    data = [":test_files"],
-    defines = select({
-        # Unfortunately we can't use $(location) in cc_library at the moment.
-        # See https://github.com/bazelbuild/bazel/issues/1023
-        # So we'll specify the path manually.
-        "@bazel_tools//src/conditions:windows":
-            ["GLSLANG_TEST_DIRECTORY='\"../../../../../Test\"'"],
-        "//conditions:default":
-            ["GLSLANG_TEST_DIRECTORY='\"Test\"'"],
-    }),
-    linkstatic = 1,
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang-default-resource-limits",
-        "@com_google_googletest//:gtest",
-    ],
-)
-
-GLSLANG_TESTS = glob(
-    ["gtests/*.FromFile.cpp"],
-    # Since we are not building the SPIRV-Tools dependency, the following tests
-    # cannot be performed.
-    exclude = [
-        "gtests/Hlsl.FromFile.cpp",
-        "gtests/Spv.FromFile.cpp",
-    ],
-)
-
-[cc_test(
-    name = test_file.replace("gtests/", "").replace(".FromFile.cpp", "") + "_test",
-    srcs = [test_file],
-    copts = COMMON_COPTS,
-    data = [
-        ":test_files",
-    ],
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang_test_lib",
-    ],
-) for test_file in GLSLANG_TESTS]
@@ -1,248 +0,0 @@
-# Copyright (C) 2018 Google, Inc.
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-#    Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-#
-#    Redistributions in binary form must reproduce the above
-#    copyright notice, this list of conditions and the following
-#    disclaimer in the documentation and/or other materials provided
-#    with the distribution.
-#
-#    Neither the name of Google Inc. nor the names of its
-#    contributors may be used to endorse or promote products derived
-#    from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-# COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-
-import("//build_overrides/glslang.gni")
-
-# Both Chromium and Fuchsia use by default a set of warning errors
-# that is far too strict to compile this project. These are also
-# typically appended after |cflags|, overriding target-specific
-# definitions. To work around this, determine which configs to
-# add and remove in order to succesfully build the project.
-if (defined(is_fuchsia_tree) && is_fuchsia_tree) {
-  _configs_to_remove = [ "//build/config:default_warnings" ]
-  _configs_to_add = []
-} else {
-  _configs_to_remove = [ "//build/config/compiler:chromium_code" ]
-  _configs_to_add = [ "//build/config/compiler:no_chromium_code" ]
-}
-
-spirv_tools_dir = glslang_spirv_tools_dir
-
-config("glslang_public") {
-  include_dirs = [ "." ]
-
-  defines = [ "ENABLE_HLSL=1" ]
-}
-
-source_set("glslang_sources") {
-  public_configs = [ ":glslang_public" ]
-
-  sources = [
-    "OGLCompilersDLL/InitializeDll.cpp",
-    "OGLCompilersDLL/InitializeDll.h",
-    "SPIRV/GLSL.ext.AMD.h",
-    "SPIRV/GLSL.ext.EXT.h",
-    "SPIRV/GLSL.ext.KHR.h",
-    "SPIRV/GLSL.ext.NV.h",
-    "SPIRV/GLSL.std.450.h",
-    "SPIRV/GlslangToSpv.cpp",
-    "SPIRV/GlslangToSpv.h",
-    "SPIRV/InReadableOrder.cpp",
-    "SPIRV/Logger.cpp",
-    "SPIRV/Logger.h",
-    "SPIRV/NonSemanticDebugPrintf.h",
-    "SPIRV/SPVRemapper.cpp",
-    "SPIRV/SPVRemapper.h",
-    "SPIRV/SpvBuilder.cpp",
-    "SPIRV/SpvBuilder.h",
-    "SPIRV/SpvPostProcess.cpp",
-    "SPIRV/SpvTools.cpp",
-    "SPIRV/SpvTools.h",
-    "SPIRV/bitutils.h",
-    "SPIRV/disassemble.cpp",
-    "SPIRV/disassemble.h",
-    "SPIRV/doc.cpp",
-    "SPIRV/doc.h",
-    "SPIRV/hex_float.h",
-    "SPIRV/spirv.hpp",
-    "SPIRV/spvIR.h",
-    "glslang/GenericCodeGen/CodeGen.cpp",
-    "glslang/GenericCodeGen/Link.cpp",
-    "glslang/Include/BaseTypes.h",
-    "glslang/Include/Common.h",
-    "glslang/Include/ConstantUnion.h",
-    "glslang/Include/InfoSink.h",
-    "glslang/Include/InitializeGlobals.h",
-    "glslang/Include/PoolAlloc.h",
-    "glslang/Include/ResourceLimits.h",
-    "glslang/Include/ShHandle.h",
-    "glslang/Include/Types.h",
-    "glslang/Include/arrays.h",
-    "glslang/Include/intermediate.h",
-    "glslang/Include/revision.h",
-    "glslang/MachineIndependent/Constant.cpp",
-    "glslang/MachineIndependent/InfoSink.cpp",
-    "glslang/MachineIndependent/Initialize.cpp",
-    "glslang/MachineIndependent/Initialize.h",
-    "glslang/MachineIndependent/IntermTraverse.cpp",
-    "glslang/MachineIndependent/Intermediate.cpp",
-    "glslang/MachineIndependent/LiveTraverser.h",
-    "glslang/MachineIndependent/ParseContextBase.cpp",
-    "glslang/MachineIndependent/ParseHelper.cpp",
-    "glslang/MachineIndependent/ParseHelper.h",
-    "glslang/MachineIndependent/PoolAlloc.cpp",
-    "glslang/MachineIndependent/RemoveTree.cpp",
-    "glslang/MachineIndependent/RemoveTree.h",
-    "glslang/MachineIndependent/Scan.cpp",
-    "glslang/MachineIndependent/Scan.h",
-    "glslang/MachineIndependent/ScanContext.h",
-    "glslang/MachineIndependent/ShaderLang.cpp",
-    "glslang/MachineIndependent/SymbolTable.cpp",
-    "glslang/MachineIndependent/SymbolTable.h",
-    "glslang/MachineIndependent/Versions.cpp",
-    "glslang/MachineIndependent/Versions.h",
-    "glslang/MachineIndependent/attribute.cpp",
-    "glslang/MachineIndependent/attribute.h",
-    "glslang/MachineIndependent/gl_types.h",
-    "glslang/MachineIndependent/glslang_tab.cpp",
-    "glslang/MachineIndependent/glslang_tab.cpp.h",
-    "glslang/MachineIndependent/intermOut.cpp",
-    "glslang/MachineIndependent/iomapper.cpp",
-    "glslang/MachineIndependent/iomapper.h",
-    "glslang/MachineIndependent/limits.cpp",
-    "glslang/MachineIndependent/linkValidate.cpp",
-    "glslang/MachineIndependent/localintermediate.h",
-    "glslang/MachineIndependent/parseConst.cpp",
-    "glslang/MachineIndependent/parseVersions.h",
-    "glslang/MachineIndependent/preprocessor/Pp.cpp",
-    "glslang/MachineIndependent/preprocessor/PpAtom.cpp",
-    "glslang/MachineIndependent/preprocessor/PpContext.cpp",
-    "glslang/MachineIndependent/preprocessor/PpContext.h",
-    "glslang/MachineIndependent/preprocessor/PpScanner.cpp",
-    "glslang/MachineIndependent/preprocessor/PpTokens.cpp",
-    "glslang/MachineIndependent/preprocessor/PpTokens.h",
-    "glslang/MachineIndependent/propagateNoContraction.cpp",
-    "glslang/MachineIndependent/propagateNoContraction.h",
-    "glslang/MachineIndependent/reflection.cpp",
-    "glslang/MachineIndependent/reflection.h",
-    "glslang/OSDependent/osinclude.h",
-    "glslang/Public/ShaderLang.h",
-    "hlsl/hlslAttributes.cpp",
-    "hlsl/hlslAttributes.h",
-    "hlsl/hlslGrammar.cpp",
-    "hlsl/hlslGrammar.h",
-    "hlsl/hlslOpMap.cpp",
-    "hlsl/hlslOpMap.h",
-    "hlsl/hlslParseHelper.cpp",
-    "hlsl/hlslParseHelper.h",
-    "hlsl/hlslParseables.cpp",
-    "hlsl/hlslParseables.h",
-    "hlsl/hlslScanContext.cpp",
-    "hlsl/hlslScanContext.h",
-    "hlsl/hlslTokenStream.cpp",
-    "hlsl/hlslTokenStream.h",
-    "hlsl/hlslTokens.h",
-  ]
-
-  defines = [ "ENABLE_OPT=1" ]
-
-  if (is_win) {
-    sources += [ "glslang/OSDependent/Windows/ossource.cpp" ]
-    defines += [ "GLSLANG_OSINCLUDE_WIN32" ]
-  } else {
-    sources += [ "glslang/OSDependent/Unix/ossource.cpp" ]
-    defines += [ "GLSLANG_OSINCLUDE_UNIX" ]
-  }
-
-  if (is_clang) {
-    cflags = [
-      "-Wno-extra-semi",
-      "-Wno-ignored-qualifiers",
-      "-Wno-implicit-fallthrough",
-      "-Wno-inconsistent-missing-override",
-      "-Wno-sign-compare",
-      "-Wno-unused-variable",
-      "-Wno-missing-field-initializers",
-      "-Wno-newline-eof",
-    ]
-  }
-  if (is_win && !is_clang) {
-    cflags = [
-      "/wd4018",  # signed/unsigned mismatch
-      "/wd4189",  # local variable is initialized but not referenced
-    ]
-  }
-
-  deps = [
-    "${spirv_tools_dir}:spvtools_opt",
-    "${spirv_tools_dir}:spvtools_val",
-  ]
-
-  configs -= _configs_to_remove
-  configs += _configs_to_add
-}
-
-source_set("glslang_default_resource_limits_sources") {
-  sources = [
-    "StandAlone/ResourceLimits.cpp",
-    "StandAlone/ResourceLimits.h",
-  ]
-  deps = [
-    ":glslang_sources",
-  ]
-  public_configs = [ ":glslang_public" ]
-
-  configs -= _configs_to_remove
-  configs += _configs_to_add
-}
-
-executable("glslang_validator") {
-  sources = [
-    "StandAlone/DirStackFileIncluder.h",
-    "StandAlone/StandAlone.cpp",
-  ]
-  if (!is_win) {
-    cflags = [ "-Woverflow" ]
-  }
-  defines = [ "ENABLE_OPT=1" ]
-  deps = [
-    ":glslang_default_resource_limits_sources",
-    ":glslang_sources",
-  ]
-
-  configs -= _configs_to_remove
-  configs += _configs_to_add
-}
-
-executable("spirv-remap") {
-  sources = [
-    "StandAlone/spirv-remap.cpp",
-  ]
-  defines = [ "ENABLE_OPT=1" ]
-  deps = [
-    ":glslang_sources",
-  ]
-
-  configs -= _configs_to_remove
-  configs += _configs_to_add
-}
@@ -1,229 +0,0 @@
-# increase to 3.1 once all major distributions
-# include a version of CMake >= 3.1
-cmake_minimum_required(VERSION 2.8.12)
-if (POLICY CMP0048)
-  cmake_policy(SET CMP0048 NEW)
-endif()
-set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-
-# Enable compile commands database
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-
-# Adhere to GNU filesystem layout conventions
-include(GNUInstallDirs)
-
-# Needed for CMAKE_DEPENDENT_OPTION macro
-include(CMakeDependentOption)
-
-option(BUILD_SHARED_LIBS "Build Shared Libraries" OFF)
-option(BUILD_EXTERNAL "Build external dependencies in /External" ON)
-
-set(LIB_TYPE STATIC)
-
-if(BUILD_SHARED_LIBS)
-    set(LIB_TYPE SHARED)
-endif()
-
-option(SKIP_GLSLANG_INSTALL "Skip installation" ${SKIP_GLSLANG_INSTALL})
-if(NOT ${SKIP_GLSLANG_INSTALL})
-  set(ENABLE_GLSLANG_INSTALL ON)
-endif()
-option(ENABLE_SPVREMAPPER "Enables building of SPVRemapper" ON)
-
-option(ENABLE_GLSLANG_BINARIES "Builds glslangValidator and spirv-remap" ON)
-
-option(ENABLE_GLSLANG_JS
-    "If using Emscripten, build glslang.js. Otherwise, builds a sample executable for binary-size testing." OFF)
-CMAKE_DEPENDENT_OPTION(ENABLE_GLSLANG_WEBMIN
-    "Reduces glslang to minimum needed for web use"
-    OFF "ENABLE_GLSLANG_JS"
-    OFF)
-CMAKE_DEPENDENT_OPTION(ENABLE_GLSLANG_WEBMIN_DEVEL
-    "For ENABLE_GLSLANG_WEBMIN builds, enables compilation error messages"
-    OFF "ENABLE_GLSLANG_WEBMIN"
-    OFF)
-CMAKE_DEPENDENT_OPTION(ENABLE_EMSCRIPTEN_SINGLE_FILE
-    "If using Emscripten, enables SINGLE_FILE build"
-    OFF "ENABLE_GLSLANG_JS AND EMSCRIPTEN"
-    OFF)
-CMAKE_DEPENDENT_OPTION(ENABLE_EMSCRIPTEN_ENVIRONMENT_NODE
-    "If using Emscripten, builds to run on Node instead of Web"
-    OFF "ENABLE_GLSLANG_JS AND EMSCRIPTEN"
-    OFF)
-
-CMAKE_DEPENDENT_OPTION(ENABLE_HLSL
-    "Enables HLSL input support"
-    ON "NOT ENABLE_GLSLANG_WEBMIN"
-    OFF)
-
-option(ENABLE_RTTI "Enables RTTI" OFF)
-option(ENABLE_OPT "Enables spirv-opt capability if present" ON)
-option(ENABLE_PCH "Enables Precompiled header" ON)
-option(ENABLE_CTEST "Enables testing" ON)
-
-if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND WIN32)
-    set(CMAKE_INSTALL_PREFIX "install" CACHE STRING "..." FORCE)
-endif()
-
-option(USE_CCACHE "Use ccache" OFF)
-if(USE_CCACHE)
-    find_program(CCACHE_FOUND ccache)
-    if(CCACHE_FOUND)
-        set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
-    endif(CCACHE_FOUND)
-endif()
-
-# Precompiled header macro. Parameters are source file list and filename for pch cpp file.
-macro(glslang_pch SRCS PCHCPP)
-  if(MSVC AND CMAKE_GENERATOR MATCHES "^Visual Studio" AND NOT ${CMAKE_CXX_COMPILER_ID} MATCHES "Clang" AND ENABLE_PCH)
-    set(PCH_NAME "$(IntDir)\\pch.pch")
-    # make source files use/depend on PCH_NAME
-    set_source_files_properties(${${SRCS}} PROPERTIES COMPILE_FLAGS "/Yupch.h /FIpch.h /Fp${PCH_NAME} /Zm300" OBJECT_DEPENDS "${PCH_NAME}")
-    # make PCHCPP file compile and generate PCH_NAME
-    set_source_files_properties(${PCHCPP} PROPERTIES COMPILE_FLAGS "/Ycpch.h /Fp${PCH_NAME} /Zm300" OBJECT_OUTPUTS "${PCH_NAME}")
-    list(APPEND ${SRCS} "${PCHCPP}")
-  endif()
-endmacro(glslang_pch)
-
-project(glslang)
-
-if(ENABLE_CTEST)
-    include(CTest)
-endif()
-
-if(ENABLE_HLSL)
-    add_definitions(-DENABLE_HLSL)
-endif(ENABLE_HLSL)
-
-if(ENABLE_GLSLANG_WEBMIN)
-    add_definitions(-DGLSLANG_WEB)
-    if(ENABLE_GLSLANG_WEBMIN_DEVEL)
-        add_definitions(-DGLSLANG_WEB_DEVEL)
-    endif(ENABLE_GLSLANG_WEBMIN_DEVEL)
-endif(ENABLE_GLSLANG_WEBMIN)
-
-if(WIN32)
-    set(CMAKE_DEBUG_POSTFIX "d")
-    if(MSVC)
-        include(ChooseMSVCCRT.cmake)
-    endif(MSVC)
-    add_definitions(-DGLSLANG_OSINCLUDE_WIN32)
-elseif(UNIX)
-    add_definitions(-DGLSLANG_OSINCLUDE_UNIX)
-else(WIN32)
-    message("unknown platform")
-endif(WIN32)
-
-if(${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
-    add_compile_options(-Wall -Wmaybe-uninitialized -Wuninitialized -Wunused -Wunused-local-typedefs
-                        -Wunused-parameter -Wunused-value  -Wunused-variable -Wunused-but-set-parameter -Wunused-but-set-variable -fno-exceptions)
-    add_compile_options(-Wno-reorder)  # disable this from -Wall, since it happens all over.
-    if(NOT ENABLE_RTTI)
-        add_compile_options(-fno-rtti)
-    endif()
-    if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "9.0.0")
-        add_compile_options(-Werror=deprecated-copy)
-    endif()
-elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang" AND NOT MSVC)
-    add_compile_options(-Wall -Wuninitialized -Wunused -Wunused-local-typedefs
-                        -Wunused-parameter -Wunused-value  -Wunused-variable)
-    add_compile_options(-Wno-reorder)  # disable this from -Wall, since it happens all over.
-    if(NOT ENABLE_RTTI)
-        add_compile_options(-fno-rtti)
-    endif()
-elseif(MSVC)
-    if(NOT ENABLE_RTTI)
-        add_compile_options(/GR-) # Disable RTTI
-    endif()
-endif()
-
-if(ENABLE_GLSLANG_JS)
-    if(MSVC)
-        add_compile_options(/Os /GR-)
-    else()
-        add_compile_options(-Os -fno-exceptions)
-        if(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang" AND NOT MSVC)
-            add_compile_options(-Wno-unused-parameter)
-            add_compile_options(-Wno-unused-variable -Wno-unused-const-variable)
-        endif()
-    endif()
-endif(ENABLE_GLSLANG_JS)
-
-# Request C++11
-if(${CMAKE_VERSION} VERSION_LESS 3.1)
-    # CMake versions before 3.1 do not understand CMAKE_CXX_STANDARD
-    # remove this block once CMake >=3.1 has fixated in the ecosystem
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-else()
-    set(CMAKE_CXX_STANDARD 11)
-    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-    set(CMAKE_CXX_EXTENSIONS OFF)
-endif()
-
-function(glslang_set_link_args TARGET)
-    # For MinGW compiles, statically link against the GCC and C++ runtimes.
-    # This avoids the need to ship those runtimes as DLLs.
-    if(WIN32 AND ${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
-        set_target_properties(${TARGET} PROPERTIES
-                              LINK_FLAGS "-static -static-libgcc -static-libstdc++")
-    endif()
-endfunction(glslang_set_link_args)
-
-# CMake needs to find the right version of python, right from the beginning,
-# otherwise, it will find the wrong version and fail later
-if(BUILD_EXTERNAL AND IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/External)
-    find_package(PythonInterp 3 REQUIRED)
-
-	# We depend on these for later projects, so they should come first.
-	add_subdirectory(External)
-endif()
-
-if(NOT TARGET SPIRV-Tools-opt)
-    set(ENABLE_OPT OFF)
-endif()
-
-if(ENABLE_OPT)
-    message(STATUS "optimizer enabled")
-    add_definitions(-DENABLE_OPT=1)
-else()
-    if(ENABLE_HLSL)
-        message(STATUS "spirv-tools not linked - illegal SPIRV may be generated for HLSL")
-    endif()
-    add_definitions(-DENABLE_OPT=0)
-endif()
-
-add_subdirectory(glslang)
-add_subdirectory(OGLCompilersDLL)
-if(ENABLE_GLSLANG_BINARIES)
-    add_subdirectory(StandAlone)
-endif()
-add_subdirectory(SPIRV)
-if(ENABLE_HLSL)
-    add_subdirectory(hlsl)
-endif(ENABLE_HLSL)
-if(ENABLE_CTEST)
-    add_subdirectory(gtests)
-endif()
-
-if(BUILD_TESTING)
-    # glslang-testsuite runs a bash script on Windows.
-    # Make sure to use '-o igncr' flag to ignore carriage returns (\r).
-    set(IGNORE_CR_FLAG "")
-    if(WIN32)
-        set(IGNORE_CR_FLAG -o igncr)
-    endif()
-
-    if (CMAKE_CONFIGURATION_TYPES)
-        set(RESULTS_PATH ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>/localResults)
-        set(VALIDATOR_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/$<CONFIGURATION>/glslangValidator)
-        set(REMAP_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/$<CONFIGURATION>/spirv-remap)
-    else(CMAKE_CONFIGURATION_TYPES)
-        set(RESULTS_PATH ${CMAKE_CURRENT_BINARY_DIR}/localResults)
-        set(VALIDATOR_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/glslangValidator)
-        set(REMAP_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/spirv-remap)
-    endif(CMAKE_CONFIGURATION_TYPES)
-
-    add_test(NAME glslang-testsuite
-        COMMAND bash ${IGNORE_CR_FLAG} runtests ${RESULTS_PATH} ${VALIDATOR_PATH} ${REMAP_PATH}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Test/)
-endif(BUILD_TESTING)