rcheevos: race condition in event handlers and async tasks

The data passed to event handlers (achievements in particular) must be
copied if used by an async task. It might be deleted before the async
task runs.
Fixes MINIDUMP-3ZR MINIDUMP-4XJ MINIDUMP-4TB MINIDUMP-4CA MINIDUMP-38H

.cirrus.yml

@@ -1,9 +0,0 @@
-freebsd_instance:
-  image_family: freebsd-12-2
-
-task:
-  install_script: pkg install -y alsa-lib cmake evdev-proto flac git libao libevdev libudev-devd libzip mesa-libs miniupnpc ninja pkgconf png pulseaudio sdl2
-  script:
-    - git submodule update --init --recursive
-    - cmake -B build -DCMAKE_BUILD_TYPE=Release -G Ninja
-    - cmake --build build --config Release

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+buy_me_a_coffee: hhwtpernwq
+custom: ['https://www.paypal.com/paypalme/FlycastEmu']

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,41 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Please Note: This form is the minimum required information for submitting bugs.**  
+**Removing this form may lead to your issue being closed until it is completed.**
+
+Platform / OS / Hardware: 
+
+Flycast version: 
+
+Hardware: 
+
+**_Description of the Issue_**
+
+Add a short, concise description of the issue here
+
+**_Debugging Steps Tested_**
+
+  * Fill in any steps already tried here
+  * Begin each new line with an asterisk
+  * If no steps are required, please skip
+
+**_Logs Gathered_**
+
+```
+
+Please paste the contents of the log / logs here
+You may leave this field blank if you have none.
+
+```
+
+
+**_Screenshots_**
+
+(Replace this line with any issue screenshots)

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/android.yml

@@ -8,44 +8,101 @@ jobs:
 
     steps:
       - name: Set up build environment
-        run: echo "y" | sudo ${ANDROID_HOME}/tools/bin/sdkmanager --install "ndk;20.0.5594570"
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ccache libcurl4-openssl-dev ninja-build
 
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
 
-      - uses: actions/cache@v2
+      - uses: actions/setup-java@v4
         with:
-          path: ~/.gradle/caches
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
-          restore-keys: |
-            ${{ runner.os }}-gradle-
+          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'
+
+      - name: Bump version code
+        uses: chkfung/[email protected]
+        with:
+          gradlePath: shell/android-studio/flycast/build.gradle 
+          versionCode: ${{ github.run_number }}
 
       - name: Gradle
         working-directory: shell/android-studio
-        run: ./gradlew assembleDebug --parallel
-
-      - uses: actions/upload-artifact@v2
-        with:
-          name: flycast-debug.apk
-          path: shell/android-studio/flycast/build/outputs/apk/debug/flycast-debug.apk
-
-      - name: Set up git vars
-        run: |
-          echo GIT_BUILD=`git describe --all --always | sed 's/remotes\/origin/heads/'`-$GITHUB_SHA >> $GITHUB_ENV
-
-      - name: Clean up
-        run: rm -f shell/android-studio/flycast/build/outputs/apk/debug/*.json
-
-      - uses: jakejarvis/s3-sync-action@master
-        with:
-          args: --acl public-read --follow-symlinks
+        run: ./gradlew assembleRelease bundleRelease --parallel
         env:
-          AWS_S3_BUCKET: flycast-builds
-          AWS_ACCESS_KEY_ID: AKIAJOZQS4H2PHQWYFCA
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_SECRET_KEY }}
-          AWS_REGION: 'us-east-2'
-          SOURCE_DIR: 'shell/android-studio/flycast/build/outputs/apk/debug/'
-          DEST_DIR: android/${{ env.GIT_BUILD }}
-        if: ${{ github.event_name == 'push' }}
+          SENTRY_UPLOAD_URL: ${{ secrets.SENTRY_UPLOAD_URL }}
+          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: flycast-release.apk
+          path: shell/android-studio/flycast/build/outputs/apk/release/flycast-release.apk
+
+      - name: Build dump_syms
+        working-directory: core/deps/breakpad
+        run: |
+          ./configure --prefix=$PWD
+          make -j2
+          make install
+
+      - name: Extract symbols
+        run: |
+          DUMP_SYMS=./core/deps/breakpad/bin/dump_syms
+          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 }'`
+            mkdir -p symbols/libflycast.so/$BUILD_ID
+            mv libflycast.so.sym symbols/libflycast.so/$BUILD_ID
+          done
+
+      - name: Configure AWS Credentials
+        id: aws-credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        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'
+
+      - name: Upload to S3
+        run: |
+          cp shell/android-studio/flycast/build/outputs/bundle/release/*.aab shell/android-studio/flycast/build/outputs/apk/release/
+          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 != '' }}
+
+      - 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 != '' }}

.github/workflows/bsd.yml

@@ -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.1'
+            pkginstall: sudo pkg install -y alsa-lib ccache cmake evdev-proto git libao libevdev libudev-devd libzip lua54 miniupnpc ninja pkgconf pulseaudio sdl2
+          - operating_system: netbsd
+            version: '10.0'
+            pkginstall: sudo pkgin update && sudo pkgin -y install alsa-lib ccache cmake gcc12 git libao libzip lua54 miniupnpc ninja-build pkgconf pulseaudio SDL2 && export PATH=/usr/pkg/gcc12/bin:$PATH
+          - operating_system: openbsd
+            version: '7.5'
+            pkginstall: sudo pkg_add ccache cmake git libao libzip miniupnpc ninja pkgconf pulseaudio sdl2
+        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 -DCMAKE_BUILD_TYPE=Release -G Ninja
+            cmake --build build --config Release

.github/workflows/c-cpp.yml

@@ -7,97 +7,176 @@ jobs:
     name: ${{ matrix.config.name }}
     runs-on: ${{ matrix.config.os }}
 
+    defaults:
+      run:
+        shell: ${{ matrix.config.shell }}
+
+    env:
+      CCACHE_DIR: ${{ github.workspace }}/.ccache
+
     strategy:
       matrix:
         config:
-          - {name: i686-pc-windows-msvc, os: windows-latest, cmakeArgs: -DCMAKE_SYSTEM_VERSION="10.0.18362.0" -G "Visual Studio 16 2019" -A Win32}
-          - {name: x86_64-apple-darwin, os: macos-latest, cmakeArgs: -G "Xcode", destDir: osx}
-          - {name: x86_64-pc-linux-gnu, os: ubuntu-latest}
-          - {name: x86_64-pc-windows-msvc, os: windows-latest, cmakeArgs: -DCMAKE_SYSTEM_VERSION="10.0.18362.0" -G "Visual Studio 16 2019" -A x64}
-          - {name: x86_64-w64-mingw32, os: windows-latest, cmakeArgs: -G "MinGW Makefiles", destDir: win}
+          - {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 -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-20.04, shell: sh, cmakeArgs: -G Ninja -DUSE_DISCORD=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, 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}
 
     steps:
-      - name: Set up build environment (macos-latest)
+      - name: Set up build environment (macOS)
         run: |
-          brew install ccache flac libao libomp pulseaudio zlib
-          echo "/usr/local/opt/ccache/libexec" >> $GITHUB_PATH
-          echo "CCACHE_DIR=/tmp/ccache" >> $GITHUB_ENV
-        if: matrix.config.os == 'macos-latest'
+          # 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 ninja 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 (ubuntu-latest)
+      - 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 libflac-dev libgl1-mesa-dev libpulse-dev libsdl2-dev libudev-dev libzip-dev libminiupnpc-dev
-          echo "CCACHE_DIR=/tmp/ccache" >> $GITHUB_ENV
-        if: matrix.config.os == 'ubuntu-latest'
+          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
+          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'
 
-      - uses: actions/cache@v2
+      - name: Set up build environment (Windows, MinGW)
+        uses: msys2/setup-msys2@v2
         with:
-          path: /tmp/ccache
-          key: ccache-${{ matrix.config.os }}-${{ github.sha }}
-          restore-keys: ccache-${{ matrix.config.os }}-
-        if: matrix.config.os != 'windows-latest'
+          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
+        if: matrix.config.shell == 'msys2 {0}'
 
-      - uses: actions/checkout@v2
+      - name: Set up build environment (Windows, Visual Studio)
+        run: |
+          choco install ccache directx-sdk ninja
+          echo DXSDK_DIR=C:\Program Files (x86)\Microsoft DirectX SDK (June 2010)>> %GITHUB_ENV%
+        if: matrix.config.shell == 'cmd'
+
+      - uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: ${{ matrix.config.arch }}
+        if: matrix.config.shell == 'cmd'
+
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
 
-      - name: Create artifact directory
-        run: mkdir -p build/artifact
+      - 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: Build SDL (macos-latest)
-        run: |
-          cd shell/apple
-          mkdir artifacts
-          brew install --build-from-source ./sdl2.rb
-        if: matrix.config.os == 'macos-latest'
+      - 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 }}
+          restore-keys: ccache-${{ matrix.config.name }}-
+        if: runner.os != 'macOS'
 
       - name: CMake
         run: |
-          cmake -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE=artifact ${{ matrix.config.cmakeArgs }}
-          cmake --build build --config Release --parallel 2
+          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: |
-          mkdir -p build/tests
-          cmake -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE=tests -DENABLE_CTEST=ON ${{ matrix.config.cmakeArgs }}
-          cmake --build build --config Release --parallel 2
-          ./build/tests/flycast
+          cmake -B build -DCMAKE_BUILD_TYPE=${{ matrix.config.buildType }} -DCMAKE_INSTALL_PREFIX=artifact -DENABLE_CTEST=ON ${{ matrix.config.cmakeArgs }}
+          cmake --build build --config ${{ matrix.config.buildType }}
+          ./build/flycast
         if: matrix.config.name == 'x86_64-pc-linux-gnu'
 
-      - uses: actions/upload-artifact@v2
+      - name: Dump symbols
+        run: |
+          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'
+
+      - 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: build/artifact
+          path: artifact/bin
 
       - name: Package app (macos)
         run: |
-          cd build/artifact
-          rm -rf Flycast.swiftmodule
-          zip -r flycast.app.zip Flycast.app
-          rm -rf Flycast.app
-        if: matrix.config.os == 'macos-latest'
+          cd artifact/bin
+          zip -rm flycast.app.zip Flycast.app
+        if: matrix.config.name == 'apple-darwin'
 
       - name: Package app (windows)
         run: |
-          powershell Compress-Archive build/artifact/flycast.exe build/artifact/flycast.zip 
-          rm build/artifact/flycast.exe
+          powershell Compress-Archive artifact/bin/flycast.exe artifact/bin/flycast.zip 
+          rm artifact/bin/flycast.exe
         if: matrix.config.name == 'x86_64-w64-mingw32'
 
-      - name: Set up git vars
-        run: |
-          echo GIT_BUILD=`git describe --all --always | sed 's/remotes\/origin/heads/'`-$GITHUB_SHA >> $GITHUB_ENV
-        shell: bash
-
       - name: Configure AWS Credentials
-        uses: aws-actions/configure-aws-credentials@v1
+        id: aws-credentials
+        uses: aws-actions/configure-aws-credentials@v4
         with:
           aws-access-key-id: AKIAJOZQS4H2PHQWYFCA
           aws-secret-access-key: ${{ secrets.S3_SECRET_KEY }}
           aws-region: us-east-2
-        if: github.event_name == 'push'
+        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push' && matrix.config.destDir != ''
 
       - name: Upload to S3
-        run: aws s3 sync build/artifact s3://flycast-builds/${{ matrix.config.destDir }}/${{ env.GIT_BUILD }} --acl public-read --follow-symlinks
-        if: github.event_name == 'push' && matrix.config.destDir != ''
+        run: aws s3 sync artifact/bin s3://flycast-builds/${{ matrix.config.destDir }}/${GITHUB_REF#refs/}-$GITHUB_SHA --acl public-read --follow-symlinks
+        shell: bash
+        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 (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
+        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') }}
+        

.github/workflows/crowdin_prep.yml

@@ -0,0 +1,36 @@
+# Prepare source texts & upload them to Crowdin
+
+name: Crowdin Source Texts Upload
+
+# on change to the English texts
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - 'shell/libretro/libretro_core_options.h'
+
+jobs:
+  upload_source_file:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Java JDK
+        uses: actions/setup-java@v4
+        with:
+          java-version: 18
+          distribution: zulu
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Upload Source
+        shell: bash
+        env:
+          CROWDIN_API_KEY: ${{ secrets.CROWDIN_API_KEY }}
+        run: |
+          python3 intl/upload_workflow.py $CROWDIN_API_KEY "flyinghead-flycast" "shell/libretro/libretro_core_options.h"

.github/workflows/crowdin_translate.yml

@@ -0,0 +1,49 @@
+# Download translations form Crowdin & Recreate libretro_core_options_intl.h
+
+name: Crowdin Translation Integration
+
+on:
+  schedule:
+  # please choose a random time & weekday to avoid all repos synching at the same time
+    - cron: '15 22 * * 5'  # Fridays at 10:15 PM, UTC
+
+jobs:
+  create_intl_file:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Java JDK
+        uses: actions/setup-java@v4
+        with:
+          java-version: 18
+          distribution: zulu
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Checkout
+        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.
+
+      - name: Create intl file
+        shell: bash
+        env:
+          CROWDIN_API_KEY: ${{ secrets.CROWDIN_API_KEY }}
+        run: |
+          python3 intl/download_workflow.py $CROWDIN_API_KEY "flyinghead-flycast" "shell/libretro/libretro_core_options_intl.h"
+
+      - name: Commit files
+        run: |
+          git config --local user.email "[email protected]"
+          git config --local user.name "github-actions[bot]"
+          git add intl/*_workflow.py "shell/libretro/libretro_core_options_intl.h"
+          git commit -m "Fetch translations & Recreate libretro_core_options_intl.h"
+
+      - name: GitHub Push
+        uses: ad-m/[email protected]
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: ${{ github.ref }}

.github/workflows/switch.yml

@@ -0,0 +1,62 @@
+name: Nintendo Switch CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    name: ${{ matrix.config.name }}
+    runs-on: ubuntu-latest
+    container: devkitpro/devkita64:latest
+
+    strategy:
+      matrix:
+        config:
+          - {name: standalone, destDir: switch}
+          - {name: libretro, cmakeArgs: -DLIBRETRO=ON}
+
+    steps:
+      - name: Set up build environment
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install awscli ccache
+
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - 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 }}
+          restore-keys: ccache-switch-${{ matrix.config.name }}-
+
+      - name: CMake
+        run: |
+          $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@v4
+        with:
+          name: flycast-switch-${{ matrix.config.name }}
+          path: artifact/bin
+
+      - name: Package app
+        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@v4
+        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 != ''
+
+      - 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 != '' }}

.github/workflows/uwp.yml

@@ -0,0 +1,54 @@
+name: Windows UWP CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - 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.22000.0
+          cmake --build build --config Release -- /m
+        shell: cmd
+
+      - uses: ilammy/msvc-dev-cmd@v1
+
+      - name: Package app
+        run: |
+          mkdir build\artifact
+          cd build\AppPackages\flycast\flycast_*_x64_Test
+          mkdir tmp
+          ren *.msix flycast.msix
+          makeappx.exe unpack /p .\flycast.msix /d tmp
+          copy ..\..\..\Release\*.dll tmp
+          makeappx pack /d tmp /p ..\..\..\artifact\flycast.appx
+
+      - name: Sign app
+        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@v4
+        with:
+          name: flycast-uwp
+          path: build/artifact
+
+      - name: Configure AWS Credentials
+        id: aws-credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        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'
+
+      - name: Upload to S3
+        run: aws s3 sync build/artifact s3://flycast-builds/xbox/${GITHUB_REF#refs/}-$GITHUB_SHA --acl public-read --follow-symlinks
+        shell: bash
+        if: ${{ steps.aws-credentials.outputs.aws-account-id != '' }}

.gitignore

@@ -1,66 +1,19 @@
-.DS_Store
-*.class
-*.orig
-*build_obj
-Workdir/data
-Workdir/reicast*
-Workdir/vmu*
-Workdir/webui*
-Workdir/emu.cfg
-Workdir/lib*ant.properties
+build/
+artifact/
 
-# iOS General
+# macOS
 .DS_Store
-*/build/*
-**/build/*
-*.pbxuser
-!default.pbxuser
-*.mode1v3
-!default.mode1v3
-*.mode2v3
-!default.mode2v3
-*.perspectivev3
-!default.perspectivev3
-xcuserdata
-profile
-*.moved-aside
-DerivedData
-*.hmap
-emulator.xccheckout
-reicast.xccheckout
-build/*
-*.so
-*Karen_angelXwind*
-local.properties
-ant.properties
-*build_obj
-*.d
-Workdir/data
-Workdir/reicast*
-Workdir/vmu*
-Workdir/webui*
-Workdir/emu.cfg
-Workdir/lib*ant.properties
-reicast-ios.xccheckout
-
-# Linux General
-shell/linux/.map
-shell/linux/flycast.elf.map
-shell/linux/nosym-flycast.elf
-shell/linux/flycast.elf
-shell/linux/dispframe.elf
+shell/apple/emulator-ios/OpenMP/OpenMP.xcframework
 
 # Visual Studio
-generated
-.vs
-
-# Android Studio
-*.iml
-shell/android-studio/.gradle/
-shell/android-studio/flycast/.cxx/
-shell/android-studio/flycast/build/
-shell/android-studio/flycast/local.properties
+.vs/
+.vscode/
+out/
 
 # JetBrains IDES
 .idea/
 cmake-build-*/
+
+# Dependencies from .gitmodules
+core/deps/breakpad/
+core/deps/glslang/

.gitlab-ci.yml

@@ -0,0 +1,171 @@
+# DESCRIPTION: GitLab CI/CD for libRetro (NOT FOR GitLab-proper)
+
+##############################################################################
+################################# BOILERPLATE ################################
+##############################################################################
+
+# Core definitions
+.core-defs:
+  variables:
+    GIT_SUBMODULE_STRATEGY: recursive
+    CORENAME: flycast
+    CORE_ARGS: -DLIBRETRO=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-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 --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
+  variables:
+    API_LEVEL: 18
+
+# Inclusion templates, required for the build to work
+include:
+  ################################## DESKTOPS ################################
+  # Windows
+  - project: 'libretro-infrastructure/ci-templates'
+    file: '/windows-cmake-mingw.yml'
+
+  # MacOS
+  - 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'
+
+  ################################## CELLULAR ################################
+  # Android
+  - 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 ##################################
+##############################################################################
+#
+################################### DESKTOPS #################################
+# Windows 64-bit
+libretro-build-windows-x64:
+  extends:
+    - .libretro-windows-cmake-x86_64
+    - .core-defs
+
+# Windows 32-bit
+libretro-build-windows-i686:
+  extends:
+    - .libretro-windows-cmake-x86
+    - .core-defs
+
+# Linux 64-bit
+libretro-build-linux-x64:
+  extends:
+    - .libretro-linux-cmake-x86_64
+    - .core-defs-linux
+
+# Linux 32-bit
+libretro-build-linux-i686:
+  extends:
+    - .libretro-linux-cmake-x86
+    - .core-defs-linux
+
+# MacOS 64-bit
+libretro-build-osx-x64:
+  extends:
+    - .libretro-osx-cmake-x86
+    - .core-defs-osx-x64
+
+# MacOS arm 64-bit
+libretro-build-osx-arm64:
+  extends:
+    - .libretro-osx-cmake-arm64
+    - .core-defs-osx-arm64
+
+################################### CELLULAR #################################
+# Android ARMv7a
+android-armeabi-v7a:
+  extends:
+    - .libretro-android-cmake-armeabi-v7a
+    - .core-defs-android
+
+# Android ARMv8a
+android-arm64-v8a:
+  extends:
+    - .libretro-android-cmake-arm64-v8a
+    - .core-defs-android
+
+# Android 64-bit x86
+android-x86_64:
+  extends:
+    - .libretro-android-cmake-x86_64
+    - .core-defs-android
+
+# Android 32-bit x86
+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

.gitmodules

@@ -4,3 +4,40 @@
 [submodule "core/deps/libchdr"]
 	path = core/deps/libchdr
 	url = https://github.com/rtissera/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

README.md

@@ -1,11 +1,14 @@
 # Flycast
 
-[![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)
 [![Android CI](https://github.com/flyinghead/flycast/actions/workflows/android.yml/badge.svg)](https://github.com/flyinghead/flycast/actions/workflows/android.yml)
+[![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)
 
-**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).
 
@@ -13,24 +16,43 @@ Join us on our [**Discord server**](https://discord.gg/X8YWP8w) for a chat.
 
 ## Install
 
-### Flatpak
+### 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`
 
-### Binaries
+### Homebrew (MacOS ![apple logo](https://flyinghead.github.io/flycast-builds/apple.png))
 
-Get fresh builds for your system [on the builds page](https://flyinghead.github.io/flycast-builds/).
+1. [Set up Homebrew](https://brew.sh).
 
-**New:** Now automated test results are available as well.
+2. Install Flycast via Homebrew:
 
-## Disclaimer
+`brew install --cask flycast`
 
-All code contritbuted to this fork is *not* bound by the Individual Contributor License Agreement of the upstream repository (https://github.com/reicast/reicast-emulator) and shall *not* be considered as a contribution to the upstream repository.
+### Xbox One/Series ![xbox logo](https://flyinghead.github.io/flycast-builds/xbox.png)
+
+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 ![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. 
+
+### Build instructions:
+```
+$ git clone --recursive https://github.com/flyinghead/flycast.git
+$ cd flycast
+$ mkdir build && cd build
+$ cmake ..
+$ make
+```

core/README.md

@@ -7,12 +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
-- emitter			-- x86 code emitter
-- 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

core/achievements/achievements.h

@@ -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);
+
+}

core/archive/7zArchive.cpp

@@ -23,30 +23,20 @@
 #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);
-#ifdef USE_WINDOWS_FILE
-	nowide::wstackstring wpath;
-	if (!wpath.convert(path))
-		return false;
-	archiveStream.file.handle = CreateFileW(wpath.c_str(),
-			GENERIC_READ, FILE_SHARE_READ, NULL,
-			OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-	if (archiveStream.file.handle == INVALID_HANDLE_VALUE)
-		return false;
-#else
-	archiveStream.file.file = nowide::fopen(path, "rb");
-	if (archiveStream.file.file == nullptr)
-		return false;
-#endif
+	archiveStream.file.file = file;
+
 	FileInStream_CreateVTable(&archiveStream);
 	LookToRead2_CreateVTable(&lookStream, 0);
 	lookStream.buf = (Byte *)ISzAlloc_Alloc(&g_Alloc, kInputBufSize);

core/archive/7zArchive.h

@@ -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;
 };

core/archive/ZipArchive.cpp

@@ -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);
+}

core/archive/ZipArchive.h

@@ -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;
 };

core/archive/archive.cpp

@@ -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);
+}
 

core/archive/archive.h

@@ -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);

core/archive/rzip.cpp

@@ -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,14 +36,44 @@ 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
+		if (size >> 32 != 0)
+		{
+			size &= 0xffffffff;
+			std::fseek(file, -4, SEEK_CUR);
+		}
 		chunk = new u8[maxChunkSize];
 		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;
 }
 
@@ -51,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)
@@ -64,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;
@@ -93,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;
@@ -106,13 +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;
-	if (std::fwrite(RZipHeader, sizeof(RZipHeader), 1, file) != 1
-		|| std::fwrite(&maxChunkSize, sizeof(maxChunkSize), 1, file) != 1
-		|| std::fwrite(&length, sizeof(length), 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;

core/archive/rzip.h

@@ -28,16 +28,20 @@ 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);
 	size_t Write(const void *data, size_t length);
+	FILE *rawFile() const { return file; }
 
 private:
 	FILE *file = nullptr;
-	size_t size = 0;
+	u64 size = 0;
 	u32 maxChunkSize = 0;
 	u8 *chunk = nullptr;
 	u32 chunkSize = 0;
 	u32 chunkIndex = 0;
+	bool write = false;
+	long startOffset = 0;
 };

core/audio/audiobackend_alsa.cpp

@@ -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

core/audio/audiobackend_coreaudio.cpp

@@ -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

core/audio/audiobackend_directsound.cpp

@@ -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

core/audio/audiobackend_libao.cpp

@@ -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

core/audio/audiobackend_null.cpp

@@ -0,0 +1,51 @@
+#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)
+		{
+			if (last_time.time_since_epoch() != the_clock::duration::zero())
+			{
+				auto fduration = std::chrono::nanoseconds(1000000000L * samples / 44100);
+				auto duration = fduration - (the_clock::now() - last_time);
+				std::this_thread::sleep_for(duration);
+				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;

core/audio/audiobackend_oboe.cpp

@@ -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

core/audio/audiobackend_omx.cpp

@@ -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

core/audio/audiobackend_oss.cpp

@@ -0,0 +1,116 @@
+#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;
+
+public:
+	OSSAudioBackend()
+		: AudioBackend("oss", "Open Sound System") {}
+
+	bool init() override
+	{
+		audioFD = open("/dev/dsp", O_WRONLY);
+		if (audioFD < 0)
+		{
+			WARN_LOG(AUDIO, "Couldn't open /dev/dsp.");
+			return false;
+		}
+		INFO_LOG(AUDIO, "sound enabled, dsp opened for write");
+		int tmp=44100;
+		int err_ret;
+		err_ret=ioctl(audioFD,SNDCTL_DSP_SPEED,&tmp);
+		INFO_LOG(AUDIO, "set Frequency to %i, return %i (rate=%i)", 44100, err_ret, tmp);
+		int channels=2;
+		err_ret=ioctl(audioFD, SNDCTL_DSP_CHANNELS, &channels);
+		INFO_LOG(AUDIO, "set dsp to stereo (%i => %i)", channels, err_ret);
+		int format=AFMT_S16_LE;
+		err_ret=ioctl(audioFD, SNDCTL_DSP_SETFMT, &format);
+		INFO_LOG(AUDIO, "set dsp to %s audio (%i/%i => %i)", "16bits signed", AFMT_S16_LE, format, err_ret);
+
+		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 = open("/dev/dsp", O_RDONLY);
+		if (recordFD < 0)
+		{
+			INFO_LOG(AUDIO, "OSS: can't open default audio capture device");
+			return false;
+		}
+		int tmp = AFMT_S16_NE;	// Native 16 bits
+		if (ioctl(recordFD, SNDCTL_DSP_SETFMT, &tmp) == -1 || tmp != AFMT_S16_NE)
+		{
+			INFO_LOG(AUDIO, "OSS: can't set sample format");
+			close(recordFD);
+			recordFD = -1;
+			return false;
+		}
+		tmp = 1;
+		if (ioctl(recordFD, SNDCTL_DSP_CHANNELS, &tmp) == -1)
+		{
+			INFO_LOG(AUDIO, "OSS: can't set channel count");
+			close(recordFD);
+			recordFD = -1;
+			return false;
+		}
+		tmp = sampling_freq;
+		if (ioctl(recordFD, SNDCTL_DSP_SPEED, &tmp) == -1)
+		{
+			INFO_LOG(AUDIO, "OSS: can't set sample rate");
+			close(recordFD);
+			recordFD = -1;
+			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

core/audio/audiobackend_pulseaudio.cpp

@@ -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

core/audio/audiobackend_sdl2.cpp

@@ -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
+

core/audio/audiostream.cpp

@@ -0,0 +1,140 @@
+#include "audiostream.h"
+#include "cfg/option.h"
+
+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()
+{
+	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;
+}

core/audio/audiostream.h

@@ -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;
+	}
+};

core/build.h

@@ -1,134 +1,16 @@
-/*
-	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
@@ -139,13 +21,10 @@
 #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
 
@@ -175,19 +54,17 @@
 #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
+#ifdef __SWITCH__
+#define FEAT_NO_RWX_PAGES
 #endif
 
 //defaults
 
 #ifndef FEAT_SHREC
-	#if HOST_CPU == CPU_MIPS
-		#define FEAT_SHREC DYNAREC_NONE
-	#else
+	#if HOST_CPU == CPU_ARM || HOST_CPU == CPU_ARM64 || HOST_CPU == CPU_X86 || HOST_CPU == CPU_X64
 		#define FEAT_SHREC DYNAREC_JIT
+	#else
+		#define FEAT_SHREC DYNAREC_NONE
 	#endif
 #endif
 
@@ -200,30 +77,13 @@
 #endif
 
 #ifndef FEAT_DSPREC
-	#if HOST_CPU == CPU_X86 || HOST_CPU == CPU_ARM64 || HOST_CPU == CPU_X64
+	#if HOST_CPU == CPU_ARM || HOST_CPU == CPU_ARM64 || HOST_CPU == CPU_X86 || HOST_CPU == CPU_X64
 		#define FEAT_DSPREC DYNAREC_JIT
 	#else
 		#define FEAT_DSPREC DYNAREC_NONE
 	#endif
 #endif
 
-#if HOST_CPU == CPU_X64 || HOST_CPU == CPU_ARM64
-#define HOST_64BIT_CPU
-#endif
-
-#define USE_MINIUPNPC
-
-// Compiler Related
-
-#ifndef _MSC_VER
-#define ATTR_USED   __attribute__((used))
-#define ATTR_UNUSED __attribute__((used))
-#else
-#define ATTR_USED
-#define ATTR_UNUSED
-#endif
-
-
 // Some restrictions on FEAT_NO_RWX_PAGES
 #if defined(FEAT_NO_RWX_PAGES) && FEAT_SHREC == DYNAREC_JIT
 #if HOST_CPU != CPU_X64 && HOST_CPU != CPU_ARM64
@@ -231,22 +91,30 @@
 #endif
 #endif
 
+#ifdef _WIN32
+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#define TARGET_UWP
+#endif
+#ifdef HAVE_D3D11
+#define USE_DX11
+#endif
+#endif
+
+#if !defined(LIBRETRO) && !defined(TARGET_NO_EXCEPTIONS)
+#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

core/cfg/cfg.cpp

@@ -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,6 +119,11 @@ 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;

core/cfg/cfg.h

@@ -5,6 +5,8 @@
 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);
@@ -12,8 +14,9 @@ bool cfgLoadBool(const std::string& section, const std::string& key, bool 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);

core/cfg/cl.cpp

@@ -1,92 +1,66 @@
 /*
 	Command line parsing
-	~yay~
-
-	Nothing too interesting here, really
 */
 
 #include <cstdio>
-#include <cctype>
 #include <cstring>
 
 #include "cfg/cfg.h"
+#include "stdclass.h"
 
-char* trim_ws(char* str)
-{
-	if (str==0 || strlen(str)==0)
-		return 0;
-
-	while(*str)
-	{
-		if (!isspace(*str))
-			break;
-		str++;
-	}
-
-	size_t l=strlen(str);
-	
-	if (l==0)
-		return 0;
-
-	while(l>0)
-	{
-		if (!isspace(str[l-1]))
-			break;
-		str[l-1]=0;
-		l--;
-	}
-
-	if (l==0)
-		return 0;
-
-	return str;
-}
-
-int setconfig(char** arg,int cl)
+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,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 number of parameters, format is section:key=value");
-			return rv;
+			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value,section:key=value,...", value.c_str());
+			break;
 		}
-		char* sep=strstr(arg[1],":");
-		if (sep==0)
+		auto eqpos = value.find('=', seppos);
+		if (eqpos == std::string::npos)
 		{
-			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value", arg[1]);
-			return rv;
-		}
-		char* value=strstr(sep+1,"=");
-		if (value==0)
-		{
-			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value", arg[1]);
-			return rv;
+			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value,section:key=value,...", value.c_str());
+			break;
 		}
 
-		*sep++=0;
-		*value++=0;
+		auto commapos = value.find(',', eqpos);
 
-		char* sect=trim_ws(arg[1]);
-		char* key=trim_ws(sep);
-		value=trim_ws(value);
+		std::string sect = trim_ws(value.substr(0, seppos));
+		std::string key = trim_ws(value.substr(seppos + 1, eqpos - seppos - 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==0 || key==0)
+		if (sect.empty() || key.empty())
 		{
-			WARN_LOG(COMMON, "-config : invalid parameter, format is section:key=value");
-			return rv;
+			WARN_LOG(COMMON, "-config : invalid parameter, format is section:key=value,section:key=value,...");
+			break;
 		}
 
-		const char* constval = value;
-		if (constval==0)
-			constval="";
-		INFO_LOG(COMMON, "Virtual cfg %s:%s=%s", sect, key, value);
+		INFO_LOG(COMMON, "Virtual cfg %s:%s=%s", sect.c_str(), key.c_str(), value.c_str());
 
-		cfgSetVirtual(sect,key,value);
-		rv++;
+		cfgSetVirtual(sect, key, value);
 
-		if (cl>=3 && stricmp(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;
@@ -112,9 +86,9 @@ static int showhelp()
 	return 0;
 }
 
-bool ParseCommandLine(int argc,char* argv[])
+void ParseCommandLine(int argc,char* argv[])
 {
-	settings.imgread.ImagePath[0] = '\0';
+	settings.content.path.clear();
 	int cl=argc-2;
 	char** arg=argv+1;
 	while(cl>=0)
@@ -136,6 +110,10 @@ bool ParseCommandLine(int argc,char* argv[])
 			cl--;
 		}
 #endif
+		else if ((*arg)[0] == '-')
+		{
+			WARN_LOG(COMMON, "Ignoring unknown command line option '%s'", *arg);
+		}
 		else
 		{
 			char* extension = strrchr(*arg, '.');
@@ -145,22 +123,21 @@ bool ParseCommandLine(int argc,char* argv[])
 					|| stricmp(extension, ".gdi") == 0 || stricmp(extension, ".cue") == 0))
 			{
 				INFO_LOG(COMMON, "Using '%s' as cd image", *arg);
-				strcpy(settings.imgread.ImagePath, *arg);
+				settings.content.path = *arg;
 			}
 			else if (extension && stricmp(extension, ".elf") == 0)
 			{
 				INFO_LOG(COMMON, "Using '%s' as reios elf file", *arg);
 				cfgSetVirtual("config", "bios.UseReios", "yes");
-				strcpy(settings.imgread.ImagePath, *arg);
+				settings.content.path = *arg;
 			}
 			else
 			{
 				INFO_LOG(COMMON, "Using '%s' as rom", *arg);
-				strcpy(settings.imgread.ImagePath, *arg);
+				settings.content.path = *arg;
 			}
 		}
 		arg++;
 		cl--;
 	}
