initial tests

.gitignore

@@ -0,0 +1,23 @@
+tags
+*.log
+*.tar.xz
+*.tar.gz
+*.zip
+/oppai
+*.json
+*.obj
+*.exe
+*.swp
+*.so
+*.dll
+*.lib
+*.exp
+/test/test_suite
+/test/oppai_test
+/swig/**/*.c
+/swig/*/*.i
+/swig/python/oppai.egg-info
+/swig/python/build
+/swig/python/oppai.py
+*.whl
+*.pyc

.travis.yml

@@ -0,0 +1,29 @@
+language: c
+
+matrix:
+  include:
+  - os: linux
+    dist: precise
+  - os: linux
+    dist: trusty
+  - os: osx
+
+install: true
+cache:
+  directories:
+  - test/test_suite
+
+script:
+- ./build
+- ./libbuild
+- cd test
+- ./download_suite
+- ./build
+- DYLD_PRINT_LIBRARIES=1 DYLD_PRINT_LIBRARIES_POST_LAUNCH=1
+  DYLD_PRINT_RPATHS=1 LD_DEBUG=libs ./oppai_test
+- wc -c ./oppai_test
+- LDFLAGS="-loppai" ./build -L..
+- LD_LIBRARY_PATH=.. DYLD_LIBRARY_PATH=..
+  DYLD_PRINT_LIBRARIES=1 DYLD_PRINT_LIBRARIES_POST_LAUNCH=1
+  DYLD_PRINT_RPATHS=1 LD_DEBUG=libs ./oppai_test
+- wc -c ./oppai_test

Dockerfile

@@ -0,0 +1,6 @@
+ARG PREFIX=
+FROM ${PREFIX}ubuntu:bionic
+RUN apt-get update && apt-get install -y \
+  gcc musl musl-tools musl-dev git-core file
+WORKDIR /tmp
+CMD setarch $arch ./release

README.md

@@ -0,0 +1,367 @@
+[![Build Status](https://travis-ci.org/Francesco149/oppai-ng.svg?branch=master)](https://travis-ci.org/Francesco149/oppai-ng)
+
+difficulty and pp calculator for osu!
+
+this is a pure C89 rewrite of
+[oppai](https://github.com/Francesco149/oppai) with much lower
+memory usage, smaller and easier to read codebase
+executable size and better performance.
+
+experimental taiko support is now available and appears to give
+correct values for actual taiko maps. converted maps are still
+unreliable due to incorrect slider conversion and might be
+completely off (use ```-m1``` or ```-taiko``` to convert a std map
+to taiko).
+
+- [installing (linux)](#installing-linux)
+- [installing (windows)](#installing-windows)
+- [installing (osx)](#installing-osx)
+- [usage](#usage)
+- [implementations for other programming languages](#implementations-for-other-programming-languages)
+- [bindings for other programming languages](#bindings-for-other-programming-languages)
+- [oppai-ng vs old oppai](#oppai-ng-vs-old-oppai)
+- [compile from source (windows)](#compile-from-source-windows)
+- [using oppai as a library or making bindings](#using-oppai-as-a-library-or-making-bindings)
+- [other build parameters](#other-build-parameters)
+
+# installing (linux)
+```sh
+wget https://github.com/Francesco149/oppai-ng/archive/HEAD.tar.gz
+tar xf HEAD.tar.gz
+cd oppai-*
+./build
+sudo install -Dm 755 oppai /usr/bin/oppai
+
+oppai
+```
+
+you can also grab pre-compiled standalone binaries (statically
+linked against musl libc) from
+[here](https://github.com/Francesco149/oppai-ng/releases) if you
+are somehow too scared to run those 5 commands.
+
+# installing (windows)
+download and unzip binaries from
+[here](https://github.com/Francesco149/oppai-ng/releases) and
+optionally add oppai's folder to your ```PATH``` environment
+variable for easy access. you can find a guide
+[here](https://www.howtogeek.com/118594/how-to-edit-your-system-path-for-easy-command-line-access/)
+if you don't know how.
+
+# installing (osx)
+## via homebrew
+```sh
+brew install --HEAD pmrowla/homebrew-tap/oppai-ng
+```
+Note that installing with ```--HEAD``` is recommended but not required.
+Installing from homebrew will place the ```oppai``` executable in your homebrew path.
+
+## manually
+Follow the same steps as for linux but substitute ```curl -O``` for ```wget``` since wget is not distributed by default in osx.
+The same caveat applies if you want to run the test suite - you will need to edit the ```download_suite``` script to use curl.
+
+# usage
+you can run oppai with no arguments to check the documentation.
+
+here's some example usages:
+
+```sh
+oppai path/to/map.osu +HDHR 98% 500x 1xmiss
+oppai path/to/map.osu 3x100
+oppai path/to/map.osu 3x100 OD10
+oppai path/to/map.osu -ojson
+```
+
+you can also pipe maps from standard input by setting the filename
+to ```-```.
+
+for example on linux you can do:
+
+```sh
+curl https://osu.ppy.sh/osu/774965 | oppai - +HDDT
+curl https://osu.ppy.sh/osu/774965 | oppai - +HDDT 1200x 1m
+```
+
+while on windows it's a bit more verbose (powershell):
+
+```powershell
+(New-Object System.Net.WebClient).DownloadString("https://osu.ppy.sh/osu/37658") | ./oppai -
+(New-Object System.Net.WebClient).DownloadString("https://osu.ppy.sh/osu/37658") | ./oppai - +HDHR
+(New-Object System.Net.WebClient).DownloadString("https://osu.ppy.sh/osu/37658") | ./oppai - +HDHR 99% 600x 1m
+```
+
+I got the .osu file url from "Grab latest .osu file" on the
+beatmap's page.
+
+# implementations for other programming languages
+oppai has been implemented for many other programming languages.
+If you feel like making your own implementation and want it listed
+here, open an issue or pull request. the requirement is that it
+should pass the same test suite that oppai-ng passes.
+
+* [ojsama (javascript)](https://github.com/Francesco149/ojsama)
+* [koohii (java)](https://github.com/Francesco149/koohii) . this
+  is currently being used in tillerino.
+* [pyttanko (python)](https://github.com/Francesco149/pyttanko)
+* [oppai5 (golang)](https://github.com/flesnuk/oppai5) (by flesnuk)
+* [OppaiSharp (C#)](https://github.com/HoLLy-HaCKeR/OppaiSharp)
+  (by HoLLy)
+* [osu-perf (rust)](https://gitlab.com/JackRedstonia/osu-perf/) (by JackRedstonia)
+
+# bindings for other programming languages
+thanks to swig it's trivial to generate native bindings for other
+programming languages. bindings are an interface to the C code, meaning
+that you get basically the same performance as C by sacrificing some
+portability
+
+* [python](https://github.com/Francesco149/oppai-ng/swig/python)
+
+# oppai-ng vs old oppai
+executable size is around 7 times smaller:
+```sh
+$ cd ~/src/oppai
+$ ./build.sh -static
+$ wc -c oppai
+574648 oppai
+
+$ cd ~/src/oppai-ng
+$ ./build -static
+$ wc -c oppai
+75512 oppai
+```
+
+oppai-ng has proper error output in whatever format you select,
+while legacy oppai either gives empty output or just dies with
+a plaintext error.
+
+oppai-ng has well-defined errno style error codes that you can
+check for when using it as a library or reading its output.
+
+the same test suite runs about 45% faster on oppai-ng compared
+to old oppai, also the peak resident memory size is 4 to 6 times
+smaller according to various ```time -v``` runs.
+
+```sh
+$ cd ~/src/oppai
+$ ./build_test.sh
+$ time -v ./oppai_test
+...
+    Command being timed: "./oppai_test"
+    User time (seconds): 13.89
+    System time (seconds): 0.10
+    Percent of CPU this job got: 99%
+    Elapsed (wall clock) time (h:mm:ss or m:ss): 0m 13.99s
+    Average shared text size (kbytes): 0
+    Average unshared data size (kbytes): 0
+    Average stack size (kbytes): 0
+    Average total size (kbytes): 0
+    Maximum resident set size (kbytes): 45184
+    Average resident set size (kbytes): 0
+    Major (requiring I/O) page faults: 0
+    Minor (reclaiming a frame) page faults: 2143
+    Voluntary context switches: 1
+    Involuntary context switches: 41
+    Swaps: 0
+    File system inputs: 0
+    File system outputs: 0
+    Socket messages sent: 0
+    Socket messages received: 0
+    Signals delivered: 0
+    Page size (bytes): 4096
+    Exit status: 0
+
+$ cd ~/src/oppai-ng/test/
+$ ./build
+$ time -v ./oppai_test
+...
+    Command being timed: "./oppai_test"
+    User time (seconds): 9.09
+    System time (seconds): 0.06
+    Percent of CPU this job got: 99%
+    Elapsed (wall clock) time (h:mm:ss or m:ss): 0m 9.15s
+    Average shared text size (kbytes): 0
+    Average unshared data size (kbytes): 0
+    Average stack size (kbytes): 0
+    Average total size (kbytes): 0
+    Maximum resident set size (kbytes): 11840
+    Average resident set size (kbytes): 0
+    Major (requiring I/O) page faults: 0
+    Minor (reclaiming a frame) page faults: 304
+    Voluntary context switches: 1
+    Involuntary context switches: 39
+    Swaps: 0
+    File system inputs: 0
+    File system outputs: 0
+    Socket messages sent: 0
+    Socket messages received: 0
+    Signals delivered: 0
+    Page size (bytes): 4096
+    Exit status: 0
+```
+
+note that when the test suite is compiled without libcurl, the
+resident memory usage drops by a flat 4mb, so almost half of that
+is curl.
+
+you can expect oppai memory usage to be under 4 mb most of the time
+with the raw parsed beatmap data not taking more than ~800k even
+for a 15 minute marathon.
+
+the codebase has ~3-4x less lines than legacy oppai, making it easy
+to read and use as a single header library. not only it is smaller,
+but it now also implements both taiko and osu, so more features
+than legacy oppai.
+
+the osu! pp and diff calc alone would be around ~3k LOC including
+the cli, which would be 5x less lines than legacy oppai for the
+same functionality.
+
+```sh
+$ cd ~/src/oppai
+$ sloc *.cc
+
+---------- Result ------------
+
+            Physical :  15310
+              Source :  14406
+             Comment :  301
+ Single-line comment :  289
+       Block comment :  12
+               Mixed :  23
+               Empty :  626
+               To Do :  11
+
+Number of files read :  10
+
+------------------------------
+
+$ cd ~/src/oppai-ng
+$ sloc *.c
+
+---------- Result ------------
+
+            Physical :  4123
+              Source :  2906
+             Comment :  492
+ Single-line comment :  1
+       Block comment :  491
+               Mixed :  64
+               Empty :  811
+               To Do :  9
+
+Number of files read :  2
+
+------------------------------
+```
+
+not to mention it's C89, which will be compatible with many more
+platforms and old compilers than c++98
+
+```oppai.c``` alone is only ~2200 LOC (~1500 without comments), and
+you can compile piece of it out when you don't need them.
+
+of course, it's not as heavily tested as legacy oppai (which runs
+24/7 on Tillerino's back-end), however the test suite is a very
+good test that runs through ~12000 unique scores and I'm confident
+this rewrite is already very stable.
+
+# compile from source (windows)
+oppai should compile even on old versions of msvc dating back to
+2005, although it was only tested on msvc 2010 and higher.
+
+have at least [microsoft c++ build tools](http://landinghub.visualstudio.com/visual-cpp-build-tools)
+installed. visual studio with c/c++ support also works.
+
+open a visual studio prompt:
+
+```bat
+cd path\to\oppai\source
+build.bat
+oppai
+```
+
+you can also probably set up mingw and cygwin and follow the linux
+instructions instead, I'm not sure. I don't use windows.
+
+# using oppai as a library or making bindings
+the new codebase is much easier to isolate and include in your
+projects.
+
+just copy oppai.c into your project, it acts as a single-header
+library.
+
+```c
+#define OPPAI_IMPLEMENTATION
+#include "../oppai.c"
+
+int main() {
+  ezpp_t ez = ezpp_new();
+  ezpp_set_mods(ez, MODS_HD | MODS_DT);
+  ezpp(ez, "-");
+  printf("%gpp\n", ezpp_pp(ez));
+  return 0;
+}
+```
+
+```sh
+gcc test.c
+cat /path/to/file.osu | ./a.out
+```
+
+read oppai.c, there's documentation for each function at the top.
+
+see examples directory for detailed examples. you can also read
+main.c to see how the CLI uses it.
+
+if you don't feel comfortable writing bindings or using oppai
+from c code, you can use the -o parameter to output in json or
+other parsable formats. ```examples/binary.c``` shows how to parse
+the binary output.
+
+# shared library
+you can also build oppai as a shared library with
+
+```sh
+./libbuild
+```
+
+this will generate a liboppai.so on linux/mac which you can copy to
+```/usr/local/lib``` or anywhere in your library search paths
+
+you can then use it by simply not defining ```OPPAI_IMPLEMENTATION``` .
+this will exclude all the oppai code and just leave the header part
+
+
+```c
+#include "oppai.c"
+
+int main() {
+  /* ... */
+}
+```
+
+then you can compile and run with
+
+```
+gcc test.c -lm -loppai
+cat /path/to/file.osu | ./a.out
+```
+
+for windows you can use ```libbuild.bat``` to build (for details see the
+info on compiling on windows) which will generate a oppai.dll and .lib pair
+
+and then compile your program with msvc like so
+
+```
+cl test.c oppai.lib
+```
+
+then you can simply place the dll in the same folder as your executable
+and run
+
+# build parameters
+when you build the oppai cli, you can pass any of these parameters
+to the build script to disable features:
+
+* ```-DOPPAI_UTF8GRAPH``` use utf-8 characters for the strains graph
+

UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

appveyor.yml

@@ -0,0 +1,67 @@
+version: b{build}
+image: Visual Studio 2017
+cache: test/test_suite -> test/suite_url
+build_script:
+- ps: >-
+    function VcVars {
+        param ([string]$VcPath, [string]$BatName)
+        Push-Location $VcPath
+        cmd /c ($BatName + "&set") |
+        ForEach-Object {
+            if ($_ -match "=") {
+                $v = $_.split("="); set-item -force -path "ENV:\$($v[0])"  -value "$($v[1])"
+            }
+        }
+        Pop-Location
+    }
+
+
+    $VcPath = "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build"
+
+
+    VcVars $VcPath vcvars32.bat
+
+    .\release.ps1; if (-not $?) { exit $LastExitCode }
+
+
+    VcVars $VcPath vcvars64.bat
+
+    .\release.ps1; if (-not $?) { exit $LastExitCode }
+
+
+    cd .\test
+
+    .\download_suite.ps1
+
+    .\build.bat; if (-not $?) { exit $LastExitCode }
+
+    .\oppai_test.exe; if (-not $?) { exit $LastExitCode }
+
+    Write-Host "bin size: " + (Get-Item '.\oppai_test.exe').length
+
+    dumpbin /dependents .\oppai_test.exe
+
+    .\build.bat ..\oppai.lib; if (-not $?) { exit $LastExitCode }
+
+    cp ..\oppai.dll .
+
+    .\oppai_test.exe; if (-not $?) { exit $LastExitCode }
+
+    Write-Host "bin size: " + (Get-Item '.\oppai_test.exe').length
+
+    dumpbin /dependents .\oppai_test.exe
+test: off
+artifacts:
+- path: oppai-*-windows-*.zip
+  name: windows-binaries
+deploy:
+- provider: GitHub
+  tag: $(appveyor_repo_tag_name)
+  release: oppai $(appveyor_repo_tag_name)-$(appveyor_build_version)
+  description: linux binaries are manually uploaded shortly after the windows release and statically linked against musl libc\n\nwindows binaries should not require the c runtime\n\nx64 and x86_64 mean 64-bit i586 and x86 mean 32-bit\n\nthe binary packages include the source code inside the src directory
+  auth_token:
+    secure: k73tV2NZTFp4thujp/KiohNwRwIpWC12gU/qsnfCqlctcC+rqWiDWet3sSAz34gT
+  artifact: windows-binaries
+  force_update: true
+  on:
+    APPVEYOR_REPO_TAG: true

build

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+dir="$(dirname "$0")"
+. "$dir"/cflags
+$cc $cflags "$@" -DOPPAI_IMPLEMENTATION main.c oppai.c $ldflags -o oppai
+

build.bat

@@ -0,0 +1,12 @@
+@echo off
+
+del oppai.exe >nul 2>&1
+del main.obj >nul 2>&1
+cl  -D_CRT_SECURE_NO_WARNINGS=1 ^
+  -DNOMINMAX=1 ^
+  -O2 -nologo -MT -Gm- -GR- -EHsc -W4 ^
+  -DOPPAI_IMPLEMENTATION ^
+  -DOPPAI_STATIC_HEADER ^
+  main.c oppai.c ^
+  -Feoppai.exe ^
+  || EXIT /B 1

cflags

@@ -0,0 +1,45 @@
+#!/bin/sh
+
+cflags="-std=c89 -pedantic"
+cflags="$cflags -Os"
+cflags="$cflags -fno-strict-aliasing"
+cflags="$cflags -Wall"
+cflags="$cflags -ffunction-sections -fdata-sections"
+if [ -z $DBGINFO ]; then
+  cflags="$cflags -g0 -fno-unwind-tables -s"
+  cflags="$cflags -fno-asynchronous-unwind-tables"
+  cflags="$cflags -fno-stack-protector"
+else
+  cflags="$cflags -g -fsanitize=address -fsanitize=leak "
+  cflags="$cflags -fsanitize=signed-integer-overflow -fsanitize=undefined -static-libasan"
+fi
+if [ $(uname) = "Darwin" ]; then
+  cflags="$cflags -Wl,-dead_strip"
+else
+  cflags="$cflags -Wl,--gc-sections,--build-id=none"
+fi
+
+ldflags="-lm"
+
+cflags="$cflags $CFLAGS"
+ldflags="$ldflags $LDFLAGS"
+
+cc="$CC"
+
+if [ $(uname) = "Darwin" ]; then
+  cc=${cc:-clang}
+else
+  cc=${cc:-gcc}
+fi
+
+uname -a > flags.log
+echo $cc >> flags.log
+echo $cflags >> flags.log
+echo $ldflags >> flags.log
+$cc --version >> flags.log
+$cc -dumpmachine >> flags.log
+
+export cflags="$cflags"
+export ldflags="$ldflags"
+export cc="$cc"
+

examples/FFI.cs

@@ -0,0 +1,26 @@
+// csc FFI.cs
+// FFI.exe /path/to/file.osu
+// make sure oppai.dll is in the same directory as FFI.exe
+// see oppai.c for a full list of functions
+
+using System;
+using System.Runtime.InteropServices;
+
+public class Program
+{
+  [DllImport(@"oppai.dll")]
+  public static extern IntPtr ezpp_new();
+
+  [DllImport(@"oppai.dll")]
+  public static extern IntPtr ezpp(IntPtr ez, char[] map);
+
+  [DllImport(@"oppai.dll")]
+  public static extern float ezpp_pp(IntPtr ez);
+
+  static void Main(string[] args)
+  {
+    IntPtr ez = ezpp_new();
+    ezpp(ez, args[0].ToCharArray());
+    Console.WriteLine($"{ezpp_pp(ez)} pp");
+  }
+}

examples/binary.c

@@ -0,0 +1,133 @@
+/*
+ * example of parsing oppai's binary output
+ *
+ * gcc binary.c
+ * oppai /path/to/file.osu -obinary | ./a.out
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+/*
+ * these are only necessary to ensure endian-ness, if you don't
+ * care about that you can read values like v = *(int*)p
+ */
+
+int read2(char** c) {
+  unsigned char* p = (unsigned char*)*c;
+  *c += 2;
+  return p[0] | (p[1] << 8);
+}
+
+int read4(char** c) {
+  unsigned char* p = (unsigned char*)*c;
+  *c += 4;
+  return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
+}
+
+float read_flt(char** p) {
+  int v = read4(p);
+  float* pf = (float*)&v;
+  return *pf;
+}
+
+char* read_str(char** p, int* len) {
+  char* res;
+  *len = read2(p);
+  res = *p;
+  *p += *len + 1;
+  return res;
+}
+
+#define MODS_NF (1<<0)
+#define MODS_EZ (1<<1)
+#define MODS_HD (1<<3)
+#define MODS_HR (1<<4)
+#define MODS_DT (1<<6)
+#define MODS_HT (1<<8)
+#define MODS_NC (1<<9)
+#define MODS_FL (1<<10)
+#define MODS_SO (1<<12)
+
+int main() {
+  char buf[8192];
+  char* p = buf;
+  int len;
+  int result;
+  int mods;
+
+  memset(buf, 0, sizeof(buf));
+
+  /* read stdin in binary mode */
+  if (!freopen(0, "rb", stdin)) {
+    perror("freopen");
+    return 1;
+  }
+
+  if (!fread(buf, 1, sizeof(buf), stdin)) {
+    perror("fread");
+    return 1;
+  }
+
+  if (strncmp((char const*)p, "binoppai", 8)) {
+    puts("invalid input");
+    return 1;
+  }
+  p += 8;
+
+  printf("oppai %d.%d.%d\n", p[0], p[1], p[2]);
+  p += 3;
+  puts("");
+
+  /* error code */
+  result = read4(&p);
+  if (result < 0) {
+    printf("error %d\n", result);
+    return 1;
+  }
+
+  printf("artist: %s\n", read_str(&p, &len));
+  printf("artist_unicode: %s\n", read_str(&p, &len));
+  printf("title: %s\n", read_str(&p, &len));
+  printf("title_unicode: %s\n", read_str(&p, &len));
+  printf("version: %s\n", read_str(&p, &len));
+  printf("creator: %s\n", read_str(&p, &len));
+
+  mods = read4(&p);
+  puts("");
+  printf("mods: ");
+  if (mods & MODS_NF) printf("NF");
+  if (mods & MODS_EZ) printf("EZ");
+  if (mods & MODS_HD) printf("HD");
+  if (mods & MODS_HR) printf("HR");
+  if (mods & MODS_DT) printf("DT");
+  if (mods & MODS_HT) printf("HT");
+  if (mods & MODS_NC) printf("NC");
+  if (mods & MODS_FL) printf("FL");
+  if (mods & MODS_SO) printf("SO");
+  puts("");
+
+  printf("OD%g ", read_flt(&p));
+  printf("AR%g ", read_flt(&p));
+  printf("CS%g ", read_flt(&p));
+  printf("HP%g\n", read_flt(&p));
+  printf("%d/%dx\n", read4(&p), read4(&p));
+  printf("%d circles ", read2(&p));
+  printf("%d sliders ", read2(&p));
+  printf("%d spinners\n", read2(&p));
+  printf("scorev%d\n", read4(&p));
+  puts("");
+  printf("%g stars ", read_flt(&p));
+  printf("(%g speed, ", read_flt(&p));
+  printf("%g aim)\n", read_flt(&p));
+  read2(&p); /* legacy */
+  read2(&p); /* legacy */
+  puts("");
+  printf("%g aim pp\n", read_flt(&p));
+  printf("%g speed pp\n", read_flt(&p));
+  printf("%g acc pp\n", read_flt(&p));
+  puts("");
+  printf("%g pp\n", read_flt(&p));
+
+  return 0;
+}

examples/min.c

@@ -0,0 +1,16 @@
+/*
+ * gcc min.c -lm
+ * cat /path/to/file.osu | ./a.out
+ */
+
+#define OPPAI_IMPLEMENTATION
+#include "../oppai.c"
+
+int main() {
+  ezpp_t ez = ezpp_new();
+  ezpp_set_mods(ez, MODS_HD | MODS_DT);
+  ezpp(ez, "-");
+  printf("%gpp\n", ezpp_pp(ez));
+  return 0;
+}
+

examples/reuse.c

@@ -0,0 +1,61 @@
+/*
+ * gcc reuse.c -lm
+ * ./a.out /path/to/file.osu
+ */
+
+#define OPPAI_IMPLEMENTATION
+#include "../oppai.c"
+
+/*
+ * for better performance, the same instance can be reused
+ * settings are remembered and map is only reparsed if mods or cs change
+ */
+
+int main(int argc, char* argv[]) {
+  ezpp_t ez = ezpp_new();
+  ezpp_set_autocalc(ez, 1); /* autorecalc pp when changing any parameter */
+  ezpp(ez, argv[1]);
+
+  puts("---");
+  puts("nomod fc");
+  printf("%gpp\n", ezpp_pp(ez));
+  puts("---");
+
+  puts("nomod 95% fc");
+  ezpp_set_accuracy_percent(ez, 95);
+  printf("%gpp\n", ezpp_pp(ez));
+  puts("---");
+
+  puts("nomod 1x100 fc");
+  ezpp_set_accuracy(ez, 1, 0);
+  printf("%gpp\n", ezpp_pp(ez));
+  puts("---");
+
+  puts("HD 1x100 1miss 300x");
+  ezpp_set_mods(ez, MODS_HD);
+  ezpp_set_nmiss(ez, 1);
+  ezpp_set_combo(ez, 300);
+  printf("%gpp\n", ezpp_pp(ez));
+  puts("---");
+
+  puts("HDDT 1x100 1xmiss 300x");
+  ezpp_set_mods(ez, MODS_HD | MODS_DT);
+  printf("%gpp\n", ezpp_pp(ez));
+  puts("---");
+
+  puts("HDDT 1x100 1xmiss 300x ends at object 300");
+  ezpp_set_end(ez, 300);
+  printf("%gpp\n", ezpp_pp(ez));
+  puts("---");
+
+  puts("HDDT fc");
+  ezpp_set_end(ez, 0);
+  ezpp_set_combo(ez, -1);
+  ezpp_set_accuracy(ez, 0, 0);
+  ezpp_set_nmiss(ez, 0);
+  printf("%gpp\n", ezpp_pp(ez));
+  puts("---");
+
+  ezpp_free(ez);
+  return 0;
+}

examples/reuse_mem.c

@@ -0,0 +1,42 @@
+#define OPPAI_IMPLEMENTATION
+#include "oppai.c"
+
+char buf[1000000];
+int mods[] = { 0, MODS_HR, MODS_HD | MODS_HR, MODS_DT, MODS_HD | MODS_DT };
+#define N_MODS (sizeof(mods) / sizeof(mods[0]))
+
+void print_mods(int mods) {
+  putchar('+');
+  if (!mods) puts("nomod");
+  else {
+    if (mods & MODS_HD) printf("hd");
+    if (mods & MODS_HR) printf("hr");
+    if (mods & MODS_DT) printf("dt");
+    puts("");
+  }
+}
+
+int main(int argc, char* argv[]) {
+  int i, j, n, acc;
+  ezpp_t ez = ezpp_new();
+  ezpp_set_autocalc(ez, 1);
+  for (i = 1; i < argc; ++i) {
+    FILE* f = fopen(argv[i], "r");
+    n = fread(buf, 1, sizeof(buf), f);
+    fclose(f);
+    ezpp_data(ez, buf, n);
+    printf("%s - %s [%s]\n", ezpp_artist(ez), ezpp_title(ez),
+      ezpp_version(ez));
+    for (j = 0; j < N_MODS; ++j) {
+      print_mods(mods[j]);
+      ezpp_set_mods(ez, mods[j]);
+      for (acc = 95; acc <= 100; ++acc) {
+        ezpp_set_accuracy_percent(ez, acc);
+        printf("%d%% -> %gpp\n", acc, ezpp_pp(ez));
+      }
+    }
+    puts("");
+  }
+  ezpp_free(ez);
+  return 0;
+}

libbuild

@@ -0,0 +1,37 @@
+#!/bin/sh
+
+dir="$(dirname "$0")"
+. "$dir"/cflags
+
+tmp=$(mktemp -d)
+
+hide_unnecessary_symbols() {
+  [ ! -d "$tmp" ] && echo "W: couldn't find tmp dir" && return
+  gcc_syms="$tmp/gcc_exports.sym"
+  clang_syms="$tmp/clang_exports.list"
+  code="$tmp/main.c"
+  echo "int main() { return 0; }" >> "$code"
+  exports='ezpp ezpp_ errstr oppai_'
+  ( printf '{global:'
+    for e in $exports; do
+      printf '%s;' "$e"
+    done
+    printf 'local:*;};' ) | sed 's/_;/_*;/g' >"$gcc_syms"
+  echo "$exports" | tr ' ' '\n' | sed s/_$/_*/g > "$clang_syms"
+  for flags in "-Wl,--version-script=$gcc_syms" \
+               "-Wl,-exported_symbols_list,$clang_syms"
+  do
+    if "$cc" $flags "$code" -o /dev/null >/dev/null 2>&1; then
+      ldflags="$ldflags $flags"
+      return
+    fi
+  done
+  echo "W: can't figure out how to hide unnecessary symbols"
+}
+
+hide_unnecessary_symbols
+
+$cc -shared $cflags -DOPPAI_EXPORT \
+  "$@" oppai.c $ldflags -fpic -o liboppai.so
+
+[ -d "$tmp" ] && rm -rf "$tmp"

libbuild.bat

@@ -0,0 +1,14 @@
+@echo off
+
+del oppai.dll >nul 2>&1
+del oppai.obj >nul 2>&1
+del oppai.exp >nul 2>&1
+echo compiling
+cl ^
+  /c /O2 /nologo /Gm- /GR- /EHsc /W4 /Gz ^
+  /D_CRT_SECURE_NO_WARNINGS=1 /DNOMINMAX=1 ^
+  /DOPPAI_EXPORT /D_WINDLL /D_USRDLL ^
+  oppai.c ^
+  || EXIT /B 1
+echo making dll
+link /OUT:oppai.dll /IMPLIB:oppai.lib /NOLOGO /DLL oppai.obj

main.c

@@ -0,0 +1,966 @@
+/*
+ * this is free and unencumbered software released into the
+ * public domain.
+ *
+ * refer to the attached UNLICENSE or http://unlicense.org/
+ * ----------------------------------------------------------------
+ * command line interface for oppai
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <math.h>
+#include <ctype.h>
+#undef OPPAI_EXPORT
+#undef OPPAI_IMPLEMENTATION
+#include "oppai.c"
+
+char* me = "oppai";
+
+#define al_round(x) (float)floor((x) + 0.5f)
+#define al_min(a, b) ((a) < (b) ? (a) : (b))
+#define al_max(a, b) ((a) > (b) ? (a) : (b))
+#define twodec(x) (al_round((x) * 100.0f) / 100.0f)
+#define array_len(x) (sizeof(x) / sizeof((x)[0]))
+
+static
+float get_inf() {
+  static unsigned raw = 0x7F800000;
+  float* p = (float*)&raw;
+  return *p;
+}
+
+static
+int is_nan(float b) {
+  int* p = (int*)&b;
+  return (
+    (*p > 0x7F800000 && *p < 0x80000000) ||
+    (*p > 0x7FBFFFFF && *p <= 0xFFFFFFFF)
+  );
+}
+
+static
+int info(char* fmt, ...) {
+  int res;
+  va_list va;
+  va_start(va, fmt);
+  res = vfprintf(stderr, fmt, va);
+  va_end(va);
+  return res;
+}
+
+void usage() {
+  /* logo by flesnuk https://github.com/Francesco149/oppai-ng/issues/10 */
+
+  info(
+    "     /\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb"
+    "\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb/ /\xe2\x8e\xbb\xe2"
+    "\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb"
+    "\xe2\x8e\xbb/ /\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2"
+    "\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb/ /\xe2\x8e"
+    "\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2"
+    "\x8e\xbb\xe2\x8e\xbb/ /\xe2\x8e\xbb/      /\xe2\x8e\xbb"
+    "\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\\    /\xe2\x8e\xbb"
+    "\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e"
+    "\xbb\xe2\x8e\xbb/\n    / /\xe2\x8e\xbb\xe2\x8e\xbb\xe2"
+    "\x8e\xbb/ / / /\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb/ / "
+  );
+
+  info(
+    "/ /\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb/ /  \xe2\x8e\xbb"
+    "\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb/ / / / "
+    "___  / /\xe2\x8e\xbb\xe2\x8e\xbb\\ \\  / /\xe2\x8e\xbb"
+    "\xe2\x8e\xbb\xe2\x8e\xbb/ /\n   / /   / / / /   / / / /"
+    "   / / /\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb\xe2\x8e\xbb"
+    "\xe2\x8e\xbb/ / / / /__/ / /   / / / /   / /\n  / /___/ "
+    "/ / /___/ / / /___/ / / /___/ / / /      / /   / / / /__"
+    "_/ /\n /_______/ / ______/ / ______/ /_______/ /_/      "
+    "/_/   /_/ /_____  /\n          / /       / /            "
+    "                              / / \n         / /       /"
+    " /                                    /\xe2\x8e\xbb/___/"
+    " / \n        /_/       /_/                              "
+    "      /_______/"
+  );
+
+  info("\n\n");
+  info("usage: %s /path/to/file.osu parameters\n\n", me);
+
+  info(
+    "set filename to '-' to read from standard input\n"
+    "all parameters are case insensitive\n"
+    "\n"
+    "-o[output_module]\n"
+    "  output module. pass ? to list modules (oppai - -o?)\n"
+    "  default: text\n"
+    "  example: -ojson\n"
+    "\n"
+    "[accuracy]%%\n"
+    "  accuracy percentage\n"
+    "  default: 100%%\n"
+    "  example: 95%%\n"
+    "\n"
+    "[n]x100\n"
+    "  amount of 100s\n"
+    "  default: 0\n"
+    "  example: 2x100\n"
+    "\n"
+  );
+
+  info(
+    "[n]x50\n"
+    "  amount of 50s\n"
+    "  default: 0\n"
+    "  example: 2x50\n"
+    "\n"
+    "[n]xm\n"
+    "[n]xmiss\n"
+    "[n]m\n"
+    "  amount of misses\n"
+    "  default: 0\n"
+    "  example: 1m\n"
+    "\n"
+    "[combo]x\n"
+    "  highest combo achieved\n"
+    "  default: full combo (calculated from map data)\n"
+    "  example: 500x\n"
+    "\n"
+    "scorev[n]\n"
+    "  scoring system\n"
+    "  default: 1\n"
+    "  example: scorev2\n"
+    "\n"
+  );
+
+  info(
+    "ar[n]\n"
+    "  base approach rate override\n"
+    "  default: map's base approach rate\n"
+    "  example: AR5\n"
+    "\n"
+    "od[n]\n"
+    "  base overall difficulty override\n"
+    "  default: map's base overall difficulty\n"
+    "  example: OD10\n"
+    "\n"
+    "cs[n]\n"
+    "  base circle size override\n"
+    "  default: map's base circle size\n"
+    "  example: CS6.5\n"
+    "\n"
+  );
+
+  info(
+    "-m[n]\n"
+    "  gamemode id override for converted maps\n"
+    "  default: uses the map's gamemode\n"
+    "  example: -m1\n"
+    "\n"
+    "-taiko\n"
+    "  forces gamemode to taiko for converted maps\n"
+    "  default: disabled\n"
+    "\n"
+    "-touch\n"
+    "  calculates pp for touchscreen / touch devices. can \n"
+    "  also be specified as mod TD\n"
+    "\n"
+    "[n]speed\n"
+    "  override speed stars. "
+    "useful for maps with incorrect star rating\n"
+    "  default: uses computed speed stars\n"
+    "  example: 3.5speed\n"
+    "\n"
+  );
+
+  info(
+    "[n]aim\n"
+    "  override aim stars. "
+    "useful for maps with incorrect star rating\n"
+    "  default: uses computed aim stars\n"
+    "  example: 2.4aim\n"
+    "\n"
+    "-end[n]\n"
+    "  cuts map to a certain number of objects\n"
+  );
+}
+
+#define output_sig(name) void name(int result, ezpp_t ez, char* mods_str)
+
+typedef output_sig(fnoutput);
+
+/* null output --------------------------------------------------------- */
+
+/* stdout must be left alone, outputting to stderr is fine tho */
+output_sig(output_null) { (void)result; (void)ez; (void)mods_str; }
+
+/* text output --------------------------------------------------------- */
+
+#define ASCIIPLT_W 51
+
+void asciiplt(float (* getvalue)(void* data, int i), int n, void* data) {
+  static char* charset[] = {
+#ifdef OPPAI_UTF8GRAPH
+    "\xe2\x96\x81",
+    "\xe2\x96\x82",
+    "\xe2\x96\x83",
+    "\xe2\x96\x84",
+    "\xe2\x96\x85",
+    "\xe2\x96\x86",
+    "\xe2\x96\x87",
+    "\xe2\x96\x88"
+#else
+    " ", "_", ".", "-", "^"
+#endif
+  };
+
+  static int charsetsize = array_len(charset);
+
+  float values[ASCIIPLT_W];
+  float minval = (float)get_inf();
+  float maxval = (float)-get_inf();
+  float range;
+  int i;
+  int chunksize;
+  int w = al_min(ASCIIPLT_W, n);
+
+  memset(values, 0, sizeof(values));
+  chunksize = (int)ceil((float)n / w);
+
+  for (i = 0; i < n; ++i) {
+    int chunki = i / chunksize;
+    values[chunki] = al_max(values[chunki], getvalue(data, i));
+  }
+
+  for (i = 0; i < n; ++i) {
+    int chunki = i / chunksize;
+    maxval = al_max(maxval, values[chunki]);
+    minval = al_min(minval, values[chunki]);
+  }
+
+  range = al_max(0.00001f, maxval - minval);
+
+  for (i = 0; i < w; ++i) {
+    int chari = (int)(((values[i] - minval) / range) * charsetsize);
+    chari = al_max(0, al_min(chari, charsetsize - 1));
+    printf("%s", charset[chari]);
+  }
+
+  puts("");
+}
+
+float getaim(void* data, int i) {
+  ezpp_t ez = data;
+  return ezpp_strain_at(ez, i, DIFF_AIM);
+}
+
+float getspeed(void* data, int i) {
+  ezpp_t ez = data;
+  return ezpp_strain_at(ez, i, DIFF_SPEED);
+}
+
+output_sig(output_text) {
+  float ar, od, cs, hp, stars, aim_stars, speed_stars, accuracy_percent;
+  float pp, aim_pp, speed_pp, acc_pp;
+
+  if (result < 0) {
+    puts(errstr(result));
+    return;
+  }
+
+  printf("%s - %s ", ezpp_artist(ez), ezpp_title(ez));
+
+  if (strcmp(ezpp_artist(ez), ezpp_artist_unicode(ez)) ||
+    strcmp(ezpp_title(ez), ezpp_title_unicode(ez)))
+  {
+    printf("(%s - %s) ", ezpp_artist_unicode(ez), ezpp_title_unicode(ez));
+  }
+
+  printf("[%s] mapped by %s ", ezpp_version(ez), ezpp_creator(ez));
+  puts("\n");
+
+  ar = twodec(ezpp_ar(ez));
+  od = twodec(ezpp_od(ez));
+  cs = twodec(ezpp_cs(ez));
+  hp = twodec(ezpp_hp(ez));
+  stars = twodec(ezpp_stars(ez));
+  aim_stars = twodec(ezpp_aim_stars(ez));
+  speed_stars = twodec(ezpp_speed_stars(ez));
+  accuracy_percent = twodec(ezpp_accuracy_percent(ez));
+  pp = twodec(ezpp_pp(ez));
+  aim_pp = twodec(ezpp_aim_pp(ez));
+  speed_pp = twodec(ezpp_speed_pp(ez));
+  acc_pp = twodec(ezpp_acc_pp(ez));
+
+  printf("AR%g OD%g ", ar, od);
+
+  if (ezpp_mode(ez) == MODE_STD) {
+    printf("CS%g ", cs);
+  }
+
+  printf("HP%g\n", hp);
+  printf("300 hitwindow: %g ms\n", ezpp_odms(ez));
+
+  printf("%d circles, %d sliders, %d spinners\n",
+    ezpp_ncircles(ez), ezpp_nsliders(ez), ezpp_nspinners(ez));
+
+  if (ezpp_mode(ez) == MODE_STD) {
+    printf("%g stars (%g aim, %g speed)\n", stars, aim_stars, speed_stars);
+    printf("\nspeed strain: ");
+    asciiplt(getspeed, ezpp_nobjects(ez), ez);
+    printf("  aim strain: ");
+    asciiplt(getaim, ezpp_nobjects(ez), ez);
+  } else {
+    printf("%g stars\n", ezpp_stars(ez));
+  }
+
+  printf("\n");
+
+  if (mods_str) {
+    printf("+%s ", mods_str);
+  }
+
+  printf("%d/%dx ", ezpp_combo(ez), ezpp_max_combo(ez));
+  printf("%g%%\n", accuracy_percent);
+  printf("%g pp (", pp);
+
+  if (ezpp_mode(ez) == MODE_STD) {
+    printf("%g aim, ", aim_pp);
+  }
+
+  printf("%g speed, ", speed_pp);
+  printf("%g acc)\n\n", acc_pp);
+}
+
+/* json output --------------------------------------------------------- */
+
+void print_escaped_json_string_ex(char* str, int quotes) {
+  char* chars_to_escape = "\\\"";
+  char* p;
+  if (quotes) {
+    putchar('"');
+  }
+  for (; *str; ++str) {
+    /* escape all characters in chars_to_escape */
+    for (p = chars_to_escape; *p; ++p) {
+      if (*p == *str) {
+        putchar('\\');
+      }
+    }
+    putchar(*str);
+  }
+  if (quotes) {
+    putchar('"');
+  }
+}
+
+#define print_escaped_json_string(x) \
+  print_escaped_json_string_ex(x, 1)
+
+/* https://www.doc.ic.ac.uk/%7Eeedwards/compsys/float/nan.html */
+
+static int is_inf(float b) {
+  int* p = (int*)&b;
+  return *p == 0x7F800000 || *p == 0xFF800000;
+}
+
+/*
+ * json is mentally challenged and can't handle inf and nan so
+ * we're gonna be mathematically incorrect
+ */
+void fix_json_flt(float* v) {
+  if (is_inf(*v)) {
+    *v = -1;
+  } else if (is_nan(*v)) {
+    *v = 0;
+  }
+}
+
+output_sig(output_json) {
+  float pp, aim_pp, speed_pp, acc_pp, stars, aim_stars, speed_stars;
+  printf("{\"oppai_version\":\"%s\",", oppai_version_str());
+
+  if (result < 0) {
+    printf("\"code\":%d,", result);
+    printf("\"errstr\":");
+    print_escaped_json_string(errstr(result));
+    printf("}");
+    return;
+  }
+
+  pp = ezpp_pp(ez);
+  aim_pp = ezpp_aim_pp(ez);
+  speed_pp = ezpp_speed_pp(ez);
+  acc_pp = ezpp_acc_pp(ez);
+  stars = ezpp_stars(ez);
+  aim_stars = ezpp_aim_stars(ez);
+  speed_stars = ezpp_speed_stars(ez);
+  fix_json_flt(&pp);
+  fix_json_flt(&aim_pp);
+  fix_json_flt(&speed_pp);
+  fix_json_flt(&acc_pp);
+  fix_json_flt(&stars);
+  fix_json_flt(&aim_stars);
+  fix_json_flt(&speed_stars);
+
+  printf("\"code\":200,\"errstr\":\"no error\",");
+
+  printf("\"artist\":");
+  print_escaped_json_string(ezpp_artist(ez));
+
+  if (strcmp(ezpp_artist(ez), ezpp_artist_unicode(ez))) {
+    printf(",\"artist_unicode\":");
+    print_escaped_json_string(ezpp_artist_unicode(ez));
+  }
+
+  printf(",\"title\":");
+  print_escaped_json_string(ezpp_title(ez));
+
+  if (strcmp(ezpp_title(ez), ezpp_title_unicode(ez))) {
+    printf(",\"title_unicode\":");
+    print_escaped_json_string(ezpp_title_unicode(ez));
+  }
+
+  printf(",\"creator\":");
+  print_escaped_json_string(ezpp_creator(ez));
+
+  printf(",\"version\":");
+  print_escaped_json_string(ezpp_version(ez));
+
+  printf(",");
+
+  if (!mods_str) {
+    mods_str = "";
+  }
+
+  printf(
+    "\"mods_str\":\"%s\",\"mods\":%d,"
+    "\"od\":%g,\"ar\":%g,\"cs\":%g,\"hp\":%g,"
+    "\"combo\":%d,\"max_combo\":%d,"
+    "\"num_circles\":%d,\"num_sliders\":%d,"
+    "\"num_spinners\":%d,\"misses\":%d,"
+    "\"score_version\":%d,\"stars\":%.17g,"
+    "\"speed_stars\":%.17g,\"aim_stars\":%.17g,"
+    "\"aim_pp\":%.17g,\"speed_pp\":%.17g,\"acc_pp\":%.17g,"
+    "\"pp\":%.17g}",
+    mods_str, ezpp_mods(ez), ezpp_od(ez), ezpp_ar(ez),
+    ezpp_cs(ez), ezpp_hp(ez), ezpp_combo(ez),
+    ezpp_max_combo(ez), ezpp_ncircles(ez), ezpp_nsliders(ez),
+    ezpp_nspinners(ez), ezpp_nmiss(ez), ezpp_score_version(ez),
+    ezpp_stars(ez), ezpp_speed_stars(ez), ezpp_aim_stars(ez),
+    ezpp_aim_pp(ez), ezpp_speed_pp(ez), ezpp_acc_pp(ez), ezpp_pp(ez)
+  );
+}
+
+/* csv output ---------------------------------------------------------- */
+
+void print_escaped_csv_string(char* str) {
+  char* chars_to_escape = "\\;";
+  char* p;
+  for (; *str; ++str) {
+    /* escape all characters in chars_to_escape */
+    for (p = chars_to_escape; *p; ++p) {
+      if (*p == *str) {
+        putchar('\\');
+      }
+    }
+    putchar(*str);
+  }
+}
+
+output_sig(output_csv) {
+  printf("oppai_version;%s\n", oppai_version_str());
+
+  if (result < 0) {
+    printf("code;%d\nerrstr;", result);
+    print_escaped_csv_string(errstr(result));
+    return;
+  }
+
+  printf("code;200\nerrstr;no error\n");
+
+  printf("artist;");
+  print_escaped_csv_string(ezpp_artist(ez));
+  puts("");
+
+  if (strcmp(ezpp_artist(ez), ezpp_artist_unicode(ez))) {
+    printf("artist_unicode;");
+    print_escaped_csv_string(ezpp_artist_unicode(ez));
+    puts("");
+  }
+
+  printf("title;");
+  print_escaped_csv_string(ezpp_title(ez));
+  puts("");
+
+  if (strcmp(ezpp_title(ez), ezpp_title_unicode(ez))) {
+    printf("title_unicode;");
+    print_escaped_csv_string(ezpp_title_unicode(ez));
+    puts("");
+  }
+
+  printf("version;");
+  print_escaped_csv_string(ezpp_version(ez));
+  puts("");
+
+  printf("creator;");
+  print_escaped_csv_string(ezpp_creator(ez));
+  puts("");
+
+  if (!mods_str) {
+    mods_str = "";
+  }
+
+  printf(
+    "mods_str;%s\nmods;%d\nod;%g\nar;%g\ncs;%g\nhp;%g\n"
+    "combo;%d\nmax_combo;%d\nnum_circles;%d\n"
+    "num_sliders;%d\nnum_spinners;%d\nmisses;%d\n"
+    "score_version;%d\nstars;%.17g\nspeed_stars;%.17g\n"
+    "aim_stars;%.17g\naim_pp;%.17g\nspeed_pp;%.17g\nacc_pp;%.17g\npp;%.17g",
+    mods_str, ezpp_mods(ez), ezpp_od(ez), ezpp_ar(ez),
+    ezpp_cs(ez), ezpp_hp(ez), ezpp_combo(ez),
+    ezpp_max_combo(ez), ezpp_ncircles(ez), ezpp_nsliders(ez),
+    ezpp_nspinners(ez), ezpp_nmiss(ez), ezpp_score_version(ez),
+    ezpp_stars(ez), ezpp_speed_stars(ez), ezpp_aim_stars(ez),
+    ezpp_aim_pp(ez), ezpp_speed_pp(ez), ezpp_acc_pp(ez), ezpp_pp(ez)
+  );
+}
+
+/* binary output ------------------------------------------------------- */
+
+void write1(int v) {
+  char buf = (char)(v & 0xFF);
+  fwrite(&buf, 1, 1, stdout);
+}
+
+void write2(int v) {
+  char buf[2];
+  buf[0] = (char)(v & 0xFF);
+  buf[1] = (char)(v >> 8);
+  fwrite(buf, 1, 2, stdout);
+}
+
+void write4(int v) {
+  char buf[4];
+  buf[0] = (char)(v & 0xFF);
+  buf[1] = (char)((v >> 8) & 0xFF);
+  buf[2] = (char)((v >> 16) & 0xFF);
+  buf[3] = (char)((v >> 24) & 0xFF);
+  fwrite(buf, 1, 4, stdout);
+}
+
+void write_flt(float f) {
+  int* p = (int*)&f;
+  write4(*p);
+}
+
+void write_str(char* str) {
+  int len = al_min(0xFFFF, (int)strlen(str));
+  write2(len);
+  printf("%s", str);
+  write1(0);
+}
+
+output_sig(output_binary) {
+  int major, minor, patch;
+  (void)mods_str;
+
+  if (!freopen(0, "wb", stdout)) {
+    perror("freopen");
+    exit(1);
+  }
+
+  printf("binoppai");
+  oppai_version(&major, &minor, &patch);
+  write1(major);
+  write1(minor);
+  write1(patch);
+  write4(result);
+
+  if (result < 0) {
+    return;
+  }
+
+  /* TODO: use varargs to group calls of the same func */
+  write_str(ezpp_artist(ez));
+  write_str(ezpp_artist_unicode(ez));
+  write_str(ezpp_title(ez));
+  write_str(ezpp_title_unicode(ez));
+  write_str(ezpp_version(ez));
+  write_str(ezpp_creator(ez));
+  write4(ezpp_mods(ez));
+  write_flt(ezpp_od(ez));
+  write_flt(ezpp_ar(ez));
+  write_flt(ezpp_cs(ez));
+  write_flt(ezpp_hp(ez));
+  write4(ezpp_combo(ez));
+  write4(ezpp_max_combo(ez));
+  write2(ezpp_ncircles(ez));
+  write2(ezpp_nsliders(ez));
+  write2(ezpp_nspinners(ez));
+  write4(ezpp_score_version(ez));
+  write_flt(ezpp_stars(ez));
+  write_flt(ezpp_speed_stars(ez));
+  write_flt(ezpp_aim_stars(ez));
+  write2(0); /* legacy (nsingles) */
+  write2(0); /* legacy (nsigles_threshold) */
+  write_flt(ezpp_aim_pp(ez));
+  write_flt(ezpp_speed_pp(ez));
+  write_flt(ezpp_acc_pp(ez));
+  write_flt(ezpp_pp(ez));
+}
+
+/* gnuplot output ------------------------------------------------------ */
+
+#define gnuplot_string(x) print_escaped_json_string_ex(x, 0)
+
+void gnuplot_strains(ezpp_t ez, int type) {
+  int i;
+  for (i = 0; i < ezpp_nobjects(ez); ++i) {
+    printf("%.17g %.17g\n", ezpp_time_at(ez, i),
+      ezpp_strain_at(ez, i, type));
+  }
+}
+
+output_sig(output_gnuplot) {
+  if (result < 0 || ezpp_mode(ez) != MODE_STD) {
+    return;
+  }
+
+  puts("set encoding utf8;");
+
+  printf("set title \"");
+  gnuplot_string(ezpp_artist(ez));
+  printf(" - ");
+  gnuplot_string(ezpp_title(ez));
+
+  if (strcmp(ezpp_artist(ez), ezpp_artist_unicode(ez)) ||
+    strcmp(ezpp_title(ez), ezpp_title_unicode(ez)))
+  {
+    printf("(");
+    gnuplot_string(ezpp_artist_unicode(ez));
+    printf(" - ");
+    gnuplot_string(ezpp_title_unicode(ez));
+    printf(")");
+  }
+
+  printf(" [");
+  gnuplot_string(ezpp_version(ez));
+  printf("] mapped by ");
+  gnuplot_string(ezpp_creator(ez));
+  if (mods_str) printf(" +%s", mods_str);
+  puts("\";");
+
+  puts(
+    "set xlabel 'time (ms)';"
+    "set ylabel 'strain';"
+    "set multiplot layout 2,1 rowsfirst;"
+    "plot '-' with lines lc 1 title 'speed'"
+  );
+  gnuplot_strains(ez, DIFF_SPEED);
+  puts("e");
+  puts("unset title;");
+  puts("plot '-' with lines lc 2 title 'aim'");
+  gnuplot_strains(ez, DIFF_AIM);
+}
+
+/* ------------------------------------------------------------- */
+
+#define CODE_DESC "the code and errstr fields " \
+  "should be checked for errors. a negative value for code " \
+  "indicates an error"
+
+typedef struct output_module {
+  char* name;
+  fnoutput* func;
+  char* description[4];
+  /* null terminated array of strings because of c90 literal limits */
+} output_module_t;
+
+output_module_t modules[] = {
+  { "null", output_null, { "no output", 0 } },
+  { "text", output_text, { "plain text", 0 } },
+  {
+    "json", output_json,
+    { "a single utf-8 json object.\n" CODE_DESC, 0 }
+  },
+  {
+    "csv", output_csv,
+    { "fieldname;value\n"
+    "one value per line. ';' characters in strings will be " 
+    "escaped to \"\\;\". utf-8.\n" CODE_DESC, 0 }
+  },
+  {
+    "binary",
+    output_binary,
+    { "binary stream of values, encoded in little endian.\n"
+    "negative code values indicate an error, which matches "
+    "the error codes defined in oppai.c\n"
+    "for an example on how to read this in C, check out "
+    "examples/binary.c in oppai-ng's source\n"
+    "\n"
+    "floats and floats are represented using whatever "
+    "convention the host machine and compiler use. unless you "
+    "are on a really exotic machine it shouldn't matter\n"
+    "\n"
+    "strings (str) are encoded as a 2-byte integer indicating "
+    "the length in bytes, followed by the string bytes and ",
+    "a null (zero) terminating byte\n"
+    "\n"
+    "binoppai (8-byte magic), "
+    "int8 oppai_ver_major, int8 oppai_ver_minor, "
+    "int8 oppai_ver_patch, int error_code, "
+    "str artist, str artist_utf8, str title, str title_utf8, "
+    "str version, str creator, "
+    "int mods_bitmask, float od, float ar, float cs, "
+    "float hp, int combo, int max_combo, "
+    "int16 ncircles, int16 nsliders, int16 nspinner, "
+    "int score_version, float total_stars, ",
+    "float speed_stars, float aim_stars, int16 nsingles, "
+    "int16 nsingles_threshold, float aim_pp, "
+    "float speed_pp, float acc_pp, float pp",
+    0 }
+  },
+  { "gnuplot", output_gnuplot, { "gnuplot .gp script", 0 } },
+};
+
+output_module_t* output_by_name(char* name) {
+  int i;
+  for (i = 0; i < array_len(modules); ++i) {
+    if (!strcmp(modules[i].name, name)) {
+      return &modules[i];
+    }
+  }
+  return 0;
+}
+
+int cmpsuffix(char* str, char* suffix) {
+  int sufflen = (int)al_min(strlen(str), strlen(suffix));
+  return strcmp(str + strlen(str) - sufflen, suffix);
+}
+
+char lowercase(char c) {
+  if (c >= 'A' && c <= 'Z') {
+    return c + ('a' - 'A');
+  }
+  return c;
+}
+
+char uppercase(char c) {
+  if (c >= 'a' && c <= 'z') {
+    return c - ('a' - 'A');
+  }
+  return c;
+}
+
+int strcmp_nc(char* a, char* b) {
+  for (;; ++a, ++b) {
+    char la = lowercase(*a);
+    char lb = lowercase(*b);
+    if (la > lb) {
+      return 1;
+    }
+    else if (la < lb) {
+      return -1;
+    }
+    if (!*a || *b) {
+      break;
+    }
+  }
+  return 0;
+}
+
+/* TODO: split main into smaller funcs for readability? */
+int main(int argc, char* argv[]) {
+  int i;
+  int result;
+  ezpp_t ez = ezpp_new();
+  output_module_t* m;
+  char* output_name = "text";
+  char* mods_str = 0;
+  int mods = MODS_NOMOD;
+  float tmpf, speed_stars = 0, aim_stars = 0, accuracy_percent = 0;
+  int tmpi, n100 = 0, n50 = 0;
+
+  /* parse arguments ------------------------------------------------- */
+  me = argv[0];
+
+  if (argc < 2) {
+    usage();
+    return 1;
+  }
+
+  if (*argv[1] == '-' && strlen(argv[1]) > 1) {
+    char* a = argv[1] + 1;
+    if (!strcmp_nc(a, "version") || !strcmp_nc(a, "v")) {
+      puts(oppai_version_str());
+      return 0;
+    }
+  }
+
+  for (i = 2; i < argc; ++i) {
+    char* a = argv[i];
+    char* p;
+    int iswhite = 1;
+
+    for (p = a; *p; ++p) {
+      if (!isspace(*p)) {
+        iswhite = 0;
+        break;
+      }
+    }
+
+    if (iswhite) {
+      continue;
+    }
+
+    for (p = a; *p; ++p) {
+      *p = lowercase(*p);
+    }
+
+    if (*a == '-' && a[1] == 'o') {
+      output_name = a + 2;
+
+      if (!strcmp(output_name, "?")) {
+        int j;
+        int nmodules = sizeof(modules) / sizeof(modules[0]);
+        for (j = 0; j < nmodules; ++j) {
+          char** d = modules[j].description;
+          puts(modules[j].name);
+          for (; *d; ++d) {
+            printf("%s", *d);
+          }
+          puts("\n-");
+        }
+        return 0;
+      }
+
+      continue;
+    }
+
+    if (!cmpsuffix(a, "%") && sscanf(a, "%f", &accuracy_percent) == 1) {
+      continue;
+    }
+
+    if (!cmpsuffix(a, "x100") && sscanf(a, "%d", &n100) == 1) {
+      continue;
+    }
+
+    if (!cmpsuffix(a, "x50") && sscanf(a, "%d", &n50) == 1) {
+      continue;
+    }
+
+    if (!cmpsuffix(a, "speed") && sscanf(a, "%f", &speed_stars) == 1) {
+      continue;
+    }
+
+    if (!cmpsuffix(a, "aim") && sscanf(a, "%f", &aim_stars) == 1) {
+      continue;
+    }
+
+    if (!cmpsuffix(a, "xm") || !cmpsuffix(a, "xmiss") ||
+      !cmpsuffix(a, "m"))
+    {
+      if (sscanf(a, "%d", &tmpi) == 1) {
+        ezpp_set_nmiss(ez, tmpi);
+        continue;
+      }
+    }
+
+    if (!cmpsuffix(a, "x") && sscanf(a, "%d", &tmpi) == 1) {
+      ezpp_set_combo(ez, tmpi);
+      continue;
+    }
+
+    if (sscanf(a, "scorev%d", &tmpi)) {
+      ezpp_set_score_version(ez, tmpi);
+      continue;
+    }
+
+    if (sscanf(a, "ar%f", &tmpf)) {
+      ezpp_set_base_ar(ez, tmpf);
+      continue;
+    }
+
+    if (sscanf(a, "od%f", &tmpf)) {
+      ezpp_set_base_od(ez, tmpf);
+      continue;
+    }
+
+    if (sscanf(a, "cs%f", &tmpf)) {
+      ezpp_set_base_cs(ez, tmpf);
+      continue;
+    }
+
+    if (sscanf(a, "-m%d", &tmpi) == 1) {
+      ezpp_set_mode_override(ez, tmpi);
+      continue;
+    }
+
+    if (sscanf(a, "-end%d", &tmpi) == 1) {
+      ezpp_set_end(ez, tmpi);
+      continue;
+    }
+
+    if (!strcmp(a, "-taiko")) {
+      ezpp_set_mode_override(ez, MODE_TAIKO);
+      continue;
+    }
+
+    if (!strcmp(a, "-touch")) {
+      mods |= MODS_TOUCH_DEVICE;
+      continue;
+    }
+
+    /* this should be last because it uppercase's the string */
+    if (*a == '+') {
+      mods_str = a + 1;
+      for (p = mods_str; *p; ++p) {
+        *p = uppercase(*p);
+      }
+
+      #define m(mod) \
+        if (!strncmp(p, #mod, strlen(#mod))) { \
+          mods |= MODS_##mod; \
+          p += strlen(#mod); \
+          continue; \
+        }
+
+      for (p = mods_str; *p;) {
+        m(NF) m(EZ) m(TD) m(HD) m(HR) m(SD) m(DT) m(RX) m(HT) m(NC) m(FL)
+        m(AT) m(SO) m(AP) m(PF) m(NOMOD)
+        ++p;
+      }
+
+      #undef m
+      continue;
+    }
+
+    info(">%s\n", a);
+    result = ERR_SYNTAX;
+    goto output;
+  }
+
+  if (accuracy_percent) {
+    ezpp_set_accuracy_percent(ez, accuracy_percent);
+  } else {
+    ezpp_set_accuracy(ez, n100, n50);
+  }
+  ezpp_set_mods(ez, mods);
+  ezpp_set_speed_stars(ez, speed_stars);
+  ezpp_set_aim_stars(ez, aim_stars);
+  result = ezpp(ez, argv[1]);
+
+output:
+  m = output_by_name(output_name);
+  if (!m) {
+    info("output module '%s' does not exist. check 'oppai - -o?'\n",
+      output_name);
+    return 1;
+  }
+
+  m->func(result, ez, mods_str);
+  ezpp_free(ez); /* just so valgrind stops crying */
+  return result < 0;
+}
+

package

@@ -0,0 +1,16 @@
+#!/bin/sh
+
+dir=$(dirname $0)
+dir=$(readlink -f $dir)
+prevdir=$(pwd)
+cd $dir
+#git pull origin master || exit $?
+for prefix in i386/ ""; do
+  container="${prefix}oppai-ng:ubuntu"
+  docker build -t "$container" \
+    --build-arg PREFIX="$prefix" . || exit $?
+  docker run --rm -v $dir:/tmp \
+    -e arch=$(echo ${prefix:-x86_64} | tr -d /) \
+    "$container" || exit $?
+done
+cd $prevdir

release

@@ -0,0 +1,49 @@
+#!/bin/sh
+
+dir=$(dirname $0)
+
+olddir=$(pwd)
+cd $dir
+
+echo""
+echo "compiling and stripping"
+CC=musl-gcc ./build -static -no-pie || exit $?
+CC=gcc ./libbuild || exit $?
+
+echo""
+echo "packaging"
+folder="oppai-$(./oppai -version)-"
+folder="${folder}$(gcc -dumpmachine)"
+
+mkdir -p "$folder" || exit $?
+mv ./oppai $folder/oppai || exit $?
+mv ./liboppai.so $folder/liboppai.so || exit $?
+git archive HEAD --prefix=src/ -o "$folder"/src.tar ||
+  exit $?
+cd "$folder" || exit $?
+tar xf src.tar || exit $?
+cd .. || exit $?
+
+rm "$folder".tar.xz
+tar -cvJf "$folder".tar.xz \
+  "$folder"/oppai \
+  "$folder"/liboppai.so \
+  "$folder"/src \
+  || exit $?
+
+echo ""
+file "$folder".tar.xz
+tar tf "$folder".tar.xz
+
+echo ""
+file "$folder"/oppai
+readelf --dynamic "$folder"/oppai
+ldd "$folder"/oppai
+
+echo ""
+file "$folder"/liboppai.so
+ldd "$folder"/liboppai.so
+
+rm -rf "$folder"
+cd $olddir
+

release.ps1

@@ -0,0 +1,59 @@
+# you must allow script execution by running
+# 'Set-ExecutionPolicy RemoteSigned' in an admin powershell
+# this requires vcvars to be already set (see vcvarsall17.ps1)
+# 7zip is also required (choco install 7zip and add it to path)
+
+$dir = Split-Path -Parent $MyInvocation.MyCommand.Definition
+
+Push-Location "$dir"
+git pull origin master -q
+
+function Write-Header {
+  param ([string]$Text)
+  Write-Host $Text -Foreground Yellow -Background Black
+}
+
+function Header {
+  param ([string]$Title)
+  Write-Header ""
+  Write-Header "##########################################################"
+  Write-Header "> $Title"
+}
+
+cmd /c "build.bat"; if (-not $?) { exit $LastExitCode }
+cmd /c "libbuild.bat"; if (-not $?) { exit $LastExitCode }
+Header "Packaging"
+$folder = "oppai-" + $(.\oppai.exe -version) + "-windows-"
+$clout = & cl 2>&1 | %{ "$_" }
+"$clout" -match "(Microsoft.*for )([a-z0-9\-_]+)" | Out-Null
+if (-not $?) {
+  exit $LastExitCode
+}
+$folder = $folder + $Matches[2]
+mkdir $folder; if (-not $?) { exit $LastExitCode }
+Copy-Item oppai.exe $folder; if (-not $?) { exit $LastExitCode }
+Copy-Item oppai.dll $folder; if (-not $?) { exit $LastExitCode }
+Copy-Item oppai.lib $folder; if (-not $?) { exit $LastExitCode }
+git archive HEAD --prefix=src\ -o $folder\src.zip
+if (-not $?) {
+  exit $LastExitCode
+}
+Set-Location $folder; if (-not $?) { exit $LastExitCode }
+&7z x src.zip; if (-not $?) { exit $LastExitCode }
+Set-Location ..; if (-not $?) { exit $LastExitCode }
+
+if (Test-Path "$folder.zip") {
+  Remove-Item "$folder.zip"
+}
+
+&7z a "$folder.zip" $folder\oppai.exe $folder\oppai.dll $folder\oppai.lib `
+  $folder\src
+if (-not $?) {
+  exit $LastExitCode
+}
+
+Header "Result:"
+&7z l "$folder.zip"
+
+Remove-Item $folder -Force -Recurse
+Pop-Location