-	return false;
 }

core/cfg/ini.cpp

@@ -1,7 +1,7 @@
 #include "ini.h"
+#include "types.h"
 #include <sstream>
-
-char* trim_ws(char* str);
+#include "stdclass.h"
 
 namespace emucfg {
 
@@ -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 ||
@@ -158,6 +166,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);
@@ -188,6 +209,13 @@ 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");
@@ -196,94 +224,53 @@ void ConfigFile::set_bool(const std::string& section_name, const std::string& en
 
 void ConfigFile::parse(FILE* file)
 {
-	if(file == NULL)
-	{
+	if (file == nullptr)
 		return;
-	}
+
 	char line[512];
-	char current_section[512] = { '\0' };
+	std::string section;
 	int cline = 0;
-	while(file && !feof(file))
+	while (true)
 	{
-		if (std::fgets(line, 512, file) == NULL || std::feof(file))
-		{
+		if (std::fgets(line, sizeof(line), file) == nullptr)
 			break;
-		}
-
 		cline++;
-
-		if (strlen(line) < 3)
+		std::string s(line);
+		s = trim_ws(s, " \r\n");
+		if (s.empty())
+			continue;
+		if (s.length() >= 3 && s[0] == '[' && s[s.length() - 1] == ']')
 		{
+			section = s.substr(1, s.length() - 2);
 			continue;
 		}
-
-		if (line[strlen(line)-1] == '\r' ||
-			  line[strlen(line)-1] == '\n')
+		auto eqpos = s.find('=');
+		if (eqpos == std::string::npos)
 		{
-			line[strlen(line)-1] = '\0';
-		}
-
-		char* tl = trim_ws(line);
-
-		if (tl[0] == '[' && tl[strlen(tl)-1] == ']')
-		{
-			tl[strlen(tl)-1] = '\0';
-
-			// FIXME: Data loss if buffer is too small
-			strncpy(current_section, tl+1, sizeof(current_section));
-			current_section[sizeof(current_section) - 1] = '\0';
-
-			trim_ws(current_section);
-		}
-		else
-		{
-			if (strlen(current_section) == 0)
-			{
-				continue; //no open section
-			}
-
-			char* separator = strstr(tl, "=");
-
-			if (!separator)
-			{
-				WARN_LOG(COMMON, "Malformed entry on config - ignoring @ %d(%s)", cline, tl);
-				continue;
-			}
-
-			*separator = '\0';
-
-			char* name = trim_ws(tl);
-			char* value = trim_ws(separator + 1);
-			if (name == NULL || value == NULL)
-			{
-				//printf("Malformed entry on config - ignoring @ %d(%s)\n",cline, tl);
-				continue;
-			}
-			else
-			{
-				this->set(std::string(current_section), std::string(name), std::string(value));
-			}
+			WARN_LOG(COMMON, "Malformed entry on config - ignoring line %d: %s", cline, s.c_str());
+			continue;
 		}
+		std::string property = trim_ws(s.substr(0, eqpos));
+		std::string value = trim_ws(s.substr(eqpos + 1));
+		if (value.length() >= 2 && value[0] == '"' && value[value.length() - 1] == '"')
+			value = value.substr(1, value.length() - 2);
+		set(section, property, value);
 	}
 }
 
 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());
 
-		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());
 		}
-
-		std::fputs("\n", file);
+		if (!section_name.empty())
+			std::fputc('\n', file);
 	}
 }
 

core/cfg/ini.h

@@ -1,6 +1,9 @@
 #pragma once
-#include "types.h"
+
+#include <cstdio>
 #include <map>
+#include <string>
+#include <cstdint>
 
 namespace emucfg {
 
@@ -9,6 +12,7 @@ struct ConfigEntry {
 	const std::string& get_string() const;
 	int get_int();
 	bool get_bool();
+	int64_t get_int64();
 };
 
 struct ConfigSection {
@@ -39,10 +43,12 @@ 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);
 		/* 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 delete_section(const std::string& section_name);

core/cfg/option.cpp

@@ -17,14 +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<bool> DynarecSafeMode("Dynarec.safe-mode");
+Option<int> Sh4Clock("Sh4Clock", 200);
 
 // General
 
@@ -32,14 +33,17 @@ 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> AutoSavestate("Dreamcast.AutoSavestate");
+Option<bool> AutoLoadState("Dreamcast.AutoLoadState");
+Option<bool> AutoSaveState("Dreamcast.AutoSaveState");
+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
 
 Option<bool> DSPEnabled("aica.DSPEnabled", false);
-Option<bool> DisableSound("aica.NoSound");
 #if HOST_CPU == CPU_ARM
 Option<int> AudioBufferSize("aica.BufferSize", 5644);	// 128 ms
 #else
@@ -54,6 +58,8 @@ Option<bool> AutoLatency("aica.AutoLatency",
 		);
 
 OptionString AudioBackend("backend", "auto", "audio");
+AudioVolumeOption AudioVolume;
+Option<bool> VmuSound("VmuSound", false, "audio");
 
 // Rendering
 
@@ -75,7 +81,11 @@ Option<bool> Fog("rend.Fog", true);
 Option<bool> FloatVMUs("rend.FloatVMUs");
 Option<bool> Rotate90("rend.Rotate90");
 Option<bool> PerStripSorting("rend.PerStripSorting");
-Option<bool> DelayFrameSwapping("rend.DelayFrameSwapping");
+#ifdef __APPLE__
+Option<bool> DelayFrameSwapping("rend.DelayFrameSwapping", false);
+#else
+Option<bool> DelayFrameSwapping("rend.DelayFrameSwapping", true);
+#endif
 Option<bool> WidescreenGameHacks("rend.WidescreenGameHacks");
 std::array<Option<int>, 4> CrosshairColor {
 	Option<int>("rend.CrossHairColor1"),
@@ -83,34 +93,74 @@ 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<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);
+Option<bool> NativeDepthInterpolation("rend.NativeDepthInterpolation", false);
+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
+
+// 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");
-
-#ifdef SUPPORT_DISPMANX
-Option<bool> DispmanxMaintainAspect("maintain_aspect", true, "dispmanx");
-#endif
+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");
+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");
 
 #ifdef USE_OMX
 Option<int> OmxAudioLatency("audio_latency", 100, "omx");
@@ -121,6 +171,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"),
@@ -141,5 +192,20 @@ std::array<std::array<Option<MapleDeviceType>, 2>, 4> MapleExpansionDevices {
 	Option<MapleDeviceType>("device4.1", MDT_None, "input"),
 	Option<MapleDeviceType>("device4.2", MDT_None, "input"),
 };
+Option<bool> PerGameVmu("PerGameVmu", false, "config");
+#ifdef _WIN32
+Option<bool, false> UseRawInput("RawInput", false, "input");
+#endif
+
+#ifdef USE_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

core/cfg/option.h

@@ -20,8 +20,13 @@
 #include <string>
 #include <vector>
 #include <array>
+#include <cmath>
+#include <type_traits>
 #include "cfg.h"
 #include "hw/maple/maple_cfg.h"
+#ifdef LIBRETRO
+#include <libretro.h>
+#endif
 
 namespace config {
 
@@ -33,6 +38,10 @@ public:
 	virtual void reset() = 0;
 };
 
+#ifdef LIBRETRO
+#include "option_lr.h"
+#else
+
 class Settings {
 public:
 	void reset() {
@@ -62,10 +71,6 @@ public:
 		cfgSetAutoSave(true);
 	}
 
-	const std::string& getGameId() const {
-		return gameId;
-	}
-
 	void setGameId(const std::string& gameId) {
 		this->gameId = gameId;
 	}
@@ -96,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:
@@ -117,7 +118,7 @@ public:
 
 	void load() override {
 		if (PerGameOption && settings.hasPerGameConfig())
-			set(doLoad(settings.getGameId(), section + "." + name));
+			set(doLoad(settings.gameId, section + "." + name));
 		else
 		{
 			set(doLoad(section, name));
@@ -138,10 +139,14 @@ 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.getGameId(), section + "." + name);
+			doSave(settings.gameId, section + "." + name);
 		else
 			doSave(section, name);
 	}
@@ -149,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;
@@ -165,40 +170,47 @@ 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 atof(strValue.c_str());
+			return (float)atof(strValue.c_str());
 	}
 
 	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, "");
@@ -208,42 +220,85 @@ protected:
 		std::vector<std::string> newValue;
 		while (true)
 		{
-			std::string::size_type end = paths.find(';', start);
-			if (end == std::string::npos)
-				end = paths.size();
-			if (start != end)
-				newValue.push_back(paths.substr(start, end - start));
-			if (end == paths.size())
-				break;
-			start = end + 1;
+			if (paths[start] == '"')
+			{
+				std::string v;
+				start++;
+				while (true)
+				{
+					if (paths[start] == '"')
+					{
+						if (start + 1 >= paths.size())
+						{
+							newValue.push_back(v);
+							return newValue;
+						}
+						if (paths[start + 1] == '"')
+						{
+							v += paths[start++];
+							start++;
+						}
+						else if (paths[start + 1] == ';')
+						{
+							newValue.push_back(v);
+							start += 2;
+							break;
+						}
+						else
+						{
+							v += paths[start++];
+						}
+					}
+					else
+						v += paths[start++];
+				}
+			}
+			else
+			{
+				std::string::size_type end = paths.find(';', start);
+				if (end == std::string::npos)
+					end = paths.size();
+				if (start != end)
+					newValue.push_back(paths.substr(start, end - start));
+				if (end == paths.size())
+					break;
+				start = end + 1;
+			}
 		}
 		return newValue;
 	}
 
 	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];
@@ -252,16 +307,36 @@ protected:
 	}
 
 	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;
-		for (auto& v : value)
+		for (const auto& v : value)
 		{
-			if (s.empty())
-				s = v;
+			if (!s.empty())
+				s += ';';
+			if (v.find(';') != std::string::npos || (!v.empty() && v[0] == '"'))
+			{
+				s += '"';
+				std::string v2 = v;
+				while (true)
+				{
+					auto pos = v2.find('"');
+					if (pos != std::string::npos)
+					{
+						s += v2.substr(0, pos + 1) + '"';
+						v2 = v2.substr(pos + 1);
+					}
+					else
+					{
+						s += v2;
+						break;
+					}
+				}
+				s += '"';
+			}
 			else
-				s += ";" + v;
+				s += v;
 		}
 		cfgSaveStr(section, name, s);
 	}
@@ -274,20 +349,16 @@ protected:
 	bool overridden = false;
 	Settings& settings;
 };
+#endif
 
 using OptionString = Option<std::string>;
 
-template<typename T, T value = T()>
-class ConstOption {
-public:
-	operator T() const { return value; }
-};
-
 // Dynarec
 
 extern Option<bool> DynarecEnabled;
-extern Option<bool> DynarecIdleSkip;
-extern Option<bool> DynarecSafeMode;
+#ifndef LIBRETRO
+extern Option<int> Sh4Clock;
+#endif
 
 // General
 
@@ -295,57 +366,74 @@ 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> AutoSavestate;
+extern Option<bool> AutoLoadState;
+extern Option<bool> AutoSaveState;
+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
 
-constexpr ConstOption<bool, true> LimitFPS;
+constexpr bool LimitFPS = true;
 extern Option<bool> DSPEnabled;
-extern Option<bool> DisableSound;
 extern Option<int> AudioBufferSize;	//In samples ,*4 for bytes
 extern Option<bool> AutoLatency;
 
 extern OptionString AudioBackend;
 
+class AudioVolumeOption : public Option<int> {
+public:
+	AudioVolumeOption() : Option<int>("aica.Volume", 100) {};
+	float logarithmic_volume_scale = 1.0;
+
+	void load() override {
+		Option<int>::load();
+		calcDbPower();
+	}
+
+	float dbPower()
+	{
+		return logarithmic_volume_scale;
+	}
+	void calcDbPower()
+	{
+		// dB scaling calculation: https://www.dr-lex.be/info-stuff/volumecontrols.html
+		logarithmic_volume_scale = std::min(std::exp(4.605f * float(value) / 100.f) / 100.f, 1.f);
+		if (value < 10)
+			logarithmic_volume_scale *= value / 10.f;
+	}
+};
+extern AudioVolumeOption AudioVolume;
+extern Option<bool> VmuSound;
+
 // Rendering
 
 class RendererOption : public Option<RenderType> {
 public:
-	RendererOption()
-		: Option<RenderType>("pvr.rend", RenderType::OpenGL) {}
+#ifdef LIBRETRO
+	RendererOption() : Option<RenderType>("",
+#else
+	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
+		) {}
 
-	bool isOpenGL() const {
-		return value == RenderType::OpenGL || value == RenderType::OpenGL_OIT;
-	}
-	void set(RenderType v)
-	{
-		newValue = v;
-	}
 	RenderType& operator=(const RenderType& v) { set(v); return value; }
 
-	void load() override {
-		RenderType current = value;
-		Option<RenderType>::load();
-		newValue = value;
-		value = current;
-	}
-
 	void reset() override {
-		// don't reset the value to avoid vk -> gl -> vk quick switching
+		// don't reset the value to avoid quick switching when starting a game
 		overridden = false;
 	}
-
-	bool pendingChange() {
-		return newValue != value;
-	}
-	void commit() {
-		value = newValue;
-	}
-
-private:
-	RenderType newValue = RenderType();
 };
 extern RendererOption RendererType;
 extern Option<bool> UseMipmaps;
@@ -355,9 +443,12 @@ extern Option<bool> ShowFPS;
 extern Option<bool> RenderToTextureBuffer;
 extern Option<bool> TranslucentPolygonDepthMask;
 extern Option<bool> ModifierVolumes;
-constexpr ConstOption<bool, true> Clipping;
+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;
 extern Option<bool> DumpTextures;
@@ -369,22 +460,53 @@ 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<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
+
+// Profiling
+extern Option<bool> ProfilerEnabled;
+extern Option<bool> ProfilerDrawToGUI;
+extern Option<bool> ProfilerOutputTTY;
+extern Option<float> ProfilerFrameWarningTime;
 
 // Network
 
@@ -392,11 +514,19 @@ extern Option<bool> NetworkEnable;
 extern Option<bool> ActAsServer;
 extern OptionString DNS;
 extern OptionString NetworkServer;
+extern Option<int> LocalPort;
 extern Option<bool> EmulateBBA;
-
-#ifdef SUPPORT_DISPMANX
-extern Option<bool> DispmanxMaintainAspect;
-#endif
+extern Option<bool> EnableUPnP;
+extern Option<bool> GGPOEnable;
+extern Option<int> GGPODelay;
+extern Option<bool> NetworkStats;
+extern Option<int> GGPOAnalogAxes;
+extern Option<bool> GGPOChat;
+extern Option<bool> GGPOChatTimeoutToggle;
+extern Option<int> GGPOChatTimeout;
+extern Option<bool> NetworkOutput;
+extern Option<int> MultiboardSlaves;
+extern Option<bool> BattleCableEnable;
 
 #ifdef USE_OMX
 extern Option<int> OmxAudioLatency;
@@ -407,8 +537,25 @@ 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, false> UseRawInput;
+#else
+constexpr bool UseRawInput = false;
+#endif
+
+#ifdef USE_LUA
+extern Option<std::string, false> LuaFileName;
+#endif
+
+// RetroAchievements
+
+extern Option<bool> EnableAchievements;
+extern Option<bool> AchievementsHardcoreMode;
+extern OptionString AchievementsUserName;
+extern OptionString AchievementsToken;
 
 } // namespace config
-

core/cheats.h

@@ -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
@@ -39,17 +42,28 @@ struct Cheat
 		runNextIfEq,
 		runNextIfNeq,
 		runNextIfGt,
-		runNextIfLt
+		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
@@ -62,12 +76,15 @@ public:
 	bool cheatEnabled(size_t index) const { return cheats[index].enabled; }
 	void enableCheat(size_t index, bool enabled) { cheats[index].enabled = enabled; }
 	void loadCheatFile(const std::string& filename);
+	void saveCheatFile(const std::string& filename);
 	// Returns true if using 16:9 anamorphic screen ratio
 	bool isWidescreen() const { return widescreen_cheat != nullptr; }
+	void addGameSharkCheat(const std::string& name, const std::string& s);
 
 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[];
@@ -75,6 +92,10 @@ private:
 	bool active = false;
 	std::vector<Cheat> cheats;
 	std::string gameId;
+
+	friend class CheatManagerTest_TestLoad_Test;
+	friend class CheatManagerTest_TestGameShark_Test;
+	friend class CheatManagerTest_TestSave_Test;
 };
 
 extern CheatManager cheatManager;

core/core.mk

@@ -1,260 +0,0 @@
-RZDCY_FILES :=
-
-RZDCY_SRC_DIR ?= $(call my-dir)
-VERSION_HEADER := $(RZDCY_SRC_DIR)/version.h
-
-RZDCY_MODULES	:=	cfg/ hw/arm7/ hw/aica/ hw/holly/ hw/ hw/gdrom/ hw/maple/ \
- hw/mem/ hw/pvr/ hw/sh4/ hw/sh4/interpr/ hw/sh4/modules/ profiler/ oslib/ \
- hw/naomi/ imgread/ ./ deps/libchdr/src/ deps/libchdr/deps/zlib-1.2.11/ \
- deps/libelf/ deps/chdpsr/ rend/ reios/ deps/xbrz/ \
- deps/imgui/ archive/ input/ log/ wsi/ network/ hw/bba/ debug/ \
- hw/modem/ deps/picotcp/modules/ deps/picotcp/stack/
-
-ifndef NO_REC
-	ifndef NOT_ARM
-	    RZDCY_MODULES += rec-ARM/ deps/vixl/ deps/vixl/aarch32/
-	endif
-	
-	ifdef X86_REC
-	    RZDCY_MODULES += rec-x86/
-	endif
-	
-	ifdef X64_REC
-	    RZDCY_MODULES += rec-x64/
-	endif
-	
-	ifdef CPP_REC
-	    RZDCY_MODULES += rec-cpp/
-	endif
-	
-	ifdef ARM64_REC
-	    RZDCY_MODULES += rec-ARM64/ deps/vixl/ deps/vixl/aarch64/
-	endif
-endif
-
-ifndef NO_REND
-    RZDCY_MODULES += rend/gles/
-    ifndef USE_GLES
-	ifndef USE_DISPMANX
-	    RZDCY_MODULES += rend/gl4/
-	endif
-    endif
-    ifdef USE_VULKAN
-    	RZDCY_MODULES += rend/vulkan/ rend/vulkan/oit/ deps/volk/ \
-    		deps/glslang/glslang/MachineIndependent/ \
-    		deps/glslang/glslang/MachineIndependent/preprocessor/ \
-    		deps/glslang/glslang/GenericCodeGen/ \
-    		deps/glslang/OGLCompilersDLL/ \
-    		deps/glslang/SPIRV/
-    	ifdef FOR_WINDOWS
-    		RZDCY_FILES += $(RZDCY_SRC_DIR)/deps/glslang/glslang/OSDependent/Windows/ossource.cpp
-    	else
-    		RZDCY_FILES += $(RZDCY_SRC_DIR)/deps/glslang/glslang/OSDependent/Unix/ossource.cpp
-    	endif
-    endif
-else
-    RZDCY_MODULES += rend/norend/
-endif
-
-ifdef USE_SDL
-    RZDCY_MODULES += sdl/
-endif
-
-ifdef FOR_LINUX
-	ifndef UNIT_TESTS
-    	RZDCY_MODULES += linux-dist/
-	endif
-    RZDCY_MODULES += linux/
-endif
-
-ifdef FOR_WINDOWS
-	ifndef UNIT_TESTS
-	    RZDCY_FILES += $(RZDCY_SRC_DIR)/windows/winmain.cpp
-	endif
-    RZDCY_FILES += $(RZDCY_SRC_DIR)/windows/win_vmem.cpp
-    RZDCY_CFLAGS += -I$(RZDCY_SRC_DIR)/deps/dirent
-endif
-
-ifdef USE_VULKAN
-	ifdef FOR_WINDOWS
-		RZDCY_CFLAGS += -DVK_USE_PLATFORM_WIN32_KHR
-	else
-		RZDCY_CFLAGS += -DVK_USE_PLATFORM_XLIB_KHR
-	endif
-	RZDCY_CFLAGS += -D USE_VULKAN
-endif
-
-RZDCY_CFLAGS += -I$(RZDCY_SRC_DIR) -I$(RZDCY_SRC_DIR)/rend/gles -I$(RZDCY_SRC_DIR)/deps \
-		 -I$(RZDCY_SRC_DIR)/deps/vixl -I$(RZDCY_SRC_DIR)/khronos -I$(RZDCY_SRC_DIR)/deps/glslang \
-		 -I$(RZDCY_SRC_DIR)/deps/glm -I$(RZDCY_SRC_DIR)/deps/xbyak -I$(RZDCY_SRC_DIR)/deps/nowide/include \
-		 -I$(RZDCY_SRC_DIR)/deps/picotcp/include -I$(RZDCY_SRC_DIR)/deps/picotcp/modules \
-		 -I$(RZDCY_SRC_DIR)/deps/libchdr/include -I$(RZDCY_SRC_DIR)/deps/libchdr/deps/zlib-1.2.11/ \
-		 -I$(RZDCY_SRC_DIR)/deps/libchdr/deps/lzma-19.00 -I$(RZDCY_SRC_DIR)/deps/libchdr/deps/lzma-19.00/include
-
-ifdef USE_SYSTEM_MINIUPNPC
-	RZDCY_CFLAGS += -I/usr/include/miniupnpc
-else
-	RZDCY_CFLAGS += -I$(RZDCY_SRC_DIR)/deps/miniupnpc
-endif
-
-ifdef NO_REC
-	RZDCY_CFLAGS += -DTARGET_NO_REC
-else
-	RZDCY_MODULES += hw/sh4/dyna/
-endif
-
-ifdef USE_GLES
-  RZDCY_CFLAGS += -DGLES -fPIC
-endif
-
-ifdef CHD5_FLAC
-	RZDCY_CFLAGS += -DCHD5_FLAC -I$(RZDCY_SRC_DIR)/deps/flac/src/libFLAC/include/ -I$(RZDCY_SRC_DIR)/deps/flac/include
-	RZDCY_CFLAGS += -DHAVE_CONFIG_H
-	RZDCY_MODULES += deps/flac/src/libFLAC/
-endif
-
-# 7-Zip/LZMA settings (CHDv5)
-ifdef CHD5_LZMA
-	RZDCY_MODULES += deps/lzma/
-	RZDCY_CFLAGS += -D_7ZIP_ST -DCHD5_LZMA
-endif
-
-RZDCY_CFLAGS += -DXXH_INLINE_ALL -I$(RZDCY_SRC_DIR)/deps/xxHash -I$(RZDCY_SRC_DIR)/deps/stb
-
-RZDCY_FILES += $(foreach dir,$(addprefix $(RZDCY_SRC_DIR)/,$(RZDCY_MODULES)),$(wildcard $(dir)*.cpp))
-RZDCY_FILES += $(foreach dir,$(addprefix $(RZDCY_SRC_DIR)/,$(RZDCY_MODULES)),$(wildcard $(dir)*.cc))
-RZDCY_FILES += $(foreach dir,$(addprefix $(RZDCY_SRC_DIR)/,$(RZDCY_MODULES)),$(wildcard $(dir)*.c))
-RZDCY_FILES += $(foreach dir,$(addprefix $(RZDCY_SRC_DIR)/,$(RZDCY_MODULES)),$(wildcard $(dir)*.S))
-
-ifdef STATIC_LIBZIP
-RZDCY_CFLAGS += -I$(RZDCY_SRC_DIR)/deps/libzip/lib
-LIBZIP_DIR = $(RZDCY_SRC_DIR)/deps/libzip/lib
-RZDCY_FILES += $(LIBZIP_DIR)/zip_add.c \
-	  $(LIBZIP_DIR)/zip_add_dir.c \
-	  $(LIBZIP_DIR)/zip_add_entry.c \
-	  $(LIBZIP_DIR)/zip_algorithm_deflate.c \
-	  $(LIBZIP_DIR)/zip_buffer.c \
-	  $(LIBZIP_DIR)/zip_close.c \
-	  $(LIBZIP_DIR)/zip_delete.c \
-	  $(LIBZIP_DIR)/zip_dir_add.c \
-	  $(LIBZIP_DIR)/zip_dirent.c \
-	  $(LIBZIP_DIR)/zip_discard.c \
-	  $(LIBZIP_DIR)/zip_entry.c \
-	  $(LIBZIP_DIR)/zip_error.c \
-	  $(LIBZIP_DIR)/zip_error_clear.c \
-	  $(LIBZIP_DIR)/zip_error_get.c \
-	  $(LIBZIP_DIR)/zip_error_get_sys_type.c \
-	  $(LIBZIP_DIR)/zip_error_strerror.c \
-	  $(LIBZIP_DIR)/zip_error_to_str.c \
-	  $(LIBZIP_DIR)/zip_extra_field.c \
-	  $(LIBZIP_DIR)/zip_extra_field_api.c \
-	  $(LIBZIP_DIR)/zip_fclose.c \
-	  $(LIBZIP_DIR)/zip_fdopen.c \
-	  $(LIBZIP_DIR)/zip_file_add.c \
-	  $(LIBZIP_DIR)/zip_file_error_clear.c \
-	  $(LIBZIP_DIR)/zip_file_error_get.c \
-	  $(LIBZIP_DIR)/zip_file_get_comment.c \
-	  $(LIBZIP_DIR)/zip_file_get_external_attributes.c \
-	  $(LIBZIP_DIR)/zip_file_get_offset.c \
-	  $(LIBZIP_DIR)/zip_file_rename.c \
-	  $(LIBZIP_DIR)/zip_file_replace.c \
-	  $(LIBZIP_DIR)/zip_file_set_comment.c \
-	  $(LIBZIP_DIR)/zip_file_set_encryption.c \
-	  $(LIBZIP_DIR)/zip_file_set_external_attributes.c \
-	  $(LIBZIP_DIR)/zip_file_set_mtime.c \
-	  $(LIBZIP_DIR)/zip_file_strerror.c \
-	  $(LIBZIP_DIR)/zip_fopen.c \
-	  $(LIBZIP_DIR)/zip_fopen_encrypted.c \
-	  $(LIBZIP_DIR)/zip_fopen_index.c \
-	  $(LIBZIP_DIR)/zip_fopen_index_encrypted.c \
-	  $(LIBZIP_DIR)/zip_fread.c \
-	  $(LIBZIP_DIR)/zip_fseek.c \
-	  $(LIBZIP_DIR)/zip_ftell.c \
-	  $(LIBZIP_DIR)/zip_get_archive_comment.c \
-	  $(LIBZIP_DIR)/zip_get_archive_flag.c \
-	  $(LIBZIP_DIR)/zip_get_encryption_implementation.c \
-	  $(LIBZIP_DIR)/zip_get_file_comment.c \
-	  $(LIBZIP_DIR)/zip_get_name.c \
-	  $(LIBZIP_DIR)/zip_get_num_entries.c \
-	  $(LIBZIP_DIR)/zip_get_num_files.c \
-	  $(LIBZIP_DIR)/zip_hash.c \
-	  $(LIBZIP_DIR)/zip_io_util.c \
-	  $(LIBZIP_DIR)/zip_libzip_version.c \
-	  $(LIBZIP_DIR)/zip_memdup.c \
-	  $(LIBZIP_DIR)/zip_name_locate.c \
-	  $(LIBZIP_DIR)/zip_new.c \
-	  $(LIBZIP_DIR)/zip_open.c \
-	  $(LIBZIP_DIR)/zip_pkware.c \
-	  $(LIBZIP_DIR)/zip_progress.c \
-	  $(LIBZIP_DIR)/zip_rename.c \
-	  $(LIBZIP_DIR)/zip_replace.c \
-	  $(LIBZIP_DIR)/zip_set_archive_comment.c \
-	  $(LIBZIP_DIR)/zip_set_archive_flag.c \
-	  $(LIBZIP_DIR)/zip_set_default_password.c \
-	  $(LIBZIP_DIR)/zip_set_file_comment.c \
-	  $(LIBZIP_DIR)/zip_set_file_compression.c \
-	  $(LIBZIP_DIR)/zip_set_name.c \
-	  $(LIBZIP_DIR)/zip_source_accept_empty.c \
-	  $(LIBZIP_DIR)/zip_source_begin_write.c \
-	  $(LIBZIP_DIR)/zip_source_begin_write_cloning.c \
-	  $(LIBZIP_DIR)/zip_source_buffer.c \
-	  $(LIBZIP_DIR)/zip_source_call.c \
-	  $(LIBZIP_DIR)/zip_source_close.c \
-	  $(LIBZIP_DIR)/zip_source_commit_write.c \
-	  $(LIBZIP_DIR)/zip_source_compress.c \
-	  $(LIBZIP_DIR)/zip_source_crc.c \
-	  $(LIBZIP_DIR)/zip_source_error.c \
-	  $(LIBZIP_DIR)/zip_source_file_common.c \
-	  $(LIBZIP_DIR)/zip_source_file_stdio.c \
-	  $(LIBZIP_DIR)/zip_source_free.c \
-	  $(LIBZIP_DIR)/zip_source_function.c \
-	  $(LIBZIP_DIR)/zip_source_get_file_attributes.c \
-	  $(LIBZIP_DIR)/zip_source_is_deleted.c \
-	  $(LIBZIP_DIR)/zip_source_layered.c \
-	  $(LIBZIP_DIR)/zip_source_open.c \
-	  $(LIBZIP_DIR)/zip_source_pkware_decode.c \
-	  $(LIBZIP_DIR)/zip_source_pkware_encode.c \
-	  $(LIBZIP_DIR)/zip_source_read.c \
-	  $(LIBZIP_DIR)/zip_source_remove.c \
-	  $(LIBZIP_DIR)/zip_source_rollback_write.c \
-	  $(LIBZIP_DIR)/zip_source_seek.c \
-	  $(LIBZIP_DIR)/zip_source_seek_write.c \
-	  $(LIBZIP_DIR)/zip_source_stat.c \
-	  $(LIBZIP_DIR)/zip_source_supports.c \
-	  $(LIBZIP_DIR)/zip_source_tell.c \
-	  $(LIBZIP_DIR)/zip_source_tell_write.c \
-	  $(LIBZIP_DIR)/zip_source_window.c \
-	  $(LIBZIP_DIR)/zip_source_write.c \
-	  $(LIBZIP_DIR)/zip_source_zip.c \
-	  $(LIBZIP_DIR)/zip_source_zip_new.c \
-	  $(LIBZIP_DIR)/zip_stat.c \
-	  $(LIBZIP_DIR)/zip_stat_index.c \
-	  $(LIBZIP_DIR)/zip_stat_init.c \
-	  $(LIBZIP_DIR)/zip_strerror.c \
-	  $(LIBZIP_DIR)/zip_string.c \
-	  $(LIBZIP_DIR)/zip_unchange.c \
-	  $(LIBZIP_DIR)/zip_unchange_all.c \
-	  $(LIBZIP_DIR)/zip_unchange_archive.c \
-	  $(LIBZIP_DIR)/zip_unchange_data.c \
-	  $(LIBZIP_DIR)/zip_utf-8.c \
-	  $(LIBZIP_DIR)/zip_err_str.c
-
-	  ifdef FOR_WINDOWS
-		  RZDCY_FILES += $(LIBZIP_DIR)/zip_source_file_win32.c \
-		  		$(LIBZIP_DIR)/zip_source_file_win32_named.c \
-			    $(LIBZIP_DIR)/zip_source_file_win32_utf16.c \
-			    $(LIBZIP_DIR)/zip_source_file_win32_utf8.c \
-				$(LIBZIP_DIR)/zip_source_file_win32_ansi.c \
-				$(LIBZIP_DIR)/zip_random_win32.c
-	  else
-		  RZDCY_FILES += $(LIBZIP_DIR)/zip_mkstempm.c \
-				$(LIBZIP_DIR)/zip_source_file_stdio_named.c \
-				$(LIBZIP_DIR)/zip_random_unix.c
-	  endif
-endif
-
-$(VERSION_HEADER):
-	echo "#define REICAST_VERSION \"`git describe --tags --always`\"" > $(VERSION_HEADER)
-	echo "#define GIT_HASH \"`git rev-parse --short HEAD`\"" >> $(VERSION_HEADER)
-	echo "#define BUILD_DATE \"`date '+%Y-%m-%d %H:%M:%S %Z'`\"" >> $(VERSION_HEADER)
-

core/debug/debug_agent.h

@@ -73,20 +73,47 @@ 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)
 			Sh4cntx.pc = pc;
-		dc_resume();
+		emu.start();
 	}
 
 	void step()
 	{
-		bool restoreBreakpoint = removeMatchpoint(0, Sh4cntx.pc, 2);
+		bool restoreBreakpoint = removeMatchpoint(Breakpoint::BP_TYPE_SOFTWARE_BREAK, Sh4cntx.pc, 2);
 		u32 savedPc = Sh4cntx.pc;
-		dc_step();
+		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)
@@ -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;
 	}
 
@@ -222,7 +249,7 @@ public:
 	{
 		config::DynarecEnabled = false;
 		exception = SIGINT;
-		dc_stop();
+		emu.stop();
 		return exception;
 	}
 
@@ -236,7 +263,7 @@ public:
 	void postDebugTrap()
 	{
 		// needed to join the emu thread since debugTrap() is called by it
-		dc_stop();
+		emu.stop();
 	}
 
 	u32 currentException()
@@ -246,14 +273,14 @@ public:
 
 	void restart()
 	{
-		dc_stop();
-		dc_reset(true);
-		dc_resume();
+		emu.unloadGame();
+		emu.loadGame(settings.content.path.c_str());
+		emu.start();
 	}
 
 	void detach()
 	{
-		dc_resume();
+		emu.start();
 	}
 
 	void kill()
@@ -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;
 };

core/debug/gdb_server.cpp

@@ -22,16 +22,19 @@
 #include "gdb_server.h"
 #include "debug_agent.h"
 #include "network/net_platform.h"
+#include "cfg/option.h"
+#include "oslib/oslib.h"
 #include <stdexcept>
 #include <thread>
 #include <chrono>
 #include <mutex>
+#include <cassert>
 
-#define SERVER_PORT 3263
+#define MAX_PACKET_LEN 4096
 
 namespace debugger {
 
-static void emuEventCallback(Event event);
+static void emuEventCallback(Event event, void *);
 
 class GdbServer
 {
@@ -40,7 +43,7 @@ public:
 		Error(const char *reason) : std::runtime_error(reason) {}
 	};
 
-	void init()
+	void init(int port)
 	{
 		if (VALID(serverSocket))
 			return;
@@ -55,7 +58,7 @@ public:
 		struct sockaddr_in serveraddr;
 		memset(&serveraddr, 0, sizeof(serveraddr));
 		serveraddr.sin_family = AF_INET;
-		serveraddr.sin_port = htons(SERVER_PORT);
+		serveraddr.sin_port = htons(port);
 
 		if (::bind(serverSocket, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
 		{
@@ -69,10 +72,16 @@ public:
 		}
 		EventManager::listen(Event::Resume, emuEventCallback);
 		EventManager::listen(Event::Terminate, emuEventCallback);
+
+		initialised = true;
 	}
 
 	void term()
 	{
+		if (!initialised)
+			return;
+		EventManager::unlisten(Event::Resume, emuEventCallback);
+		EventManager::unlisten(Event::Terminate, emuEventCallback);
 		stop();
 		if (VALID(clientSocket))
 		{
@@ -88,12 +97,21 @@ public:
 
 	void run()
 	{
+		if (!initialised || thread.joinable())
+			return;
 		DEBUG_LOG(COMMON, "GdbServer starting");
 		thread = std::thread(&GdbServer::serverThread, this);
+		if (config::GDBWaitForConnection)
+		{
+			DEBUG_LOG(COMMON, "Waiting for GDB connection...");
+			agentInterrupt();
+		}
 	}
 
 	void stop()
 	{
+		if (!initialised)
+			return;
 		if (thread.joinable())
 		{
 			DEBUG_LOG(COMMON, "GdbServer stopping");
@@ -104,7 +122,7 @@ public:
 	}
 
 	bool isRunning() const {
-		return thread.joinable();
+		return initialised && thread.joinable();
 	}
 
 	// called on the emu thread
@@ -123,6 +141,7 @@ private:
 
 	void serverThread()
 	{
+		ThreadName _("GdbServer");
 		while (!stopRequested)
 		{
 			fd_set fds;
@@ -181,18 +200,22 @@ private:
 		{
 			NOTICE_LOG(NETWORK, "gdb: client connection");
 			attached = true;
-			agent.interrupt();
+			agentInterrupt();
 		}
 	}
 
 	void readCommand()
 	{
-		if (postDebugTrapNeeded)
-		{
-			postDebugTrapNeeded = false;
-			agent.postDebugTrap();
-		}
-		try {
+        try {
+			if (postDebugTrapNeeded)
+			{
+				postDebugTrapNeeded = false;
+				try {
+					agent.postDebugTrap();
+				} catch (const FlycastException& e) {
+					throw Error(e.what());
+				}
+			}
 			std::string packet = recvPacket();
 			if (packet.empty())
 				return;
@@ -494,7 +517,12 @@ private:
 				const u32 *data = agent.getStack(len);
 				len /= 4;
 
+#if _MSC_VER // Non-const array size is a GCC extension
+				assert((len * 9 * 2 + 1) < MAX_PACKET_LEN);
+				char reply[MAX_PACKET_LEN];
+#else
 				char reply[len * 9 * 2 + 1];
+#endif
 				char *r = reply;
 				for (u32 i = 0; i < len; i++)
 				{
@@ -513,9 +541,13 @@ private:
 				sendPacket("");
 		}
 		else if (pkt.rfind("qSupported", 0) == 0)
+		{
 			// Tell the remote stub about features supported by GDB,
 			// and query the stub for features it supports
-			sendPacket("PacketSize=10000");
+			char qsupported[128];
+			snprintf(qsupported, 128, "PacketSize=%i;vContSupported+", MAX_PACKET_LEN);
+			sendPacket(qsupported);
+		}
 		else if (pkt.rfind("qSymbol:", 0) == 0)
 			// Notify the target that GDB is prepared to serve symbol lookup requests
 			sendPacket("OK");
@@ -568,11 +600,41 @@ private:
 		if (pkt.rfind("vAttach;", 0) == 0)
 			sendPacket("S05");
 		else if (pkt.rfind("vCont?", 0) == 0)
-			// not supported
-			sendPacket("vCont;s;c");
+			// supported vCont actions - (c)ontinue, (C)ontinue with signal, (s)tep, (S)tep with signal, (r)ange-step
+			sendPacket("vCont;c;C;s;S;t;r");
 		else if (pkt.rfind("vCont", 0) == 0)
-			// not supported
-			WARN_LOG(COMMON, "vCont not supported %s", pkt.c_str());
+		{
+			std::string vContCmd = pkt.substr(strlen("vCont;"));
+			switch (vContCmd[0])
+			{
+			case 'c':
+			case 'C':
+				sendContinue(vContCmd);
+				break;
+			case 's':
+				step(EXCEPT_NONE);
+				break;
+			case 'S':
+				step();
+			case 'r':
+			{
+				u32 from, to;
+				if (sscanf(vContCmd.c_str(), "r%x,%x", &from, &to) == 2)
+				{
+					stepRange(from, to);
+				}
+				else
+				{
+					WARN_LOG(COMMON, "Unsupported vCont:r format %s", pkt.c_str());
+					sendContinue("c");
+				}
+
+				break;
+			}
+			default:
+				WARN_LOG(COMMON, "vCont action not supported %s", pkt.c_str());
+			}
+		}
 		else if (pkt.rfind("vFile:", 0) == 0)
 			// not supported
 			sendPacket("");
@@ -597,11 +659,11 @@ private:
 			sendPacket("OK");
 			agent.kill();
 		}
-		else if (pkt.rfind("vMustReplyEmpty", 0) == 0)
-			// Reply empty packet
-			sendPacket("");
 		else
+		{
 			WARN_LOG(COMMON, "unknown v packet: %s", pkt.c_str());
+			sendPacket("");
+		}
 	}
 
 	void restart()
@@ -611,8 +673,23 @@ private:
 
 	void step(u32 what = 0)
 	{
-		agent.step();
-		sendPacket("S05");
+		try {
+			agent.step();
+			sendPacket("S05");
+		} catch (const FlycastException& e) {
+			throw Error(e.what());
+		}
+	}
+
+	void stepRange(u32 from, u32 to)
+	{
+		try {
+			sendPacket("OK");
+			agent.stepRange(from, to);
+			sendPacket("S05");
+		} catch (const FlycastException& e) {
+			throw Error(e.what());
+		}
 	}
 
 	void insertMatchpoint(const std::string& pkt)
@@ -625,22 +702,23 @@ private:
 			sendPacket("E01");
 		}
 		switch (type) {
-		    case 0:		// soft bp
-		    	if (agent.insertMatchpoint(0, addr, len))
+			case DebugAgent::Breakpoint::BP_TYPE_SOFTWARE_BREAK:		// soft bp
+		    	if (agent.insertMatchpoint(DebugAgent::Breakpoint::BP_TYPE_SOFTWARE_BREAK,
+		    			addr, len))
 		    		sendPacket("OK");
 		    	else
 		    		sendPacket("E01");
 		    	break;
-		    case 1:		// hardware bp
+		    case DebugAgent::Breakpoint::BP_TYPE_HARDWARE_BREAK:		// hardware bp
 		    	sendPacket("");
 		    	break;
-		    case 2:		// write watchpoint
+		    case DebugAgent::Breakpoint::BP_TYPE_WRITE_WATCHPOINT:	// write watchpoint
 		    	sendPacket("");
 		    	break;
-		    case 3:		// read watchpoint
+		    case DebugAgent::Breakpoint::BP_TYPE_READ_WATCHPOINT:		// read watchpoint
 		    	sendPacket("");
 		    	break;
-		    case 4:		// access watchpoint
+		    case DebugAgent::Breakpoint::BP_TYPE_ACCESS_WATCHPOINT:	// access watchpoint
 		    	sendPacket("");
 		    	break;
 		    default:
@@ -660,7 +738,8 @@ private:
 		}
 		switch (type) {
 		    case 0:		// soft bp
-		    	if (agent.removeMatchpoint(0, addr, len))
+		    	if (agent.removeMatchpoint(DebugAgent::Breakpoint::BP_TYPE_SOFTWARE_BREAK,
+		    			addr, len))
 		    		sendPacket("OK");
 		    	else
 		    		sendPacket("E01");
@@ -685,7 +764,7 @@ private:
 
 	void interrupt()
 	{
-		u32 signal = agent.interrupt();
+		u32 signal = agentInterrupt();
 		char s[10];
 		sprintf(s, "S%02x", signal);
 		sendPacket(s);
@@ -825,6 +904,16 @@ private:
 			throw Error("I/O error");
 	}
 
+	u32 agentInterrupt()
+	{
+		try {
+			return agent.interrupt();
+		} catch (const FlycastException& e) {
+			throw Error(e.what());
+		}
+	}
+
+	bool initialised = false;
 	bool stopRequested = false;
 	bool attached = false;
 	bool postDebugTrapNeeded = false;
@@ -838,9 +927,9 @@ public:
 
 static GdbServer gdbServer;
 
-void init()
+void init(int port)
 {
-	gdbServer.init();
+	gdbServer.init(port);
 }
 
 void term()
@@ -863,13 +952,17 @@ void subroutineReturn()
 	gdbServer.agent.subroutineReturn();
 }
 
-static void emuEventCallback(Event event)
+static void emuEventCallback(Event event, void *)
 {
 	switch (event)
 	{
 	case Event::Resume:
-		if (!gdbServer.isRunning())
-			gdbServer.run();
+		try {
+			if (!gdbServer.isRunning())
+				gdbServer.run();
+		} catch (const GdbServer::Error& e) {
+			ERROR_LOG(COMMON, "%s", e.what());
+		}
 		break;
 	case Event::Terminate:
 		gdbServer.stop();

core/debug/gdb_server.h

@@ -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) {}

core/deps/chdpsr/cdipsr.cpp

@@ -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;
 }
 

core/deps/chdpsr/cdipsr.h

@@ -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

core/deps/crypto/md5.cpp

@@ -1,239 +0,0 @@
-/*
- * This code implements the MD5 message-digest algorithm.
- * The algorithm is due to Ron Rivest.  This code was
- * written by Colin Plumb in 1993, no copyright is claimed.
- * This code is in the public domain; do with it what you wish.
- *
- * Equivalent code is available from RSA Data Security, Inc.
- * This code has been tested against that, and is equivalent,
- * except that you don't need to include two pages of legalese
- * with every copy.
- *
- * To compute the message digest of a chunk of bytes, declare an
- * MD5Context structure, pass it to MD5Init, call MD5Update as
- * needed on buffers full of bytes, and then call MD5Final, which
- * will fill a supplied 16-byte array with the digest.
- *
- * Changed so as no longer to depend on Colin Plumb's `usual.h' header
- * definitions; now uses stuff from dpkg's config.h.
- *  - Ian Jackson <[email protected]>.
- * Still in the public domain.
- */
-
-#include <string.h>		/* for memcpy() */
-
-#include "md5.h"
-
-#ifndef LSB_FIRST
-void
-byteSwap(UWORD32 *buf, unsigned words)
-{
-	md5byte *p = (md5byte *)buf;
-
-	do {
-		*buf++ = (UWORD32)((unsigned)p[3] << 8 | p[2]) << 16 |
-			((unsigned)p[1] << 8 | p[0]);
-		p += 4;
-	} while (--words);
-}
-#else
-#define byteSwap(buf,words)
-#endif
-
-/*
- * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
- * initialization constants.
- */
-void
-MD5Init(struct MD5Context *ctx)
-{
-	ctx->buf[0] = 0x67452301;
-	ctx->buf[1] = 0xefcdab89;
-	ctx->buf[2] = 0x98badcfe;
-	ctx->buf[3] = 0x10325476;
-
-	ctx->bytes[0] = 0;
-	ctx->bytes[1] = 0;
-}
-
-/*
- * Update context to reflect the concatenation of another buffer full
- * of bytes.
- */
-void
-MD5Update(struct MD5Context *ctx, md5byte const *buf, unsigned len)
-{
-	UWORD32 t;
-
-	/* Update byte count */
-
-	t = ctx->bytes[0];
-	if ((ctx->bytes[0] = t + len) < t)
-		ctx->bytes[1]++;	/* Carry from low to high */
-
-	t = 64 - (t & 0x3f);	/* Space available in ctx->in (at least 1) */
-	if (t > len) {
-		memcpy((md5byte *)ctx->in + 64 - t, buf, len);
-		return;
-	}
-	/* First chunk is an odd size */
-	memcpy((md5byte *)ctx->in + 64 - t, buf, t);
-	byteSwap(ctx->in, 16);
-	MD5Transform(ctx->buf, ctx->in);
-	buf += t;
-	len -= t;
-
-	/* Process data in 64-byte chunks */
-	while (len >= 64) {
-		memcpy(ctx->in, buf, 64);
-		byteSwap(ctx->in, 16);
-		MD5Transform(ctx->buf, ctx->in);
-		buf += 64;
-		len -= 64;
-	}
-
-	/* Handle any remaining bytes of data. */
-	memcpy(ctx->in, buf, len);
-}
-
-/*
- * Final wrapup - pad to 64-byte boundary with the bit pattern
- * 1 0* (64-bit count of bits processed, MSB-first)
- */
-void
-MD5Final(md5byte digest[16], struct MD5Context *ctx)
-{
-	int count = ctx->bytes[0] & 0x3f;	/* Number of bytes in ctx->in */
-	md5byte *p = (md5byte *)ctx->in + count;
-
-	/* Set the first char of padding to 0x80.  There is always room. */
-	*p++ = 0x80;
-
-	/* Bytes of padding needed to make 56 bytes (-8..55) */
-	count = 56 - 1 - count;
-
-	if (count < 0) {	/* Padding forces an extra block */
-		memset(p, 0, count + 8);
-		byteSwap(ctx->in, 16);
-		MD5Transform(ctx->buf, ctx->in);
-		p = (md5byte *)ctx->in;
-		count = 56;
-	}
-	memset(p, 0, count);
-	byteSwap(ctx->in, 14);
-
-	/* Append length in bits and transform */
-	ctx->in[14] = ctx->bytes[0] << 3;
-	ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;
-	MD5Transform(ctx->buf, ctx->in);
-
-	byteSwap(ctx->buf, 4);
-	memcpy(digest, ctx->buf, 16);
-	memset(ctx, 0, sizeof(*ctx));	/* In case it's sensitive */
-}
-
-#ifndef ASM_MD5
-
-/* The four core functions - F1 is optimized somewhat */
-
-/* #define F1(x, y, z) (x & y | ~x & z) */
-#define F1(x, y, z) (z ^ (x & (y ^ z)))
-#define F2(x, y, z) F1(z, x, y)
-#define F3(x, y, z) (x ^ y ^ z)
-#define F4(x, y, z) (y ^ (x | ~z))
-
-/* This is the central step in the MD5 algorithm. */
-#define MD5STEP(f,w,x,y,z,in,s) \
-	 (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
-
-/*
- * The core of the MD5 algorithm, this alters an existing MD5 hash to
- * reflect the addition of 16 longwords of new data.  MD5Update blocks
- * the data and converts bytes into longwords for this routine.
- */
-void
-MD5Transform(UWORD32 buf[4], UWORD32 const in[16])
-{
-	register UWORD32 a, b, c, d;
-
-	a = buf[0];
-	b = buf[1];
-	c = buf[2];
-	d = buf[3];
-
-	MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
-	MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
-	MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
-	MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
-	MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
-	MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
-	MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
-	MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
-	MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
-	MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
-	MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
-	MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
-	MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
-	MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
-	MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
-	MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
-
-	MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
-	MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
-	MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
-	MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
-	MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
-	MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
-	MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
-	MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
-	MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
-	MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
-	MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
-	MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
-	MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
-	MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
-	MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
-	MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
-
-	MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
-	MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
-	MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
-	MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
-	MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
-	MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
-	MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
-	MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
-	MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
-	MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
-	MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
-	MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
-	MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
-	MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
-	MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
-	MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
-
-	MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
-	MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
-	MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
-	MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
-	MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
-	MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
-	MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
-	MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
-	MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
-	MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
-	MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
-	MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
-	MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
-	MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
-	MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
-	MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
-
-	buf[0] += a;
-	buf[1] += b;
-	buf[2] += c;
-	buf[3] += d;
-}
-
-#endif
-

core/deps/crypto/md5.h

@@ -1,42 +0,0 @@
-/*
- * This is the header file for the MD5 message-digest algorithm.
- * The algorithm is due to Ron Rivest.  This code was
- * written by Colin Plumb in 1993, no copyright is claimed.
- * This code is in the public domain; do with it what you wish.
- *
- * Equivalent code is available from RSA Data Security, Inc.
- * This code has been tested against that, and is equivalent,
- * except that you don't need to include two pages of legalese
- * with every copy.
- *
- * To compute the message digest of a chunk of bytes, declare an
- * MD5Context structure, pass it to MD5Init, call MD5Update as
- * needed on buffers full of bytes, and then call MD5Final, which
- * will fill a supplied 16-byte array with the digest.
- *
- * Changed so as no longer to depend on Colin Plumb's `usual.h'
- * header definitions; now uses stuff from dpkg's config.h
- *  - Ian Jackson <[email protected]>.
- * Still in the public domain.
- */
-
-#ifndef MD5_H
-#define MD5_H
-
-typedef unsigned int UWORD32;
-
-#define md5byte unsigned char
-
-struct MD5Context {
-	UWORD32 buf[4];
-	UWORD32 bytes[2];
-	UWORD32 in[16];
-};
-
-void MD5Init(struct MD5Context *context);
-void MD5Update(struct MD5Context *context, md5byte const *buf, unsigned len);
-void MD5Final(unsigned char digest[16], struct MD5Context *context);
-void MD5Transform(UWORD32 buf[4], UWORD32 const in[16]);
-
-#endif /* !MD5_H */
-

core/deps/crypto/sha1.cpp

@@ -1,387 +0,0 @@
-/* sha1.h
- *
- * The sha1 hash function.
- */
-
-/* nettle, low-level cryptographics library
- *
- * Copyright 2001 Peter Gutmann, Andrew Kuchling, Niels Moeller
- *
- * The nettle library is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at your
- * option) any later version.
- *
- * The nettle library 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 Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the nettle library; see the file COPYING.LIB.  If not, write to
- * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- * MA 02111-1307, USA.
- */
-
-#include "sha1.h"
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-
-static unsigned int READ_UINT32(const UINT8* data)
-{
-	return ((UINT32)data[0] << 24) |
-		((UINT32)data[1] << 16) |
-		((UINT32)data[2] << 8) |
-		((UINT32)data[3]);
-}
-
-static void WRITE_UINT32(unsigned char* data, UINT32 val)
-{
-	data[0] = (val >> 24) & 0xFF;
-	data[1] = (val >> 16) & 0xFF;
-	data[2] = (val >> 8) & 0xFF;
-	data[3] = (val >> 0) & 0xFF;
-}
-
-
-/* A block, treated as a sequence of 32-bit words. */
-#define SHA1_DATA_LENGTH 16
-
-/* The SHA f()-functions.  The f1 and f3 functions can be optimized to
-   save one boolean operation each - thanks to Rich Schroeppel,
-   [email protected] for discovering this */
-
-/* #define f1(x,y,z) ( ( x & y ) | ( ~x & z ) )            Rounds  0-19 */
-#define f1(x,y,z)   ( z ^ ( x & ( y ^ z ) ) )           /* Rounds  0-19 */
-#define f2(x,y,z)   ( x ^ y ^ z )                       /* Rounds 20-39 */
-/* #define f3(x,y,z) ( ( x & y ) | ( x & z ) | ( y & z ) ) Rounds 40-59 */
-#define f3(x,y,z)   ( ( x & y ) | ( z & ( x | y ) ) )   /* Rounds 40-59 */
-#define f4(x,y,z)   ( x ^ y ^ z )                       /* Rounds 60-79 */
-
-/* The SHA Mysterious Constants */
-
-#define K1  0x5A827999L                                 /* Rounds  0-19 */
-#define K2  0x6ED9EBA1L                                 /* Rounds 20-39 */
-#define K3  0x8F1BBCDCL                                 /* Rounds 40-59 */
-#define K4  0xCA62C1D6L                                 /* Rounds 60-79 */
-
-/* SHA initial values */
-
-#define h0init  0x67452301L
-#define h1init  0xEFCDAB89L
-#define h2init  0x98BADCFEL
-#define h3init  0x10325476L
-#define h4init  0xC3D2E1F0L
-
-/* 32-bit rotate left - kludged with shifts */
-#ifdef _MSC_VER
-#define ROTL(n,X)  _lrotl(X, n)
-#else
-#define ROTL(n,X)  ( ( (X) << (n) ) | ( (X) >> ( 32 - (n) ) ) )
-#endif
-
-/* The initial expanding function.  The hash function is defined over an
-   80-word expanded input array W, where the first 16 are copies of the input
-   data, and the remaining 64 are defined by
-
-        W[ i ] = W[ i - 16 ] ^ W[ i - 14 ] ^ W[ i - 8 ] ^ W[ i - 3 ]
-
-   This implementation generates these values on the fly in a circular
-   buffer - thanks to Colin Plumb, [email protected] for this
-   optimization.
-
-   The updated SHA changes the expanding function by adding a rotate of 1
-   bit.  Thanks to Jim Gillogly, [email protected], and an anonymous contributor
-   for this information */
-
-#define expand(W,i) ( W[ i & 15 ] = \
-		      ROTL( 1, ( W[ i & 15 ] ^ W[ (i - 14) & 15 ] ^ \
-				 W[ (i - 8) & 15 ] ^ W[ (i - 3) & 15 ] ) ) )
-
-
-/* The prototype SHA sub-round.  The fundamental sub-round is:
-
-        a' = e + ROTL( 5, a ) + f( b, c, d ) + k + data;
-        b' = a;
-        c' = ROTL( 30, b );
-        d' = c;
-        e' = d;
-
-   but this is implemented by unrolling the loop 5 times and renaming the
-   variables ( e, a, b, c, d ) = ( a', b', c', d', e' ) each iteration.
-   This code is then replicated 20 times for each of the 4 functions, using
-   the next 20 values from the W[] array each time */
-
-#define subRound(a, b, c, d, e, f, k, data) \
-    ( e += ROTL( 5, a ) + f( b, c, d ) + k + data, b = ROTL( 30, b ) )
-
-/* Initialize the SHA values */
-
-void
-sha1_init(struct sha1_ctx *ctx)
-{
-  /* Set the h-vars to their initial values */
-  ctx->digest[ 0 ] = h0init;
-  ctx->digest[ 1 ] = h1init;
-  ctx->digest[ 2 ] = h2init;
-  ctx->digest[ 3 ] = h3init;
-  ctx->digest[ 4 ] = h4init;
-
-  /* Initialize bit count */
-  ctx->count_low = ctx->count_high = 0;
-
-  /* Initialize buffer */
-  ctx->index = 0;
-}
-
-/* Perform the SHA transformation.  Note that this code, like MD5, seems to
-   break some optimizing compilers due to the complexity of the expressions
-   and the size of the basic block.  It may be necessary to split it into
-   sections, e.g. based on the four subrounds
-
-   Note that this function destroys the data area */
-
-static void
-sha1_transform(UINT32 *state, UINT32 *data)
-{
-  UINT32 A, B, C, D, E;     /* Local vars */
-
-  /* Set up first buffer and local data buffer */
-  A = state[0];
-  B = state[1];
-  C = state[2];
-  D = state[3];
-  E = state[4];
-
-  /* Heavy mangling, in 4 sub-rounds of 20 interations each. */
-  subRound( A, B, C, D, E, f1, K1, data[ 0] );
-  subRound( E, A, B, C, D, f1, K1, data[ 1] );
-  subRound( D, E, A, B, C, f1, K1, data[ 2] );
-  subRound( C, D, E, A, B, f1, K1, data[ 3] );
-  subRound( B, C, D, E, A, f1, K1, data[ 4] );
-  subRound( A, B, C, D, E, f1, K1, data[ 5] );
-  subRound( E, A, B, C, D, f1, K1, data[ 6] );
-  subRound( D, E, A, B, C, f1, K1, data[ 7] );
-  subRound( C, D, E, A, B, f1, K1, data[ 8] );
-  subRound( B, C, D, E, A, f1, K1, data[ 9] );
-  subRound( A, B, C, D, E, f1, K1, data[10] );
-  subRound( E, A, B, C, D, f1, K1, data[11] );
-  subRound( D, E, A, B, C, f1, K1, data[12] );
-  subRound( C, D, E, A, B, f1, K1, data[13] );
-  subRound( B, C, D, E, A, f1, K1, data[14] );
-  subRound( A, B, C, D, E, f1, K1, data[15] );
-  subRound( E, A, B, C, D, f1, K1, expand( data, 16 ) );
-  subRound( D, E, A, B, C, f1, K1, expand( data, 17 ) );
-  subRound( C, D, E, A, B, f1, K1, expand( data, 18 ) );
-  subRound( B, C, D, E, A, f1, K1, expand( data, 19 ) );
-
-  subRound( A, B, C, D, E, f2, K2, expand( data, 20 ) );
-  subRound( E, A, B, C, D, f2, K2, expand( data, 21 ) );
-  subRound( D, E, A, B, C, f2, K2, expand( data, 22 ) );
-  subRound( C, D, E, A, B, f2, K2, expand( data, 23 ) );
-  subRound( B, C, D, E, A, f2, K2, expand( data, 24 ) );
-  subRound( A, B, C, D, E, f2, K2, expand( data, 25 ) );
-  subRound( E, A, B, C, D, f2, K2, expand( data, 26 ) );
-  subRound( D, E, A, B, C, f2, K2, expand( data, 27 ) );
-  subRound( C, D, E, A, B, f2, K2, expand( data, 28 ) );
-  subRound( B, C, D, E, A, f2, K2, expand( data, 29 ) );
-  subRound( A, B, C, D, E, f2, K2, expand( data, 30 ) );
-  subRound( E, A, B, C, D, f2, K2, expand( data, 31 ) );
-  subRound( D, E, A, B, C, f2, K2, expand( data, 32 ) );
-  subRound( C, D, E, A, B, f2, K2, expand( data, 33 ) );
-  subRound( B, C, D, E, A, f2, K2, expand( data, 34 ) );
-  subRound( A, B, C, D, E, f2, K2, expand( data, 35 ) );
-  subRound( E, A, B, C, D, f2, K2, expand( data, 36 ) );
-  subRound( D, E, A, B, C, f2, K2, expand( data, 37 ) );
-  subRound( C, D, E, A, B, f2, K2, expand( data, 38 ) );
-  subRound( B, C, D, E, A, f2, K2, expand( data, 39 ) );
-
-  subRound( A, B, C, D, E, f3, K3, expand( data, 40 ) );
-  subRound( E, A, B, C, D, f3, K3, expand( data, 41 ) );
-  subRound( D, E, A, B, C, f3, K3, expand( data, 42 ) );
-  subRound( C, D, E, A, B, f3, K3, expand( data, 43 ) );
-  subRound( B, C, D, E, A, f3, K3, expand( data, 44 ) );
-  subRound( A, B, C, D, E, f3, K3, expand( data, 45 ) );
-  subRound( E, A, B, C, D, f3, K3, expand( data, 46 ) );
-  subRound( D, E, A, B, C, f3, K3, expand( data, 47 ) );
-  subRound( C, D, E, A, B, f3, K3, expand( data, 48 ) );
-  subRound( B, C, D, E, A, f3, K3, expand( data, 49 ) );
-  subRound( A, B, C, D, E, f3, K3, expand( data, 50 ) );
-  subRound( E, A, B, C, D, f3, K3, expand( data, 51 ) );
-  subRound( D, E, A, B, C, f3, K3, expand( data, 52 ) );
-  subRound( C, D, E, A, B, f3, K3, expand( data, 53 ) );
-  subRound( B, C, D, E, A, f3, K3, expand( data, 54 ) );
-  subRound( A, B, C, D, E, f3, K3, expand( data, 55 ) );
-  subRound( E, A, B, C, D, f3, K3, expand( data, 56 ) );
-  subRound( D, E, A, B, C, f3, K3, expand( data, 57 ) );
-  subRound( C, D, E, A, B, f3, K3, expand( data, 58 ) );
-  subRound( B, C, D, E, A, f3, K3, expand( data, 59 ) );
-
-  subRound( A, B, C, D, E, f4, K4, expand( data, 60 ) );
-  subRound( E, A, B, C, D, f4, K4, expand( data, 61 ) );
-  subRound( D, E, A, B, C, f4, K4, expand( data, 62 ) );
-  subRound( C, D, E, A, B, f4, K4, expand( data, 63 ) );
-  subRound( B, C, D, E, A, f4, K4, expand( data, 64 ) );
-  subRound( A, B, C, D, E, f4, K4, expand( data, 65 ) );
-  subRound( E, A, B, C, D, f4, K4, expand( data, 66 ) );
-  subRound( D, E, A, B, C, f4, K4, expand( data, 67 ) );
-  subRound( C, D, E, A, B, f4, K4, expand( data, 68 ) );
-  subRound( B, C, D, E, A, f4, K4, expand( data, 69 ) );
-  subRound( A, B, C, D, E, f4, K4, expand( data, 70 ) );
-  subRound( E, A, B, C, D, f4, K4, expand( data, 71 ) );
-  subRound( D, E, A, B, C, f4, K4, expand( data, 72 ) );
-  subRound( C, D, E, A, B, f4, K4, expand( data, 73 ) );
-  subRound( B, C, D, E, A, f4, K4, expand( data, 74 ) );
-  subRound( A, B, C, D, E, f4, K4, expand( data, 75 ) );
-  subRound( E, A, B, C, D, f4, K4, expand( data, 76 ) );
-  subRound( D, E, A, B, C, f4, K4, expand( data, 77 ) );
-  subRound( C, D, E, A, B, f4, K4, expand( data, 78 ) );
-  subRound( B, C, D, E, A, f4, K4, expand( data, 79 ) );
-
-  /* Build message digest */
-  state[0] += A;
-  state[1] += B;
-  state[2] += C;
-  state[3] += D;
-  state[4] += E;
-}
-
-static void
-sha1_block(struct sha1_ctx *ctx, const UINT8 *block)
-{
-  UINT32 data[SHA1_DATA_LENGTH];
-  int i;
-
-  /* Update block count */
-  if (!++ctx->count_low)
-    ++ctx->count_high;
-
-  /* Endian independent conversion */
-  for (i = 0; i<SHA1_DATA_LENGTH; i++, block += 4)
-    data[i] = READ_UINT32(block);
-
-  sha1_transform(ctx->digest, data);
-}
-
-void
-sha1_update(struct sha1_ctx *ctx,
-	    unsigned length, const UINT8 *buffer)
-{
-  if (ctx->index)
-    { /* Try to fill partial block */
-      unsigned left = SHA1_DATA_SIZE - ctx->index;
-      if (length < left)
-	{
-	  memcpy(ctx->block + ctx->index, buffer, length);
-	  ctx->index += length;
-	  return; /* Finished */
-	}
-      else
-	{
-	  memcpy(ctx->block + ctx->index, buffer, left);
-	  sha1_block(ctx, ctx->block);
-	  buffer += left;
-	  length -= left;
-	}
-    }
-  while (length >= SHA1_DATA_SIZE)
-    {
-      sha1_block(ctx, buffer);
-      buffer += SHA1_DATA_SIZE;
-      length -= SHA1_DATA_SIZE;
-    }
-  ctx->index = length;
-  if (length)
-    /* Buffer leftovers */
-    memcpy(ctx->block, buffer, length);
-}
-
-/* Final wrapup - pad to SHA1_DATA_SIZE-byte boundary with the bit pattern
-   1 0* (64-bit count of bits processed, MSB-first) */
-
-void
-sha1_final(struct sha1_ctx *ctx)
-{
-  UINT32 data[SHA1_DATA_LENGTH];
-  int i;
-  int words;
-
-  i = ctx->index;
-
-  /* Set the first char of padding to 0x80.  This is safe since there is
-     always at least one byte free */
-
-  assert(i < SHA1_DATA_SIZE);
-  ctx->block[i++] = 0x80;
-
-  /* Fill rest of word */
-  for( ; i & 3; i++)
-    ctx->block[i] = 0;
-
-  /* i is now a multiple of the word size 4 */
-  words = i >> 2;
-  for (i = 0; i < words; i++)
-    data[i] = READ_UINT32(ctx->block + 4*i);
-
-  if (words > (SHA1_DATA_LENGTH-2))
-    { /* No room for length in this block. Process it and
-       * pad with another one */
-      for (i = words ; i < SHA1_DATA_LENGTH; i++)
-	data[i] = 0;
-      sha1_transform(ctx->digest, data);
-      for (i = 0; i < (SHA1_DATA_LENGTH-2); i++)
-	data[i] = 0;
-    }
-  else
-    for (i = words ; i < SHA1_DATA_LENGTH - 2; i++)
-      data[i] = 0;
-
-  /* There are 512 = 2^9 bits in one block */
-  data[SHA1_DATA_LENGTH-2] = (ctx->count_high << 9) | (ctx->count_low >> 23);
-  data[SHA1_DATA_LENGTH-1] = (ctx->count_low << 9) | (ctx->index << 3);
-  sha1_transform(ctx->digest, data);
-}
-
-void
-sha1_digest(const struct sha1_ctx *ctx,
-	    unsigned length,
-	    UINT8 *digest)
-{
-  unsigned i;
-  unsigned words;
-  unsigned leftover;
-
-  assert(length <= SHA1_DIGEST_SIZE);
-
-  words = length / 4;
-  leftover = length % 4;
-
-  for (i = 0; i < words; i++, digest += 4)
-    WRITE_UINT32(digest, ctx->digest[i]);
-
-  if (leftover)
-    {
-      UINT32 word;
-      unsigned j = leftover;
-
-      assert(i < _SHA1_DIGEST_LENGTH);
-
-      word = ctx->digest[i];
-
-      switch (leftover)
-	{
-	default:
-		/* this is just here to keep the compiler happy; it can never happen */
-	case 3:
-	  digest[--j] = (word >> 8) & 0xff;
-	  /* Fall through */
-	case 2:
-	  digest[--j] = (word >> 16) & 0xff;
-	  /* Fall through */
-	case 1:
-	  digest[--j] = (word >> 24) & 0xff;
-	}
-    }
-}

core/deps/crypto/sha1.h

@@ -1,63 +0,0 @@
-/* sha1.h
- *
- * The sha1 hash function.
- */
-
-/* nettle, low-level cryptographics library
- *
- * Copyright 2001 Niels Moeller
- *
- * The nettle library is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at your
- * option) any later version.
- *
- * The nettle library 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 Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the nettle library; see the file COPYING.LIB.  If not, write to
- * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- * MA 02111-1307, USA.
- */
-
-#ifndef NETTLE_SHA1_H_INCLUDED
-#define NETTLE_SHA1_H_INCLUDED
-
-#include "../chdr/coretypes.h"
-
-
-
-#define SHA1_DIGEST_SIZE 20
-#define SHA1_DATA_SIZE 64
-
-/* Digest is kept internally as 4 32-bit words. */
-#define _SHA1_DIGEST_LENGTH 5
-
-struct sha1_ctx
-{
-  UINT32 digest[_SHA1_DIGEST_LENGTH];   /* Message digest */
-  UINT32 count_low, count_high;         /* 64-bit block count */
-  UINT8 block[SHA1_DATA_SIZE];          /* SHA1 data buffer */
-  unsigned int index;                     /* index into buffer */
-};
-
-void
-sha1_init(struct sha1_ctx *ctx);
-
-void
-sha1_update(struct sha1_ctx *ctx,
-	    unsigned length,
-	    const UINT8 *data);
-
-void
-sha1_final(struct sha1_ctx *ctx);
-
-void
-sha1_digest(const struct sha1_ctx *ctx,
-	    unsigned length,
-	    UINT8 *digest);
-
-#endif /* NETTLE_SHA1_H_INCLUDED */

core/deps/crypto/sha256.cpp

@@ -1,161 +0,0 @@
-/*********************************************************************
-* Filename:   sha256.c
-* Author:     Brad Conte (brad AT bradconte.com)
-* Copyright:
-* Disclaimer: This code is presented "as is" without any guarantees.
-* Details:    Implementation of the SHA-256 hashing algorithm.
-              SHA-256 is one of the three algorithms in the SHA2
-              specification. The others, SHA-384 and SHA-512, are not
-              offered in this implementation.
-              Algorithm specification can be found here:
-               * http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf
-              This implementation uses little endian byte order.
-*********************************************************************/
-
-/*************************** HEADER FILES ***************************/
-#include <stdlib.h>
-#include <string.h>
-#include "sha256.h"
-
-#define WORD uint32_t
-#define BYTE uint8_t
-
-/****************************** MACROS ******************************/
-#define ROTLEFT(a,b) (((a) << (b)) | ((a) >> (32-(b))))
-#define ROTRIGHT(a,b) (((a) >> (b)) | ((a) << (32-(b))))
-
-#define CH(x,y,z) (((x) & (y)) ^ (~(x) & (z)))
-#define MAJ(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
-#define EP0(x) (ROTRIGHT(x,2) ^ ROTRIGHT(x,13) ^ ROTRIGHT(x,22))
-#define EP1(x) (ROTRIGHT(x,6) ^ ROTRIGHT(x,11) ^ ROTRIGHT(x,25))
-#define SIG0(x) (ROTRIGHT(x,7) ^ ROTRIGHT(x,18) ^ ((x) >> 3))
-#define SIG1(x) (ROTRIGHT(x,17) ^ ROTRIGHT(x,19) ^ ((x) >> 10))
-
-/**************************** VARIABLES *****************************/
-static const WORD k[64] = {
-	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
-	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
-	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
-	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
-	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
-	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
-	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
-	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
-};
-
-/*********************** FUNCTION DEFINITIONS ***********************/
-void sha256_transform(SHA256_CTX *ctx, const BYTE data[])
-{
-	WORD a, b, c, d, e, f, g, h, i, j, t1, t2, m[64];
-
-	for (i = 0, j = 0; i < 16; ++i, j += 4)
-		m[i] = (data[j] << 24) | (data[j + 1] << 16) | (data[j + 2] << 8) | (data[j + 3]);
-	for ( ; i < 64; ++i)
-		m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
-
-	a = ctx->state[0];
-	b = ctx->state[1];
-	c = ctx->state[2];
-	d = ctx->state[3];
-	e = ctx->state[4];
-	f = ctx->state[5];
-	g = ctx->state[6];
-	h = ctx->state[7];
-
-	for (i = 0; i < 64; ++i) {
-		t1 = h + EP1(e) + CH(e,f,g) + k[i] + m[i];
-		t2 = EP0(a) + MAJ(a,b,c);
-		h = g;
-		g = f;
-		f = e;
-		e = d + t1;
-		d = c;
-		c = b;
-		b = a;
-		a = t1 + t2;
-	}
-
-	ctx->state[0] += a;
-	ctx->state[1] += b;
-	ctx->state[2] += c;
-	ctx->state[3] += d;
-	ctx->state[4] += e;
-	ctx->state[5] += f;
-	ctx->state[6] += g;
-	ctx->state[7] += h;
-}
-
-void sha256_init(SHA256_CTX *ctx)
-{
-	ctx->datalen = 0;
-	ctx->bitlen = 0;
-	ctx->state[0] = 0x6a09e667;
-	ctx->state[1] = 0xbb67ae85;
-	ctx->state[2] = 0x3c6ef372;
-	ctx->state[3] = 0xa54ff53a;
-	ctx->state[4] = 0x510e527f;
-	ctx->state[5] = 0x9b05688c;
-	ctx->state[6] = 0x1f83d9ab;
-	ctx->state[7] = 0x5be0cd19;
-}
-
-void sha256_update(SHA256_CTX *ctx, const BYTE data[], size_t len)
-{
-	WORD i;
-
-	for (i = 0; i < len; ++i) {
-		ctx->data[ctx->datalen] = data[i];
-		ctx->datalen++;
-		if (ctx->datalen == 64) {
-			sha256_transform(ctx, ctx->data);
-			ctx->bitlen += 512;
-			ctx->datalen = 0;
-		}
-	}
-}
-
-void sha256_final(SHA256_CTX *ctx, BYTE hash[])
-{
-	WORD i;
-
-	i = ctx->datalen;
-
-	// Pad whatever data is left in the buffer.
-	if (ctx->datalen < 56) {
-		ctx->data[i++] = 0x80;
-		while (i < 56)
-			ctx->data[i++] = 0x00;
-	}
-	else {
-		ctx->data[i++] = 0x80;
-		while (i < 64)
-			ctx->data[i++] = 0x00;
-		sha256_transform(ctx, ctx->data);
-		memset(ctx->data, 0, 56);
-	}
-
-	// Append to the padding the total message's length in bits and transform.
-	ctx->bitlen += ctx->datalen * 8;
-	ctx->data[63] = (BYTE)(ctx->bitlen);
-	ctx->data[62] = (BYTE)(ctx->bitlen >> 8);
-	ctx->data[61] = (BYTE)(ctx->bitlen >> 16);
-	ctx->data[60] = (BYTE)(ctx->bitlen >> 24);
-	ctx->data[59] = (BYTE)(ctx->bitlen >> 32);
-	ctx->data[58] = (BYTE)(ctx->bitlen >> 40);
-	ctx->data[57] = (BYTE)(ctx->bitlen >> 48);
-	ctx->data[56] = (BYTE)(ctx->bitlen >> 56);
-	sha256_transform(ctx, ctx->data);
-
-	// Since this implementation uses little endian byte ordering and SHA uses big endian,
-	// reverse all the bytes when copying the final state to the output hash.
-	for (i = 0; i < 4; ++i) {
-		hash[i]      = (ctx->state[0] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 4]  = (ctx->state[1] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 8]  = (ctx->state[2] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 12] = (ctx->state[3] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 16] = (ctx->state[4] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 20] = (ctx->state[5] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 24] = (ctx->state[6] >> (24 - i * 8)) & 0x000000ff;
-		hash[i + 28] = (ctx->state[7] >> (24 - i * 8)) & 0x000000ff;
-	}
-}

core/deps/crypto/sha256.h

@@ -1,37 +0,0 @@
-/*********************************************************************
-* Filename:   sha256.h
-* Author:     Brad Conte (brad AT bradconte.com)
-* Copyright:
-* Disclaimer: This code is presented "as is" without any guarantees.
-* Details:    Defines the API for the corresponding SHA1 implementation.
-*********************************************************************/
-
-#ifndef SHA256_H
-#define SHA256_H
-
-/*************************** HEADER FILES ***************************/
-#include <stddef.h>
-#include <stdint.h>
-
-/****************************** MACROS ******************************/
-#define SHA256_BLOCK_SIZE 32            // SHA256 outputs a 32 byte digest
-
-/**************************** DATA TYPES ****************************/
-/*
-typedef uint8_t BYTE;             // 8-bit byte
-typedef uint32_t WORD;             // 32-bit word, change to "long" for 16-bit machines
-*/
-
-typedef struct {
-	uint8_t data[64];
-	uint32_t datalen;
-	uint64_t bitlen;
-	uint32_t state[8];
-} SHA256_CTX;
-
-/*********************** FUNCTION DECLARATIONS **********************/
-void sha256_init(SHA256_CTX *ctx);
-void sha256_update(SHA256_CTX *ctx, const uint8_t data[], size_t len);
-void sha256_final(SHA256_CTX *ctx, uint8_t hash[]);
-
-#endif   // SHA256_H

core/deps/dirent/dirent.h

@@ -29,6 +29,10 @@
 #include <sys/stat.h>
 #include <errno.h>
 
+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_PC_APP || WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
+#define FindFirstFileExW FindFirstFileExFromAppW
+#endif
+
 /* Indicates that d_type field is available in dirent structure */
 #define _DIRENT_HAVE_D_TYPE
 
@@ -613,7 +617,7 @@ dirent_first(
         /* Failed to re-open directory: no directory entry in memory */
         dirp->cached = 0;
         datap = NULL;
-
+        dirent_set_errno(GetLastError()); /* Not a valid errno but better than nothing */
     }
     return datap;
 }