swig/README.md

@@ -0,0 +1,17 @@
+these are maintainer instructions, check the readme's in the binding
+directories for user guides
+
+# requirements
+* swig
+* docker
+* twine (pip)
+
+# building all bindings
+```sh
+./build.sh
+```
+
+# publishing all bindings
+```sh
+PUBLISH=1 ./build.sh
+```

swig/build.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+runall() {
+  for d in ./*/; do
+    [ "$d" = "." ] && continue
+    cd "$d"
+    ./build.sh || return $?
+    [ ! -z $PUBLISH ] && ./publish.sh
+    cd ..
+  done
+}
+
+dir="$(dirname "$0")"
+olddir="$(pwd)"
+cd "$dir"
+runall
+res=$?
+cd "$olddir"
+exit $res

swig/oppai.i

@@ -0,0 +1,11 @@
+%module oppai
+%feature("autodoc", "3");
+%apply int *OUTPUT {int*}
+%begin{
+#define SWIG_PYTHON_2_UNICODE
+}
+%{
+#define OPPAI_IMPLEMENTATION
+#include "oppai.c"
+%}
+#include "oppai.c"

swig/python/README.rst

@@ -0,0 +1,42 @@
+osu! pp and difficulty calculator. automatically generated C bindings for
+https://github.com/Francesco149/oppai-ng
+
+usage
+===========
+.. code-block:: sh
+
+    pip install oppai
+
+
+.. code-block:: python
+
+    #!/usr/bin/env python
+
+    import sys
+    from oppai import *
+
+    ez = ezpp_new()
+    ezpp(ez, sys.argv[1])
+    print("%g pp" % ezpp_pp(ez))
+    ezpp_free(ez)
+
+
+.. code-block:: sh
+
+    ./example.py /path/to/file.osu
+
+.. code-block:: sh
+
+    python -c 'help("oppai")'
+
+for a list of functions, or just read the top of oppai.c for better doc
+
+
+limitations
+===========
+for some reason, python3 doesn't provide a persisting pointer to strings
+you pass to c code even if you aren't doing anything with them, so if you
+want to reuse the handle at all you have to use ezpp_dup and ezpp_data_dup,
+which create a copy of the strings you pass in. this is inefficient so
+it's recommended to use autocalc mode and only call ezpp_dup or
+ezpp_data_dup when you're actually changing map

swig/python/build.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+rm -rf ./dist
+cp ../../oppai.c .
+cp ../oppai.i .
+swig -python -includeall oppai.i || exit
+for img in quay.io/pypa/manylinux2010_x86_64 quay.io/pypa/manylinux2010_i686; do
+  docker run --user 1000:1000 --rm -v $(pwd):/io -w /io $img \
+    ./build_wheels.sh || exit
+done

swig/python/build_wheels.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+# this is meant to be used from docker
+
+for pybin in /opt/python/*/bin
+do
+  rm *.so
+  "$pybin/pip" wheel . -w dist/ || exit
+done
+
+"$pybin/python" ./setup.py sdist || exit
+
+for w in dist/*linux_*.whl; do
+  auditwheel repair "$w" -w dist/ || exit
+done
+rm dist/*linux_*.whl

swig/python/examples/basic.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+
+import sys
+from oppai import *
+
+ez = ezpp_new()
+ezpp(ez, sys.argv[1])
+print("%g pp" % ezpp_pp(ez))
+ezpp_free(ez)

swig/python/examples/reuse.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+
+import sys
+from oppai import *
+
+ez = ezpp_new()
+ezpp_set_autocalc(ez, 1)
+for osufile in sys.argv[1:]:
+  ezpp_dup(ez, osufile)
+  print("%s - %s [%s]" % (ezpp_artist(ez), ezpp_title(ez), ezpp_version(ez)))
+  print("%g stars" % ezpp_stars(ez))
+  for acc in range(95, 101):
+    ezpp_set_accuracy_percent(ez, acc)
+    print("%g%% -> %g pp" % (acc, ezpp_pp(ez)))
+  print("")
+ezpp_free(ez)

swig/python/examples/reuse_mem.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+
+import sys
+from oppai import *
+
+if sys.version_info[0] < 3:
+  # hack to force utf-8 on py < 3
+  reload(sys)
+  sys.setdefaultencoding("utf-8")
+
+def mods_str(mods):
+  mods_str = "+"
+  if mods == 0:
+    mods_str += "nomod"
+  else:
+    if mods & MODS_HD: mods_str += "hd"
+    if mods & MODS_DT: mods_str += "dt"
+    if mods & MODS_HR: mods_str += "hr"
+  return mods_str
+
+ez = ezpp_new()
+ezpp_set_autocalc(ez, 1)
+for osufile in sys.argv[1:]:
+  # by providing the map in memory we can speed up subsequent re-parses
+  f = open(osufile, 'r')
+  data = f.read()
+  f.close()
+  ezpp_data_dup(ez, data, len(data.encode('utf-8')))
+  print("%s - %s [%s]" % (ezpp_artist(ez), ezpp_title(ez), ezpp_version(ez)))
+  print("%g stars" % ezpp_stars(ez))
+  for mods in [ 0, MODS_HR, MODS_HD | MODS_HR, MODS_DT, MODS_HD | MODS_DT ]:
+    print(mods_str(mods))
+    ezpp_set_mods(ez, mods)
+    for acc in range(95, 101):
+      ezpp_set_accuracy_percent(ez, acc)
+      print("%g%% -> %g pp" % (acc, ezpp_pp(ez)))
+  print("")
+ezpp_free(ez)

swig/python/examples/timing.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+
+import sys
+from oppai import *
+
+# prints timing points (just a test for this interface)
+ez = ezpp_new()
+ezpp(ez, sys.argv[1])
+for i in range(ezpp_ntiming_points(ez)):
+  time = ezpp_timing_time(ez, i)
+  ms_per_beat = ezpp_timing_ms_per_beat(ez, i)
+  change = ezpp_timing_change(ez, i)
+  print("%f | %f beats per ms | change: %d" % (time, ms_per_beat, change))
+ezpp_free(ez)

swig/python/publish.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+twine upload dist/*

swig/python/python.yml

@@ -0,0 +1,25 @@
+environment:
+  TWINE_USERNAME: lolisamurai
+  TWINE_PASSWORD:
+    secure: DTyX4L2loxFxlsbPYAwuga0DyOlGiOnJyEwi/j08gba0NyNx21TvRFMHpITIqcfg
+cache:
+- C:\ProgramData\chocolatey\bin
+- C:\ProgramData\chocolatey\lib
+- C:\Users\appveyor\AppData\Local\pip\Cache
+install:
+- IF NOT EXIST C:\ProgramData\chocolatey\bin\swig.exe choco install swig --version 3.0.12 --yes --limit-output
+- python -m pip install twine
+- python -m pip install cibuildwheel==0.10.1
+build_script:
+- cd swig/python
+- copy ..\..\oppai.c .
+- copy ..\oppai.i .
+- swig -python -includeall oppai.i
+- cibuildwheel --output-dir wheelhouse
+- ps: >-
+    if ($env:APPVEYOR_REPO_TAG -eq "true") {
+      Invoke-Expression "python -m twine upload --skip-existing wheelhouse/*.whl"
+    }
+artifacts:
+  - path: "swig\\python\\wheelhouse\\*.whl"
+    name: wheels

swig/python/setup.cfg

@@ -0,0 +1,2 @@
+[build_ext]
+swig-opts=-includeall

swig/python/setup.py

@@ -0,0 +1,58 @@
+import os
+import sys
+
+def parse_version_str():
+  import re
+  version_re = re.compile('^#define OPPAI_VERSION_(MAJOR|MINOR|PATCH)')
+  version = []
+  with open('oppai.c', 'r') as f:
+    for line in f:
+      if version_re.match(line):
+        version.append(str(int(line.split(' ')[2])))
+  return '.'.join(version)
+
+try:
+    from setuptools import setup, Extension
+except ImportError:
+    from distutils.core import setup, Extension
+
+try:
+  from oppai import oppai_version_str
+except Exception:
+  def oppai_version_str():
+    try:
+      return parse_version_str()
+    except Exception:
+      return "INVALID"
+
+oppai_classifiers = [
+    "Programming Language :: Python :: 2",
+    "Programming Language :: Python :: 3",
+    "Intended Audience :: Developers",
+    "License :: Public Domain",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Utilities",
+]
+
+f = open("README.rst", "r")
+oppai_readme = f.read()
+f.close()
+
+oppai_sources=['oppai.i']
+if os.system('swig') != 0:
+  oppai_sources=['oppai_wrap.c', 'oppai.c']
+
+setup(
+    name="oppai",
+    version=oppai_version_str(),
+    author="Franc[e]sco",
+    author_email="lolisamurai@tfwno.gf",
+    url="https://github.com/Francesco149/oppai-ng",
+    ext_modules=[Extension('_oppai', oppai_sources)],
+    py_modules=["oppai"],
+    description="osu! pp and difficulty calculator, C bindings",
+    long_description=oppai_readme,
+    license="Unlicense",
+    classifiers=oppai_classifiers,
+    keywords="osu! osu"
+)

test/build

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+dir="$(dirname "$0")"
+. "$dir"/../cflags
+
+$cc $cflags ${@:--DOPPAI_IMPLEMENTATION} \
+  test.c $ldflags -o oppai_test
+

test/build.bat

@@ -0,0 +1,16 @@
+@echo off
+
+set flags="%*"
+IF "%1"=="" (
+  set flags=-DOPPAI_IMPLEMENTATION
+)
+
+del oppai_test.exe >nul 2>&1
+del test.obj >nul 2>&1
+cl  -D_CRT_SECURE_NO_WARNINGS=1 ^
+  -DNOMINMAX=1 ^
+  -O2 -nologo -MT -Gm- -GR- -EHsc -W4 ^
+  %flags% ^
+  test.c ^
+  -Feoppai_test.exe ^
+  || EXIT /B 1

test/download_suite

@@ -0,0 +1,21 @@
+#!/bin/sh
+
+dir="$(dirname "$0")"
+if command -v realpath 2>&1 >/dev/null; then
+  wdir="$(realpath "$dir")"
+else
+  wdir="$dir"
+fi
+olddir="$(pwd)"
+cd "$wdir" || exit $?
+
+url="$(cat ./suite_url)"
+
+if [ $(find test_suite 2>/dev/null | tail -n +2 | wc -l) = "0" ]; then
+  curl -LO "$url" || exit $?
+  tar xf "$(basename $url)" || exit $?
+else
+  echo "using existing test_suite"
+fi
+
+cd "$olddir"

test/download_suite.ps1

@@ -0,0 +1,19 @@
+# you must allow script execution by running
+# 'Set-ExecutionPolicy RemoteSigned' in an admin powershell
+# 7zip is also required (choco install 7zip and add it to path)
+
+$url = Get-Content .\suite_url -Raw
+$dir = Split-Path -Parent $MyInvocation.MyCommand.Definition
+Push-Location "$dir"
+
+if ((Test-Path .\test_suite) -and (Get-ChildItem .\test_suite | Measure-Object).Count -gt 0) {
+  Write-Host "using existing test_suite"
+} else {
+  # my windows 7 install doesn't support Tls3
+  [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+  (New-Object System.Net.WebClient).DownloadFile($url, "$dir\test_suite.tar.gz")
+  &7z x .\test_suite.tar.gz
+  &7z x .\test_suite.tar
+}
+
+Pop-Location

test/download_suite.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+
+# very rough script that downloads unique maps from test_suite.json that
+# gensuite.py generates
+
+import sys
+import json
+
+try:
+    import httplib
+except ImportError:
+    import http.client as httplib
+
+try:
+    import urllib
+except ImportError:
+    import urllib.parse as urllib
+
+osu = httplib.HTTPSConnection('osu.ppy.sh')
+
+def osu_get(path):
+    while True:
+        try:
+            osu.request('GET', path)
+            r = osu.getresponse()
+
+            raw = bytes()
+
+            while True:
+                try:
+                    raw += r.read()
+                    break
+                except httplib.IncompleteRead as e:
+                    raw += e.partial
+
+            return raw
+
+        except (httplib.HTTPException, ValueError) as e:
+            sys.stderr.write('%s\n' % (traceback.format_exc()))
+
+            # prevents exceptions on next request if the
+            # response wasn't previously read due to errors
+            try:
+                osu.getresponse().read()
+            except httplib.HTTPException:
+                pass
+
+            time.sleep(5)
+
+
+if len(sys.argv) != 2:
+    sys.stderr.write('usage: %s test_suite.json\n' % sys.argv[0])
+    sys.exit(1)
+
+with open(sys.argv[1], 'r') as f:
+    scores = json.loads(f.read())
+
+unique_maps = set([s['beatmap_id'] for m in [0, 1] for s in scores[m]])
+i = 1
+
+for b in unique_maps:
+    sys.stderr.write(
+        "[%.02f%% - %d/%d] %s" % (i / float(len(unique_maps)) * 100, i,
+            len(unique_maps), b)
+    )
+    i += 1
+
+    # TODO: tmp file and rename
+    try:
+        with open(b + '.osu', 'r') as f:
+            sys.stderr.write(' (already exists)\n')
+            continue
+    except FileNotFoundError:
+        pass
+
+    sys.stderr.write('\n')
+
+    with open(b + '.osu', 'wb') as f:
+        f.write(osu_get('/osu/' + b))

test/gentest.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python
+
+import sys
+import os
+import time
+import json
+import traceback
+import argparse
+import hashlib
+
+if sys.version_info[0] < 3:
+  # hack to force utf-8
+  reload(sys)
+  sys.setdefaultencoding('utf-8')
+
+try:
+  import httplib
+except ImportError:
+  import http.client as httplib
+
+try:
+  import urllib
+except ImportError:
+  import urllib.parse as urllib
+
+# -------------------------------------------------------------------------
+
+parser = argparse.ArgumentParser(
+  description = (
+    'generates the oppai test suite. outputs c++ code to ' +
+    'stdout and the json dump to a file.'
+  )
+)
+
+parser.add_argument(
+  '-key',
+  default = None,
+  help = (
+    'osu! api key. required if -input-file is not present. ' +
+    'can also be specified through the OSU_API_KEY ' +
+    'environment variable'
+  )
+)
+
+parser.add_argument(
+  '-output-file',
+  default = 'test_suite.json',
+  help = 'dumps json to this file'
+)
+
+parser.add_argument(
+  '-input-file',
+  default = None,
+  help = (
+    'loads test suite from this json file instead of '
+    'fetching it from osu api. if set to "-", json will be '
+    'read from standard input'
+  )
+)
+
+args = parser.parse_args()
+
+if args.key == None and 'OSU_API_KEY' in os.environ:
+  args.key = os.environ['OSU_API_KEY']
+
+# -------------------------------------------------------------------------
+
+osu_treset = time.time() + 60
+osu_ncalls = 0
+
+def osu_get(conn, endpoint, paramsdict=None):
+  # GETs /api/endpoint?paramsdict&k=args.key from conn
+  # return json object, exits process on api errors
+  global osu_treset, osu_ncalls, args
+
+  sys.stderr.write('%s %s\n' % (endpoint, str(paramsdict)))
+
+  paramsdict['k'] = args.key
+  path = '/api/%s?%s' % (endpoint, urllib.urlencode(paramsdict))
+
+  while True:
+    while True:
+      if time.time() >= osu_treset:
+        osu_ncalls = 0
+        osu_treset = time.time() + 60
+        sys.stderr.write('\napi ready\n')
+
+      if osu_ncalls < 60:
+        break
+      else:
+        sys.stderr.write('waiting for api cooldown...\r')
+        time.sleep(1)
+
+
+    try:
+      conn.request('GET', path)
+      osu_ncalls += 1
+      r = conn.getresponse()
+
+      raw = ''
+
+      while True:
+        try:
+          raw += r.read()
+          break
+        except httplib.IncompleteRead as e:
+          raw += e.partial
+
+      j = json.loads(raw)
+
+      if 'error' in j:
+        sys.stderr.write('%s\n' % j['error'])
+        sys.exit(1)
+
+      return j
+
+    except (httplib.HTTPException, ValueError) as e:
+      sys.stderr.write('%s\n' % (traceback.format_exc()))
+
+      try:
+        # prevents exceptions on next request if the
+        # response wasn't previously read due to errors
+        conn.getresponse().read()
+
+      except httplib.HTTPException:
+        pass
+
+      time.sleep(5)
+
+
+def gen_modstr(bitmask):
+  # generates c++ code for a mod combination's bitmask
+  mods = []
+
+  allmods = {
+    (1<< 0, 'nf'), (1<< 1, 'ez'), (1<< 2, 'td'), (1<< 3, 'hd'),
+    (1<< 4, 'hr'), (1<< 6, 'dt'), (1<< 8, 'ht'),
+    (1<< 9, 'nc'), (1<<10, 'fl'), (1<<12, 'so')
+  }
+
+  for bit, string in allmods:
+    if bitmask & bit != 0:
+      mods.append(string)
+
+  if len(mods) == 0:
+    return 'nomod'
+
+  return ' | '.join(mods)
+
+# -------------------------------------------------------------------------
+
+if args.key == None:
+  sys.stderr.write(
+    'please set OSU_API_KEY or pass it as a parameter\n'
+  )
+  sys.exit(1)
+
+
+scores = []
+
+top_players = [
+  [ 124493, 4787150, 2558286, 1777162, 2831793, 50265 ],
+  [ 3174184, 8276884, 5991961, 2774767 ]
+]
+
+if args.input_file == None:
+  # fetch a fresh test suite from osu api
+  osu = httplib.HTTPSConnection('osu.ppy.sh')
+
+  for m in [0, 1]:
+    for u in top_players[m]:
+      params = { 'u': u, 'limit': 100, 'type': 'id', 'm': m }
+      batch = osu_get(osu, 'get_user_best', params)
+      for s in batch:
+        s['mode'] = m
+      scores += batch
+
+  # temporarily removed, not all std scores are recalc'd
+  #params = { 'm': 0, 'since': '2015-11-26' }
+  #maps = osu_get(osu, 'get_beatmaps', params)
+
+  # no taiko converts here because as explained below, tiny float
+  # errors can lead to completely broken conversions
+  for mode in [1]:
+    params = { 'm': mode, 'since': '2015-11-26' }
+    maps = osu_get(osu, 'get_beatmaps', params)
+
+    for m in maps:
+      params = { 'b': m['beatmap_id'], 'm': mode }
+      map_scores = osu_get(osu, 'get_scores', params)
+
+      if len(map_scores) == 0:
+        sys.stderr.write('W: map has no scores???\n')
+        continue
+
+      # note: api also returns qualified and loved, so ignore
+      # maps that don't have pp in rankings
+      if not 'pp' in map_scores[0] or map_scores[0]['pp'] is None:
+        sys.stderr.write('W: ignoring loved/qualified map\n')
+        continue
+
+      for s in map_scores:
+        s['beatmap_id'] = m['beatmap_id']
+        s['mode'] = mode
+
+      scores += map_scores
+
+
+  with open(args.output_file, 'w+') as f:
+    f.write(json.dumps(scores))
+
+else:
+  # load existing test suite from json file
+  with open(args.input_file, 'r') as f:
+    scores = json.loads(f.read())
+  # sort by mode by map
+  scores.sort(key=lambda x: int(x['beatmap_id'])<<32|x['mode'],
+    reverse=True)
+
+
+print('/* this code was automatically generated by gentest.py */')
+print('')
+
+# make code a little nicer by shortening mods
+allmods = {
+  'nf', 'ez', 'td', 'hd', 'hr', 'dt', 'ht', 'nc', 'fl', 'so', 'nomod'
+}
+
+for mod in allmods:
+  print('#define %s MODS_%s' % (mod, mod.upper()))
+
+print('''
+typedef struct {
+  int mode;
+  int id;
+  int max_combo;
+  int n300, n100, n50, nmiss;
+  int mods;
+  double pp;
+} score_t;
+
+score_t suite[] = {''')
+
+seen_hashes = []
+
+for s in scores:
+  # due to tiny floating point errors, maps can even double
+  # in combo and not even lazer gets this right, taiko converts are hell
+  # so I'm just gonna exclude them
+  if s['mode'] == 1:
+    is_convert = False
+    with open('test_suite/'+s['beatmap_id']+'.osu') as f:
+      for line in f:
+        split = line.split(':')
+        if len(split) >= 2 and split[0] == 'Mode' and int(split[1]) == 0:
+          is_convert = True
+          break
+
+    if is_convert:
+        continue
+
+    # some taiko maps ignore combo scaling for no apparent reason
+    # so i will only include full combos for now
+    if int(s['countmiss']) != 0:
+        continue
+
+  if s['pp'] is None:
+    continue
+
+  # why is every value returned by osu api a string?
+  line = (
+    '  { %d, %s, %s, %s, %s, %s, %s, %s, %s },' %
+    (
+      s['mode'], s['beatmap_id'], s['maxcombo'], s['count300'],
+      s['count100'], s['count50'], s['countmiss'],
+      gen_modstr(int(s['enabled_mods'])), s['pp']
+    )
+  )
+
+  # don't include identical scores by different people
+  s = hashlib.sha1(line).digest()
+  if s in seen_hashes:
+    continue
+
+  print(line)
+  seen_hashes.append(s)
+
+print('};\n')
+
+for mod in allmods:
+  print('#undef %s' % (mod))
+

test/pack_suite

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+dir="$(dirname "$0")"
+wdir="$(realpath "$dir")"
+
+olddir="$(pwd)"
+cd "$wdir" || exit $?
+tar -zcvf test_suite_$(date +%F).tar.gz test_suite/*.osu
+res=$?
+cd "$olddir"
+exit $res

test/suite_url

@@ -0,0 +1 @@
+https://github.com/Francesco149/oppai-ng/releases/download/2.3.2/test_suite_2019-02-19.tar.gz

test/test.c

@@ -0,0 +1,119 @@
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../oppai.c"
+#include "test_suite.c" /* defines suite */
+
+#define ERROR_MARGIN 0.02f /* pp can be off by +- 2% */
+
+/*
+ * margin is actually
+ * - 3x for < 100pp
+ * - 2x for 100-200pp
+ * - 1.5x for 200-300pp
+ */
+
+void print_score(score_t* s) {
+  char mods_str_buf[20];
+  char* mods_str = mods_str_buf;
+
+  strcpy(mods_str, "nomod");
+
+#define m(mod) \
+  if (s->mods & MODS_##mod) { \
+    mods_str += sprintf(mods_str, #mod); \
+  } \
+
+  m(HR) m(NC) m(HT) m(SO) m(NF) m(EZ) m(DT) m(FL) m(HD)
+#undef m
+
+  printf("m=%d %u +%s %dx %dx300 %dx100 %dx50 %dxmiss %g pp\n",
+    s->mode, s->id, mods_str_buf, s->max_combo, s->n300, s->n100,
+    s->n50, s->nmiss, s->pp);
+}
+
+int main() {
+  char fname_buf[4096];
+  char* fname = fname_buf;
+  int i, n = (int)(sizeof(suite) / sizeof(suite[0]));
+  float max_err[2] = { 0, 0 };
+  int max_err_map[2] = { 0, 0 };
+  float avg_err[2] = { 0, 0 };
+  int count[2] = { 0, 0 };
+  float error = 0;
+  float error_percent = 0;
+  ezpp_t ez = ezpp_new();
+  int err;
+  int last_id = 0;
+
+  fname += sprintf(fname, "test_suite/");
+
+  for (i = 0; i < n; ++i) {
+    score_t* s = &suite[i];
+    float margin;
+    float pptotal;
+
+    print_score(s);
+    if (s->id != last_id) {
+      sprintf(fname, "%u.osu", s->id);
+      last_id = s->id;
+      /* force reparse and don't reuse prev map ar/cs/od/hp */
+      ezpp_set_base_cs(ez, -1);
+      ezpp_set_base_ar(ez, -1);
+      ezpp_set_base_od(ez, -1);
+      ezpp_set_base_hp(ez, -1);
+    }
+    ezpp_set_mods(ez, s->mods);
+    ezpp_set_accuracy(ez, s->n100, s->n50);
+    ezpp_set_nmiss(ez, s->nmiss);
+    ezpp_set_combo(ez, s->max_combo);
+    ezpp_set_mode_override(ez, s->mode);
+    err = ezpp(ez, fname_buf);
+    if (err < 0) {
+      printf("%s\n", errstr(err));
+      exit(1);
+    }
+    pptotal = ezpp_pp(ez);
+    ++count[s->mode];
+
+    margin = (float)s->pp * ERROR_MARGIN;
+    if (s->pp < 100) {
+      margin *= 3;
+    } else if (s->pp < 200) {
+      margin *= 2;
+    } else if (s->pp < 300) {
+      margin *= 1.5f;
+    }
+
+    error = (float)fabs(pptotal - (float)s->pp);
+    error_percent = error / (float)s->pp;
+    avg_err[s->mode] += error_percent;
+    if (error_percent > max_err[s->mode]) {
+      max_err[s->mode] = error_percent;
+      max_err_map[s->mode] = s->id;
+    }
+
+    if (error >= margin) {
+      printf("failed test: got %g pp, expected %g\n", pptotal, s->pp);
+      exit(1);
+    }
+  }
+
+  for (i = 0; i < 2; ++i) {
+    switch (i) {
+      case MODE_STD: puts("osu"); break;
+      case MODE_TAIKO: puts("taiko"); break;
+    }
+    avg_err[i] /= count[i];
+    printf("%d scores\n", count[i]);
+    printf("avg err %f\n", avg_err[i]);
+    printf("max err %f on %d\n", max_err[i], max_err_map[i]);
+  }
+
+  ezpp_free(ez);
+
+  return 0;
+}
+

valgrind

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+valgrind --leak-check=full --track-origins=yes --show-leak-kinds=all "$@"

vcvarsall17.ps1

@@ -0,0 +1,15 @@
+# https://stackoverflow.com/questions/2124753/how-can-i-use-powershell-with-the-visual-studio-command-prompt
+
+param (
+  [string]$arch = "amd64"
+)
+
+Push-Location "C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\Common7\Tools"
+cmd /c "VsDevCmd.bat -arch=$arch&set" |
+ForEach-Object {
+  if ($_ -match "=") {
+    $v = $_.split("="); set-item -force -path "ENV:\$($v[0])"  -value "$($v[1])"
+  }
+}
+Pop-Location
+Write-Host "`nVisual Studio 2017 Command Prompt variables set." -ForegroundColor Yellow