@@ -647,6 +651,8 @@ dirent_next(
             FindClose (dirp->handle);
             dirp->handle = INVALID_HANDLE_VALUE;
             p = NULL;
+            if (GetLastError() != ERROR_NO_MORE_FILES)
+            	dirent_set_errno(GetLastError());
         }
 
     } else {

core/deps/ggpo/include/ggponet.h

@@ -0,0 +1,598 @@
+/* -----------------------------------------------------------------------
+ * 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 _GGPONET_H_
+#define _GGPONET_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+
+// On windows, export at build time and import at runtime.
+// ELF systems don't need an explicit export/import.
+#ifdef _WIN32
+#  if defined(GGPO_SHARED_LIB)
+#  ifdef GGPO_SDK_EXPORT
+#       define GGPO_API __declspec(dllexport)
+#     else
+#       define GGPO_API __declspec(dllimport)
+#     endif
+#  else
+#     define GGPO_API
+#  endif
+#else
+#  define GGPO_API
+#endif
+
+#ifdef __GNUC__
+#if defined(_WIN32) && !defined(_WIN64)
+#define __cdecl __attribute__((cdecl))
+#elif !defined(__cdecl)
+#define __cdecl
+#endif
+#endif
+
+#define GGPO_MAX_PLAYERS                  4
+#define GGPO_MAX_PREDICTION_FRAMES        8
+#define GGPO_MAX_SPECTATORS              32
+
+#define GGPO_SPECTATOR_INPUT_INTERVAL     4
+
+typedef struct GGPOSession GGPOSession;
+
+typedef int GGPOPlayerHandle;
+
+typedef enum {
+   GGPO_PLAYERTYPE_LOCAL,
+   GGPO_PLAYERTYPE_REMOTE,
+   GGPO_PLAYERTYPE_SPECTATOR,
+} GGPOPlayerType;
+
+/*
+ * The GGPOPlayer structure used to describe players in ggpo_add_player
+ *
+ * size: Should be set to the sizeof(GGPOPlayer)
+ *
+ * type: One of the GGPOPlayerType values describing how inputs should be handled
+ *       Local players must have their inputs updated every frame via
+ *       ggpo_add_local_inputs.  Remote players values will come over the
+ *       network.
+ *
+ * player_num: The player number.  Should be between 1 and the number of players
+ *       In the game (e.g. in a 2 player game, either 1 or 2).
+ *
+ * If type == GGPO_PLAYERTYPE_REMOTE:
+ * 
+ * u.remote.ip_address:  The ip address of the ggpo session which will host this
+ *       player.
+ *
+ * u.remote.port: The port where udp packets should be sent to reach this player.
+ *       All the local inputs for this session will be sent to this player at
+ *       ip_address:port.
+ *
+ */
+
+typedef struct GGPOPlayer {
+   int               size;
+   GGPOPlayerType    type;
+   int               player_num;
+   union {
+      struct {
+         bool _unused;
+      } local;
+      struct {
+         char           ip_address[32];
+         unsigned short port;
+      } remote;
+   } u;
+} GGPOPlayer;
+
+typedef struct GGPOLocalEndpoint {
+   int      player_num;
+} GGPOLocalEndpoint;
+
+
+#define GGPO_ERRORLIST                                               \
+   GGPO_ERRORLIST_ENTRY(GGPO_OK,                               0)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_SUCCESS,                0)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_GENERAL_FAILURE,        -1)   \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_INVALID_SESSION,        1)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_INVALID_PLAYER_HANDLE,  2)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_PLAYER_OUT_OF_RANGE,    3)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_PREDICTION_THRESHOLD,   4)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_UNSUPPORTED,            5)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_NOT_SYNCHRONIZED,       6)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_IN_ROLLBACK,            7)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_INPUT_DROPPED,          8)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_PLAYER_DISCONNECTED,    9)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_TOO_MANY_SPECTATORS,   10)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_INVALID_REQUEST,       11)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_INPUT_SIZE_DIFF,       12)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_NETWORK_ERROR,         13)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_VERIFICATION_ERROR,    14)
+
+#define GGPO_ERRORLIST_ENTRY(name, value)       name = value,
+typedef enum {
+   GGPO_ERRORLIST
+} GGPOErrorCode;
+#undef GGPO_ERRORLIST_ENTRY
+
+#define GGPO_SUCCEEDED(result)      ((result) == GGPO_ERRORCODE_SUCCESS)
+
+
+#define GGPO_INVALID_HANDLE      (-1)
+
+
+/*
+ * The GGPOEventCode enumeration describes what type of event just happened.
+ *
+ * GGPO_EVENTCODE_CONNECTED_TO_PEER - Handshake with the game running on the
+ * other side of the network has been completed.
+ * 
+ * GGPO_EVENTCODE_SYNCHRONIZING_WITH_PEER - Beginning the synchronization
+ * process with the client on the other end of the networking.  The count
+ * and total fields in the u.synchronizing struct of the GGPOEvent
+ * object indicate progress.
+ *
+ * GGPO_EVENTCODE_SYNCHRONIZED_WITH_PEER - The synchronziation with this
+ * peer has finished.
+ *
+ * GGPO_EVENTCODE_RUNNING - All the clients have synchronized.  You may begin
+ * sending inputs with ggpo_synchronize_inputs.
+ *
+ * GGPO_EVENTCODE_DISCONNECTED_FROM_PEER - The network connection on 
+ * the other end of the network has closed.
+ *
+ * GGPO_EVENTCODE_TIMESYNC - The time synchronziation code has determined
+ * that this client is too far ahead of the other one and should slow
+ * down to ensure fairness.  The u.timesync.frames_ahead parameter in
+ * the GGPOEvent object indicates how many frames the client is.
+ *
+ */
+typedef enum {
+   GGPO_EVENTCODE_CONNECTED_TO_PEER            = 1000,
+   GGPO_EVENTCODE_SYNCHRONIZING_WITH_PEER      = 1001,
+   GGPO_EVENTCODE_SYNCHRONIZED_WITH_PEER       = 1002,
+   GGPO_EVENTCODE_RUNNING                      = 1003,
+   GGPO_EVENTCODE_DISCONNECTED_FROM_PEER       = 1004,
+   GGPO_EVENTCODE_TIMESYNC                     = 1005,
+   GGPO_EVENTCODE_CONNECTION_INTERRUPTED       = 1006,
+   GGPO_EVENTCODE_CONNECTION_RESUMED           = 1007,
+} GGPOEventCode;
+
+/*
+ * The GGPOEvent structure contains an asynchronous event notification sent
+ * by the on_event callback.  See GGPOEventCode, above, for a detailed
+ * explanation of each event.
+ */
+typedef struct {
+   GGPOEventCode code;
+   union {
+      struct {
+         GGPOPlayerHandle  player;
+      } connected;
+      struct {
+         GGPOPlayerHandle  player;
+         int               count;
+         int               total;
+      } synchronizing;
+      struct {
+         GGPOPlayerHandle  player;
+      } synchronized;
+      struct {
+         GGPOPlayerHandle  player;
+      } disconnected;
+      struct {
+         int               frames_ahead;
+      } timesync;
+      struct {
+         GGPOPlayerHandle  player;
+         int               disconnect_timeout;
+      } connection_interrupted;
+      struct {
+         GGPOPlayerHandle  player;
+      } connection_resumed;
+   } u;
+} GGPOEvent;
+
+/*
+ * The GGPOSessionCallbacks structure contains the callback functions that
+ * your application must implement.  GGPO.net will periodically call these
+ * functions during the game.  All callback functions must be implemented.
+ */
+typedef struct {
+   /*
+    * begin_game callback - This callback has been deprecated.  You must
+    * implement it, but should ignore the 'game' parameter.
+    */
+   bool (__cdecl *begin_game)(const char *game);
+
+   /*
+    * save_game_state - The client should allocate a buffer, copy the
+    * entire contents of the current game state into it, and copy the
+    * length into the *len parameter.  Optionally, the client can compute
+    * a checksum of the data and store it in the *checksum argument.
+    */
+   bool (__cdecl *save_game_state)(unsigned char **buffer, int *len, int *checksum, int frame);
+
+   /*
+    * load_game_state - GGPO.net will call this function at the beginning
+    * of a rollback.  The buffer and len parameters contain a previously
+    * saved state returned from the save_game_state function.  The client
+    * should make the current game state match the state contained in the
+    * buffer.
+    */
+   bool (__cdecl *load_game_state)(unsigned char *buffer, int len);
+
+   /*
+    * log_game_state - Used in diagnostic testing.  The client should use
+    * the ggpo_log function to write the contents of the specified save
+    * state in a human readible form.
+    */
+   bool (__cdecl *log_game_state)(char *filename, unsigned char *buffer, int len);
+
+   /*
+    * free_buffer - Frees a game state allocated in save_game_state.  You
+    * should deallocate the memory contained in the buffer.
+    */
+   void (__cdecl *free_buffer)(void *buffer);
+
+   /*
+    * advance_frame - Called during a rollback.  You should advance your game
+    * state by exactly one frame.  Before each frame, call ggpo_synchronize_input
+    * to retrieve the inputs you should use for that frame.  After each frame,
+    * you should call ggpo_advance_frame to notify GGPO.net that you're
+    * finished.
+    *
+    * The flags parameter is reserved.  It can safely be ignored at this time.
+    */
+   bool (__cdecl *advance_frame)(int flags);
+
+   /* 
+    * on_event - Notification that something has happened.  See the GGPOEventCode
+    * structure above for more information.
+    */
+   bool (__cdecl *on_event)(GGPOEvent *info);
+
+   /*
+    * on_message - Delivers an application message. Allows arbitrary data to be
+    * exchanged with peers. This callback is optional.
+    */
+   void (__cdecl *on_message)(unsigned char *msg, int len);
+} GGPOSessionCallbacks;
+
+/*
+ * The GGPONetworkStats function contains some statistics about the current
+ * session.
+ *
+ * network.send_queue_len - The length of the queue containing UDP packets
+ * which have not yet been acknowledged by the end client.  The length of
+ * the send queue is a rough indication of the quality of the connection.
+ * The longer the send queue, the higher the round-trip time between the
+ * clients.  The send queue will also be longer than usual during high
+ * packet loss situations.
+ *
+ * network.recv_queue_len - The number of inputs currently buffered by the
+ * GGPO.net network layer which have yet to be validated.  The length of
+ * the prediction queue is roughly equal to the current frame number
+ * minus the frame number of the last packet in the remote queue.
+ *
+ * network.ping - The roundtrip packet transmission time as calcuated
+ * by GGPO.net.  This will be roughly equal to the actual round trip
+ * packet transmission time + 2 the interval at which you call ggpo_idle
+ * or ggpo_advance_frame.
+ *
+ * network.kbps_sent - The estimated bandwidth used between the two
+ * clients, in kilobits per second.
+ *
+ * timesync.local_frames_behind - The number of frames GGPO.net calculates
+ * that the local client is behind the remote client at this instant in
+ * time.  For example, if at this instant the current game client is running
+ * frame 1002 and the remote game client is running frame 1009, this value
+ * will mostly likely roughly equal 7.
+ *
+ * timesync.remote_frames_behind - The same as local_frames_behind, but
+ * calculated from the perspective of the remote player.
+ *
+ */
+typedef struct GGPONetworkStats {
+   struct {
+      int   send_queue_len;
+      int   recv_queue_len;
+      int   ping;
+      int   kbps_sent;
+   } network;
+   struct {
+      int   local_frames_behind;
+      int   remote_frames_behind;
+   } timesync;
+   struct {
+	   int predicted_frames;
+   } sync;
+} GGPONetworkStats;
+
+/*
+ * ggpo_start_session --
+ *
+ * Used to being a new GGPO.net session.  The ggpo object returned by ggpo_start_session
+ * uniquely identifies the state for this session and should be passed to all other
+ * functions.
+ *
+ * session - An out parameter to the new ggpo session object.
+ *
+ * cb - A GGPOSessionCallbacks structure which contains the callbacks you implement
+ * to help GGPO.net synchronize the two games.  You must implement all functions in
+ * cb, even if they do nothing but 'return true';
+ *
+ * game - The name of the game.  This is used internally for GGPO for logging purposes only.
+ *
+ * num_players - The number of players which will be in this game.  The number of players
+ * per session is fixed.  If you need to change the number of players or any player
+ * disconnects, you must start a new session.
+ *
+ * input_size - The size of the game inputs which will be passsed to ggpo_add_local_input.
+ *
+ * local_port - The port GGPO should bind to for UDP traffic.
+ *
+ * verification - Some optional data that will be matched with the peers during initial sync.
+ * Can be set to null if verification_size is zero. This can be used to check that all peers are
+ * running the same version of the application and of the game, are using the same settings, etc.
+ *
+ * verification_size - Size of the verification data. Can be set to zero to not exchange verification data.
+ * Maximum size is 256 bytes.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_start_session(GGPOSession **session,
+                                                  GGPOSessionCallbacks *cb,
+                                                  const char *game,
+                                                  int num_players,
+                                                  int input_size,
+                                                  unsigned short localport,
+												  const void *verification,
+												  int verification_size);
+
+
+/*
+ * ggpo_add_player --
+ *
+ * Must be called for each player in the session (e.g. in a 3 player session, must
+ * be called 3 times).
+ *
+ * player - A GGPOPlayer struct used to describe the player.
+ *
+ * handle - An out parameter to a handle used to identify this player in the future.
+ * (e.g. in the on_event callbacks).
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_add_player(GGPOSession *session,
+                                               GGPOPlayer *player,
+                                               GGPOPlayerHandle *handle);
+
+
+/*
+ * ggpo_start_synctest --
+ *
+ * Used to being a new GGPO.net sync test session.  During a sync test, every
+ * frame of execution is run twice: once in prediction mode and once again to
+ * verify the result of the prediction.  If the checksums of your save states
+ * do not match, the test is aborted.
+ *
+ * cb - A GGPOSessionCallbacks structure which contains the callbacks you implement
+ * to help GGPO.net synchronize the two games.  You must implement all functions in
+ * cb, even if they do nothing but 'return true';
+ *
+ * game - The name of the game.  This is used internally for GGPO for logging purposes only.
+ *
+ * num_players - The number of players which will be in this game.  The number of players
+ * per session is fixed.  If you need to change the number of players or any player
+ * disconnects, you must start a new session.
+ *
+ * input_size - The size of the game inputs which will be passsed to ggpo_add_local_input.
+ *
+ * frames - The number of frames to run before verifying the prediction.  The
+ * recommended value is 1.
+ *
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_start_synctest(GGPOSession **session,
+                                                   GGPOSessionCallbacks *cb,
+                                                   const char *game,
+                                                   int num_players,
+                                                   int input_size,
+                                                   int frames);
+
+
+/*
+ * ggpo_start_spectating --
+ *
+ * Start a spectator session.
+ *
+ * cb - A GGPOSessionCallbacks structure which contains the callbacks you implement
+ * to help GGPO.net synchronize the two games.  You must implement all functions in
+ * cb, even if they do nothing but 'return true';
+ *
+ * game - The name of the game.  This is used internally for GGPO for logging purposes only.
+ *
+ * num_players - The number of players which will be in this game.  The number of players
+ * per session is fixed.  If you need to change the number of players or any player
+ * disconnects, you must start a new session.
+ *
+ * input_size - The size of the game inputs which will be passsed to ggpo_add_local_input.
+ *
+ * local_port - The port GGPO should bind to for UDP traffic.
+ *
+ * host_ip - The IP address of the host who will serve you the inputs for the game.  Any
+ * player partcipating in the session can serve as a host.
+ *
+ * host_port - The port of the session on the host
+ *
+ * verification - Some optional data that will be matched with the peers during initial sync.
+ * Can be set to null if verification_size is zero. This can be used to check that all peers are
+ * running the same version of the application and of the game, are using the same settings, etc.
+ *
+ * verification_size - Size of the verification data. Can be set to zero to not exchange verification data.
+ * Maximum size is 256 bytes.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_start_spectating(GGPOSession **session,
+                                                     GGPOSessionCallbacks *cb,
+                                                     const char *game,
+                                                     int num_players,
+                                                     int input_size,
+                                                     unsigned short local_port,
+                                                     char *host_ip,
+                                                     unsigned short host_port,
+													 const void *verification,
+													 int verification_size);
+
+/*
+ * ggpo_close_session --
+ * Used to close a session.  You must call ggpo_close_session to
+ * free the resources allocated in ggpo_start_session.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_close_session(GGPOSession *);
+
+
+/*
+ * ggpo_set_frame_delay --
+ *
+ * Change the amount of frames ggpo will delay local input.  Must be called
+ * before the first call to ggpo_synchronize_input.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_set_frame_delay(GGPOSession *,
+                                                    GGPOPlayerHandle player,
+                                                    int frame_delay);
+
+/*
+ * ggpo_idle --
+ * Should be called periodically by your application to give GGPO.net
+ * a chance to do some work.  Most packet transmissions and rollbacks occur
+ * in ggpo_idle.
+ *
+ * timeout - The amount of time GGPO.net is allowed to spend in this function,
+ * in milliseconds.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_idle(GGPOSession *,
+                                         int timeout);
+
+/*
+ * ggpo_add_local_input --
+ *
+ * Used to notify GGPO.net of inputs that should be trasmitted to remote
+ * players.  ggpo_add_local_input must be called once every frame for
+ * all player of type GGPO_PLAYERTYPE_LOCAL.
+ *
+ * player - The player handle returned for this player when you called
+ * ggpo_add_local_player.
+ *
+ * values - The controller inputs for this player.
+ *
+ * size - The size of the controller inputs.  This must be exactly equal to the
+ * size passed into ggpo_start_session.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_add_local_input(GGPOSession *,
+                                                    GGPOPlayerHandle player,
+                                                    void *values,
+                                                    int size);
+
+/*
+ * ggpo_synchronize_input --
+ *
+ * You should call ggpo_synchronize_input before every frame of execution,
+ * including those frames which happen during rollback.
+ *
+ * values - When the function returns, the values parameter will contain
+ * inputs for this frame for all players.  The values array must be at
+ * least (size * players) large.
+ *
+ * size - The size of the values array.
+ *
+ * disconnect_flags - Indicated whether the input in slot (1 << flag) is
+ * valid.  If a player has disconnected, the input in the values array for
+ * that player will be zeroed and the i-th flag will be set.  For example,
+ * if only player 3 has disconnected, disconnect flags will be 8 (i.e. 1 << 3).
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_synchronize_input(GGPOSession *,
+                                                      void *values,
+                                                      int size,
+                                                      int *disconnect_flags);
+
+/*
+ * ggpo_disconnect_player --
+ *
+ * Disconnects a remote player from a game.  Will return GGPO_ERRORCODE_PLAYER_DISCONNECTED
+ * if you try to disconnect a player who has already been disconnected.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_disconnect_player(GGPOSession *,
+                                                      GGPOPlayerHandle player);
+
+/*
+ * ggpo_advance_frame --
+ *
+ * You should call ggpo_advance_frame to notify GGPO.net that you have
+ * advanced your gamestate by a single frame.  You should call this everytime
+ * you advance the gamestate by a frame, even during rollbacks.  GGPO.net
+ * may call your save_state callback before this function returns.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_advance_frame(GGPOSession *);
+
+/*
+ * ggpo_get_network_stats --
+ *
+ * Used to fetch some statistics about the quality of the network connection.
+ *
+ * player - The player handle returned from the ggpo_add_player function you used
+ * to add the remote player.
+ *
+ * stats - Out parameter to the network statistics.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_get_network_stats(GGPOSession *,
+                                                      GGPOPlayerHandle player,
+                                                      GGPONetworkStats *stats);
+
+/*
+ * ggpo_set_disconnect_timeout --
+ *
+ * Sets the disconnect timeout.  The session will automatically disconnect
+ * from a remote peer if it has not received a packet in the timeout window.
+ * You will be notified of the disconnect via a GGPO_EVENTCODE_DISCONNECTED_FROM_PEER
+ * event.
+ *
+ * Setting a timeout value of 0 will disable automatic disconnects.
+ *
+ * timeout - The time in milliseconds to wait before disconnecting a peer.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_set_disconnect_timeout(GGPOSession *,
+                                                           int timeout);
+
+/*
+ * ggpo_set_disconnect_notify_start --
+ *
+ * The time to wait before the first GGPO_EVENTCODE_NETWORK_INTERRUPTED timeout
+ * will be sent.
+ *
+ * timeout - The amount of time which needs to elapse without receiving a packet
+ *           before the GGPO_EVENTCODE_NETWORK_INTERRUPTED event is sent.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_set_disconnect_notify_start(GGPOSession *,
+                                                                int timeout);
+
+/*
+ * ggpo_send_message --
+ *
+ * Sends application-specific data to other peers. The message is
+ * delivered by the on_user_message callback.
+ * If spectators is true, the message is also sent to spectators.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_send_message(GGPOSession *,
+                                                 const void *msg,
+                                                 int len,
+												 bool spectators);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif

core/deps/ggpo/lib/ggpo/backends/backend.h

@@ -0,0 +1,33 @@
+/* -----------------------------------------------------------------------
+ * 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 _BACKEND_H
+#define _BACKEND_H
+
+#include "../ggpo_types.h"
+#include "ggponet.h"
+
+struct GGPOSession {
+   virtual ~GGPOSession() { }
+   virtual GGPOErrorCode DoPoll(int timeout) { return GGPO_OK; }
+   virtual GGPOErrorCode AddPlayer(GGPOPlayer *player, GGPOPlayerHandle *handle) = 0;
+   virtual GGPOErrorCode AddLocalInput(GGPOPlayerHandle player, void *values, int size) = 0;
+   virtual GGPOErrorCode SyncInput(void *values, int size, int *disconnect_flags) = 0;
+   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 SetFrameDelay(GGPOPlayerHandle player, int delay) { return GGPO_ERRORCODE_UNSUPPORTED; }
+   virtual GGPOErrorCode SetDisconnectTimeout(int timeout) { return GGPO_ERRORCODE_UNSUPPORTED; }
+   virtual GGPOErrorCode SetDisconnectNotifyStart(int timeout) { return GGPO_ERRORCODE_UNSUPPORTED; }
+   virtual GGPOErrorCode SendMessage(const void *msg, int len, bool spectators) { return GGPO_ERRORCODE_UNSUPPORTED; }
+};
+
+typedef struct GGPOSession Quark, IQuarkBackend; /* XXX: nuke this */
+
+#endif
+

core/deps/ggpo/lib/ggpo/backends/p2p.cpp

@@ -0,0 +1,664 @@
+/* -----------------------------------------------------------------------
+ * 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 "p2p.h"
+#include <chrono>
+#include <thread>
+
+static const int RECOMMENDATION_INTERVAL           = 240;
+static const int DEFAULT_DISCONNECT_TIMEOUT        = 5000;
+static const int DEFAULT_DISCONNECT_NOTIFY_START   = 750;
+
+Peer2PeerBackend::Peer2PeerBackend(GGPOSessionCallbacks *cb,
+                                   const char *gamename,
+                                   uint16 localport,
+                                   int num_players,
+                                   int input_size,
+								   const void *verification,
+								   int verification_size) :
+    _sync(_local_connect_status),
+	_endpoints(nullptr),
+    _num_spectators(0),
+    _input_size(input_size),
+    _num_players(num_players),
+    _next_spectator_frame(0),
+    _disconnect_timeout(DEFAULT_DISCONNECT_TIMEOUT),
+    _disconnect_notify_start(DEFAULT_DISCONNECT_NOTIFY_START)
+{
+   _callbacks = *cb;
+   _synchronizing = true;
+   _next_recommended_sleep = 0;
+
+   /*
+    * Initialize the synchronziation layer
+    */
+   Sync::Config config = { 0 };
+   config.num_players = num_players;
+   config.input_size = input_size;
+   config.callbacks = _callbacks;
+   config.num_prediction_frames = MAX_PREDICTION_FRAMES;
+   _sync.Init(config);
+
+   /*
+    * Initialize the UDP port
+    */
+   _udp.Init(localport, &_poll, this);
+
+   _endpoints = new UdpProtocol[_num_players];
+   for (int i = 0; i < _num_players; i++)
+	   _endpoints[i].SetVerificationData(verification, verification_size);
+   memset(_local_connect_status, 0, sizeof(_local_connect_status));
+   for (unsigned i = 0; i < ARRAY_SIZE(_local_connect_status); i++) {
+      _local_connect_status[i].last_frame = -1;
+   }
+
+   /*
+    * Preload the ROM
+    */
+   _callbacks.begin_game(gamename);
+}
+  
+Peer2PeerBackend::~Peer2PeerBackend()
+{
+   delete [] _endpoints;
+}
+
+void
+Peer2PeerBackend::AddRemotePlayer(char *ip,
+                                  uint16 port,
+                                  int queue)
+{
+   /*
+    * Start the state machine (xxx: no)
+    */
+   _synchronizing = true;
+   
+   _endpoints[queue].Init(&_udp, _poll, queue, ip, port, _local_connect_status);
+   _endpoints[queue].SetDisconnectTimeout(_disconnect_timeout);
+   _endpoints[queue].SetDisconnectNotifyStart(_disconnect_notify_start);
+   _endpoints[queue].Synchronize();
+}
+
+GGPOErrorCode Peer2PeerBackend::AddSpectator(char *ip,
+                                             uint16 port)
+{
+   if (_num_spectators == GGPO_MAX_SPECTATORS) {
+      return GGPO_ERRORCODE_TOO_MANY_SPECTATORS;
+   }
+   /*
+    * Currently, we can only add spectators before the game starts.
+    */
+   if (!_synchronizing) {
+      return GGPO_ERRORCODE_INVALID_REQUEST;
+   }
+   int queue = _num_spectators++;
+
+   _spectators[queue].Init(&_udp, _poll, queue + 1000, ip, port, _local_connect_status);
+   _spectators[queue].SetDisconnectTimeout(_disconnect_timeout);
+   _spectators[queue].SetDisconnectNotifyStart(_disconnect_notify_start);
+   _spectators[queue].Synchronize();
+
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::DoPoll(int timeout)
+{
+   if (!_sync.InRollback()) {
+      _poll.Pump(0);
+
+      PollUdpProtocolEvents();
+
+      if (!_synchronizing) {
+         _sync.CheckSimulation(timeout);
+
+         // notify all of our endpoints of their local frame number for their
+         // next connection quality report
+         int current_frame = _sync.GetFrameCount();
+         for (int i = 0; i < _num_players; i++) {
+            _endpoints[i].SetLocalFrameNumber(current_frame);
+         }
+
+         int total_min_confirmed;
+         if (_num_players <= 2) {
+            total_min_confirmed = Poll2Players(current_frame);
+         } else {
+            total_min_confirmed = PollNPlayers(current_frame);
+         }
+
+         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.", _next_spectator_frame);
+   
+                  GameInput input;
+                  input.frame = _next_spectator_frame;
+                  input.size = _input_size * _num_players;
+                  _sync.GetConfirmedInputs(input.bits, _input_size * _num_players, _next_spectator_frame);
+                  for (int i = 0; i < _num_spectators; i++) {
+                     _spectators[i].SendInput(input);
+                  }
+                  _next_spectator_frame++;
+               }
+            }
+            Log("setting confirmed frame in sync to %d.", total_min_confirmed);
+            _sync.SetLastConfirmedFrame(total_min_confirmed);
+         }
+
+         // send timesync notifications if now is the proper time
+         if (current_frame > _next_recommended_sleep) {
+            int interval = 0;
+            for (int i = 0; i < _num_players; i++) {
+               interval = MAX(interval, _endpoints[i].RecommendFrameDelay());
+            }
+
+            if (interval > 0) {
+               GGPOEvent info;
+               info.code = GGPO_EVENTCODE_TIMESYNC;
+               info.u.timesync.frames_ahead = interval;
+               _callbacks.on_event(&info);
+               _next_recommended_sleep = current_frame + RECOMMENDATION_INTERVAL;
+            }
+         }
+         // XXX: this is obviously a farce...
+         if (timeout)
+        	 std::this_thread::sleep_for(std::chrono::milliseconds(1));
+      }
+   }
+   return GGPO_OK;
+}
+
+int Peer2PeerBackend::Poll2Players(int current_frame)
+{
+   int i;
+
+   // discard confirmed frames as appropriate
+   int total_min_confirmed = MAX_INT;
+   for (i = 0; i < _num_players; i++) {
+      bool queue_connected = true;
+      if (_endpoints[i].IsRunning()) {
+         int ignore;
+         queue_connected = _endpoints[i].GetPeerConnectStatus(i, &ignore);
+      }
+      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.", !_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.", i);
+         DisconnectPlayerQueue(i, total_min_confirmed);
+      }
+      Log("  total_min_confirmed = %d.", total_min_confirmed);
+   }
+   return total_min_confirmed;
+}
+
+int Peer2PeerBackend::PollNPlayers(int current_frame)
+{
+   int i, queue, last_received;
+
+   // discard confirmed frames as appropriate
+   int total_min_confirmed = MAX_INT;
+   for (queue = 0; queue < _num_players; queue++) {
+      bool queue_connected = true;
+      int queue_min_confirmed = MAX_INT;
+      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
+         // throw away the rest.
+         if (_endpoints[i].IsRunning()) {
+            bool connected = _endpoints[i].GetPeerConnectStatus(queue, &last_received);
+
+            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.", i, connected, last_received, queue_min_confirmed);
+         } else {
+            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.", !_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);
+      } else {
+         // check to see if this disconnect notification is further back than we've been before.  If
+         // 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.", queue);
+            DisconnectPlayerQueue(queue, queue_min_confirmed);
+         }
+      }
+      Log("  total_min_confirmed = %d.", total_min_confirmed);
+   }
+   return total_min_confirmed;
+}
+
+
+GGPOErrorCode
+Peer2PeerBackend::AddPlayer(GGPOPlayer *player,
+                            GGPOPlayerHandle *handle)
+{
+   if (player->type == GGPO_PLAYERTYPE_SPECTATOR) {
+      return AddSpectator(player->u.remote.ip_address, player->u.remote.port);
+   }
+
+   int queue = player->player_num - 1;
+   if (player->player_num < 1 || player->player_num > _num_players) {
+      return GGPO_ERRORCODE_PLAYER_OUT_OF_RANGE;
+   }
+   *handle = QueueToPlayerHandle(queue);
+
+   if (player->type == GGPO_PLAYERTYPE_REMOTE) {
+      AddRemotePlayer(player->u.remote.ip_address, player->u.remote.port, queue);
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::AddLocalInput(GGPOPlayerHandle player,
+                                void *values,
+                                int size)
+{
+   int queue;
+   GameInput input;
+   GGPOErrorCode result;
+
+   if (_sync.InRollback()) {
+      return GGPO_ERRORCODE_IN_ROLLBACK;
+   }
+   if (_synchronizing) {
+      return GGPO_ERRORCODE_NOT_SYNCHRONIZED;
+   }
+   
+   result = PlayerHandleToQueue(player, &queue);
+   if (!GGPO_SUCCEEDED(result)) {
+      return result;
+   }
+
+   input.init(-1, (char *)values, size);
+
+   // Feed the input for the current frame into the synchronzation layer.
+   if (!_sync.AddLocalInput(queue, input)) {
+      return GGPO_ERRORCODE_PREDICTION_THRESHOLD;
+   }
+
+   if (input.frame != GameInput::NullFrame) { // xxx: <- comment why this is the case
+      // Update the local connect status state to indicate that we've got a
+      // confirmed local frame for this player.  this must come first so it
+      // gets incorporated into the next packet we send.
+
+      Log("setting local connect status for local queue %d to %d", queue, input.frame);
+      _local_connect_status[queue].last_frame = input.frame;
+
+      // Send the input to all the remote players.
+      for (int i = 0; i < _num_players; i++) {
+         if (_endpoints[i].IsInitialized()) {
+            _endpoints[i].SendInput(input);
+         }
+      }
+   }
+
+   return GGPO_OK;
+}
+
+
+GGPOErrorCode
+Peer2PeerBackend::SyncInput(void *values,
+                            int size,
+                            int *disconnect_flags)
+{
+   int flags;
+
+   // Wait until we've started to return inputs.
+   if (_synchronizing) {
+      return GGPO_ERRORCODE_NOT_SYNCHRONIZED;
+   }
+   flags = _sync.SynchronizeInputs(values, size);
+   if (disconnect_flags) {
+      *disconnect_flags = flags;
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::IncrementFrame(void)
+{  
+   Log("End of frame (%d)...", _sync.GetFrameCount());
+   _sync.IncrementFrame();
+   DoPoll(0);
+   PollSyncEvents();
+
+   return GGPO_OK;
+}
+
+
+void
+Peer2PeerBackend::PollSyncEvents(void)
+{
+   Sync::Event e;
+   while (_sync.GetEvent(e)) {
+      OnSyncEvent(e);
+   }
+   return;
+}
+
+void
+Peer2PeerBackend::PollUdpProtocolEvents(void)
+{
+   UdpProtocol::Event evt;
+   for (int i = 0; i < _num_players; i++) {
+      while (_endpoints[i].GetEvent(evt)) {
+         OnUdpProtocolPeerEvent(evt, i);
+      }
+   }
+   for (int i = 0; i < _num_spectators; i++) {
+      while (_spectators[i].GetEvent(evt)) {
+         OnUdpProtocolSpectatorEvent(evt, i);
+      }
+   }
+}
+
+void
+Peer2PeerBackend::OnUdpProtocolPeerEvent(UdpProtocol::Event &evt, int queue)
+{
+   OnUdpProtocolEvent(evt, QueueToPlayerHandle(queue));
+   switch (evt.type) {
+      case UdpProtocol::Event::Input:
+         if (!_local_connect_status[queue].disconnected) {
+            int current_remote_frame = _local_connect_status[queue].last_frame;
+            int new_remote_frame = evt.u.input.input.frame;
+            ASSERT(current_remote_frame == -1 || new_remote_frame == (current_remote_frame + 1));
+
+            _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", queue, evt.u.input.input.frame);
+            _local_connect_status[queue].last_frame = evt.u.input.input.frame;
+         }
+         break;
+
+   case UdpProtocol::Event::Disconnected:
+      DisconnectPlayer(QueueToPlayerHandle(queue));
+      break;
+
+   case UdpProtocol::Event::AppData:
+	   if (evt.u.app_data.spectators)
+		   for (int i = 0; i < _num_spectators; i++)
+			   if (_spectators[i].IsInitialized())
+				   _spectators[i].SendAppData(evt.u.app_data.data, evt.u.app_data.size, true);
+	   Log("calling on_message callback with %d bytes", evt.u.app_data.size);
+	   if (_callbacks.on_message != nullptr)
+		   _callbacks.on_message(evt.u.app_data.data, evt.u.app_data.size);
+	  break;
+
+   default:
+	  break;
+   }
+}
+
+
+void
+Peer2PeerBackend::OnUdpProtocolSpectatorEvent(UdpProtocol::Event &evt, int queue)
+{
+   GGPOPlayerHandle handle = QueueToSpectatorHandle(queue);
+   OnUdpProtocolEvent(evt, handle);
+
+   if (evt.type == UdpProtocol::Event::Disconnected)
+   {
+      _spectators[queue].Disconnect();
+
+      GGPOEvent info;
+      info.code = GGPO_EVENTCODE_DISCONNECTED_FROM_PEER;
+      info.u.disconnected.player = handle;
+      _callbacks.on_event(&info);
+   }
+}
+
+void
+Peer2PeerBackend::OnUdpProtocolEvent(UdpProtocol::Event &evt, GGPOPlayerHandle handle)
+{
+   GGPOEvent info;
+
+   switch (evt.type) {
+   case UdpProtocol::Event::Connected:
+      info.code = GGPO_EVENTCODE_CONNECTED_TO_PEER;
+      info.u.connected.player = handle;
+      _callbacks.on_event(&info);
+      break;
+   case UdpProtocol::Event::Synchronizing:
+      info.code = GGPO_EVENTCODE_SYNCHRONIZING_WITH_PEER;
+      info.u.synchronizing.player = handle;
+      info.u.synchronizing.count = evt.u.synchronizing.count;
+      info.u.synchronizing.total = evt.u.synchronizing.total;
+      _callbacks.on_event(&info);
+      break;
+   case UdpProtocol::Event::Synchronzied:
+      info.code = GGPO_EVENTCODE_SYNCHRONIZED_WITH_PEER;
+      info.u.synchronized.player = handle;
+      _callbacks.on_event(&info);
+
+      CheckInitialSync();
+      break;
+
+   case UdpProtocol::Event::NetworkInterrupted:
+      info.code = GGPO_EVENTCODE_CONNECTION_INTERRUPTED;
+      info.u.connection_interrupted.player = handle;
+      info.u.connection_interrupted.disconnect_timeout = evt.u.network_interrupted.disconnect_timeout;
+      _callbacks.on_event(&info);
+      break;
+
+   case UdpProtocol::Event::NetworkResumed:
+      info.code = GGPO_EVENTCODE_CONNECTION_RESUMED;
+      info.u.connection_resumed.player = handle;
+      _callbacks.on_event(&info);
+      break;
+
+   default:
+	  break;
+   }
+}
+
+/*
+ * Called only as the result of a local decision to disconnect.  The remote
+ * decisions to disconnect are a result of us parsing the peer_connect_settings
+ * blob in every endpoint periodically.
+ */
+GGPOErrorCode
+Peer2PeerBackend::DisconnectPlayer(GGPOPlayerHandle player)
+{
+   int queue;
+   GGPOErrorCode result;
+
+   result = PlayerHandleToQueue(player, &queue);
+   if (!GGPO_SUCCEEDED(result)) {
+      return result;
+   }
+   
+   if (_local_connect_status[queue].disconnected) {
+      return GGPO_ERRORCODE_PLAYER_DISCONNECTED;
+   }
+
+   if (!_endpoints[queue].IsInitialized()) {
+      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.", 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.", queue, _local_connect_status[queue].last_frame);
+      DisconnectPlayerQueue(queue, _local_connect_status[queue].last_frame);
+   }
+   return GGPO_OK;
+}
+
+void
+Peer2PeerBackend::DisconnectPlayerQueue(int queue, int syncto)
+{
+   GGPOEvent info;
+   int framecount = _sync.GetFrameCount();
+
+   _endpoints[queue].Disconnect();
+
+   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.", queue, syncto);
+      _sync.AdjustSimulation(syncto);
+      Log("finished adjusting simulation.");
+   }
+
+   info.code = GGPO_EVENTCODE_DISCONNECTED_FROM_PEER;
+   info.u.disconnected.player = QueueToPlayerHandle(queue);
+   _callbacks.on_event(&info);
+
+   CheckInitialSync();
+}
+
+
+GGPOErrorCode
+Peer2PeerBackend::GetNetworkStats(GGPONetworkStats *stats, GGPOPlayerHandle player)
+{
+   int queue;
+   GGPOErrorCode result;
+
+   result = PlayerHandleToQueue(player, &queue);
+   if (!GGPO_SUCCEEDED(result)) {
+      return result;
+   }
+
+   memset(stats, 0, sizeof *stats);
+   _endpoints[queue].GetNetworkStats(stats);
+   stats->sync.predicted_frames = _sync.GetPredictedFrames();
+
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::SetFrameDelay(GGPOPlayerHandle player, int delay) 
+{ 
+   int queue;
+   GGPOErrorCode result;
+
+   result = PlayerHandleToQueue(player, &queue);
+   if (!GGPO_SUCCEEDED(result)) {
+      return result;
+   }
+   _sync.SetFrameDelay(queue, delay);
+   return GGPO_OK; 
+}
+
+GGPOErrorCode
+Peer2PeerBackend::SetDisconnectTimeout(int timeout)
+{
+   _disconnect_timeout = timeout;
+   for (int i = 0; i < _num_players; i++) {
+      if (_endpoints[i].IsInitialized()) {
+         _endpoints[i].SetDisconnectTimeout(_disconnect_timeout);
+      }
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::SetDisconnectNotifyStart(int timeout)
+{
+   _disconnect_notify_start = timeout;
+   for (int i = 0; i < _num_players; i++) {
+      if (_endpoints[i].IsInitialized()) {
+         _endpoints[i].SetDisconnectNotifyStart(_disconnect_notify_start);
+      }
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::PlayerHandleToQueue(GGPOPlayerHandle player, int *queue)
+{
+   int offset = ((int)player - 1);
+   if (offset < 0 || offset >= _num_players) {
+      return GGPO_ERRORCODE_INVALID_PLAYER_HANDLE;
+   }
+   *queue = offset;
+   return GGPO_OK;
+}
+
+ 
+void
+Peer2PeerBackend::OnMsg(sockaddr_in &from, UdpMsg *msg, int len)
+{
+   for (int i = 0; i < _num_players; i++) {
+      if (_endpoints[i].HandlesMsg(from, msg)) {
+         _endpoints[i].OnMsg(msg, len);
+         return;
+      }
+   }
+   for (int i = 0; i < _num_spectators; i++) {
+      if (_spectators[i].HandlesMsg(from, msg)) {
+         _spectators[i].OnMsg(msg, len);
+         return;
+      }
+   }
+}
+
+void
+Peer2PeerBackend::CheckInitialSync()
+{
+   int i;
+
+   if (_synchronizing) {
+      // Check to see if everyone is now synchronized.  If so,
+      // go ahead and tell the client that we're ok to accept input.
+      for (i = 0; i < _num_players; i++) {
+         // xxx: IsInitialized() must go... we're actually using it as a proxy for "represents the local player"
+         if (_endpoints[i].IsInitialized() && !_endpoints[i].IsSynchronized() && !_local_connect_status[i].disconnected) {
+            return;
+         }
+      }
+      for (i = 0; i < _num_spectators; i++) {
+         if (_spectators[i].IsInitialized() && !_spectators[i].IsSynchronized()) {
+            return;
+         }
+      }
+
+      GGPOEvent info;
+      info.code = GGPO_EVENTCODE_RUNNING;
+      _callbacks.on_event(&info);
+      _synchronizing = false;
+   }
+}
+
+GGPOErrorCode Peer2PeerBackend::SendMessage(const void *msg, int len, bool spectators)
+{
+	if (_synchronizing)
+		return GGPO_ERRORCODE_NOT_SYNCHRONIZED;
+	if (len > MAX_APPDATA_SIZE)
+		return GGPO_ERRORCODE_INVALID_REQUEST;
+	for (int i = 0; i < _num_players; i++)
+        if (_endpoints[i].IsInitialized())
+           _endpoints[i].SendAppData(msg, len, spectators);
+	if (spectators)
+		for (int i = 0; i < _num_spectators; i++)
+	        if (_spectators[i].IsInitialized())
+	        	_spectators[i].SendAppData(msg, len, spectators);
+
+	return GGPO_ERRORCODE_SUCCESS;
+}

core/deps/ggpo/lib/ggpo/backends/p2p.h

@@ -0,0 +1,79 @@
+/* -----------------------------------------------------------------------
+ * 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 _P2P_H
+#define _P2P_H
+
+#include "ggpo_types.h"
+#include "ggpo_poll.h"
+#include "sync.h"
+#include "backend.h"
+#include "timesync.h"
+#include "network/udp_proto.h"
+
+class Peer2PeerBackend : public IQuarkBackend, IPollSink, Udp::Callbacks {
+public:
+   Peer2PeerBackend(GGPOSessionCallbacks *cb, const char *gamename, uint16 localport, int num_players, int input_size,
+		   const void *verification, int verification_size);
+   virtual ~Peer2PeerBackend();
+
+
+public:
+   GGPOErrorCode DoPoll(int timeout) override;
+   GGPOErrorCode AddPlayer(GGPOPlayer *player, GGPOPlayerHandle *handle) override;
+   GGPOErrorCode AddLocalInput(GGPOPlayerHandle player, void *values, int size) override;
+   GGPOErrorCode SyncInput(void *values, int size, int *disconnect_flags) override;
+   GGPOErrorCode IncrementFrame(void) override;
+   GGPOErrorCode DisconnectPlayer(GGPOPlayerHandle handle) override;
+   GGPOErrorCode GetNetworkStats(GGPONetworkStats *stats, GGPOPlayerHandle handle) override;
+   GGPOErrorCode SetFrameDelay(GGPOPlayerHandle player, int delay) override;
+   GGPOErrorCode SetDisconnectTimeout(int timeout) override;
+   GGPOErrorCode SetDisconnectNotifyStart(int timeout) override;
+   GGPOErrorCode SendMessage(const void *msg, int len, bool spectators) override;
+
+public:
+   void OnMsg(sockaddr_in &from, UdpMsg *msg, int len) override;
+
+protected:
+   GGPOErrorCode PlayerHandleToQueue(GGPOPlayerHandle player, int *queue);
+   GGPOPlayerHandle QueueToPlayerHandle(int queue) { return (GGPOPlayerHandle)(queue + 1); }
+   GGPOPlayerHandle QueueToSpectatorHandle(int queue) { return (GGPOPlayerHandle)(queue + 1000); } /* out of range of the player array, basically */
+   void DisconnectPlayerQueue(int queue, int syncto);
+   void PollSyncEvents(void);
+   void PollUdpProtocolEvents(void);
+   void CheckInitialSync(void);
+   int Poll2Players(int current_frame);
+   int PollNPlayers(int current_frame);
+   void AddRemotePlayer(char *remoteip, uint16 reportport, int queue);
+   GGPOErrorCode AddSpectator(char *remoteip, uint16 reportport);
+   virtual void OnSyncEvent(Sync::Event &e) { }
+   virtual void OnUdpProtocolEvent(UdpProtocol::Event &e, GGPOPlayerHandle handle);
+   virtual void OnUdpProtocolPeerEvent(UdpProtocol::Event &e, int queue);
+   virtual void OnUdpProtocolSpectatorEvent(UdpProtocol::Event &e, int queue);
+
+protected:
+   GGPOSessionCallbacks  _callbacks;
+   Poll                  _poll;
+   Sync                  _sync;
+   Udp                   _udp;
+   UdpProtocol           *_endpoints;
+   UdpProtocol           _spectators[GGPO_MAX_SPECTATORS];
+   int                   _num_spectators;
+   int                   _input_size;
+
+   bool                  _synchronizing;
+   int                   _num_players;
+   int                   _next_recommended_sleep;
+
+   int                   _next_spectator_frame;
+   int                   _disconnect_timeout;
+   int                   _disconnect_notify_start;
+
+   UdpMsg::connect_status _local_connect_status[UDP_MSG_MAX_PLAYERS];
+};
+
+#endif

core/deps/ggpo/lib/ggpo/backends/spectator.cpp

@@ -0,0 +1,189 @@
+/* -----------------------------------------------------------------------
+ * 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 "spectator.h"
+
+SpectatorBackend::SpectatorBackend(GGPOSessionCallbacks *cb,
+                                   const char* gamename,
+                                   uint16 localport,
+                                   int num_players,
+                                   int input_size,
+                                   char *hostip,
+                                   u_short hostport,
+								   const void *verification,
+								   int verification_size) :
+   _input_size(input_size),
+   _num_players(num_players),
+   _next_input_to_send(0)
+{
+   _callbacks = *cb;
+   _synchronizing = true;
+
+   for (size_t i = 0; i < ARRAY_SIZE(_inputs); i++) {
+      _inputs[i].frame = -1;
+   }
+
+   /*
+    * Initialize the UDP port
+    */
+   _udp.Init(localport, &_poll, this);
+
+   /*
+    * Init the host endpoint
+    */
+   _host.SetVerificationData(verification, verification_size);
+   _host.Init(&_udp, _poll, 0, hostip, hostport, NULL);
+   _host.Synchronize();
+
+   /*
+    * Preload the ROM
+    */
+   _callbacks.begin_game(gamename);
+}
+  
+SpectatorBackend::~SpectatorBackend()
+{
+}
+
+GGPOErrorCode
+SpectatorBackend::DoPoll(int timeout)
+{
+   _poll.Pump(0);
+
+   PollUdpProtocolEvents();
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SpectatorBackend::SyncInput(void *values,
+                            int size,
+                            int *disconnect_flags)
+{
+   // Wait until we've started to return inputs.
+   if (_synchronizing) {
+      return GGPO_ERRORCODE_NOT_SYNCHRONIZED;
+   }
+
+   GameInput &input = _inputs[_next_input_to_send % SPECTATOR_FRAME_BUFFER_SIZE];
+   if (input.frame < _next_input_to_send) {
+      // Haven't received the input from the host yet.  Wait
+      return GGPO_ERRORCODE_PREDICTION_THRESHOLD;
+   }
+   if (input.frame > _next_input_to_send) {
+      // The host is way way way far ahead of the spectator.  How'd this
+      // happen?  Anyway, the input we need is gone forever.
+      return GGPO_ERRORCODE_GENERAL_FAILURE;
+   }
+
+   ASSERT(size >= _input_size * _num_players);
+   memcpy(values, input.bits, _input_size * _num_players);
+   if (disconnect_flags) {
+      *disconnect_flags = 0; // xxx: should get them from the host!
+   }
+   _next_input_to_send++;
+
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SpectatorBackend::IncrementFrame(void)
+{  
+   Log("End of frame (%d)...", _next_input_to_send - 1);
+   DoPoll(0);
+   PollUdpProtocolEvents();
+
+   return GGPO_OK;
+}
+
+void
+SpectatorBackend::PollUdpProtocolEvents(void)
+{
+   UdpProtocol::Event evt;
+   while (_host.GetEvent(evt)) {
+      OnUdpProtocolEvent(evt);
+   }
+}
+
+void
+SpectatorBackend::OnUdpProtocolEvent(UdpProtocol::Event &evt)
+{
+   GGPOEvent info;
+
+   switch (evt.type) {
+   case UdpProtocol::Event::Connected:
+      info.code = GGPO_EVENTCODE_CONNECTED_TO_PEER;
+      info.u.connected.player = 0;
+      _callbacks.on_event(&info);
+      break;
+   case UdpProtocol::Event::Synchronizing:
+      info.code = GGPO_EVENTCODE_SYNCHRONIZING_WITH_PEER;
+      info.u.synchronizing.player = 0;
+      info.u.synchronizing.count = evt.u.synchronizing.count;
+      info.u.synchronizing.total = evt.u.synchronizing.total;
+      _callbacks.on_event(&info);
+      break;
+   case UdpProtocol::Event::Synchronzied:
+      if (_synchronizing) {
+         info.code = GGPO_EVENTCODE_SYNCHRONIZED_WITH_PEER;
+         info.u.synchronized.player = 0;
+         _callbacks.on_event(&info);
+
+         info.code = GGPO_EVENTCODE_RUNNING;
+         _callbacks.on_event(&info);
+         _synchronizing = false;
+      }
+      break;
+
+   case UdpProtocol::Event::NetworkInterrupted:
+      info.code = GGPO_EVENTCODE_CONNECTION_INTERRUPTED;
+      info.u.connection_interrupted.player = 0;
+      info.u.connection_interrupted.disconnect_timeout = evt.u.network_interrupted.disconnect_timeout;
+      _callbacks.on_event(&info);
+      break;
+
+   case UdpProtocol::Event::NetworkResumed:
+      info.code = GGPO_EVENTCODE_CONNECTION_RESUMED;
+      info.u.connection_resumed.player = 0;
+      _callbacks.on_event(&info);
+      break;
+
+   case UdpProtocol::Event::Disconnected:
+      info.code = GGPO_EVENTCODE_DISCONNECTED_FROM_PEER;
+      info.u.disconnected.player = 0;
+      _callbacks.on_event(&info);
+      break;
+
+   case UdpProtocol::Event::Input:
+   	  {
+   		  GameInput& input = evt.u.input.input;
+
+   		  _host.SetLocalFrameNumber(input.frame);
+   		  _host.SendInputAck();
+   		  _inputs[input.frame % SPECTATOR_FRAME_BUFFER_SIZE] = input;
+   	  }
+      break;
+
+   case UdpProtocol::Event::AppData:
+	  Log("calling on_message callback with %d bytes", evt.u.app_data.size);
+	  if (_callbacks.on_message != nullptr)
+		  _callbacks.on_message(evt.u.app_data.data, evt.u.app_data.size);
+	  break;
+
+
+   default:
+	  break;
+   }
+}
+ 
+void
+SpectatorBackend::OnMsg(sockaddr_in &from, UdpMsg *msg, int len)
+{
+   if (_host.HandlesMsg(from, msg)) {
+      _host.OnMsg(msg, len);
+   }
+}
+

core/deps/ggpo/lib/ggpo/backends/spectator.h

@@ -0,0 +1,60 @@
+/* -----------------------------------------------------------------------
+ * 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 _SPECTATOR_H
+#define _SPECTATOR_H
+
+#include "../ggpo_poll.h"
+#include "../ggpo_types.h"
+#include "sync.h"
+#include "backend.h"
+#include "timesync.h"
+#include "network/udp_proto.h"
+
+#define SPECTATOR_FRAME_BUFFER_SIZE    64
+
+class SpectatorBackend : public IQuarkBackend, IPollSink, Udp::Callbacks {
+public:
+   SpectatorBackend(GGPOSessionCallbacks *cb, const char *gamename, uint16 localport, int num_players, int input_size, char *hostip, u_short hostport,
+		   const void *verification, int verification_size);
+   virtual ~SpectatorBackend();
+
+
+public:
+   GGPOErrorCode DoPoll(int timeout) override;
+   GGPOErrorCode AddPlayer(GGPOPlayer *player, GGPOPlayerHandle *handle) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+   GGPOErrorCode AddLocalInput(GGPOPlayerHandle player, void *values, int size) override { return GGPO_OK; }
+   GGPOErrorCode SyncInput(void *values, int size, int *disconnect_flags) override;
+   GGPOErrorCode IncrementFrame(void) override;
+   GGPOErrorCode DisconnectPlayer(GGPOPlayerHandle handle) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+   GGPOErrorCode GetNetworkStats(GGPONetworkStats *stats, GGPOPlayerHandle handle) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+   GGPOErrorCode SetFrameDelay(GGPOPlayerHandle player, int delay) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+   GGPOErrorCode SetDisconnectTimeout(int timeout) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+   GGPOErrorCode SetDisconnectNotifyStart(int timeout) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+
+public:
+   void OnMsg(sockaddr_in &from, UdpMsg *msg, int len) override;
+
+protected:
+   void PollUdpProtocolEvents(void);
+   void CheckInitialSync(void);
+
+   void OnUdpProtocolEvent(UdpProtocol::Event &e);
+
+protected:
+   GGPOSessionCallbacks  _callbacks;
+   Poll                  _poll;
+   Udp                   _udp;
+   UdpProtocol           _host;
+   bool                  _synchronizing;
+   int                   _input_size;
+   int                   _num_players;
+   int                   _next_input_to_send;
+   GameInput             _inputs[SPECTATOR_FRAME_BUFFER_SIZE];
+};
+
+#endif

core/deps/ggpo/lib/ggpo/backends/synctest.cpp

@@ -0,0 +1,184 @@
+/* -----------------------------------------------------------------------
+ * 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 "synctest.h"
+
+SyncTestBackend::SyncTestBackend(GGPOSessionCallbacks *cb,
+                                 const char *gamename,
+                                 int frames,
+                                 int num_players) :
+   _sync(NULL)
+{
+   _callbacks = *cb;
+   _num_players = num_players;
+   _check_distance = frames;
+   _last_verified = 0;
+   _rollingback = false;
+   _running = false;
+   _logfp = NULL;
+   _current_input.erase();
+   strcpy(_game, gamename);
+
+   /*
+    * Initialize the synchronziation layer
+    */
+   Sync::Config config = { 0 };
+   config.callbacks = _callbacks;
+   config.num_prediction_frames = MAX_PREDICTION_FRAMES;
+   _sync.Init(config);
+
+   /*
+    * Preload the ROM
+    */
+   _callbacks.begin_game(gamename);
+}
+
+SyncTestBackend::~SyncTestBackend()
+{
+}
+
+GGPOErrorCode
+SyncTestBackend::DoPoll(int timeout)
+{
+   if (!_running) {
+      GGPOEvent info;
+
+      info.code = GGPO_EVENTCODE_RUNNING;
+      _callbacks.on_event(&info);
+      _running = true;
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SyncTestBackend::AddPlayer(GGPOPlayer *player, GGPOPlayerHandle *handle)
+{
+   if (player->player_num < 1 || player->player_num > _num_players) {
+      return GGPO_ERRORCODE_PLAYER_OUT_OF_RANGE;
+   }
+   *handle = (GGPOPlayerHandle)(player->player_num - 1);
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SyncTestBackend::AddLocalInput(GGPOPlayerHandle player, void *values, int size)
+{
+   if (!_running) {
+      return GGPO_ERRORCODE_NOT_SYNCHRONIZED;
+   }
+
+   int index = (int)player;
+   for (int i = 0; i < size; i++) {
+      _current_input.bits[(index * size) + i] |= ((char *)values)[i];
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SyncTestBackend::SyncInput(void *values,
+                           int size,
+                           int *disconnect_flags)
+{
+   if (_rollingback) {
+      _last_input = _saved_frames.front().input;
+   } else {
+      if (_sync.GetFrameCount() == 0 && _sync.GetLastSavedFrame().buf == nullptr) {
+         _sync.SaveCurrentFrame();
+      }
+      _last_input = _current_input;
+   }
+   memcpy(values, _last_input.bits, size);
+   if (disconnect_flags) {
+      *disconnect_flags = 0;
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SyncTestBackend::IncrementFrame(void)
+{  
+   _sync.IncrementFrame();
+   _current_input.erase();
+   
+   DEBUG_LOG(NETWORK, "End of frame(%d)...", _sync.GetFrameCount());
+
+   if (_rollingback) {
+      return GGPO_OK;
+   }
+
+   int frame = _sync.GetFrameCount();
+   // Hold onto the current frame in our queue of saved states.  We'll need
+   // the checksum later to verify that our replay of the same frame got the
+   // same results.
+   SavedInfo info;
+   info.frame = frame;
+   info.input = _last_input;
+   info.cbuf = _sync.GetLastSavedFrame().cbuf;
+   info.buf = (char *)malloc(info.cbuf);
+   memcpy(info.buf, _sync.GetLastSavedFrame().buf, info.cbuf);
+   info.checksum = _sync.GetLastSavedFrame().checksum;
+   _saved_frames.push(info);
+
+   if (frame - _last_verified == _check_distance) {
+      // We've gone far enough ahead and should now start replaying frames.
+      // Load the last verified frame and set the rollback flag to true.
+      _sync.LoadFrame(_last_verified);
+
+      _rollingback = true;
+      while(!_saved_frames.empty()) {
+         _callbacks.advance_frame(0);
+
+         // Verify that the checksumn of this frame is the same as the one in our
+         // list.
+         info = _saved_frames.front();
+         _saved_frames.pop();
+
+         if (info.frame != _sync.GetFrameCount()) {
+            RaiseSyncError("Frame number %d does not match saved frame number %d", info.frame, frame);
+         }
+         int checksum = _sync.GetLastSavedFrame().checksum;
+         if (info.checksum != checksum) {
+            LogSaveStates(info);
+            RaiseSyncError("Checksum for frame %d does not match saved (%d != %d)", frame, checksum, info.checksum);
+         }
+         else
+        	 printf("Checksum %08d for frame %d matches.\n", checksum, info.frame);
+         free(info.buf);
+      }
+      _last_verified = frame;
+      _rollingback = false;
+   }
+
+   return GGPO_OK;
+}
+
+void
+SyncTestBackend::RaiseSyncError(const char *fmt, ...)
+{
+   char buf[1024];
+   va_list args;
+   va_start(args, fmt);
+   vsnprintf(buf, ARRAY_SIZE(buf), fmt, args);
+   va_end(args);
+
+   puts(buf);
+#ifdef _WIN32
+   OutputDebugStringA(buf);
+#endif
+//   DebugBreak();
+}
+
+void
+SyncTestBackend::LogSaveStates(SavedInfo &info)
+{
+   char filename[MAX_PATH];
+   snprintf(filename, ARRAY_SIZE(filename), "synclogs/state-%04d-original.log", _sync.GetFrameCount());
+   _callbacks.log_game_state(filename, (unsigned char *)info.buf, info.cbuf);
+
+   snprintf(filename, ARRAY_SIZE(filename), "synclogs/state-%04d-replay.log", _sync.GetFrameCount());
+   _callbacks.log_game_state(filename, _sync.GetLastSavedFrame().buf, _sync.GetLastSavedFrame().cbuf);
+}

core/deps/ggpo/lib/ggpo/backends/synctest.h

@@ -0,0 +1,57 @@
+/* -----------------------------------------------------------------------
+ * 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 _SYNCTEST_H
+#define _SYNCTEST_H
+
+#include "ggpo_types.h"
+#include "backend.h"
+#include "sync.h"
+
+#include "ring_buffer.h"
+
+class SyncTestBackend : public IQuarkBackend {
+public:
+   SyncTestBackend(GGPOSessionCallbacks *cb, const char *gamename, int frames, int num_players);
+   virtual ~SyncTestBackend();
+
+   virtual GGPOErrorCode DoPoll(int timeout);
+   virtual GGPOErrorCode AddPlayer(GGPOPlayer *player, GGPOPlayerHandle *handle);
+   virtual GGPOErrorCode AddLocalInput(GGPOPlayerHandle player, void *values, int size);
+   virtual GGPOErrorCode SyncInput(void *values, int size, int *disconnect_flags);
+   virtual GGPOErrorCode IncrementFrame(void);
+
+protected:
+   struct SavedInfo {
+      int         frame;
+      int         checksum;
+      char        *buf;
+      int         cbuf;
+      GameInput   input;
+   };
+
+   void RaiseSyncError(const char *fmt, ...);
+   void LogSaveStates(SavedInfo &info);
+
+protected:
+   GGPOSessionCallbacks   _callbacks;
+   Sync                   _sync;
+   int                    _num_players;
+   int                    _check_distance;
+   int                    _last_verified;
+   bool                   _rollingback;
+   bool                   _running;
+   FILE                   *_logfp;
+   char                   _game[128];
+
+   GameInput                  _current_input;
+   GameInput                  _last_input;
+   RingBuffer<SavedInfo, 32>  _saved_frames;
+};
+
+#endif
+

core/deps/ggpo/lib/ggpo/bitvector.cpp

@@ -0,0 +1,55 @@
+/* -----------------------------------------------------------------------
+ * 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 "bitvector.h"
+
+void
+BitVector_SetBit(uint8 *vector, int *offset)
+{
+   vector[(*offset) / 8] |= (1 << ((*offset) % 8));
+   *offset += 1;
+}
+
+void
+BitVector_ClearBit(uint8 *vector, int *offset)
+{
+   vector[(*offset) / 8] &= ~(1 << ((*offset) % 8));
+   *offset += 1;
+}
+
+void
+BitVector_WriteNibblet(uint8 *vector, int nibble, int *offset)
+{
+   ASSERT(nibble < (1 << BITVECTOR_NIBBLE_SIZE));
+   for (int i = 0; i < BITVECTOR_NIBBLE_SIZE; i++) {
+      if (nibble & (1 << i)) {
+         BitVector_SetBit(vector, offset);
+      } else {
+         BitVector_ClearBit(vector, offset);
+      }
+   }
+}
+
+int
+BitVector_ReadBit(uint8 *vector, int *offset)
+{
+   int retval = !!(vector[(*offset) / 8] & (1 << ((*offset) % 8)));
+   *offset += 1;
+   return retval;
+}
+
+int
+BitVector_ReadNibblet(uint8 *vector, int *offset)
+{
+   int nibblet = 0;
+   for (int i = 0; i < BITVECTOR_NIBBLE_SIZE; i++) {
+      nibblet |= (BitVector_ReadBit(vector, offset) << i);
+   }
+   return nibblet;
+}
+

core/deps/ggpo/lib/ggpo/bitvector.h

@@ -0,0 +1,19 @@
+/* -----------------------------------------------------------------------
+ * 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 _BITVECTOR_H
+#define _BITVECTOR_H
+
+#define BITVECTOR_NIBBLE_SIZE 8
+
+void BitVector_SetBit(uint8 *vector, int *offset);
+void BitVector_ClearBit(uint8 *vector, int *offset);
+void BitVector_WriteNibblet(uint8 *vector, int nibble, int *offset);
+int BitVector_ReadBit(uint8 *vector, int *offset);
+int BitVector_ReadNibblet(uint8 *vector, int *offset);
+
+#endif // _BITVECTOR_H

core/deps/ggpo/lib/ggpo/game_input.cpp

@@ -0,0 +1,86 @@
+/* -----------------------------------------------------------------------
+ * 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 "game_input.h"
+
+#include "ggpo_types.h"
+
+void
+GameInput::init(int iframe, char *ibits, int isize, int offset)
+{
+   ASSERT(isize);
+   ASSERT(isize <= GAMEINPUT_MAX_BYTES);
+   frame = iframe;
+   size = isize;
+   memset(bits, 0, sizeof(bits));
+   if (ibits) {
+      memcpy(bits + (offset * isize), ibits, isize);
+   }
+}
+
+void
+GameInput::init(int iframe, char *ibits, int isize)
+{
+   ASSERT(isize);
+   ASSERT(isize <= GAMEINPUT_MAX_BYTES * GAMEINPUT_MAX_PLAYERS);
+   frame = iframe;
+   size = isize;
+   memset(bits, 0, sizeof(bits));
+   if (ibits) {
+      memcpy(bits, ibits, isize);
+   }
+}
+
+void
+GameInput::desc(char *buf, size_t buf_size, bool show_frame) const
+{
+   ASSERT(size);
+   size_t remaining = buf_size;
+   if (show_frame) {
+      remaining -= snprintf(buf, buf_size, "(frame:%d size:%d ", frame, size);
+   } else {
+      remaining -= snprintf(buf, buf_size, "(size:%d ", size);
+   }
+
+   for (int i = 0; i < size * 8; i++) {
+      char buf2[16];
+      if (value(i)) {
+         int c = snprintf(buf2, ARRAY_SIZE(buf2), "%2d ", i);
+         strncat(buf, buf2, ARRAY_SIZE(buf2));
+         remaining -= c;
+      }
+   }
+   strcat(buf, ")");
+}
+
+void
+GameInput::log(char *prefix, bool show_frame) const
+{
+	char buf[1024];
+	size_t c = strlen(prefix);
+	strcpy(buf, prefix);
+	desc(buf + c, ARRAY_SIZE(buf) - c, show_frame);
+	Log("%s", buf);
+}
+
+bool
+GameInput::equal(GameInput &other, bool bitsonly)
+{
+   if (!bitsonly && frame != other.frame) {
+      Log("frames don't match: %d, %d", frame, other.frame);
+   }
+   if (size != other.size) {
+      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 && match;
+}
+

core/deps/ggpo/lib/ggpo/game_input.h

@@ -0,0 +1,40 @@
+/* -----------------------------------------------------------------------
+ * 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 _GAMEINPUT_H
+#define _GAMEINPUT_H
+
+#include <stdio.h>
+#include <memory.h>
+
+// GAMEINPUT_MAX_BYTES * GAMEINPUT_MAX_PLAYERS * 8 must be less than
+// 2^BITVECTOR_NIBBLE_SIZE (see bitvector.h)
+
+#define GAMEINPUT_MAX_BYTES      9
+#define GAMEINPUT_MAX_PLAYERS    2
+
+struct GameInput {
+   enum Constants {
+      NullFrame = -1
+   };
+   int      frame;
+   int      size; /* size in bytes of the entire input for all players */
+   char     bits[GAMEINPUT_MAX_BYTES * GAMEINPUT_MAX_PLAYERS];
+
+   bool is_null() { return frame == NullFrame; }
+   void init(int frame, char *bits, int size, int offset);
+   void init(int frame, char *bits, int size);
+   bool value(int i) const { return (bits[i/8] & (1 << (i%8))) != 0; }
+   void set(int i) { bits[i/8] |= (1 << (i%8)); }
+   void clear(int i) { bits[i/8] &= ~(1 << (i%8)); }
+   void erase() { memset(bits, 0, sizeof(bits)); }
+   void desc(char *buf, size_t buf_size, bool show_frame = true) const;
+   void log(char *prefix, bool show_frame = true) const;
+   bool equal(GameInput &input, bool bitsonly = false);
+};
+
+#endif

core/deps/ggpo/lib/ggpo/ggpo_poll.h

@@ -0,0 +1,66 @@
+/* -----------------------------------------------------------------------
+ * 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 _POLL_H
+#define _POLL_H
+
+#include "static_buffer.h"
+
+#define MAX_POLLABLE_HANDLES     64
+
+
+class IPollSink {
+public:
+   virtual ~IPollSink() { }
+   virtual bool OnHandlePoll(void *) { return true; }
+   virtual bool OnMsgPoll(void *) { return true; }
+   virtual bool OnPeriodicPoll(void *, int ) { return true; }
+   virtual bool OnLoopPoll(void *) { return true; }
+};
+
+class Poll {
+public:
+   Poll(void);
+//   void RegisterHandle(IPollSink *sink, HANDLE h, void *cookie = NULL);
+   void RegisterMsgLoop(IPollSink *sink, void *cookie = NULL);
+   void RegisterPeriodic(IPollSink *sink, int interval, void *cookie = NULL);
+   void RegisterLoop(IPollSink *sink, void *cookie = NULL);
+
+   void Run();
+   bool Pump(int timeout);
+
+protected:
+   int ComputeWaitTime(int elapsed);
+
+   struct PollSinkCb {
+      IPollSink   *sink;
+      void        *cookie;
+      PollSinkCb() : sink(NULL), cookie(NULL) { }
+      PollSinkCb(IPollSink *s, void *c) : sink(s), cookie(c) { }
+   };
+
+   struct PollPeriodicSinkCb : public PollSinkCb {
+      int         interval;
+      int         last_fired;
+      PollPeriodicSinkCb() : PollSinkCb(NULL, NULL), interval(0), last_fired(0) { }
+      PollPeriodicSinkCb(IPollSink *s, void *c, int i) :
+         PollSinkCb(s, c), interval(i), last_fired(0) { }
+   };
+
+   int               _start_time;
+   int               _handle_count;
+#ifdef _WIN32
+   HANDLE            _handles[MAX_POLLABLE_HANDLES];
+#endif
+   PollSinkCb        _handle_sinks[MAX_POLLABLE_HANDLES];
+
+   StaticBuffer<PollSinkCb, 16>          _msg_sinks;
+   StaticBuffer<PollSinkCb, 16>          _loop_sinks;
+   StaticBuffer<PollPeriodicSinkCb, 16>  _periodic_sinks;
+};
+
+#endif

core/deps/ggpo/lib/ggpo/ggpo_types.h

@@ -0,0 +1,96 @@
+/* -----------------------------------------------------------------------
+ * 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 _TYPES_H
+#define _TYPES_H
+/*
+ * Keep the compiler happy
+ */
+
+#ifdef _MSC_VER
+/*
+ * Disable specific compiler warnings
+ *   4018 - '<' : signed/unsigned mismatch
+ *   4100 - 'xxx' : unreferenced formal parameter
+ *   4127 - conditional expression is constant
+ *   4201 - nonstandard extension used : nameless struct/union
+ *   4389 - '!=' : signed/unsigned mismatch
+ *   4800 - 'int' : forcing value to bool 'true' or 'false' (performance warning)
+ */
+#pragma warning(disable: 4018 4100 4127 4201 4389 4800)
+#endif
+
+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#define TARGET_UWP
+#endif
+
+/*
+ * Simple types
+ */
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint32;
+typedef unsigned char byte;
+typedef char int8;
+typedef short int16;
+typedef int int32;
+
+#include "ggponet.h"
+#include "log/Log.h"
+#include <stdexcept>
+
+class GGPOException : public std::runtime_error {
+public:
+	GGPOException(const char *what, GGPOErrorCode ggpoError)
+		: std::runtime_error(what), ggpoError(ggpoError) {}
+
+	GGPOErrorCode ggpoError;
+};
+
+/*
+ * Additional headers
+ */
+#if defined(_WIN32)
+#  include "platform_windows.h"
+#elif defined(__unix__) || defined(__APPLE__) || defined(__SWITCH__)
+#  include "platform_linux.h"
+#else
+#  error Unsupported platform
+#endif
+
+/*
+ * Macros
+ */
+#define ASSERT(x)                                           \
+   do {                                                     \
+      if (!(x)) {                                           \
+         char assert_buf[1024];                             \
+         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
+
+#ifndef MAX_INT
+#  define MAX_INT          0xEFFFFFF
+#endif
+
+#ifndef MAX
+#  define MAX(x, y)        (((x) > (y)) ? (x) : (y))
+#endif
+
+#ifndef MIN
+#  define MIN(x, y)        (((x) < (y)) ? (x) : (y))
+#endif
+
+#endif // _TYPES_H

core/deps/ggpo/lib/ggpo/input_queue.cpp

@@ -0,0 +1,305 @@
+/* -----------------------------------------------------------------------
+ * 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 "input_queue.h"
+#include "ggpo_types.h"
+
+#define PREVIOUS_FRAME(offset)   (((offset) == 0) ? (INPUT_QUEUE_LENGTH - 1) : ((offset) - 1))
+
+InputQueue::InputQueue(int input_size)
+{
+   Init(-1, input_size);
+}
+
+InputQueue::~InputQueue()
+{
+}
+
+void
+InputQueue::Init(int id, int input_size)
+{
+   _id = id;
+   _head = 0;
+   _tail = 0;
+   _length = 0;
+   _frame_delay = 0;
+   _first_frame = true;
+   _last_user_added_frame = GameInput::NullFrame;
+   _first_incorrect_frame = GameInput::NullFrame;
+   _last_frame_requested = GameInput::NullFrame;
+   _last_added_frame = GameInput::NullFrame;
+
+   _prediction.init(GameInput::NullFrame, NULL, input_size);
+
+   /*
+    * This is safe because we know the GameInput is a proper structure (as in,
+    * no virtual methods, no contained classes, etc.).
+    */
+   memset(_inputs, 0, sizeof _inputs);
+   for (size_t i = 0; i < ARRAY_SIZE(_inputs); i++) {
+      _inputs[i].size = input_size;
+   }
+}
+
+int
+InputQueue::GetLastConfirmedFrame()
+{
+   Log("input q%d | returning last confirmed frame %d.", _id, _last_added_frame);
+   return _last_added_frame;
+}
+
+int
+InputQueue::GetFirstIncorrectFrame()
+{
+   return _first_incorrect_frame;
+}
+
+void
+InputQueue::DiscardConfirmedFrames(int frame)
+{
+   ASSERT(frame >= 0);
+
+   if (_last_frame_requested != GameInput::NullFrame) {
+      frame = MIN(frame, _last_frame_requested);
+   }
+
+   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("input q%d | difference of %d frames.", _id, offset);
+      ASSERT(offset >= 0);
+
+      _tail = (_tail + offset) % INPUT_QUEUE_LENGTH;
+      _length -= offset;
+   }
+
+   Log("input q%d | after discarding, new tail is %d (frame:%d).", _id, _tail, _inputs[_tail].frame);
+   ASSERT(_length >= 0);
+}
+
+void
+InputQueue::ResetPrediction(int frame)
+{
+   ASSERT(_first_incorrect_frame == GameInput::NullFrame || frame <= _first_incorrect_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
+    * state and the incorrect frame counter...
+    */
+   _prediction.frame = GameInput::NullFrame;
+   _first_incorrect_frame = GameInput::NullFrame;
+   _last_frame_requested = GameInput::NullFrame;
+}
+
+bool
+InputQueue::GetConfirmedInput(int requested_frame, GameInput *input)
+{
+   ASSERT(_first_incorrect_frame == GameInput::NullFrame || requested_frame < _first_incorrect_frame);
+   int offset = requested_frame % INPUT_QUEUE_LENGTH; 
+   if (_inputs[offset].frame != requested_frame) {
+      return false;
+   }
+   *input = _inputs[offset];
+   return true;
+}
+
+bool
+InputQueue::GetInput(int requested_frame, GameInput *input)
+{
+   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
+    * error.  Doing so means that we're just going further down the wrong
+    * path.  ASSERT this to verify that it's true.
+    */
+   ASSERT(_first_incorrect_frame == GameInput::NullFrame);
+
+   /*
+    * Remember the last requested frame number for later.  We'll need
+    * this in AddInput() to drop out of prediction mode.
+    */
+   _last_frame_requested = requested_frame;
+
+   ASSERT(requested_frame >= _inputs[_tail].frame);
+
+   if (_prediction.frame == GameInput::NullFrame) {
+      /*
+       * If the frame requested is in our range, fetch it out of the queue and
+       * return it.
+       */
+      int offset = requested_frame - _inputs[_tail].frame;
+
+      if (offset < _length) {
+         offset = (offset + _tail) % INPUT_QUEUE_LENGTH;
+         ASSERT(_inputs[offset].frame == requested_frame);
+         *input = _inputs[offset];
+         Log("input q%d | returning confirmed frame number %d.", _id, input->frame);
+         return true;
+      }
+
+      /*
+       * The requested frame isn't in the queue.  Bummer.  This means we need
+       * to return a prediction frame.  Predict that the user will do the
+       * same thing they did last time.
+       */
+      if (requested_frame == 0) {
+         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("input q%d | basing new prediction frame from nothing, since we have no frames yet.", _id);
+         _prediction.erase();
+      } else {
+         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)];
+      }
+      _prediction.frame++;
+   }
+
+   ASSERT(_prediction.frame >= 0);
+
+   /*
+    * If we've made it this far, we must be predicting.  Go ahead and
+    * forward the prediction frame contents.  Be sure to return the
+    * frame number requested by the client, though.
+    */
+   *input = _prediction;
+   input->frame = requested_frame;
+   Log("input q%d | returning prediction frame number %d (%d).", _id, input->frame, _prediction.frame);
+
+   return false;
+}
+
+void
+InputQueue::AddInput(GameInput &input)
+{
+   int new_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 
+    * sequentially by the user, regardless of frame delay.
+    */
+   ASSERT(_last_user_added_frame == GameInput::NullFrame ||
+          input.frame == _last_user_added_frame + 1);
+   _last_user_added_frame = input.frame;
+
+   /*
+    * Move the queue head to the correct point in preparation to
+    * input the frame into the queue.
+    */
+   new_frame = AdvanceQueueHead(input.frame);
+   if (new_frame != GameInput::NullFrame) {
+      AddDelayedInputToQueue(input, new_frame);
+   }
+   
+   /*
+    * Update the frame number for the input.  This will also set the
+    * frame to GameInput::NullFrame for frames that get dropped (by
+    * design).
+    */
+   input.frame = new_frame;
+}
+
+void
+InputQueue::AddDelayedInputToQueue(GameInput &input, int 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);
+
+   ASSERT(_last_added_frame == GameInput::NullFrame || frame_number == _last_added_frame + 1);
+
+   ASSERT(frame_number == 0 || _inputs[PREVIOUS_FRAME(_head)].frame == frame_number - 1);
+
+   /*
+    * Add the frame to the back of the queue
+    */ 
+   _inputs[_head] = input;
+   _inputs[_head].frame = frame_number;
+   _head = (_head + 1) % INPUT_QUEUE_LENGTH;
+   _length++;
+   _first_frame = false;
+
+   _last_added_frame = frame_number;
+
+   if (_prediction.frame != GameInput::NullFrame) {
+      ASSERT(frame_number == _prediction.frame);
+
+      /*
+       * We've been predicting...  See if the inputs we've gotten match
+       * what we've been predicting.  If so, don't worry about it.  If not,
+       * remember the first input which was incorrect so we can report it
+       * in GetFirstIncorrectFrame()
+       */
+      if (_first_incorrect_frame == GameInput::NullFrame && !_prediction.equal(input, true)) {
+         Log("input q%d | frame %d does not match prediction.  marking error.", _id, frame_number);
+         _first_incorrect_frame = frame_number;
+      }
+
+      /*
+       * If this input is the same frame as the last one requested and we
+       * still haven't found any mis-predicted inputs, we can dump out
+       * of predition mode entirely!  Otherwise, advance the prediction frame
+       * count up.
+       */
+      if (_prediction.frame == _last_frame_requested && _first_incorrect_frame == GameInput::NullFrame) {
+         Log("input q%d | prediction is correct!  dumping out of prediction mode.", _id);
+         _prediction.frame = GameInput::NullFrame;
+      } else {
+         _prediction.frame++;
+      }
+   }
+   ASSERT(_length <= INPUT_QUEUE_LENGTH);
+}
+
+int
+InputQueue::AdvanceQueueHead(int 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;
+
+   frame += _frame_delay;
+
+   if (expected_frame > frame) {
+      /*
+       * This can occur when the frame delay has dropped since the last
+       * time we shoved a frame into the system.  In this case, there's
+       * no room on the queue.  Toss it.
+       */
+      Log("input q%d | Dropping input frame %d (expected next frame to be %d).", _id,
+          frame, expected_frame);
+      return GameInput::NullFrame;
+   }
+
+   while (expected_frame < frame) {
+      /*
+       * This can occur when the frame delay has been increased since the last
+       * time we shoved a frame into the system.  We need to replicate the
+       * last frame in the queue several times in order to fill the space
+       * left.
+       */
+      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);
+      expected_frame++;
+   }
+
+   ASSERT(frame == 0 || frame == _inputs[PREVIOUS_FRAME(_head)].frame + 1);
+   return frame;
+}

core/deps/ggpo/lib/ggpo/input_queue.h

@@ -0,0 +1,59 @@
+/* -----------------------------------------------------------------------
+ * 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 _INPUT_QUEUE_H
+#define _INPUT_QUEUE_H
+
+#include "game_input.h"
+
+#define INPUT_QUEUE_LENGTH    128
+#define DEFAULT_INPUT_SIZE      4
+
+class InputQueue {
+public:
+   InputQueue(int input_size = DEFAULT_INPUT_SIZE);
+   ~InputQueue();
+
+public:
+   void Init(int id, int input_size);
+   int GetLastConfirmedFrame();
+   int GetFirstIncorrectFrame();
+   int GetLength() { return _length; }
+
+   void SetFrameDelay(int delay) { _frame_delay = delay; }
+   void ResetPrediction(int frame);
+   void DiscardConfirmedFrames(int frame);
+   bool GetConfirmedInput(int frame, GameInput *input);
+   bool GetInput(int frame, GameInput *input);
+   void AddInput(GameInput &input);
+
+protected:
+   int AdvanceQueueHead(int frame);
+   void AddDelayedInputToQueue(GameInput &input, int i);
+
+protected:
+   int                  _id;
+   int                  _head;
+   int                  _tail;
+   int                  _length;
+   bool                 _first_frame;
+
+   int                  _last_user_added_frame;
+   int                  _last_added_frame;
+   int                  _first_incorrect_frame;
+   int                  _last_frame_requested;
+
+   int                  _frame_delay;
+
+   GameInput            _inputs[INPUT_QUEUE_LENGTH];
+   GameInput            _prediction;
+};
+
+#endif
+
+
+

core/deps/ggpo/lib/ggpo/main.cpp

@@ -0,0 +1,260 @@
+/* -----------------------------------------------------------------------
+ * 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 "backends/p2p.h"
+#include "backends/synctest.h"
+#include "backends/spectator.h"
+#include "ggpo_types.h"
+#include "ggponet.h"
+
+struct Init
+{
+	Init() {
+		srand(GGPOPlatform::GetCurrentTimeMS() + GGPOPlatform::GetProcessID());
+#ifdef _WIN32
+		WSADATA wsaData;
+		WSAStartup(MAKEWORD(2, 0), &wsaData);
+#endif
+	}
+};
+static Init init;
+
+GGPOErrorCode
+ggpo_start_session(GGPOSession **session,
+                   GGPOSessionCallbacks *cb,
+                   const char *game,
+                   int num_players,
+                   int input_size,
+                   unsigned short localport,
+				   const void *verification,
+				   int verification_size)
+{
+	try {
+	   *session= (GGPOSession *)new Peer2PeerBackend(cb,
+													 game,
+													 localport,
+													 num_players,
+													 input_size,
+													 verification,
+													 verification_size);
+	   return GGPO_OK;
+	} catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_start_session: %s", e.what());
+	   return e.ggpoError;
+	}
+}
+
+GGPOErrorCode
+ggpo_add_player(GGPOSession *ggpo,
+                GGPOPlayer *player,
+                GGPOPlayerHandle *handle)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->AddPlayer(player, handle);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_add_player: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+
+
+GGPOErrorCode
+ggpo_start_synctest(GGPOSession **ggpo,
+                    GGPOSessionCallbacks *cb,
+                    const char *game,
+                    int num_players,
+                    int input_size,
+                    int frames)
+{
+	try {
+	   *ggpo = (GGPOSession *)new SyncTestBackend(cb, game, frames, num_players);
+	   return GGPO_OK;
+	} catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_start_synctest: %s", e.what());
+	   return e.ggpoError;
+	}
+}
+
+GGPOErrorCode
+ggpo_set_frame_delay(GGPOSession *ggpo,
+                     GGPOPlayerHandle player,
+                     int frame_delay)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->SetFrameDelay(player, frame_delay);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_set_frame_delay: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_idle(GGPOSession *ggpo, int timeout)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->DoPoll(timeout);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_idle: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_add_local_input(GGPOSession *ggpo,
+                     GGPOPlayerHandle player,
+                     void *values,
+                     int size)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+      return ggpo->AddLocalInput(player, values, size);
+   } catch (const GGPOException& e) {
+	  ERROR_LOG(NETWORK, "GGPOException in ggpo_add_local_input: %s", e.what());
+      return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_synchronize_input(GGPOSession *ggpo,
+                       void *values,
+                       int size,
+                       int *disconnect_flags)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+      return ggpo->SyncInput(values, size, disconnect_flags);
+   } catch (const GGPOException& e) {
+	  ERROR_LOG(NETWORK, "GGPOException in ggpo_synchronize_input: %s", e.what());
+      return e.ggpoError;
+   }
+}
+
+GGPOErrorCode ggpo_disconnect_player(GGPOSession *ggpo,
+                                     GGPOPlayerHandle player)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->DisconnectPlayer(player);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_disconnect_player: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_advance_frame(GGPOSession *ggpo)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->IncrementFrame();
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_advance_frame: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_get_network_stats(GGPOSession *ggpo,
+                       GGPOPlayerHandle player,
+                       GGPONetworkStats *stats)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->GetNetworkStats(stats, player);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_get_network_stats: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+
+GGPOErrorCode
+ggpo_close_session(GGPOSession *ggpo)
+{
+   if (!ggpo) {
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   }
+   delete ggpo;
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+ggpo_set_disconnect_timeout(GGPOSession *ggpo, int timeout)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->SetDisconnectTimeout(timeout);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_set_disconnect_timeout: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_set_disconnect_notify_start(GGPOSession *ggpo, int timeout)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->SetDisconnectNotifyStart(timeout);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_set_disconnect_notify_start: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode ggpo_start_spectating(GGPOSession **session,
+                                    GGPOSessionCallbacks *cb,
+                                    const char *game,
+                                    int num_players,
+                                    int input_size,
+                                    unsigned short local_port,
+                                    char *host_ip,
+                                    unsigned short host_port,
+									const void *verification,
+									int verification_size)
+{
+	try {
+	   *session= (GGPOSession *)new SpectatorBackend(cb,
+													 game,
+													 local_port,
+													 num_players,
+													 input_size,
+													 host_ip,
+													 host_port,
+													 verification,
+													 verification_size);
+	   return GGPO_OK;
+	} catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_start_spectating: %s", e.what());
+	   return e.ggpoError;
+	}
+}
+
+GGPOErrorCode ggpo_send_message(GGPOSession *ggpo,
+                                const void *msg,
+                                int len,
+								bool spectators)
+{
+	if (ggpo == nullptr)
+		return GGPO_ERRORCODE_INVALID_SESSION;
+	return ggpo->SendMessage(msg, len, spectators);
+}
+

core/deps/ggpo/lib/ggpo/network/udp.cpp

@@ -0,0 +1,113 @@
+/* -----------------------------------------------------------------------
+ * 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 "udp.h"
+
+SOCKET
+CreateSocket(uint16 bind_port, int retries)
+{
+   SOCKET s;
+   sockaddr_in sin;
+   uint16 port;
+   int optval = 1;
+
+   s = socket(AF_INET, SOCK_DGRAM, 0);
+   setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char *)&optval, sizeof optval);
+   optval = 0;
+   setsockopt(s, SOL_SOCKET, SO_LINGER, (const char *)&optval, sizeof optval);
+
+   // non-blocking...
+#ifndef _WIN32
+	fcntl(s, F_SETFL, O_NONBLOCK);
+#else
+	u_long iMode = 1;
+	ioctlsocket(s, FIONBIO, &iMode);
+#endif
+
+   sin.sin_family = AF_INET;
+   sin.sin_addr.s_addr = htonl(INADDR_ANY);
+   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.", port);
+         return s;
+      }
+   }
+   closesocket(s);
+   return INVALID_SOCKET;
+}
+
+Udp::Udp() :
+   _socket(INVALID_SOCKET),
+   _callbacks(NULL)
+{
+}
+
+Udp::~Udp(void)
+{
+   if (_socket != INVALID_SOCKET) {
+      closesocket(_socket);
+      _socket = INVALID_SOCKET;
+   }
+}
+
+void
+Udp::Init(uint16 port, Poll *poll, Callbacks *callbacks)
+{
+   _callbacks = callbacks;
+   poll->RegisterLoop(this);
+
+   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);
+}
+
+void
+Udp::SendTo(char *buffer, int len, int flags, struct sockaddr *dst, int destlen)
+{
+   struct sockaddr_in *to = (struct sockaddr_in *)dst;
+
+   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).", res, err);
+      ASSERT(false && "Unknown error in sendto");
+   }
+   char dst_ip[1024];
+   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
+Udp::OnLoopPoll(void *cookie)
+{
+   uint8          recv_buf[MAX_UDP_PACKET_SIZE];
+   sockaddr_in    recv_addr;
+   socklen_t      recv_addr_len;
+
+   for (;;) {
+      recv_addr_len = sizeof(recv_addr);
+      int len = recvfrom(_socket, (char *)recv_buf, MAX_UDP_PACKET_SIZE, 0, (struct sockaddr *)&recv_addr, &recv_addr_len);
+
+      // TODO: handle len == 0... indicates a disconnect.
+
+      if (len == -1) {
+         int error = WSAGetLastError();
+         if (error != WSAEWOULDBLOCK) {
+            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).", 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;
+}

core/deps/ggpo/lib/ggpo/network/udp.h

@@ -0,0 +1,53 @@
+/* -----------------------------------------------------------------------
+ * 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 _UDP_H
+#define _UDP_H
+
+#include "ggpo_poll.h"
+#include "udp_msg.h"
+#include "ggponet.h"
+#include "ring_buffer.h"
+
+#define MAX_UDP_ENDPOINTS     16
+
+constexpr size_t MAX_UDP_PACKET_SIZE = sizeof(UdpMsg);
+
+class Udp : public IPollSink
+{
+public:
+   struct Stats {
+      int      bytes_sent;
+      int      packets_sent;
+      float    kbps_sent;
+   };
+
+   struct Callbacks {
+      virtual ~Callbacks() { }
+      virtual void OnMsg(sockaddr_in &from, UdpMsg *msg, int len) = 0;
+   };
+
+   Udp();
+
+   void Init(uint16 port, Poll *p, Callbacks *callbacks);
+   
+   void SendTo(char *buffer, int len, int flags, struct sockaddr *dst, int destlen);
+
+   virtual bool OnLoopPoll(void *cookie);
+
+public:
+   ~Udp(void);
+
+protected:
+   // Network transmission information
+   SOCKET         _socket;
+
+   // state management
+   Callbacks      *_callbacks;
+};
+
+#endif

core/deps/ggpo/lib/ggpo/network/udp_msg.h

@@ -0,0 +1,121 @@
+/* -----------------------------------------------------------------------
+ * 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 _UDP_MSG_H
+#define _UDP_MSG_H
+
+#define MAX_COMPRESSED_BITS       4096
+#define UDP_MSG_MAX_PLAYERS          4
+#define MAX_VERIFICATION_SIZE      256
+#define MAX_APPDATA_SIZE           512
+
+#pragma pack(push, 1)
+
+struct UdpMsg
+{
+   enum MsgType {
+      Invalid       = 0,
+      SyncRequest   = 1,
+      SyncReply     = 2,
+      Input         = 3,
+      QualityReport = 4,
+      QualityReply  = 5,
+      KeepAlive     = 6,
+      InputAck      = 7,
+	  AppData       = 8
+   };
+
+   struct connect_status {
+      unsigned int   disconnected:1;
+      int            last_frame:31;
+   };
+
+   struct {
+      uint16         magic;
+      uint16         sequence_number;
+      uint8          type;            /* packet type */
+   } hdr;
+   union {
+      struct {
+         uint32      random_request;  /* please reply back with this random data */
+         uint16      remote_magic;
+         uint8       remote_endpoint;
+         uint8       verification[MAX_VERIFICATION_SIZE];
+      } sync_request;
+      
+      struct {
+         uint32      random_reply;    /* OK, here's your random data back */
+         uint8       verification_failure; /* set to one by peer if verification failed */
+      } sync_reply;
+      
+      struct {
+         int8        frame_advantage; /* what's the other guy's frame advantage? */
+         uint32      ping;
+      } quality_report;
+      
+      struct {
+         uint32      pong;
+      } quality_reply;
+
+      struct {
+         connect_status    peer_connect_status[UDP_MSG_MAX_PLAYERS];
+
+         uint32            start_frame;
+
+         int               disconnect_requested:1;
+         int               ack_frame:31;
+
+         uint16            num_bits;
+         uint8             input_size; // XXX: shouldn't be in every single packet!
+         uint8             bits[MAX_COMPRESSED_BITS / 8]; /* must be last */
+      } input;
+
+      struct {
+         int               ack_frame:31;
+      } input_ack;
+
+      struct {
+    	  uint16 size;
+    	  uint8 spectators;
+    	  uint8 data[MAX_APPDATA_SIZE];
+      } app_data;
+
+   } u;
+
+   int verification_size = 0;
+
+public:
+   int PacketSize() {
+      return sizeof(hdr) + PayloadSize();
+   }
+
+   int PayloadSize() {
+      switch (hdr.type) {
+      case SyncRequest:   return (int)(&u.sync_request.verification[0] - (uint8 *)&u) + verification_size;
+      case SyncReply:     return sizeof(u.sync_reply);
+      case QualityReport: return sizeof(u.quality_report);
+      case QualityReply:  return sizeof(u.quality_reply);
+      case InputAck:      return sizeof(u.input_ack);
+      case KeepAlive:     return 0;
+      case Input:
+		  {
+			 int size = (int)((char *)&u.input.bits - (char *)&u.input);
+			 size += (u.input.num_bits + 7) / 8;
+			 return size;
+		  }
+      case AppData:       return sizeof(u.app_data) - sizeof(u.app_data.data) + u.app_data.size;
+      }
+      ASSERT(false);
+      return 0;
+   }
+
+   UdpMsg(MsgType t) { hdr.type = (uint8)t; }
+};
+
+#pragma pack(pop)
+
+#endif   

core/deps/ggpo/lib/ggpo/network/udp_proto.cpp

@@ -0,0 +1,815 @@
+/* -----------------------------------------------------------------------
+ * 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 "udp_proto.h"
+
+#include "../ggpo_types.h"
+#include "bitvector.h"
+
+static const int UDP_HEADER_SIZE = 28;     /* Size of IP + UDP headers */
+static const int NUM_SYNC_PACKETS = 5;
+static const int SYNC_RETRY_INTERVAL = 2000;
+static const int SYNC_FIRST_RETRY_INTERVAL = 500;
+static const int RUNNING_RETRY_INTERVAL = 200;
+static const int KEEP_ALIVE_INTERVAL    = 200;
+static const int QUALITY_REPORT_INTERVAL = 1000;
+static const int NETWORK_STATS_INTERVAL  = 1000;
+static const int UDP_SHUTDOWN_TIMER = 5000;
+static const int MAX_SEQ_DISTANCE = (1 << 15);
+
+UdpProtocol::UdpProtocol() :
+   _udp(NULL),
+   _magic_number(0),
+   _queue(-1),
+   _remote_magic_number(0),
+   _connected(false),
+   _packets_sent(0),
+   _bytes_sent(0),
+   _stats_start_time(0),
+   _local_frame_advantage(0),
+   _remote_frame_advantage(0),
+   _last_send_time(0),
+   _shutdown_timeout(0),
+   _disconnect_event_sent(false),
+   _disconnect_timeout(0),
+   _disconnect_notify_start(0),
+   _disconnect_notify_sent(false),
+   _next_send_seq(0),
+   _next_recv_seq(0)
+{
+   _last_sent_input.init(-1, NULL, 1);
+   _last_received_input.init(-1, NULL, 1);
+   _last_acked_input.init(-1, NULL, 1);
+
+   memset(&_state, 0, sizeof _state);
+   memset(_peer_connect_status, 0, sizeof(_peer_connect_status));
+   for (unsigned i = 0; i < ARRAY_SIZE(_peer_connect_status); i++) {
+      _peer_connect_status[i].last_frame = -1;
+   }
+   memset(&_peer_addr, 0, sizeof _peer_addr);
+   _oo_packet.msg = NULL;
+
+   _send_latency = GGPOPlatform::GetConfigInt("GGPO_NETWORK_DELAY");
+   _oop_percent = GGPOPlatform::GetConfigInt("GGPO_OOP_PERCENT");
+}
+
+UdpProtocol::~UdpProtocol()
+{
+   ClearSendQueue();
+}
+
+void
+UdpProtocol::Init(Udp *udp,
+                  Poll &poll,
+                  int queue,
+                  char *ip,
+                  u_short port,
+                  UdpMsg::connect_status *status)
+{  
+   _udp = udp;
+   _queue = queue;
+   _local_connect_status = status;
+
+   _peer_addr.sin_family = AF_INET;
+   if (ip != nullptr && ip[0] != '\0')
+   {
+	   _peer_addr.sin_port = htons(port);
+	   inet_pton(AF_INET, ip, &_peer_addr.sin_addr.s_addr);
+   }
+
+   do {
+      _magic_number = (uint16)rand();
+   } while (_magic_number == 0);
+   poll.RegisterLoop(this);
+}
+
+void
+UdpProtocol::SendInput(GameInput &input)
+{
+   if (_udp) {
+      if (_current_state == Running) {
+         /*
+          * Check to see if this is a good time to adjust for the rift...
+          */
+         _timesync.advance_frame(input, _local_frame_advantage, _remote_frame_advantage);
+
+         /*
+          * Save this input packet
+          *
+          * XXX: This queue may fill up for spectators who do not ack input packets in a timely
+          * manner.  When this happens, we can either resize the queue (ug) or disconnect them
+          * (better, but still ug).  For the meantime, make this queue really big to decrease
+          * the odds of this happening...
+          */
+         _pending_output.push(input);
+      }
+      SendPendingOutput();
+   }  
+}
+
+void
+UdpProtocol::SendPendingOutput()
+{
+   UdpMsg *msg = new UdpMsg(UdpMsg::Input);
+   int i, j, offset = 0;
+   uint8 *bits;
+   GameInput last;
+
+   if (_pending_output.size()) {
+      last = _last_acked_input;
+      bits = msg->u.input.bits;
+
+      msg->u.input.start_frame = _pending_output.front().frame;
+      msg->u.input.input_size = (uint8)_pending_output.front().size;
+
+      ASSERT(last.frame == -1 || last.frame + 1 == (int)msg->u.input.start_frame);
+      for (j = 0; j < _pending_output.size(); j++) {
+         GameInput &current = _pending_output.item(j);
+         if (memcmp(current.bits, last.bits, current.size) != 0) {
+            ASSERT((GAMEINPUT_MAX_BYTES * GAMEINPUT_MAX_PLAYERS * 8) < (1 << BITVECTOR_NIBBLE_SIZE));
+            for (i = 0; i < current.size * 8; i++) {
+               ASSERT(i < (1 << BITVECTOR_NIBBLE_SIZE));
+               if (current.value(i) != last.value(i)) {
+                  BitVector_SetBit(msg->u.input.bits, &offset);
+                  (current.value(i) ? BitVector_SetBit : BitVector_ClearBit)(bits, &offset);
+                  BitVector_WriteNibblet(bits, i, &offset);
+               }
+            }
+         }
+         BitVector_ClearBit(msg->u.input.bits, &offset);
+         last = _last_sent_input = current;
+      }
+   } else {
+      msg->u.input.start_frame = 0;
+      msg->u.input.input_size = 0;
+   }
+   msg->u.input.ack_frame = _last_received_input.frame;
+   msg->u.input.num_bits = (uint16)offset;
+
+   msg->u.input.disconnect_requested = _current_state == Disconnected;
+   if (_local_connect_status) {
+      memcpy(msg->u.input.peer_connect_status, _local_connect_status, sizeof(UdpMsg::connect_status) * UDP_MSG_MAX_PLAYERS);
+   } else {
+      memset(msg->u.input.peer_connect_status, 0, sizeof(UdpMsg::connect_status) * UDP_MSG_MAX_PLAYERS);
+   }
+
+   ASSERT(offset < MAX_COMPRESSED_BITS);
+
+   SendMsg(msg);
+}
+
+void
+UdpProtocol::SendInputAck()
+{
+   UdpMsg *msg = new UdpMsg(UdpMsg::InputAck);
+   msg->u.input_ack.ack_frame = _last_received_input.frame;
+   SendMsg(msg);
+}
+
+bool
+UdpProtocol::GetEvent(UdpProtocol::Event &e)
+{
+   if (_event_queue.size() == 0) {
+      return false;
+   }
+   e = _event_queue.front();
+   _event_queue.pop();
+   return true;
+}
+
+
+bool
+UdpProtocol::OnLoopPoll(void *cookie)
+{
+   if (!_udp) {
+      return true;
+   }
+
+   unsigned int now = GGPOPlatform::GetCurrentTimeMS();
+   unsigned int next_interval;
+
+   PumpSendQueue();
+   switch (_current_state) {
+   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("udpproto%d | No luck syncing after %d ms... Re-queueing sync packet.", _queue, next_interval);
+         SendSyncRequest();
+      }
+      break;
+
+   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("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;
+      }
+
+      if (!_state.running.last_quality_report_time || _state.running.last_quality_report_time + QUALITY_REPORT_INTERVAL < now) {
+         UdpMsg *msg = new UdpMsg(UdpMsg::QualityReport);
+         msg->u.quality_report.ping = GGPOPlatform::GetCurrentTimeMS();
+         msg->u.quality_report.frame_advantage = (uint8)_local_frame_advantage;
+         SendMsg(msg);
+         _state.running.last_quality_report_time = now;
+      }
+
+      if (!_state.running.last_network_stats_interval || _state.running.last_network_stats_interval + NETWORK_STATS_INTERVAL < now) {
+         UpdateNetworkStats();
+         _state.running.last_network_stats_interval =  now;
+      }
+
+      if (_last_send_time && _last_send_time + KEEP_ALIVE_INTERVAL < now) {
+         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("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);
+         _disconnect_notify_sent = true;
+      }
+
+      if (_disconnect_timeout && (_last_recv_time + _disconnect_timeout < now)) {
+         if (!_disconnect_event_sent) {
+            Log("udpproto%d | Endpoint has stopped receiving packets for %d ms.  Disconnecting.", _queue, _disconnect_timeout);
+            QueueEvent(Event(Event::Disconnected));
+            _disconnect_event_sent = true;
+         }
+      }
+      break;
+
+   case Disconnected:
+      if (_shutdown_timeout < now) {
+         Log("udpproto%d | Shutting down udp connection.", _queue);
+         _udp = NULL;
+         _shutdown_timeout = 0;
+      }
+      break;
+
+   default:
+	  break;
+   }
+
+
+   return true;
+}
+
+void
+UdpProtocol::Disconnect()
+{
+   _current_state = Disconnected;
+   _shutdown_timeout = GGPOPlatform::GetCurrentTimeMS() + UDP_SHUTDOWN_TIMER;
+}
+
+void
+UdpProtocol::SendSyncRequest()
+{
+   _state.sync.random = rand() & 0xFFFF;
+   UdpMsg *msg = new UdpMsg(UdpMsg::SyncRequest);
+   msg->u.sync_request.random_request = _state.sync.random;
+   msg->verification_size = verification.size();
+   if (!verification.empty())
+	   memcpy(&msg->u.sync_request.verification[0], &verification[0], verification.size());
+   SendMsg(msg);
+}
+
+void
+UdpProtocol::SendMsg(UdpMsg *msg)
+{
+   LogMsg("send", msg);
+
+   {
+	   std::lock_guard<std::mutex> lock(_send_mutex);
+	   _packets_sent++;
+	   _last_send_time = GGPOPlatform::GetCurrentTimeMS();
+	   _bytes_sent += msg->PacketSize();
+
+	   msg->hdr.magic = _magic_number;
+	   msg->hdr.sequence_number = _next_send_seq++;
+
+	   _send_queue.push(QueueEntry(GGPOPlatform::GetCurrentTimeMS(), _peer_addr, msg));
+   }
+   PumpSendQueue();
+}
+
+bool
+UdpProtocol::HandlesMsg(sockaddr_in &from,
+                        UdpMsg *msg)
+{
+   if (!_udp) {
+      return false;
+   }
+   if (_peer_addr.sin_addr.s_addr == 0)
+   {
+	   _peer_addr.sin_addr.s_addr = from.sin_addr.s_addr;
+	   _peer_addr.sin_port = from.sin_port;
+	   return true;
+   }
+   return _peer_addr.sin_addr.s_addr == from.sin_addr.s_addr &&
+          _peer_addr.sin_port == from.sin_port;
+}
+
+void
+UdpProtocol::OnMsg(UdpMsg *msg, int len)
+{
+   bool handled = false;
+   typedef bool (UdpProtocol::*DispatchFn)(UdpMsg *msg, int len);
+   static const DispatchFn table[] = {
+      &UdpProtocol::OnInvalid,             /* Invalid */
+      &UdpProtocol::OnSyncRequest,         /* SyncRequest */
+      &UdpProtocol::OnSyncReply,           /* SyncReply */
+      &UdpProtocol::OnInput,               /* Input */
+      &UdpProtocol::OnQualityReport,       /* QualityReport */
+      &UdpProtocol::OnQualityReply,        /* QualityReply */
+      &UdpProtocol::OnKeepAlive,           /* KeepAlive */
+      &UdpProtocol::OnInputAck,            /* InputAck */
+      &UdpProtocol::OnAppData,             /* AppData */
+   };
+
+   // filter out messages that don't match what we expect
+   uint16 seq = msg->hdr.sequence_number;
+   if (msg->hdr.type != UdpMsg::SyncRequest &&
+       msg->hdr.type != UdpMsg::SyncReply) {
+      if (msg->hdr.magic != _remote_magic_number) {
+         LogMsg("recv rejecting", msg);
+         return;
+      }
+
+      // filter out out-of-order packets
+      uint16 skipped = (uint16)((int)seq - (int)_next_recv_seq);
+      // Log("udpproto%d | checking sequence number -> next - seq : %d - %d = %d", _queue, seq, _next_recv_seq, skipped);
+      if (skipped > MAX_SEQ_DISTANCE) {
+         Log("udpproto%d | dropping out of order packet (seq: %d, last seq:%d)", _queue, seq, _next_recv_seq);
+         return;
+      }
+   }
+
+   _next_recv_seq = seq;
+   LogMsg("recv", msg);
+   if (msg->hdr.type >= ARRAY_SIZE(table)) {
+      OnInvalid(msg, len);
+   } else {
+      handled = (this->*(table[msg->hdr.type]))(msg, len);
+   }
+   if (handled) {
+      _last_recv_time = GGPOPlatform::GetCurrentTimeMS();
+      if (_disconnect_notify_sent && _current_state == Running) {
+         QueueEvent(Event(Event::NetworkResumed));   
+         _disconnect_notify_sent = false;
+      }
+   }
+}
+
+void
+UdpProtocol::UpdateNetworkStats(void)
+{
+   int now = GGPOPlatform::GetCurrentTimeMS();
+
+   if (_stats_start_time == 0) {
+      _stats_start_time = now;
+   }
+
+   int total_bytes_sent = _bytes_sent + (UDP_HEADER_SIZE * _packets_sent);
+   float seconds = (float)((now - _stats_start_time) / 1000.0);
+   float Bps = total_bytes_sent / seconds;
+   float udp_overhead = (float)(100.0 * (UDP_HEADER_SIZE * _packets_sent) / _bytes_sent);
+
+   _kbps_sent = int(Bps / 1024);
+
+   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,
+       udp_overhead);
+}
+
+
+void
+UdpProtocol::QueueEvent(const UdpProtocol::Event &evt)
+{
+   LogEvent("Queuing event", evt);
+   _event_queue.push(evt);
+}
+
+void
+UdpProtocol::Synchronize()
+{
+   if (_udp) {
+      _current_state = Syncing;
+      _state.sync.roundtrips_remaining = NUM_SYNC_PACKETS;
+      if (_peer_addr.sin_addr.s_addr != 0)
+    	  SendSyncRequest();
+   }
+}
+
+bool
+UdpProtocol::GetPeerConnectStatus(int id, int *frame)
+{
+   *frame = _peer_connect_status[id].last_frame;
+   return !_peer_connect_status[id].disconnected;
+}
+
+void
+UdpProtocol::LogMsg(const char *prefix, UdpMsg *msg)
+{
+   switch (msg->hdr.type) {
+   case UdpMsg::SyncRequest:
+      Log("udpproto%d | %s sync-request (%d).", _queue, prefix,
+          msg->u.sync_request.random_request);
+      break;
+   case UdpMsg::SyncReply:
+      Log("udpproto%d | %s sync-reply (%d).", _queue, prefix,
+          msg->u.sync_reply.random_reply);
+      break;
+   case UdpMsg::QualityReport:
+      Log("udpproto%d | %s quality report.", _queue, prefix);
+      break;
+   case UdpMsg::QualityReply:
+      Log("udpproto%d | %s quality reply.", _queue, prefix);
+      break;
+   case UdpMsg::KeepAlive:
+      Log("udpproto%d | %s keep alive.", _queue, prefix);
+      break;
+   case UdpMsg::Input:
+      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("udpproto%d | %s input ack.", _queue, prefix);
+      break;
+   case UdpMsg::AppData:
+      Log("udpproto%d | %s app data (%d bytes).", _queue, prefix, msg->u.app_data.size);
+      break;
+   default:
+      ASSERT(false && "Unknown UdpMsg type.");
+   }
+}
+
+void
+UdpProtocol::LogEvent(const char *prefix, const UdpProtocol::Event &evt)
+{
+   if (evt.type == UdpProtocol::Event::Synchronzied)
+      Log("udpproto%d | %s (event: Synchronized).", _queue, prefix);
+}
+
+bool
+UdpProtocol::OnInvalid(UdpMsg *msg, int len)
+{
+   ASSERT(false && "Invalid msg in UdpProtocol");
+   return false;
+}
+
+bool
+UdpProtocol::OnSyncRequest(UdpMsg *msg, int len)
+{
+   if (_remote_magic_number != 0 && msg->hdr.magic != _remote_magic_number) {
+      Log("udpproto%d | Ignoring sync request from unknown endpoint (%d != %d).", _queue,
+           msg->hdr.magic, _remote_magic_number);
+      return false;
+   }
+   UdpMsg *reply = new UdpMsg(UdpMsg::SyncReply);
+   reply->u.sync_reply.random_reply = msg->u.sync_request.random_request;
+   // Calculate incoming verif data size
+   msg->verification_size = 0;
+   int msgVerifSize = len - msg->PacketSize();
+   if (msgVerifSize != (int)verification.size()
+		   || (msgVerifSize != 0 && memcmp(&msg->u.sync_request.verification[0], &verification[0], msgVerifSize)))
+   {
+	   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("udpproto%d | Sync request 0 received... Re-queueing sync packet.", _queue);
+      SendSyncRequest();
+   }
+
+   reply->u.sync_reply.verification_failure = 0;
+   SendMsg(reply);
+
+   return true;
+}
+
+bool
+UdpProtocol::OnSyncReply(UdpMsg *msg, int len)
+{
+   if (_current_state != Syncing) {
+      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("udpproto%d | sync reply %d != %d.  Keep looking...", _queue,
+          msg->u.sync_reply.random_reply, _state.sync.random);
+      return false;
+   }
+   if (msg->u.sync_reply.verification_failure == 1)
+	   throw GGPOException("Peer reported verification failure", GGPO_ERRORCODE_VERIFICATION_ERROR);
+
+   if (!_connected) {
+      QueueEvent(Event(Event::Connected));
+      _connected = true;
+   }
+
+   Log("udpproto%d | Checking sync state (%d round trips remaining).", _queue, _state.sync.roundtrips_remaining);
+   if (--_state.sync.roundtrips_remaining == 0) {
+      Log("udpproto%d | Synchronized!", _queue);
+      QueueEvent(UdpProtocol::Event(UdpProtocol::Event::Synchronzied));
+      _current_state = Running;
+      _last_received_input.frame = -1;
+      _remote_magic_number = msg->hdr.magic;
+   } else {
+      UdpProtocol::Event evt(UdpProtocol::Event::Synchronizing);
+      evt.u.synchronizing.total = NUM_SYNC_PACKETS;
+      evt.u.synchronizing.count = NUM_SYNC_PACKETS - _state.sync.roundtrips_remaining;
+      QueueEvent(evt);
+      SendSyncRequest();
+   }
+   return true;
+}
+
+bool
+UdpProtocol::OnInput(UdpMsg *msg, int len)
+{
+   /*
+    * If a disconnect is requested, go ahead and disconnect now.
+    */
+   bool disconnect_requested = msg->u.input.disconnect_requested;
+   if (disconnect_requested) {
+      if (_current_state != Disconnected && !_disconnect_event_sent) {
+         Log("udpproto%d | Disconnecting endpoint on remote request.", _queue);
+         QueueEvent(Event(Event::Disconnected));
+         _disconnect_event_sent = true;
+      }
+   } else {
+      /*
+       * Update the peer connection status if this peer is still considered to be part
+       * of the network.
+       */
+      UdpMsg::connect_status* remote_status = msg->u.input.peer_connect_status;
+      for (unsigned i = 0; i < ARRAY_SIZE(_peer_connect_status); i++) {
+         ASSERT(remote_status[i].last_frame >= _peer_connect_status[i].last_frame);
+         _peer_connect_status[i].disconnected = _peer_connect_status[i].disconnected || remote_status[i].disconnected;
+         _peer_connect_status[i].last_frame = MAX(_peer_connect_status[i].last_frame, remote_status[i].last_frame);
+      }
+   }
+
+   /*
+    * Decompress the input.
+    */
+   int last_received_frame_number = _last_received_input.frame;
+   if (msg->u.input.num_bits) {
+      int offset = 0;
+      uint8 *bits = (uint8 *)msg->u.input.bits;
+      int numBits = msg->u.input.num_bits;
+      int currentFrame = msg->u.input.start_frame;
+
+      _last_received_input.size = msg->u.input.input_size;
+      if (_last_received_input.frame < 0) {
+         _last_received_input.frame = msg->u.input.start_frame - 1;
+      }
+      while (offset < numBits) {
+         /*
+          * Keep walking through the frames (parsing bits) until we reach
+          * the inputs for the frame right after the one we're on.
+          */
+         ASSERT(currentFrame <= (_last_received_input.frame + 1));
+         bool useInputs = currentFrame == _last_received_input.frame + 1;
+
+         while (BitVector_ReadBit(bits, &offset)) {
+            int on = BitVector_ReadBit(bits, &offset);
+            int button = BitVector_ReadNibblet(bits, &offset);
+            if (useInputs) {
+               if (on) {
+                  _last_received_input.set(button);
+               } else {
+                  _last_received_input.clear(button);
+               }
+            }
+         }
+         ASSERT(offset <= numBits);
+
+         /*
+          * Now if we want to use these inputs, go ahead and send them to
+          * the emulator.
+          */
+         if (useInputs) {
+            /*
+             * Move forward 1 frame in the stream.
+             */
+            char desc[1024];
+            ASSERT(currentFrame == _last_received_input.frame + 1);
+            _last_received_input.frame = currentFrame;
+
+            /*
+             * Send the event to the emulator
+             */
+            UdpProtocol::Event evt(UdpProtocol::Event::Input);
+            evt.u.input.input = _last_received_input;
+
+            if (LogTypes::LDEBUG <= MAX_LOGLEVEL)
+            	_last_received_input.desc(desc, ARRAY_SIZE(desc));
+
+            _state.running.last_input_packet_recv_time = GGPOPlatform::GetCurrentTimeMS();
+
+            Log("udpproto%d | Sending frame %d to emu queue %d (%s).", _queue, _last_received_input.frame, _queue, desc);
+            QueueEvent(evt);
+
+         } else {
+            Log("udpproto%d | Skipping past frame:(%d) current is %d.", _queue, currentFrame, _last_received_input.frame);
+         }
+
+         /*
+          * Move forward 1 frame in the input stream.
+          */
+         currentFrame++;
+      }
+   }
+   ASSERT(_last_received_input.frame >= last_received_frame_number);
+
+   /*
+    * Get rid of our buffered input
+    */
+   while (_pending_output.size() && _pending_output.front().frame < msg->u.input.ack_frame) {
+      Log("udpproto%d | Throwing away pending output frame %d", _queue, _pending_output.front().frame);
+      _last_acked_input = _pending_output.front();
+      _pending_output.pop();
+   }
+   return true;
+}
+
+
+bool
+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("udpproto%d | Throwing away pending output frame %d", _queue, _pending_output.front().frame);
+      _last_acked_input = _pending_output.front();
+      _pending_output.pop();
+   }
+   return true;
+}
+
+bool
+UdpProtocol::OnQualityReport(UdpMsg *msg, int len)
+{
+   // send a reply so the other side can compute the round trip transmit time.
+   UdpMsg *reply = new UdpMsg(UdpMsg::QualityReply);
+   reply->u.quality_reply.pong = msg->u.quality_report.ping;
+   SendMsg(reply);
+
+   _remote_frame_advantage = msg->u.quality_report.frame_advantage;
+   return true;
+}
+
+bool
+UdpProtocol::OnQualityReply(UdpMsg *msg, int len)
+{
+   _round_trip_time = GGPOPlatform::GetCurrentTimeMS() - msg->u.quality_reply.pong;
+   return true;
+}
+
+bool
+UdpProtocol::OnKeepAlive(UdpMsg *msg, int len)
+{
+   return true;
+}
+
+void
+UdpProtocol::GetNetworkStats(struct GGPONetworkStats *s)
+{
+   s->network.ping = _round_trip_time;
+   s->network.send_queue_len = _pending_output.size();
+   s->network.kbps_sent = _kbps_sent;
+   s->timesync.remote_frames_behind = _remote_frame_advantage;
+   s->timesync.local_frames_behind = _local_frame_advantage;
+}
+
+void
+UdpProtocol::SetLocalFrameNumber(int localFrame)
+{
+   /*
+    * Estimate which frame the other guy is one by looking at the
+    * last frame they gave us plus some delta for the one-way packet
+    * trip time.
+    */
+   int remoteFrame = _last_received_input.frame + (_round_trip_time * 60 / 1000);
+
+   /*
+    * Our frame advantage is how many frames *behind* the other guy
+    * we are.  Counter-intuative, I know.  It's an advantage because
+    * it means they'll have to predict more often and our moves will
+    * pop more frequenetly.
+    */
+   _local_frame_advantage = remoteFrame - localFrame;
+}
+
+int
+UdpProtocol::RecommendFrameDelay()
+{
+   // XXX: require idle input should be a configuration parameter
+   return _timesync.recommend_frame_wait_duration(false);
+}
+
+
+void
+UdpProtocol::SetDisconnectTimeout(int timeout)
+{
+   _disconnect_timeout = timeout;
+}
+
+void
+UdpProtocol::SetDisconnectNotifyStart(int timeout)
+{
+   _disconnect_notify_start = timeout;
+}
+
+void
+UdpProtocol::PumpSendQueue()
+{
+   std::lock_guard<std::mutex> lock(_send_mutex);
+   while (!_send_queue.empty()) {
+      QueueEntry &entry = _send_queue.front();
+
+      if (_send_latency) {
+         // should really come up with a gaussian distributation based on the configured
+         // value, but this will do for now.
+         int jitter = (_send_latency * 2 / 3) + ((rand() % _send_latency) / 3);
+         if ((int)GGPOPlatform::GetCurrentTimeMS() < _send_queue.front().queue_time + jitter) {
+            break;
+         }
+      }
+      if (_oop_percent && !_oo_packet.msg && ((rand() % 100) < _oop_percent)) {
+         int delay = rand() % (_send_latency * 10 + 1000);
+         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;
+      } else {
+         ASSERT(entry.dest_addr.sin_addr.s_addr);
+
+         _udp->SendTo((char *)entry.msg, entry.msg->PacketSize(), 0,
+                      (struct sockaddr *)&entry.dest_addr, sizeof entry.dest_addr);
+
+         delete entry.msg;
+      }
+      _send_queue.pop();
+   }
+   if (_oo_packet.msg && _oo_packet.send_time < (int)GGPOPlatform::GetCurrentTimeMS()) {
+      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);
+
+      delete _oo_packet.msg;
+      _oo_packet.msg = NULL;
+   }
+}
+
+void
+UdpProtocol::ClearSendQueue()
+{
+   std::lock_guard<std::mutex> lock(_send_mutex);
+   while (!_send_queue.empty()) {
+      delete _send_queue.front().msg;
+      _send_queue.pop();
+   }
+}
+
+void UdpProtocol::SendAppData(const void *data, int len, bool spectators)
+{
+	if (_udp == nullptr)
+		return;
+	if (_current_state != Synchronzied && _current_state != Running)
+		return;
+
+	UdpMsg *msg = new UdpMsg(UdpMsg::AppData);
+	msg->u.app_data.spectators = spectators;
+	msg->u.app_data.size = len;
+	memcpy(msg->u.app_data.data, data, len);
+
+	SendMsg(msg);
+}
+
+bool UdpProtocol::OnAppData(UdpMsg *msg, int len)
+{
+    UdpProtocol::Event evt(UdpProtocol::Event::AppData);
+    evt.u.app_data.spectators = msg->u.app_data.spectators != 0;
+    evt.u.app_data.size = msg->u.app_data.size;
+    memcpy(evt.u.app_data.data, msg->u.app_data.data, msg->u.app_data.size);
+    QueueEvent(evt);
+	return true;
+}

core/deps/ggpo/lib/ggpo/network/udp_proto.h

@@ -0,0 +1,223 @@
+/* -----------------------------------------------------------------------
+ * 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 _UDP_PROTO_H_
+#define _UDP_PROTO_H_
+
+#include "ggpo_poll.h"
+#include "udp.h"
+#include "udp_msg.h"
+#include "game_input.h"
+#include "timesync.h"
+#include "ggponet.h"
+#include "ring_buffer.h"
+#include <vector>
+#include <mutex>
+
+class UdpProtocol : public IPollSink
+{
+public:
+   struct Stats {
+      int                 ping;
+      int                 remote_frame_advantage;
+      int                 local_frame_advantage;
+      int                 send_queue_len;
+      Udp::Stats          udp;
+   };
+
+   struct Event {
+      enum Type {
+         Unknown = -1,
+         Connected,
+         Synchronizing,
+         Synchronzied,
+         Input,
+         Disconnected,
+         NetworkInterrupted,
+         NetworkResumed,
+		 AppData,
+      };
+
+      Type      type;
+      union {
+         struct {
+            GameInput   input;
+         } input;
+         struct {
+            int         total;
+            int         count;
+         } synchronizing;
+         struct {
+            int         disconnect_timeout;
+         } network_interrupted;
+         struct {
+        	 bool spectators;
+        	 int size;
+        	 uint8 data[MAX_APPDATA_SIZE];
+         } app_data;
+      } u;
+
+      Event(Type t = Unknown) : type(t) { }
+   };
+
+public:
+   virtual bool OnLoopPoll(void *cookie);
+
+public:
+   UdpProtocol();
+   virtual ~UdpProtocol();
+
+   void Init(Udp *udp, Poll &p, int queue, char *ip, u_short port, UdpMsg::connect_status *status);
+
+   void Synchronize();
+   bool GetPeerConnectStatus(int id, int *frame);
+   bool IsInitialized() { return _udp != NULL; }
+   bool IsSynchronized() { return _current_state == Running; }
+   bool IsRunning() { return _current_state == Running; }
+   void SendInput(GameInput &input);
+   void SendInputAck();
+   bool HandlesMsg(sockaddr_in &from, UdpMsg *msg);
+   void OnMsg(UdpMsg *msg, int len);
+   void Disconnect();
+   void SendAppData(const void *data, int len, bool spectators);
+  
+   void GetNetworkStats(struct GGPONetworkStats *stats);
+   bool GetEvent(UdpProtocol::Event &e);
+   void GGPONetworkStats(Stats *stats);
+   void SetLocalFrameNumber(int num);
+   int RecommendFrameDelay();
+   void SetVerificationData(const void *verification, int verification_size) {
+	   ASSERT(verification_size <= MAX_VERIFICATION_SIZE);
+	   this->verification.resize(verification_size);
+	   memcpy(&this->verification[0], verification, verification_size);
+   }
+
+   void SetDisconnectTimeout(int timeout);
+   void SetDisconnectNotifyStart(int timeout);
+
+protected:
+   enum State {
+      Syncing,
+      Synchronzied,
+      Running,
+      Disconnected
+   };
+   struct QueueEntry {
+      int         queue_time;
+      sockaddr_in dest_addr;
+      UdpMsg      *msg;
+
+      QueueEntry() {}
+      QueueEntry(int time, sockaddr_in &dst, UdpMsg *m) : queue_time(time), dest_addr(dst), msg(m) { }
+   };
+
+   bool CreateSocket(int retries);
+   void UpdateNetworkStats(void);
+   void QueueEvent(const UdpProtocol::Event &evt);
+   void ClearSendQueue(void);
+   void LogMsg(const char *prefix, UdpMsg *msg);
+   void LogEvent(const char *prefix, const UdpProtocol::Event &evt);
+   void SendSyncRequest();
+   void SendMsg(UdpMsg *msg);
+   void PumpSendQueue();
+   void SendPendingOutput();
+   bool OnInvalid(UdpMsg *msg, int len);
+   bool OnSyncRequest(UdpMsg *msg, int len);
+   bool OnSyncReply(UdpMsg *msg, int len);
+   bool OnInput(UdpMsg *msg, int len);
+   bool OnInputAck(UdpMsg *msg, int len);
+   bool OnQualityReport(UdpMsg *msg, int len);
+   bool OnQualityReply(UdpMsg *msg, int len);
+   bool OnKeepAlive(UdpMsg *msg, int len);
+   bool OnAppData(UdpMsg *msg, int len);
+
+protected:
+   /*
+    * Network transmission information
+    */
+   Udp            *_udp;
+   sockaddr_in    _peer_addr; 
+   uint16         _magic_number;
+   int            _queue;
+   uint16         _remote_magic_number;
+   bool           _connected;
+   int            _send_latency;
+   int            _oop_percent;
+   struct {
+      int         send_time;
+      sockaddr_in dest_addr;
+      UdpMsg*     msg;
+   }              _oo_packet;
+   RingBuffer<QueueEntry, 64> _send_queue;
+   std::mutex     _send_mutex;
+
+   std::vector<uint8> verification;
+
+   /*
+    * Stats
+    */
+   int            _round_trip_time;
+   int            _packets_sent;
+   int            _bytes_sent;
+   int            _kbps_sent;
+   int            _stats_start_time;
+
+   /*
+    * The state machine
+    */
+   UdpMsg::connect_status *_local_connect_status;
+   UdpMsg::connect_status _peer_connect_status[UDP_MSG_MAX_PLAYERS];
+
+   State          _current_state;
+   union {
+      struct {
+         uint32   roundtrips_remaining;
+         uint32   random;
+      } sync;
+      struct {
+         uint32   last_quality_report_time;
+         uint32   last_network_stats_interval;
+         uint32   last_input_packet_recv_time;
+      } running;
+   } _state;
+
+   /*
+    * Fairness.
+    */
+   int               _local_frame_advantage;
+   int               _remote_frame_advantage;
+
+   /*
+    * Packet loss...
+    */
+   RingBuffer<GameInput, 64>  _pending_output;
+   GameInput                  _last_received_input;
+   GameInput                  _last_sent_input;
+   GameInput                  _last_acked_input;
+   unsigned int               _last_send_time;
+   unsigned int               _last_recv_time;
+   unsigned int               _shutdown_timeout;
+   unsigned int               _disconnect_event_sent;
+   unsigned int               _disconnect_timeout;
+   unsigned int               _disconnect_notify_start;
+   bool                       _disconnect_notify_sent;
+
+   uint16                     _next_send_seq;
+   uint16                     _next_recv_seq;
+
+   /*
+    * Rift synchronization.
+    */
+   TimeSync                   _timesync;
+
+   /*
+    * Event queue
+    */
+   RingBuffer<UdpProtocol::Event, 64>  _event_queue;
+};
+
+#endif

core/deps/ggpo/lib/ggpo/platform_linux.cpp

@@ -0,0 +1,38 @@
+/* -----------------------------------------------------------------------
+ * 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.
+ */
+#if defined(__unix__) || defined(__APPLE__) || defined(__SWITCH__)
+
+#include "platform_linux.h"
+#include <time.h>
+#include <strings.h>
+#include <chrono>
+
+uint32_t GGPOPlatform::GetCurrentTimeMS()
+{
+	using namespace std::chrono;
+	static steady_clock::time_point startTime = steady_clock::now();
+
+	return (uint32_t)duration_cast<milliseconds>(steady_clock::now() - startTime).count();
+}
+
+int GGPOPlatform::GetConfigInt(const char* name)
+{
+   char *buf = getenv(name);
+   if (buf == nullptr)
+      return 0;
+   return atoi(buf);
+}
+
+bool GGPOPlatform::GetConfigBool(const char* name)
+{
+	char *buf = getenv(name);
+	if (buf == nullptr)
+		return false;
+   return atoi(buf) != 0 || strcasecmp(buf, "true") == 0;
+}
+
+#endif

core/deps/ggpo/lib/ggpo/platform_linux.h

@@ -0,0 +1,69 @@
+/* -----------------------------------------------------------------------
+ * 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 _GGPO_LINUX_H_
+#define _GGPO_LINUX_H_
+
+#include <limits>
+#include <stdio.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <cstdint>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#ifdef __SWITCH__
+#include "nswitch.h"
+#else
+#include <netinet/ip.h>
+#endif
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+
+using SOCKET = int;
+#define closesocket close
+#define INVALID_SOCKET (-1)
+#define SOCKET_ERROR (-1)
+#define WSAEWOULDBLOCK EWOULDBLOCK
+
+constexpr size_t MAX_PATH = 4096;
+#ifdef INT_MAX
+#undef INT_MAX
+#endif
+constexpr int INT_MAX = std::numeric_limits<int>::max();
+
+class GGPOPlatform {
+public:  // types
+   typedef pid_t ProcessID;
+
+public:  // functions
+   static ProcessID GetProcessID() { return getpid(); }
+   static void AssertFailed(char *msg) { fprintf(stderr, "%s", msg); }
+   static uint32_t GetCurrentTimeMS();
+   static int GetConfigInt(const char* name);
+   static bool GetConfigBool(const char* name);
+};
+
+extern "C" {
+
+inline static void DebugBreak()
+{
+	__builtin_trap();
+}
+
+inline static int WSAGetLastError() {
+	return errno;
+}
+
+}
+
+#endif

core/deps/ggpo/lib/ggpo/platform_windows.cpp

@@ -0,0 +1,28 @@
+/* -----------------------------------------------------------------------
+ * 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.
+ */
+#ifdef _WIN32
+#include "platform_windows.h"
+
+int
+GGPOPlatform::GetConfigInt(const char* name)
+{
+   char buf[1024];
+   if (GetEnvironmentVariableA(name, buf, ARRAY_SIZE(buf)) == 0) {
+      return 0;
+   }
+   return atoi(buf);
+}
+
+bool GGPOPlatform::GetConfigBool(const char* name)
+{
+   char buf[1024];
+   if (GetEnvironmentVariableA(name, buf, ARRAY_SIZE(buf)) == 0) {
+      return false;
+   }
+   return atoi(buf) != 0 || _stricmp(buf, "true") == 0;
+}
+#endif

core/deps/ggpo/lib/ggpo/platform_windows.h

@@ -0,0 +1,44 @@
+/* -----------------------------------------------------------------------
+ * 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 _GGPO_WINDOWS_H_
+#define _GGPO_WINDOWS_H_
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#include <stdio.h>
+#include <chrono>
+
+#include "ggpo_types.h"
+
+class GGPOPlatform {
+public:  // types
+   typedef DWORD ProcessID;
+
+public:  // functions
+   static ProcessID GetProcessID() { return GetCurrentProcessId(); }
+   static void AssertFailed(char *msg) { 
+#ifndef TARGET_UWP
+	   MessageBoxA(NULL, msg, "GGPO Assertion Failed", MB_OK | MB_ICONEXCLAMATION);
+#endif
+   }
+   static uint32 GetCurrentTimeMS() {
+#ifdef TARGET_UWP
+	   using namespace std::chrono;
+	   static steady_clock::time_point startTime = steady_clock::now();
+
+	   return (uint32_t)duration_cast<milliseconds>(steady_clock::now() - startTime).count();
+#else
+	   return timeGetTime();
+#endif
+   }
+   static int GetConfigInt(const char* name);
+   static bool GetConfigBool(const char* name);
+};
+
+#endif

core/deps/ggpo/lib/ggpo/poll.cpp

@@ -0,0 +1,127 @@
+/* -----------------------------------------------------------------------
+ * 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_poll.h"
+#include "ggpo_types.h"
+
+#ifndef _WIN32
+#include <chrono>
+#include <thread>
+constexpr int INFINITE = -1;
+#endif
+
+Poll::Poll(void) :
+   _start_time(0),
+   _handle_count(0)
+{
+   /*
+    * Create a dummy handle to simplify things.
+    */
+#ifdef _WIN32
+   _handles[_handle_count++] = CreateEvent(NULL, true, false, NULL);
+#endif
+}
+
+#if 0
+void
+Poll::RegisterHandle(IPollSink *sink, HANDLE h, void *cookie)
+{
+   ASSERT(_handle_count < MAX_POLLABLE_HANDLES - 1);
+
+   _handles[_handle_count] = h;
+   _handle_sinks[_handle_count] = PollSinkCb(sink, cookie);
+   _handle_count++;
+}
+#endif
+
+void
+Poll::RegisterMsgLoop(IPollSink *sink, void *cookie)
+{
+   _msg_sinks.push_back(PollSinkCb(sink, cookie));
+}
+
+void
+Poll::RegisterLoop(IPollSink *sink, void *cookie)
+{
+   _loop_sinks.push_back(PollSinkCb(sink, cookie));
+}
+void
+Poll::RegisterPeriodic(IPollSink *sink, int interval, void *cookie)
+{
+   _periodic_sinks.push_back(PollPeriodicSinkCb(sink, cookie, interval));
+}
+
+void
+Poll::Run()
+{
+   while (Pump(100)) {
+      continue;
+   }
+}
+
+bool
+Poll::Pump(int timeout)
+{
+   int i;
+   bool finished = false;
+
+   if (_start_time == 0) {
+      _start_time = GGPOPlatform::GetCurrentTimeMS();
+   }
+   int elapsed = GGPOPlatform::GetCurrentTimeMS() - _start_time;
+   int maxwait = ComputeWaitTime(elapsed);
+   if (maxwait != INFINITE) {
+      timeout = MIN(timeout, maxwait);
+   }
+
+#ifdef _WIN32
+   DWORD res = WaitForMultipleObjects(_handle_count, _handles, false, timeout);
+   if (res >= WAIT_OBJECT_0 && res < WAIT_OBJECT_0 + _handle_count) {
+      i = res - WAIT_OBJECT_0;
+      finished = !_handle_sinks[i].sink->OnHandlePoll(_handle_sinks[i].cookie) || finished;
+   }
+#else
+   if (timeout > 0)
+	   std::this_thread::sleep_for(std::chrono::milliseconds(timeout));
+#endif
+   for (i = 0; i < _msg_sinks.size(); i++) {
+      PollSinkCb &cb = _msg_sinks[i];
+      finished = !cb.sink->OnMsgPoll(cb.cookie) || finished;
+   }
+
+   for (i = 0; i < _periodic_sinks.size(); i++) {
+      PollPeriodicSinkCb &cb = _periodic_sinks[i];
+      if (cb.interval + cb.last_fired <= elapsed) {
+         cb.last_fired = (elapsed / cb.interval) * cb.interval;
+         finished = !cb.sink->OnPeriodicPoll(cb.cookie, cb.last_fired) || finished;
+      }
+   }
+
+   for (i = 0; i < _loop_sinks.size(); i++) {
+      PollSinkCb &cb = _loop_sinks[i];
+      finished = !cb.sink->OnLoopPoll(cb.cookie) || finished;
+   }
+   return finished;
+}
+
+int
+Poll::ComputeWaitTime(int elapsed)
+{
+   int waitTime = INFINITE;
+   size_t count = _periodic_sinks.size();
+
+   if (count > 0) {
+      for (size_t i = 0; i < count; i++) {
+         PollPeriodicSinkCb &cb = _periodic_sinks[i];
+         int timeout = (cb.interval + cb.last_fired) - elapsed;
+         if (waitTime == INFINITE || (timeout < waitTime)) {
+            waitTime = MAX(timeout, 0);
+         }         
+      }
+   }
+   return waitTime;
+}

core/deps/ggpo/lib/ggpo/ring_buffer.h

@@ -0,0 +1,60 @@
+/* -----------------------------------------------------------------------
+ * 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 _RING_BUFFER_H
+#define _RING_BUFFER_H
+
+#include "ggpo_types.h"
+
+template<class T, int N> class RingBuffer
+{
+public:
+   RingBuffer<T, N>() : 
+      _head(0),
+      _tail(0),
+      _size(0) {
+  } 
+
+   T &front() {
+      ASSERT(_size != N);
+      return _elements[_tail];
+   }
+   
+   T &item(int i) {
+      ASSERT(i < _size);
+      return _elements[(_tail + i) % N];
+   }
+
+   void pop() {
+      ASSERT(_size != N);
+      _tail = (_tail + 1) % N;
+      _size--;
+   }
+
+   void push(const T &t) {
+      ASSERT(_size != (N-1));
+      _elements[_head] = t;
+      _head = (_head + 1) % N;
+      _size++;
+   }
+
+   int size() {
+      return _size;
+   }
+
+   bool empty() {
+      return _size == 0;
+   }
+
+protected:
+   T        _elements[N];
+   int      _head;
+   int      _tail;
+   int      _size;
+};
+
+#endif

core/deps/ggpo/lib/ggpo/static_buffer.h

@@ -0,0 +1,40 @@
+/* -----------------------------------------------------------------------
+ * 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 _STATIC_BUFFER_H
+#define _STATIC_BUFFER_H
+
+#include "ggpo_types.h"
+
+template<class T, int N> class StaticBuffer
+{
+public:
+   StaticBuffer<T, N>() :
+      _size(0) {
+   } 
+
+   T& operator[](int i) {
+      ASSERT(i >= 0 && i < _size);
+      return _elements[i];
+   }
+
+   void push_back(const T &t) {
+      ASSERT(_size != (N-1));
+      _elements[_size++] = t;
+   }
+
+   int size() {
+      return _size;
+   }
+
+
+protected:
+   T        _elements[N];
+   int      _size;
+};
+
+#endif

core/deps/ggpo/lib/ggpo/sync.cpp

@@ -0,0 +1,304 @@
+/* -----------------------------------------------------------------------
+ * 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 "sync.h"
+
+Sync::Sync(UdpMsg::connect_status *connect_status) :
+_input_queues(NULL),
+ _local_connect_status(connect_status)
+{
+   _framecount = 0;
+   _last_confirmed_frame = -1;
+   _max_prediction_frames = 0;
+   memset(&_savedstate, 0, sizeof(_savedstate));
+}
+
+Sync::~Sync()
+{
+   /*
+    * Delete frames manually here rather than in a destructor of the SavedFrame
+    * structure so we can efficently copy frames via weak references.
+    */
+   for (size_t i = 0; i < ARRAY_SIZE(_savedstate.frames); i++) {
+      _callbacks.free_buffer(_savedstate.frames[i].buf);
+   }
+   delete [] _input_queues;
+   _input_queues = NULL;
+}
+
+void
+Sync::Init(Sync::Config &config)
+{
+   _config = config;
+   _callbacks = config.callbacks;
+   _framecount = 0;
+   _rollingback = false;
+
+   _max_prediction_frames = config.num_prediction_frames;
+
+   CreateQueues(config);
+}
+
+void
+Sync::SetLastConfirmedFrame(int frame) 
+{   
+   _last_confirmed_frame = frame;
+   if (_last_confirmed_frame > 0) {
+      for (int i = 0; i < _config.num_players; i++) {
+         _input_queues[i].DiscardConfirmedFrames(frame - 1);
+      }
+   }
+}
+
+bool
+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.");
+      return false;
+   }
+
+   if (_framecount == 0) {
+      SaveCurrentFrame();
+   }
+
+   Log("Sending undelayed local frame %d to queue %d.", _framecount, queue);
+   input.frame = _framecount;
+   _input_queues[queue].AddInput(input);
+
+   return true;
+}
+
+void
+Sync::AddRemoteInput(int queue, GameInput &input)
+{
+   _input_queues[queue].AddInput(input);
+}
+
+int
+Sync::GetConfirmedInputs(void *values, int size, int frame)
+{
+   int disconnect_flags = 0;
+   char *output = (char *)values;
+
+   ASSERT(size >= _config.num_players * _config.input_size);
+
+   memset(output, 0, size);
+   for (int i = 0; i < _config.num_players; i++) {
+      GameInput input;
+      if (_local_connect_status[i].disconnected && frame > _local_connect_status[i].last_frame) {
+         disconnect_flags |= (1 << i);
+         input.erase();
+      } else {
+         _input_queues[i].GetConfirmedInput(frame, &input);
+      }
+      memcpy(output + (i * _config.input_size), input.bits, _config.input_size);
+   }
+   return disconnect_flags;
+}
+
+int
+Sync::SynchronizeInputs(void *values, int size)
+{
+   int disconnect_flags = 0;
+   char *output = (char *)values;
+
+   ASSERT(size >= _config.num_players * _config.input_size);
+
+   memset(output, 0, size);
+   for (int i = 0; i < _config.num_players; i++) {
+      GameInput input;
+      if (_local_connect_status[i].disconnected && _framecount > _local_connect_status[i].last_frame) {
+         disconnect_flags |= (1 << i);
+         input.erase();
+      } else {
+         _input_queues[i].GetInput(_framecount, &input);
+      }
+      memcpy(output + (i * _config.input_size), input.bits, _config.input_size);
+   }
+   return disconnect_flags;
+}
+
+void
+Sync::CheckSimulation(int timeout)
+{
+   int seek_to;
+   if (!CheckSimulationConsistency(&seek_to)) {
+      AdjustSimulation(seek_to);
+   }
+}
+
+void
+Sync::IncrementFrame(void)
+{
+   _framecount++;
+   SaveCurrentFrame();
+}
+
+void
+Sync::AdjustSimulation(int seek_to)
+{
+   int framecount = _framecount;
+   int count = _framecount - seek_to;
+
+   Log("Catching up");
+   _rollingback = true;
+
+   /*
+    * Flush our input queue and load the last frame.
+    */
+   LoadFrame(seek_to);
+   ASSERT(_framecount == seek_to);
+
+   /*
+    * Advance frame by frame (stuffing notifications back to 
+    * the master).
+    */
+   ResetPrediction(_framecount);
+   for (int i = 0; i < count; i++) {
+      _callbacks.advance_frame(0);
+   }
+   ASSERT(_framecount == framecount);
+
+   _rollingback = false;
+
+   Log("---");
+}
+
+void
+Sync::LoadFrame(int frame)
+{
+   // find the frame in question
+   if (frame == _framecount) {
+      Log("Skipping NOP.");
+      return;
+   }
+
+   // Move the head pointer back and load it up
+   _savedstate.head = FindSavedFrameIndex(frame);
+   SavedFrame *state = _savedstate.frames + _savedstate.head;
+
+   Log("=== Loading frame info %d (size: %d  checksum: %08x).",
+       state->frame, state->cbuf, state->checksum);
+
+   ASSERT(state->buf && state->cbuf);
+   _callbacks.load_game_state(state->buf, state->cbuf);
+
+   // Reset framecount and the head of the state ring-buffer to point in
+   // advance of the current frame (as if we had just finished executing it).
+   _framecount = state->frame;
+   _savedstate.head = (_savedstate.head + 1) % ARRAY_SIZE(_savedstate.frames);
+}
+
+void
+Sync::SaveCurrentFrame()
+{
+   /*
+    * See StateCompress for the real save feature implemented by FinalBurn.
+    * Write everything into the head, then advance the head pointer.
+    */
+   SavedFrame *state = _savedstate.frames + _savedstate.head;
+   if (state->buf) {
+      _callbacks.free_buffer(state->buf);
+      state->buf = NULL;
+   }
+   state->frame = _framecount;
+   _callbacks.save_game_state(&state->buf, &state->cbuf, &state->checksum, state->frame);
+
+   Log("=== Saved frame info %d (size: %d  checksum: %08x).", state->frame, state->cbuf, state->checksum);
+   _savedstate.head = (_savedstate.head + 1) % ARRAY_SIZE(_savedstate.frames);
+}
+
+Sync::SavedFrame&
+Sync::GetLastSavedFrame()
+{
+   int i = _savedstate.head - 1;
+   if (i < 0) {
+      i = ARRAY_SIZE(_savedstate.frames) - 1;
+   }
+   return _savedstate.frames[i];
+}
+
+
+int
+Sync::FindSavedFrameIndex(int frame)
+{
+   int i, count = ARRAY_SIZE(_savedstate.frames);
+   for (i = 0; i < count; i++) {
+      if (_savedstate.frames[i].frame == frame) {
+         break;
+      }
+   }
+   if (i == count) {
+      ASSERT(false);
+   }
+   return i;
+}
+
+
+bool
+Sync::CreateQueues(Config &config)
+{
+   delete [] _input_queues;
+   _input_queues = new InputQueue[_config.num_players];
+
+   for (int i = 0; i < _config.num_players; i++) {
+      _input_queues[i].Init(i, _config.input_size);
+   }
+   return true;
+}
+
+bool
+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.", incorrect, i);
+
+      if (incorrect != GameInput::NullFrame && (first_incorrect == GameInput::NullFrame || incorrect < first_incorrect)) {
+         first_incorrect = incorrect;
+      }
+   }
+
+   if (first_incorrect == GameInput::NullFrame) {
+      Log("prediction ok.  proceeding.");
+      return true;
+   }
+   *seekTo = first_incorrect;
+   return false;
+}
+
+void
+Sync::SetFrameDelay(int queue, int delay)
+{
+   _input_queues[queue].SetFrameDelay(delay);
+}
+
+
+void
+Sync::ResetPrediction(int frameNumber)
+{
+   for (int i = 0; i < _config.num_players; i++) {
+      _input_queues[i].ResetPrediction(frameNumber);
+   }
+}
+
+
+bool
+Sync::GetEvent(Event &e)
+{
+   if (_event_queue.size()) {
+      e = _event_queue.front();
+      _event_queue.pop();
+      return true;
+   }
+   return false;
+}
+
+

core/deps/ggpo/lib/ggpo/sync.h

@@ -0,0 +1,105 @@
+/* -----------------------------------------------------------------------
+ * 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 _SYNC_H
+#define _SYNC_H
+
+#include "ggponet.h"
+#include "game_input.h"
+#include "ggpo_types.h"
+#include "input_queue.h"
+#include "ring_buffer.h"
+#include "network/udp_msg.h"
+
+#define MAX_PREDICTION_FRAMES    8
+
+class SyncTestBackend;
+
+class Sync {
+public:
+   struct Config {
+      GGPOSessionCallbacks    callbacks;
+      int                     num_prediction_frames;
+      int                     num_players;
+      int                     input_size;
+   };
+   struct Event {
+      enum {
+         ConfirmedInput,
+      } type;
+      union {
+         struct {
+            GameInput   input;
+         } confirmedInput;
+      } u;
+   };
+
+public:
+   Sync(UdpMsg::connect_status *connect_status);
+   virtual ~Sync();
+
+   void Init(Config &config);
+
+   void SetLastConfirmedFrame(int frame);
+   void SetFrameDelay(int queue, int delay);
+   bool AddLocalInput(int queue, GameInput &input);
+   void AddRemoteInput(int queue, GameInput &input);
+   int GetConfirmedInputs(void *values, int size, int frame);
+   int SynchronizeInputs(void *values, int size);
+
+   void CheckSimulation(int timeout);
+   void AdjustSimulation(int seek_to);
+   void IncrementFrame(void);
+
+   int GetFrameCount() { return _framecount; }
+   bool InRollback() { return _rollingback; }
+   int GetPredictedFrames() { return _framecount - _last_confirmed_frame; }
+
+   bool GetEvent(Event &e);
+
+protected:
+   friend SyncTestBackend;
+
+   struct SavedFrame {
+      byte    *buf;
+      int      cbuf;
+      int      frame;
+      int      checksum;
+      SavedFrame() : buf(NULL), cbuf(0), frame(-1), checksum(0) { }
+   };
+   struct SavedState {
+      SavedFrame frames[MAX_PREDICTION_FRAMES + 2];
+      int head;
+   };
+
+   void LoadFrame(int frame);
+   void SaveCurrentFrame();
+   int FindSavedFrameIndex(int frame);
+   SavedFrame &GetLastSavedFrame();
+
+   bool CreateQueues(Config &config);
+   bool CheckSimulationConsistency(int *seekTo);
+   void ResetPrediction(int frameNumber);
+
+protected:
+   GGPOSessionCallbacks _callbacks;
+   SavedState     _savedstate;
+   Config         _config;
+
+   bool           _rollingback;
+   int            _last_confirmed_frame;
+   int            _framecount;
+   int            _max_prediction_frames;
+
+   InputQueue     *_input_queues;
+
+   RingBuffer<Event, 32> _event_queue;
+   UdpMsg::connect_status *_local_connect_status;
+};
+
+#endif
+