Add bootstrap binary for elf2pe

It's now easier to cross compile a 2.5 kb hello world program for win32,
on arm64 xnu, that'll run on the very latest Windows, e.g.

cosmo-make -j12 m=x86_64 o/x86_64/tool/hello/hello-pe.ape

.git-blame-ignore-revs

@@ -27,3 +27,5 @@ da8baf2aa5ce93b958aca90a0ae69f537806324b
 369f9740de4534c28d0e81ab2afc99decbb9a3e6
 # Get rid of .internal.h convention in LIBC_INTRIN
 86d884cce24d773e298a2714c1e3d91ecab9be45
+# Remove .internal from more header filenames
+31194165d2afca36c2315a6e7ca2f0797dde09e3

.gitattributes

@@ -1,4 +1,10 @@
 # -*- conf -*-
 *.gz                         binary
-/build/bootstrap/*.com       binary
+*.so                         binary
+*.dll                        binary
+*.dylib                      binary
+/build/bootstrap/*           binary
+/usr/share/terminfo/*        binary
+/usr/share/terminfo/*/*      binary
 /usr/share/zoneinfo/*        binary
+/usr/share/zoneinfo/*/*      binary

.github/workflows/build.yml

@@ -1,5 +1,8 @@
 name: build
 
+env:
+  COSMOCC_VERSION: 3.9.2
+
 on:
   push:
     branches:
@@ -17,15 +20,50 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        mode: ["", tiny, rel, tinylinux, optlinux]
+        mode: ["", tiny, rel, tinylinux]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          # Full checkout needed for git-restore-mtime-bare.
+          fetch-depth: 0
+
+      # TODO(jart): fork this action.
+      - uses: chetan/git-restore-mtime-action@v2
+
+      - uses: actions/cache/restore@v4
+        id: cache
+        with:
+          path: |
+            .cosmocc
+            o
+          key: ${{ env.COSMOCC_VERSION }}-${{ matrix.mode }}-${{ github.sha }}
+          restore-keys: |
+            ${{ env.COSMOCC_VERSION }}-${{ matrix.mode }}-
+            ${{ env.COSMOCC_VERSION }}-
+
+      - name: Restore mtimes
+        if: steps.cache.outputs.cache-hit == 'true'
+        run: |
+          while read mtime file; do
+            [ -f "$file" ] && touch -d "@$mtime" "$file"
+          done < o/.mtimes
 
       - name: support ape bins 1
-        run: sudo cp build/bootstrap/ape.elf /usr/bin/ape
+        run: sudo cp -a build/bootstrap/ape.elf /usr/bin/ape
 
       - name: support ape bins 2
         run: sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
 
       - name: make matrix
         run: V=0 make -j2 MODE=${{ matrix.mode }}
+
+      - name: Save mtimes
+        run: |
+          find o -type f -exec stat -c "%Y %n" {} \; > o/.mtimes
+
+      - uses: actions/cache/save@v4
+        with:
+          path: |
+            .cosmocc
+            o
+          key: ${{ env.COSMOCC_VERSION }}-${{ matrix.mode }}-${{ github.sha }}

.github/workflows/nightly-cosmocc.yml

@@ -0,0 +1,24 @@
+name: Nightly cosmocc
+on:
+  schedule:
+    # https://crontab.guru/#37_4_*_*_*
+    - cron: "37 4 * * *"
+  workflow_dispatch:
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: true
+jobs:
+  build-cosmocc:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: |
+          sudo cp build/bootstrap/ape.elf /usr/bin/ape
+          sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
+      - run: tool/cosmocc/package.sh
+      # https://github.com/actions/upload-artifact/issues/590
+      - uses: actions/[email protected]
+        with:
+          name: cosmocc
+          path: cosmocc
+          compression-level: 9

.gitignore

@@ -1,6 +1,7 @@
 # -*- conf -*-
 
 /o
+/core
 /cosmocc
 /.cosmocc
 
@@ -15,3 +16,4 @@ __pycache__
 /tool/emacs/*.elc
 /perf.data
 /perf.data.old
+/qemu*core

.vscode/c_cpp_properties.json

@@ -0,0 +1,29 @@
+{
+    "configurations": [
+        {
+            "name": "Cosmopolitan",
+            "includePath": [
+                "${workspaceFolder}",
+                "${workspaceFolder}/libc/isystem"
+            ],
+            "defines": [
+                "_COSMO_SOURCE",
+                "MODE=\"aarch64\""
+            ],
+            "compilerPath": "${workspaceFolder}/.cosmocc/3.9.2/bin/aarch64-linux-cosmo-gcc",
+            "cStandard": "c17",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "gcc-arm64",
+            "compilerArgs": [
+                "-nostdinc",
+                "-iquote",
+                "${workspaceFolder}",
+                "-isystem",
+                "${workspaceFolder}/libc/isystem",
+                "-include",
+                "libc/integral/normalize.inc"
+            ]
+        }
+    ],
+    "version": 4
+}

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+    "[c]": {
+        "editor.tabSize": 2,
+        "editor.insertSpaces": true
+    },
+    "[cpp]": {
+        "editor.tabSize": 2,
+        "editor.insertSpaces": true
+    },
+    "[makefile]": {
+        "editor.tabSize": 8,
+        "editor.insertSpaces": false
+    },
+    "[make]": {
+        "editor.tabSize": 8,
+        "editor.insertSpaces": false
+    },
+    "[assembly]": {
+        "editor.tabSize": 8,
+        "editor.insertSpaces": true
+    },
+    "files.associations": {
+        "log.h": "c",
+        "*.inc": "c"
+    }
+}

Makefile

@@ -77,7 +77,8 @@ COMMA := ,
 PWD := $(shell pwd)
 
 # detect wsl2 running cosmopolitan binaries on the host by checking whether:
-# - user ran build/bootstrap/make, in which case make's working directory is in wsl
+# - user ran .cosmocc/current/bin/make, in which case make's working directory
+#   is in wsl
 # - user ran make, in which case cocmd's working directory is in wsl
 ifneq ($(findstring //wsl.localhost/,$(CURDIR) $(PWD)),)
 $(warning wsl2 interop is enabled)
@@ -89,7 +90,7 @@ UNAME_S := $(shell uname -s)
 
 # apple still distributes a 17 year old version of gnu make
 ifeq ($(MAKE_VERSION), 3.81)
-$(error please use build/bootstrap/make)
+$(error please use https://cosmo.zip/pub/cosmos/bin/make)
 endif
 
 LC_ALL = C
@@ -109,16 +110,15 @@ ECHO = $(BOOTSTRAP)/echo.ape
 CHMOD = $(BOOTSTRAP)/chmod.ape
 TOUCH = $(BOOTSTRAP)/touch.ape
 PKG = $(BOOTSTRAP)/package.ape
-MKDEPS = $(BOOTSTRAP)/mkdeps
+MKDEPS = build/bootstrap/mkdeps
 ZIPOBJ = $(BOOTSTRAP)/zipobj
 ZIPCOPY = $(BOOTSTRAP)/zipcopy
+ELF2PE = build/bootstrap/elf2pe
 PECHECK = $(BOOTSTRAP)/pecheck
-FIXUPOBJ = $(BOOTSTRAP)/fixupobj
+FIXUPOBJ = build/bootstrap/fixupobj
 OBJBINCOPY = $(BOOTSTRAP)/objbincopy
-MKDIR = build/bootstrap/mkdir -p
-COMPILE = build/bootstrap/compile -V9 -M2048m -P8192 $(QUOTA)
-
-IGNORE := $(shell $(MKDIR) $(TMPDIR))
+MKDIR = $(BOOTSTRAP)/mkdir.ape -p
+COMPILE = $(BOOTSTRAP)/compile.ape -V9 -M2048m -P8192 $(QUOTA)
 
 # the default build modes is empty string
 # on x86_64 hosts, MODE= is the same as MODE=x86_64
@@ -134,14 +134,13 @@ endif
 
 ifneq ($(findstring aarch64,$(MODE)),)
 ARCH = aarch64
-HOSTS ?= pi studio freebsdarm
+HOSTS ?= pi pi5 studio freebsdarm
 else
 ARCH = x86_64
-HOSTS ?= freebsd rhel7 xnu openbsd netbsd win10
+HOSTS ?= freebsd xnu win10 luna netbsd
 endif
 
 ZIPOBJ_FLAGS += -a$(ARCH)
-IGNORE := $(shell $(MKDIR) $(TMPDIR))
 
 export ADDR2LINE
 export LC_ALL
@@ -150,14 +149,20 @@ export MODE
 export SOURCE_DATE_EPOCH
 export TMPDIR
 
-COSMOCC = .cosmocc/3.5.7
+COSMOCC = .cosmocc/3.9.2
 BOOTSTRAP = $(COSMOCC)/bin
 TOOLCHAIN = $(COSMOCC)/bin/$(ARCH)-linux-cosmo-
-DOWNLOAD := $(shell build/download-cosmocc.sh $(COSMOCC) 3.5.7 596876951b62ad2530c63afc40edd805d751fcb2416e544d249af04ad00bb4ed)
+DOWNLOAD := $(shell build/download-cosmocc.sh $(COSMOCC) 3.9.2 f4ff13af65fcd309f3f1cfd04275996fb7f72a4897726628a8c9cf732e850193)
+
+IGNORE := $(shell $(MKDIR) $(TMPDIR))
+
+ifeq ($(ARCH), x86_64)
+TLSCC = build/bootstrap/tlscc
+endif
 
 AS = $(TOOLCHAIN)as
-CC = $(TOOLCHAIN)gcc
-CXX = $(TOOLCHAIN)g++
+CC = $(TLSCC) $(TOOLCHAIN)gcc
+CXX = $(TLSCC) $(TOOLCHAIN)g++
 CXXFILT = $(TOOLCHAIN)c++filt
 LD = $(TOOLCHAIN)ld.bfd
 NM = $(TOOLCHAIN)nm
@@ -190,39 +195,42 @@ o/$(MODE):			\
 o/$(MODE)/: o/$(MODE)
 o/$(MODE)/.: o/$(MODE)
 
-# check if we're using o//third_party/make/make
-# we added sandboxing to guarantee cosmo's makefile is hermetic
-# it also shaves away 200ms of startup latency with native $(uniq)
-ifneq ($(LANDLOCKMAKE_VERSION),)
-ifeq ($(UNAME_S),Linux)
-ifeq ($(wildcard /usr/bin/ape),)
-$(warning please run ape/apeinstall.sh if you intend to use landlock make)
-$(shell sleep .5)
-endif
-endif
 ifneq ($(TOOLCHAIN),)
-.STRICT = 1
-endif
-endif
-
-.PLEDGE += stdio rpath wpath cpath fattr proc
-.UNVEIL +=					\
-	libc/integral				\
-	libc/stdbool.h				\
-	rwc:/dev/shm				\
+# If you're using Cosmopolitan Make as your `make` command (you can
+# build it by saying `make o//third_party/make/make`) then these
+# variables will activate its pledge() and unveil() sandboxing
+# functionality when running on Linux. When cross-compiling, it's
+# important that your qemu binaries be statically compiled. See
+# third_party/qemu/ for our prebuilt qemu-aarch64 binary. Yes
+# binfmt_misc has to be configured to use it on foreign bins.
+.SANDBOXED = 1
+.PLEDGE := stdio rpath wpath cpath fattr proc
+.UNVEIL :=					\
+	rwcx:o					\
+	rwcx:/tmp				\
+	rwcx:$(TMPDIR)				\
+	rx:/usr/bin/ape				\
 	rx:.cosmocc				\
 	rx:build/bootstrap			\
-	r:build/portcosmo.h			\
+	libc/integral				\
+	rwc:/dev/shm				\
 	/proc/stat				\
 	rw:/dev/null				\
 	rw:/dev/full				\
-	w:o/stack.log				\
 	/etc/hosts				\
+	/etc/ape.trust				\
+	/etc/ape.revoke				\
+	/etc/ssh/ssh_host_ed25519_key.pub	\
 	~/.runit.psk				\
+	~/.ssh/authorized_keys			\
+	~/.ssh/id_ed25519.pub			\
+	~/.ape.trust				\
+	~/.ape.revoke				\
 	/proc/self/status			\
 	rx:/usr/bin/qemu-aarch64		\
-	rx:o/third_party/qemu/qemu-aarch64	\
-	/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
+	rx:/usr/bin/qemu-x86_64			\
+	rx:/usr/libexec/qemu-binfmt/aarch64-binfmt-P
+endif
 
 PKGS =
 
@@ -257,8 +265,10 @@ include third_party/gdtoa/BUILD.mk		# ├──DYNAMIC RUNTIME
 include third_party/nsync/mem/BUILD.mk		# │  You can now use stdio
 include libc/proc/BUILD.mk			# │  You can now use threads
 include libc/dlopen/BUILD.mk			# │  You can now use processes
-include libc/thread/BUILD.mk			# │  You can finally call malloc()
+include third_party/libunwind/BUILD.mk		# |  You can finally call malloc()
+include libc/thread/BUILD.mk			# │
 include third_party/zlib/BUILD.mk		# │
+include third_party/haclstar/BUILD.mk		# │
 include libc/stdio/BUILD.mk			# │
 include tool/hello/BUILD.mk			# │
 include third_party/tz/BUILD.mk			# │
@@ -275,33 +285,39 @@ include libc/BUILD.mk				#─┘
 include libc/sock/BUILD.mk			#─┐
 include net/http/BUILD.mk			# ├──ONLINE RUNTIME
 include third_party/musl/BUILD.mk		# │  You can communicate with the network
+include third_party/regex/BUILD.mk		# │
+include third_party/tr/BUILD.mk			# │
+include third_party/sed/BUILD.mk		# │
+include libc/system/BUILD.mk			# │
 include libc/x/BUILD.mk				# │
 include dsp/scale/BUILD.mk			# │
 include dsp/mpeg/BUILD.mk			# │
 include dsp/tty/BUILD.mk			# │
+include dsp/audio/BUILD.mk			# │
 include dsp/BUILD.mk				# │
 include third_party/stb/BUILD.mk		# │
 include third_party/mbedtls/BUILD.mk		# │
 include third_party/ncurses/BUILD.mk		# │
 include third_party/readline/BUILD.mk		# │
-include third_party/libunwind/BUILD.mk		# |
 include third_party/libcxxabi/BUILD.mk		# |
+include third_party/miniaudio/BUILD.mk		# |
 include third_party/double-conversion/BUILD.mk	# │
+include dsp/prog/BUILD.mk			# │
 include ctl/BUILD.mk				# │
 include third_party/libcxx/BUILD.mk		# │
 include third_party/openmp/BUILD.mk		# │
 include third_party/pcre/BUILD.mk		# │
 include third_party/less/BUILD.mk		# │
-include net/https/BUILD.mk			# │
-include third_party/regex/BUILD.mk		# │
-include third_party/bash/BUILD.mk		#─┘
+include net/https/BUILD.mk			#─┘
 include third_party/tidy/BUILD.mk
 include third_party/BUILD.mk
 include third_party/nsync/testing/BUILD.mk
 include libc/testlib/BUILD.mk
 include tool/viz/lib/BUILD.mk
 include tool/args/BUILD.mk
+include tool/chat/BUILD.mk
 include test/math/BUILD.mk
+include test/c11/BUILD.mk
 include test/posix/BUILD.mk
 include test/ctl/BUILD.mk
 include test/libcxx/BUILD.mk
@@ -310,11 +326,11 @@ include third_party/linenoise/BUILD.mk
 include third_party/maxmind/BUILD.mk
 include net/finger/BUILD.mk
 include third_party/double-conversion/test/BUILD.mk
+include third_party/dash/BUILD.mk
+include third_party/netcat/BUILD.mk
 include third_party/lua/BUILD.mk
 include third_party/tree/BUILD.mk
 include third_party/zstd/BUILD.mk
-include third_party/tr/BUILD.mk
-include third_party/sed/BUILD.mk
 include third_party/awk/BUILD.mk
 include third_party/hiredis/BUILD.mk
 include third_party/make/BUILD.mk
@@ -343,7 +359,6 @@ include tool/decode/lib/BUILD.mk
 include tool/decode/BUILD.mk
 include tool/lambda/lib/BUILD.mk
 include tool/lambda/BUILD.mk
-include tool/plinko/lib/BUILD.mk
 include tool/plinko/BUILD.mk
 include test/tool/plinko/BUILD.mk
 include tool/net/BUILD.mk
@@ -367,6 +382,7 @@ include test/libc/fmt/BUILD.mk
 include test/libc/time/BUILD.mk
 include test/libc/proc/BUILD.mk
 include test/libc/stdio/BUILD.mk
+include test/libc/system/BUILD.mk
 include test/libc/BUILD.mk
 include test/net/http/BUILD.mk
 include test/net/https/BUILD.mk
@@ -411,87 +427,91 @@ o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(
 o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x)))) $(INCS) $(INCS)
 	$(file >$@,$(INCS))
 o/$(MODE)/depend: o/$(MODE)/.x o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt o/$(MODE)/incs.txt $(SRCS) $(HDRS) $(INCS)
-	$(COMPILE) -AMKDEPS -L320 $(MKDEPS) -o $@ -s -r o/$(MODE)/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt @o/$(MODE)/incs.txt
+	$(COMPILE) -AMKDEPS -L320 $(MKDEPS) -o $@ -s -r o/$(MODE)/ -S c++:third_party/libcxx/ -S libc/isystem/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt @o/$(MODE)/incs.txt
 
 o/$(MODE)/srcs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(SRCS),$(file >>$@,$(x)))
 o/$(MODE)/hdrs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(HDRS) $(INCS),$(file >>$@,$(x)))
 
-TAGS: private .UNSANDBOXED = 1
+TAGS: private .SANDBOXED = 0
 TAGS:	o/$(MODE)/srcs-old.txt $(SRCS) #o/$(MODE)/third_party/ctags/ctags
 	@$(RM) $@
 	@o/$(MODE)/third_party/ctags/ctags $(TAGSFLAGS) -L $< -o $@
 
-HTAGS: private .UNSANDBOXED = 1
+HTAGS: private .SANDBOXED = 0
 HTAGS:	o/$(MODE)/hdrs-old.txt $(filter-out third_party/libcxx/%,$(HDRS)) #o/$(MODE)/third_party/ctags/ctags
 	@$(RM) $@
 	@build/htags o/$(MODE)/third_party/ctags/ctags -L $< -o $@
 
-loc: private .UNSANDBOXED = 1
+loc: private .SANDBOXED = 0
 loc: o/$(MODE)/tool/build/summy
-	find -name \*.h -or -name \*.c -or -name \*.S | \
+	find -name \*.h -or -name \*.hpp -or -name \*.c -or -name \*.cc -or -name \*.cpp -or -name \*.S -or -name \*.mk | \
 	$(XARGS) wc -l | grep total | awk '{print $$1}' | $<
 
-# PLEASE: MAINTAIN TOPOLOGICAL ORDER
-# FROM HIGHEST LEVEL TO LOWEST LEVEL
-COSMOPOLITAN_OBJECTS =			\
+COSMOPOLITAN =				\
 	CTL				\
-	THIRD_PARTY_DOUBLECONVERSION	\
-	THIRD_PARTY_OPENMP		\
-	TOOL_ARGS			\
-	NET_HTTP			\
-	LIBC_SOCK			\
-	LIBC_NT_WS2_32			\
-	LIBC_NT_IPHLPAPI		\
-	LIBC_X				\
-	THIRD_PARTY_GETOPT		\
+	DSP_AUDIO			\
+	LIBC_CALLS			\
+	LIBC_DLOPEN			\
+	LIBC_ELF			\
+	LIBC_FMT			\
+	LIBC_INTRIN			\
+	LIBC_IRQ			\
 	LIBC_LOG			\
-	THIRD_PARTY_TZ			\
-	THIRD_PARTY_MUSL		\
-	THIRD_PARTY_ZLIB_GZ		\
+	LIBC_MEM			\
+	LIBC_NEXGEN32E			\
+	LIBC_NT_ADVAPI32		\
+	LIBC_NT_BCRYPTPRIMITIVES	\
+	LIBC_NT_COMDLG32		\
+	LIBC_NT_GDI32			\
+	LIBC_NT_IPHLPAPI		\
+	LIBC_NT_KERNEL32		\
+	LIBC_NT_NTDLL			\
+	LIBC_NT_PDH			\
+	LIBC_NT_POWRPROF		\
+	LIBC_NT_PSAPI			\
+	LIBC_NT_REALTIME		\
+	LIBC_NT_SHELL32			\
+	LIBC_NT_SYNCHRONIZATION		\
+	LIBC_NT_USER32			\
+	LIBC_NT_WINMM			\
+	LIBC_NT_WS2_32			\
+	LIBC_PROC			\
+	LIBC_RUNTIME			\
+	LIBC_SOCK			\
+	LIBC_STDIO			\
+	LIBC_STR			\
+	LIBC_SYSTEM			\
+	LIBC_SYSV			\
+	LIBC_SYSV_CALLS			\
+	LIBC_THREAD			\
+	LIBC_TINYMATH			\
+	LIBC_VGA			\
+	LIBC_X				\
+	NET_HTTP			\
+	THIRD_PARTY_COMPILER_RT		\
+	THIRD_PARTY_DLMALLOC		\
+	THIRD_PARTY_DOUBLECONVERSION	\
+	THIRD_PARTY_GDTOA		\
+	THIRD_PARTY_GETOPT		\
 	THIRD_PARTY_LIBCXXABI		\
 	THIRD_PARTY_LIBUNWIND		\
-	LIBC_STDIO			\
-	THIRD_PARTY_GDTOA		\
-	THIRD_PARTY_REGEX		\
-	LIBC_THREAD			\
-	LIBC_PROC			\
-	THIRD_PARTY_NSYNC_MEM		\
-	LIBC_MEM			\
-	THIRD_PARTY_DLMALLOC		\
-	LIBC_DLOPEN			\
-	LIBC_RUNTIME			\
+	THIRD_PARTY_MUSL		\
 	THIRD_PARTY_NSYNC		\
-	LIBC_ELF			\
-	LIBC_IRQ			\
-	LIBC_CALLS			\
-	LIBC_SYSV_CALLS			\
-	LIBC_VGA			\
-	LIBC_NT_PSAPI			\
-	LIBC_NT_POWRPROF		\
-	LIBC_NT_PDH			\
-	LIBC_NT_GDI32			\
-	LIBC_NT_COMDLG32		\
-	LIBC_NT_USER32			\
-	LIBC_NT_NTDLL			\
-	LIBC_NT_ADVAPI32		\
-	LIBC_NT_SYNCHRONIZATION		\
-	LIBC_FMT			\
-	THIRD_PARTY_ZLIB		\
+	THIRD_PARTY_NSYNC_MEM		\
+	THIRD_PARTY_OPENMP		\
 	THIRD_PARTY_PUFF		\
-	THIRD_PARTY_COMPILER_RT		\
-	LIBC_TINYMATH			\
+	THIRD_PARTY_REGEX		\
+	THIRD_PARTY_TZ			\
 	THIRD_PARTY_XED			\
-	LIBC_STR			\
-	LIBC_SYSV			\
-	LIBC_INTRIN			\
-	LIBC_NT_BCRYPTPRIMITIVES	\
-	LIBC_NT_KERNEL32		\
-	LIBC_NEXGEN32E
+	THIRD_PARTY_ZLIB		\
+	THIRD_PARTY_ZLIB_GZ		\
+	TOOL_ARGS			\
 
 COSMOPOLITAN_H_PKGS =			\
 	APE				\
+	DSP_AUDIO			\
 	LIBC				\
 	LIBC_CALLS			\
 	LIBC_ELF			\
@@ -535,21 +555,21 @@ COSMOCC_PKGS =				\
 	THIRD_PARTY_INTEL
 
 o/$(MODE)/cosmopolitan.a:		\
-		$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_A_OBJS))
+		$(call reverse,$(call uniq,$(foreach x,$(COSMOPOLITAN),$($(x)))))
 
 COSMOCC_HDRS =								\
 	$(wildcard libc/integral/*)					\
 	$(foreach x,$(COSMOCC_PKGS),$($(x)_HDRS))			\
 	$(foreach x,$(COSMOCC_PKGS),$($(x)_INCS))
 
-o/cosmocc.h.txt: Makefile
+o/cosmocc.h.txt: Makefile libc $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x)))) $(HDRS) $(INCS)
 	$(file >$@, $(call uniq,$(COSMOCC_HDRS)))
 
 COSMOPOLITAN_H_ROOT_HDRS =						\
 	libc/integral/normalize.inc					\
 	$(foreach x,$(COSMOPOLITAN_H_PKGS),$($(x)_HDRS))
 
-o/cosmopolitan.html: private .UNSANDBOXED = 1
+o/cosmopolitan.html: private .SANDBOXED = 0
 o/cosmopolitan.html:							\
 		o/$(MODE)/third_party/chibicc/chibicc.dbg		\
 		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))	\
@@ -572,6 +592,7 @@ ifeq ($(ARCH), x86_64)
 TOOLCHAIN_ARTIFACTS =				\
 	o/$(MODE)/ape/ape.lds			\
 	o/$(MODE)/libc/crt/crt.o		\
+	o/$(MODE)/libc/crt/crtfastmath.o	\
 	o/$(MODE)/ape/ape.elf			\
 	o/$(MODE)/ape/ape.o			\
 	o/$(MODE)/ape/ape-copy-self.o		\
@@ -590,6 +611,7 @@ TOOLCHAIN_ARTIFACTS =				\
 	o/$(MODE)/ape/ape.elf			\
 	o/$(MODE)/ape/aarch64.lds		\
 	o/$(MODE)/libc/crt/crt.o		\
+	o/$(MODE)/libc/crt/crtfastmath.o	\
 	o/$(MODE)/cosmopolitan.a		\
 	o/$(MODE)/third_party/libcxx/libcxx.a	\
 	o/$(MODE)/tool/build/march-native	\
@@ -605,7 +627,7 @@ clean_toolchain:
 	$(RM) $(TOOLCHAIN_ARTIFACTS)
 
 aarch64: private .INTERNET = true
-aarch64: private .UNSANDBOXED = true
+aarch64: private .SANDBOXED = 0
 aarch64:
 	$(MAKE) m=aarch64
 

README.md

@@ -3,12 +3,12 @@
 [![build](https://github.com/jart/cosmopolitan/actions/workflows/build.yml/badge.svg)](https://github.com/jart/cosmopolitan/actions/workflows/build.yml)
 # Cosmopolitan
 
-[Cosmopolitan Libc](https://justine.lol/cosmopolitan/index.html) makes C
+[Cosmopolitan Libc](https://justine.lol/cosmopolitan/index.html) makes C/C++
 a build-once run-anywhere language, like Java, except it doesn't need an
 interpreter or virtual machine. Instead, it reconfigures stock GCC and
 Clang to output a POSIX-approved polyglot format that runs natively on
-Linux + Mac + Windows + FreeBSD + OpenBSD + NetBSD + BIOS with the best
-possible performance and the tiniest footprint imaginable.
+Linux + Mac + Windows + FreeBSD + OpenBSD 7.3 + NetBSD + BIOS with the
+best possible performance and the tiniest footprint imaginable.
 
 ## Background
 
@@ -87,15 +87,22 @@ ape/apeinstall.sh
 ```
 
 You can now build the mono repo with any modern version of GNU Make. To
-make life easier, we've included one in the cosmocc toolchain, which is
-guaranteed to be compatible and furthermore includes our extensions for
-doing build system sandboxing.
+bootstrap your build, you can install Cosmopolitan Make from this site:
+
+https://cosmo.zip/pub/cosmos/bin/make
+
+E.g.:
 
 ```sh
-build/bootstrap/make -j8
+curl -LO https://cosmo.zip/pub/cosmos/bin/make
+./make -j8
 o//examples/hello
 ```
 
+After you've built the repo once, you can also use the make from your
+cosmocc at `.cosmocc/current/bin/make`. You might even prefer to alias
+make to `$COSMO/.cosmocc/current/bin/make`.
+
 Since the Cosmopolitan repository is very large, you might only want to
 build one particular thing. Here's an example of a target that can be
 compiled relatively quickly, which is a simple POSIX test that only
@@ -103,7 +110,7 @@ depends on core LIBC packages.
 
 ```sh
 rm -rf o//libc o//test
-build/bootstrap/make o//test/posix/signal_test
+.cosmocc/current/bin/make o//test/posix/signal_test
 o//test/posix/signal_test
 ```
 
@@ -112,21 +119,21 @@ list out each individual one. For example if you wanted to build and run
 all the unit tests in the `TEST_POSIX` package, you could say:
 
 ```sh
-build/bootstrap/make o//test/posix
+.cosmocc/current/bin/make o//test/posix
 ```
 
 Cosmopolitan provides a variety of build modes. For example, if you want
 really tiny binaries (as small as 12kb in size) then you'd say:
 
 ```sh
-build/bootstrap/make m=tiny
+.cosmocc/current/bin/make m=tiny
 ```
 
 You can furthermore cut out the bloat of other operating systems, and
 have Cosmopolitan become much more similar to Musl Libc.
 
 ```sh
-build/bootstrap/make m=tinylinux
+.cosmocc/current/bin/make m=tinylinux
 ```
 
 For further details, see [//build/config.mk](build/config.mk).
@@ -242,16 +249,16 @@ server. You're welcome to join us! <https://discord.gg/FwAVVu7eJ4>
 
 ## Support Vector
 
-| Platform       | Min Version | Circa |
-| :---           | ---:        | ---:  |
-| AMD            | K8 Venus    | 2005  |
-| Intel          | Core        | 2006  |
-| Linux          | 2.6.18      | 2007  |
-| Windows        | 8 [1]       | 2012  |
-| Darwin (macOS) | 23.1.0+     | 2023  |
-| OpenBSD        | 7           | 2021  |
-| FreeBSD        | 13          | 2020  |
-| NetBSD         | 9.2         | 2021  |
+| Platform       | Min Version    | Circa |
+| :---           | ---:           | ---:  |
+| AMD            | K8             | 2003  |
+| Intel          | Core           | 2006  |
+| Linux          | 2.6.18         | 2007  |
+| Windows        | 8 [1]          | 2012  |
+| Darwin (macOS) | 23.1.0+        | 2023  |
+| OpenBSD        | 7.3 or earlier | 2023  |
+| FreeBSD        | 13             | 2020  |
+| NetBSD         | 9.2            | 2021  |
 
 [1] See our [vista branch](https://github.com/jart/cosmopolitan/tree/vista)
     for a community supported version of Cosmopolitan that works on Windows

ape/BUILD.mk

@@ -45,10 +45,12 @@ o/$(MODE)/ape: $(APE)
 
 o/$(MODE)/ape/aarch64.lds:			\
 	ape/aarch64.lds				\
-	libc/zip.internal.h			\
+	libc/zip.h				\
 	libc/thread/tls.h			\
 	libc/calls/struct/timespec.h		\
-	libc/macros.internal.h			\
+	libc/macros.h				\
+	libc/sysv/consts/prot.h			\
+	libc/dce.h				\
 	libc/str/str.h
 
 APE_LOADER_LDFLAGS =				\
@@ -162,8 +164,8 @@ o/$(MODE)/ape/ape-no-modify-self.o:		\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/thread/tls.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
+		libc/macho.h			\
+		libc/macros.h			\
 		libc/nexgen32e/uart.internal.h	\
 		libc/calls/metalfile.internal.h	\
 		libc/nt/pedef.internal.h	\
@@ -188,8 +190,8 @@ o/$(MODE)/ape/ape-copy-self.o:			\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/thread/tls.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
+		libc/macho.h			\
+		libc/macros.h			\
 		libc/nexgen32e/uart.internal.h	\
 		libc/calls/metalfile.internal.h	\
 		libc/nt/pedef.internal.h	\
@@ -246,8 +248,6 @@ o/$(MODE)/ape:	$(APE_CHECKS)			\
 		o/$(MODE)/ape/ape.lds		\
 		o/$(MODE)/ape/ape.elf		\
 		o/$(MODE)/ape/ape.macho		\
-		o/$(MODE)/ape/ape-copy-self.o	\
-		o/$(MODE)/ape/ape-no-modify-self.o
 
 endif
 
@@ -261,8 +261,8 @@ o/$(MODE)/ape/ape.o:				\
 		libc/thread/tls.h		\
 		ape/ape.internal.h		\
 		ape/macros.internal.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
+		libc/macho.h			\
+		libc/macros.h			\
 		libc/sysv/consts/prot.h		\
 		libc/nt/pedef.internal.h	\
 		libc/runtime/pc.internal.h	\
@@ -283,7 +283,7 @@ o/$(MODE)/ape/ape.lds:				\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/elf/pf2prot.internal.h	\
-		libc/macros.internal.h		\
+		libc/macros.h			\
 		libc/nt/pedef.internal.h	\
 		libc/str/str.h			\
-		libc/zip.internal.h
+		libc/zip.h

ape/aarch64.lds

@@ -4,6 +4,8 @@
 #include "libc/sysv/consts/prot.h"
 #include "libc/thread/tls.h"
 
+#define CACHELINE 64
+
 ENTRY(_start)
 OUTPUT_ARCH(aarch64)
 OUTPUT_FORMAT("elf64-littleaarch64",
@@ -73,13 +75,16 @@ SECTIONS {
     KEEP(*(SORT_NONE(.fini)))
   } =0x1f2003d5
 
-  . += CONSTANT(MAXPAGESIZE);
+  . = ALIGN(CONSTANT(MAXPAGESIZE));
+  __privileged_start = .;
 
   .privileged : {
-    __privileged_start = ABSOLUTE(.) & -CONSTANT(MAXPAGESIZE);
     *(.privileged*)
   } =0x1f2003d6
 
+  . = ALIGN(CONSTANT(MAXPAGESIZE));
+  _rodata = .;
+
   .rodata : {
     KEEP(*(.rodata.pytab.0));
     KEEP(*(.rodata.pytab.1));
@@ -103,10 +108,8 @@ SECTIONS {
     *(.eh_frame_entry .eh_frame_entry.*)
   }
 
-  .eh_frame : ONLY_IF_RO {
-    KEEP(*(.eh_frame))
-    *(.eh_frame.*)
-  }
+  __eh_frame_hdr_start = SIZEOF(.eh_frame_hdr) > 0 ? ADDR(.eh_frame_hdr) : 0;
+  __eh_frame_hdr_end = SIZEOF(.eh_frame_hdr) > 0 ? . : 0;
 
   .gcc_except_table : ONLY_IF_RO {
     *(.gcc_except_table .gcc_except_table.*)
@@ -127,9 +130,11 @@ SECTIONS {
   . += CONSTANT(MAXPAGESIZE);
   . = DATA_SEGMENT_ALIGN(CONSTANT(MAXPAGESIZE), CONSTANT(COMMONPAGESIZE));
 
-  .eh_frame : ONLY_IF_RW {
+  .eh_frame : {
+    __eh_frame_start = .;
     KEEP(*(.eh_frame))
     *(.eh_frame.*)
+    __eh_frame_end = .;
   }
 
   .gnu_extab : ONLY_IF_RW {
@@ -200,6 +205,9 @@ SECTIONS {
   .data : {
     __data_start = .;
     KEEP(*(SORT_BY_NAME(.piro.data.sort.*)))
+    . = ALIGN(CACHELINE);
+    *(.data.rarechange)
+    . = ALIGN(CACHELINE);
     *(.data .data.* .gnu.linkonce.d.*)
     KEEP(*(SORT_BY_NAME(.sort.data.*)))
     SORT(CONSTRUCTORS)
@@ -214,6 +222,9 @@ SECTIONS {
 
   .bss : {
     *(.dynbss)
+    . = ALIGN(CACHELINE);
+    *(.bss.rarechange)
+    . = ALIGN(CACHELINE);
     *(.bss .bss.* .gnu.linkonce.b.*)
     KEEP(*(SORT_BY_NAME(.piro.bss.sort.*)))
     *(COMMON)
@@ -259,6 +270,9 @@ SECTIONS {
   .debug_ranges       0 : { *(.debug_ranges) }
   .debug_macro        0 : { *(.debug_macro) }
   .debug_addr         0 : { *(.debug_addr) }
+  .debug_names        0 : { *(.debug_names) }
+  .debug_loclists     0 : { *(.debug_loclists) }
+  .debug_str_offsets  0 : { *(.debug_str_offsets) }
   .ARM.attributes     0 : { KEEP(*(.ARM.attributes)) KEEP(*(.gnu.attributes)) }
   .note.gnu.arm.ident 0 : { KEEP(*(.note.gnu.arm.ident)) }
 

ape/ape-m1.c

@@ -16,6 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#ifndef __APPLE__
+#error "ape/ape-m1.c is for apple silicon. chances you want ape/loader.c"
+#endif
+#ifndef __aarch64__
+#error "ape/ape-m1.c is for apple silicon; you want: make o//ape/ape.macho"
+#endif
 #include <assert.h>
 #include <dispatch/dispatch.h>
 #include <dlfcn.h>

ape/ape.S

@@ -37,7 +37,7 @@
 #include "libc/calls/metalfile.internal.h"
 #include "libc/dce.h"
 #include "libc/elf/def.h"
-#include "libc/macho.internal.h"
+#include "libc/macho.h"
 #include "libc/nexgen32e/uart.internal.h"
 #include "libc/nt/pedef.internal.h"
 #include "libc/runtime/pc.internal.h"
@@ -789,6 +789,33 @@ ape.ident:
 	.type	ape.ident,@object
 	.previous
 
+#if SupportsFreebsd()
+//
+//	This PT_NOTE enables the following kernel behaviors:
+//
+//	- P_OSREL_SIGSEGV ensures SIGEGV signals aren't misdelivered as
+//	  as SIGBUS with invalid siginfo fields.
+//
+//	- P_OSREL_SHUTDOWN_ENOTCONN is probably a good thing
+//
+//	- P_OSREL_SIGWAIT prevents sigwait() from raising EINTR
+//
+//	- P_OSREL_MAP_FSTRICT (basically MAP_SHARED_VALIDATE?)
+//
+	.section .note.freebsd.ident,"a",@progbits
+	.balign	4
+freebsd.ident:
+	.long	2f-1f
+	.long	4f-3f
+	.long	1 // NT_FREEBSD_ABI_TAG
+1:	.asciz	"FreeBSD"
+2:	.balign	4
+3:	.long	1300000 // v13.0+ c. 2020
+4:	.size	freebsd.ident,.-freebsd.ident
+	.type	freebsd.ident,@object
+	.previous
+#endif /* SupportsFreebsd() */
+
 #if SupportsOpenbsd()
 	.section .note.openbsd.ident,"a",@progbits
 	.balign	4
@@ -1086,6 +1113,19 @@ ape_pe:	.ascin	"PE",4
 	.long	PERDAT			// Flags
 	.previous
 
+	.section .pe.sections,"a",@progbits
+	.ascin	".idata",8		// Section Name
+	.long	ape_idt_memsz		// Virtual Size or Physical Address
+	.long	ape_idt_rva		// Relative Virtual Address
+	.long	ape_idt_filesz		// Physical Size
+	.long	ape_idt_offset		// Physical Offset
+	.long	0			// Relocation Table Offset
+	.long	0			// Line Number Table Offset
+	.short	0			// Relocation Count
+	.short	0			// Line Number Count
+	.long	PEIMPS			// Flags
+	.previous
+
 	.section .pe.sections,"a",@progbits
 	.ascin	".data",8		// Section Name
 	.long	ape_ram_memsz		// Virtual Size or Physical Address
@@ -1711,6 +1751,7 @@ kernel:	movabs	$ape_stack_vaddr,%rsp
 	mov	$0x79000,%esi
 	mov	$0x7f000,%edx
 	call	__reclaim_boot_pages
+	movl	$1,__pib(%rip)
 	push	$_HOSTMETAL			// sets __hostos in crt.S
 	pop	%rcx
 	pushq	.Lenv0(%rip)			// envp[0][0]
@@ -1828,7 +1869,7 @@ __bss_end:
 	.section .notice,"aR",@progbits
 	.asciz	"\n\n\
 Cosmopolitan\n\
-Copyright 2024 Justine Alexandra Roberts Tunney\n\
+Copyright 2025 Justine Alexandra Roberts Tunney\n\
 \n\
 Permission to use, copy, modify, and/or distribute this software for\n\
 any purpose with or without fee is hereby granted, provided that the\n\
@@ -1844,4 +1885,4 @@ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n\
 PERFORMANCE OF THIS SOFTWARE."
 
 .end
-
+

ape/ape.lds

@@ -186,6 +186,8 @@
 /* uncomment if .com.dbg won't execute on your kernel (will break .com file) */
 /* #define APE_FIX_COM_DBG */
 
+#define CACHELINE 64
+
 #ifdef __x86__
 #define CODE_GRANULE 1
 #else
@@ -199,7 +201,7 @@
 #endif
 
 #ifndef IMAGE_BASE_VIRTUAL
-#define IMAGE_BASE_VIRTUAL 0x400000
+#define IMAGE_BASE_VIRTUAL 0x4200000
 #endif
 
 #if IMAGE_BASE_VIRTUAL > 0xffffffff
@@ -237,11 +239,10 @@ SECTIONS {
     KEEP(*(.elf.phdrs))
     ape_phdrs_end = .;
 
-    /* OpenBSD */
+    /* ELF PT_NOTE data structures */
     . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 0);
     ape_note = .;
-    KEEP(*(.note.openbsd.ident))
-    KEEP(*(.note.netbsd.ident))
+    KEEP(*(.note.*))
     ape_note_end = .;
 
     /* Portable Executable */
@@ -310,7 +311,7 @@ SECTIONS {
     . = ALIGN(__privileged_end > __privileged_start ? CONSTANT(COMMONPAGESIZE) : 0);
 /*END: morphable code */
     __privileged_start = .;
-    *(.privileged)
+    *(.privileged .privileged.*)
     __privileged_end = .;
 
     KEEP(*(.ape.pad.text))
@@ -321,6 +322,7 @@ SECTIONS {
 /*BEGIN: Read Only Data */
 
   .rodata ALIGN(CONSTANT(COMMONPAGESIZE)) : {
+    _rodata = .;
     KEEP(*(.rodata.pytab.0));
     KEEP(*(.rodata.pytab.1));
     KEEP(*(.rodata.pytab.2));
@@ -329,6 +331,10 @@ SECTIONS {
     *(.ubsan.types)
     *(.ubsan.data)
 
+    __eh_frame_hdr_start_actual = .;
+    *(.eh_frame_hdr)
+    __eh_frame_hdr_end_actual = .;
+
     /* Legal Notices */
     __notices = .;
     KEEP(*(.notice))
@@ -338,12 +344,6 @@ SECTIONS {
 
 /*BEGIN: read-only data that's only needed for initialization */
 
-#if SupportsWindows()
-    /* Windows DLL Import Directory */
-    KEEP(*(.idata.ro));
-    KEEP(*(SORT_BY_NAME(.idata.ro.*)))
-#endif
-
     /* Encoded Data Structures w/ Linear Initialization Order */
     KEEP(*(.initroprologue))
     KEEP(*(SORT_BY_NAME(.initro.*)))
@@ -382,13 +382,34 @@ SECTIONS {
     _tbss_end = .;
   } :Tls
 
+  .idata : {
+#if SupportsWindows()
+    KEEP(*(.dllstr));
+    KEEP(*(.idata.ro));
+    KEEP(*(SORT_BY_NAME(.idata.ro.*)));
+    KEEP(*(SORT_BY_NAME(.piro.data.sort.iat.*)));
+    KEEP(*(.data.nt.*));
+#endif
+    . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
+  } :Ram
+
+  .eh_frame : {
+    __eh_frame_start = .;
+    KEEP(*(.eh_frame))
+    *(.eh_frame.*)
+    __eh_frame_end = .;
+  } :Ram
+
   .data . : {
 /*BEGIN: Read/Write Data */
-#if SupportsWindows()
-    KEEP(*(SORT_BY_NAME(.piro.data.sort.iat.*)))
-#endif
 /*BEGIN: NT FORK COPYING */
     KEEP(*(.dataprologue))
+
+    /* Precious Runtime Constants */
+    . = ALIGN(CACHELINE);
+    *(.data.rarechange)
+    . = ALIGN(CACHELINE);
+
     *(.data .data.*)
     *(.gnu_extab)
     *(.gcc_except_table .gcc_except_table.*)
@@ -430,7 +451,6 @@ SECTIONS {
     KEEP(*(.piro.pad.data))
     *(.igot.plt)
     KEEP(*(.dataepilogue))
-
     . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
 /*END: NT FORK COPYING */
     _edata = .;
@@ -454,6 +474,11 @@ SECTIONS {
     . += . > 0 ? CODE_GRANULE : 0;
 /*END: Post-Initialization Read-Only */
 
+    /* Precious Runtime Constants */
+    . = ALIGN(CACHELINE);
+    *(.bss.rarechange)
+    . = ALIGN(CACHELINE);
+
     /* Statically Allocated Empty Space */
     *(SORT_BY_ALIGNMENT(.bss))
     *(SORT_BY_ALIGNMENT(.bss.*))
@@ -510,6 +535,9 @@ SECTIONS {
   .debug_rnglists    0 : { *(.debug_rnglists) }
   .debug_macro       0 : { *(.debug_macro) }
   .debug_addr        0 : { *(.debug_addr) }
+  .debug_names       0 : { *(.debug_names) }
+  .debug_loclists    0 : { *(.debug_loclists) }
+  .debug_str_offsets 0 : { *(.debug_str_offsets) }
   .gnu.attributes    0 : { KEEP(*(.gnu.attributes)) }
   .GCC.command.line  0 : { *(.GCC.command.line) }
 
@@ -536,7 +564,7 @@ SECTIONS {
   }
 }
 
-ape_pe_filealignment = 512;
+ape_pe_filealignment = 4096;
 ape_pe_sectionalignment = 4096;
 ape_pe_sizeofheaders = SIZEOF(.head);
 ape_pe_sizeofimage = ROUNDUP(_end - __executable_start, ape_pe_sectionalignment);
@@ -573,11 +601,19 @@ ape_rom_memsz = ape_rom_filesz;
 ape_rom_align = CONSTANT(COMMONPAGESIZE);
 ape_rom_rva = RVA(ape_rom_vaddr);
 
-ape_ram_vaddr = ADDR(.data);
+ape_idt_vaddr = ADDR(.idata);
+ape_idt_offset = ape_idt_vaddr - __executable_start;
+ape_idt_paddr = LOADADDR(.idata);
+ape_idt_filesz = ADDR(.eh_frame) - ADDR(.idata);
+ape_idt_memsz = ape_idt_filesz;
+ape_idt_align = CONSTANT(COMMONPAGESIZE);
+ape_idt_rva = RVA(ape_idt_vaddr);
+
+ape_ram_vaddr = ADDR(.eh_frame);
 ape_ram_offset = ape_ram_vaddr - __executable_start;
-ape_ram_paddr = LOADADDR(.data);
-ape_ram_filesz = ADDR(.bss) - ADDR(.data);
-ape_ram_memsz = _end - ADDR(.data);
+ape_ram_paddr = LOADADDR(.eh_frame);
+ape_ram_filesz = ADDR(.bss) - ADDR(.eh_frame);
+ape_ram_memsz = _end - ADDR(.eh_frame);
 ape_ram_align = CONSTANT(COMMONPAGESIZE);
 ape_ram_rva = RVA(ape_ram_vaddr);
 
@@ -587,7 +623,7 @@ ape_stack_offset = 0;
 ape_stack_vaddr = DEFINED(ape_stack_vaddr) ? ape_stack_vaddr : 0x700000000000;
 ape_stack_paddr = ape_ram_paddr + ape_ram_filesz;
 ape_stack_filesz = 0;
-ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : 8 * 1024 * 1024;
+ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : 8 * 1024 * 1024;  /* for gnu make */
 
 ape_note_offset = ape_cod_offset + (ape_note - ape_cod_vaddr);
 ape_note_filesz = ape_note_end - ape_note;
@@ -601,6 +637,9 @@ ape_text_memsz = ape_text_filesz;
 ape_text_align = CONSTANT(COMMONPAGESIZE);
 ape_text_rva = RVA(ape_text_vaddr);
 
+__eh_frame_hdr_start = __eh_frame_hdr_end_actual > __eh_frame_hdr_start_actual ? __eh_frame_hdr_start_actual : 0;
+__eh_frame_hdr_end = __eh_frame_hdr_end_actual > __eh_frame_hdr_start_actual ? __eh_frame_hdr_end_actual : 0;
+
 /* we roundup here because xnu wants the file load segments page-aligned */
 /* but we don't want to add the nop padding to the ape program, so we'll */
 /* let ape.S dd read past the end of the file into the wrapping binaries */
@@ -698,8 +737,10 @@ CHURN(ape_pe_sections);
 CHURN(ape_pe_sections_end);
 CHURN(ape_pe_shnum);
 CHURN(ape_phdrs_end);
-CHURN(WinMain);
 #endif /* SupportsWindows() */
+#if SupportsWindows()
+CHURN(WinMain);
+#endif
 #endif /* SupportsXnu() */
 
 #if SupportsWindows() || SupportsMetal()

ape/apeinstall.sh

@@ -10,8 +10,8 @@ if [ ! -f ape/loader.c ]; then
   cd "$COSMO" || exit
 fi
 
-if [ -x build/bootstrap/make ]; then
-  MAKE=build/bootstrap/make
+if [ -x .cosmocc/current/bin/make ]; then
+  MAKE=.cosmocc/current/bin/make
 else
   MAKE=make
 fi

ape/idata.internal.h

@@ -107,7 +107,7 @@
 	*/.section ".piro.data.sort.iat.2.\name\().3","awG",@progbits,"\name",comdat
 	.quad	0
   .previous
-  .section .rodata.str1.1,"aSM",@progbits,1
+  .section .dllstr,"aSM",@progbits,1
 ".Lidata.str.\name":
 	.asciz	"\name\().dll"
   .previous

ape/launch.S

@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Calls _start() function of loaded program.
 //

ape/loader-macho.S

@@ -16,10 +16,10 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macho.internal.h"
+#include "libc/macho.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Apple Mach-O Executable Headers
 //	Fixups are applied by objbincopy

ape/macros.internal.h

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #ifndef APE_MACROS_H_
 #define APE_MACROS_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #ifdef __ASSEMBLER__
 /* clang-format off */
 

ape/relocations.h

@@ -14,7 +14,7 @@
 #define IMAGE_BASE_REAL 0x2000
 
 #ifndef IMAGE_BASE_VIRTUAL
-#define IMAGE_BASE_VIRTUAL 0x400000
+#define IMAGE_BASE_VIRTUAL 0x4200000
 #endif
 
 #ifndef IMAGE_BASE_PHYSICAL

ape/sections.internal.h

@@ -6,6 +6,7 @@ extern const char __notices[] __attribute__((__weak__));
 extern unsigned char __executable_start[] __attribute__((__weak__));
 extern unsigned char __privileged_start[] __attribute__((__weak__));
 extern unsigned char _ehead[] __attribute__((__weak__));
+extern unsigned char _rodata[] __attribute__((__weak__));
 extern unsigned char _etext[] __attribute__((__weak__));
 extern unsigned char _edata[] __attribute__((__weak__));
 extern unsigned char _ezip[] __attribute__((__weak__));
@@ -28,5 +29,8 @@ extern unsigned long __got_start[] __attribute__((__weak__));
 extern unsigned long __got_end[] __attribute__((__weak__));
 extern unsigned char ape_phdrs[] __attribute__((__weak__));
 
+#define __rarechange      _Section(".bss.rarechange")
+#define __data_rarechange _Section(".data.rarechange")
+
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_ */

ape/specification.md

@@ -361,13 +361,13 @@ Here's the TLS memory layout on x86_64:
 ```
                           __get_tls()
                               │
-                             %fs OpenBSD/NetBSD
+                             %fs Linux/FreeBSD/NetBSD/OpenBSD
            _Thread_local      │
     ┌───┬──────────┬──────────┼───┐
     │pad│  .tdata  │  .tbss   │tib│
     └───┴──────────┴──────────┼───┘
                               │
-   Linux/FreeBSD/Windows/Mac %gs
+                 Windows/Mac %gs
 ```
 
 Quite possibly the greatest challenge in Actually Portable Executable
@@ -401,80 +401,56 @@ arises in the fact that our Linux-flavored GCC and Clang toolchains
 (which are used to produce cross-OS binaries) are also only capable of
 producing TLS instructions that use the %fs convention.
 
-To solve these challenges, the `cosmocc` compiler will rewrite binary
-objects after they've been compiled by GCC, so that the `%gs` register
-is used, rather than `%fs`. Morphing x86-64 binaries after they've been
-compiled is normally difficult, due to the complexity of the machine
-instruction language. However GCC provides `-mno-tls-direct-seg-refs`
-which greatly reduces the complexity of this task. This flag forgoes
-some optimizations to make the generated code simpler. Rather than doing
-clever arithmetic with `%fs` prefixes, the compiler will always generate
-the thread information block address load as a separate instruction.
+To solve these challenges, the `cosmocc` compiler rewrites GCC generated
+assembly so that the `%fs` referencing instructions created by GCC when
+using the `-mno-tls-direct-seg-refs` flag are replaced by calls to the
+following functions:
 
-```c
-// Change AMD code to use %gs:0x30 instead of %fs:0
-// We assume -mno-tls-direct-seg-refs has been used
-static void ChangeTlsFsToGs(unsigned char *p, size_t n) {
-  unsigned char *e = p + n - 9;
-  while (p <= e) {
-    // we're checking for the following expression:
-    //   0144 == p[0] &&           // %fs
-    //   0110 == (p[1] & 0373) &&  // rex.w (and ignore rex.r)
-    //   (0213 == p[2] ||          // mov reg/mem → reg (word-sized)
-    //   0003 == p[2]) &&          // add reg/mem → reg (word-sized)
-    //   0004 == (p[3] & 0307) &&  // mod/rm (4,reg,0) means sib → reg
-    //   0045 == p[4] &&           // sib (5,4,0) → (rbp,rsp,0) → disp32
-    //   0000 == p[5] &&           // displacement (von Neumann endian)
-    //   0000 == p[6] &&           // displacement
-    //   0000 == p[7] &&           // displacement
-    //   0000 == p[8]              // displacement
-    uint64_t w = READ64LE(p) & READ64LE("\377\373\377\307\377\377\377\377");
-    if ((w == READ64LE("\144\110\213\004\045\000\000\000") ||
-         w == READ64LE("\144\110\003\004\045\000\000\000")) &&
-        !p[8]) {
-      p[0] = 0145;  // change %fs to %gs
-      p[5] = 0x30;  // change 0 to 0x30
-      p += 9;
-    } else {
-      ++p;
-    }
-  }
-}
-```
+- `__get_tls_rax`
+- `__get_tls_rbx`
+- `__get_tls_rcx`
+- `__get_tls_rdx`
+- `__get_tls_rdi`
+- `__get_tls_rsi`
+- `__get_tls_rbp`
+- `__get_tls_r8`
+- `__get_tls_r9`
+- `__get_tls_r10`
+- `__get_tls_r11`
+- `__get_tls_r12`
+- `__get_tls_r13`
+- `__get_tls_r14`
+- `__get_tls_r15`
+- `__add_tls_rax`
+- `__add_tls_rbx`
+- `__add_tls_rcx`
+- `__add_tls_rdx`
+- `__add_tls_rdi`
+- `__add_tls_rsi`
+- `__add_tls_rbp`
+- `__add_tls_r8`
+- `__add_tls_r9`
+- `__add_tls_r10`
+- `__add_tls_r11`
+- `__add_tls_r12`
+- `__add_tls_r13`
+- `__add_tls_r14`
+- `__add_tls_r15`
 
-By favoring `%gs` we've now ensured friction-free compatibility for the
-APE runtime on MacOS, Linux, and FreeBSD which are all able to conform
-easily to this convention. However additional work needs to be done at
-runtime when an APE program is started on Windows, OpenBSD, and NetBSD.
-On these platforms, all executable pages must be faulted and morphed to
-fixup the TLS instructions.
+The `cosmocc` script internally uses a tool named `tlscc` which wraps a
+gcc or clang compilation so it generates intermediate assembly code that
+it can modify to call the above functions. In the process, it also adds
+the `-mno-tls-direct-seg-refs` and `-mno-red-zone` flags to the compile
+command to ensure the compiler only generates TLS assembly instructions
+that are understood by the tool.
 
-On OpenBSD and NetBSD, this is as simple as undoing the example
-operation above. Earlier at compile-time we turned `%fs` into `%gs`.
-Now, at runtime, `%gs` must be turned back into `%fs`. Since the
-executable is morphing itself, this is easier said than done.
+The above functions do not clobber any registers. The function name
+specifies the register to which the result is stored or added. The only
+above function that can be called by C code is `__get_tls_rax`.
 
-OpenBSD for example enforces a `W^X` invariant. Code that's executing
-can't modify itself at the same time. The way Cosmopolitan solves this
-is by defining a special part of the binary called `.text.privileged`.
-This section is aligned to page boundaries. A GNU ld linker script is
-used to ensure that code which morphs code is placed into this section,
-through the use of a header-defined cosmo-specific keyword `privileged`.
-Additionally, the `fixupobj` program is used by the Cosmo build system
-to ensure that compiled objects don't contain privileged functions that
-call non-privileged functions. Needless to say, `mprotect()` needs to be
-a privileged function, so that it can be used to disable the execute bit
-on all other parts of the executable except for the privileged section,
-thereby making it writable. Once this has been done, code can change.
-
-On Windows the displacement bytes of the TLS instruction are changed to
-use the `%gs:0x1480+i*8` ABI where `i` is a number assigned by the WIN32
-`TlsAlloc()` API. This avoids the need to call `TlsGetValue()` which is
-implemented this exact same way under the hood. Even though 0x1480 isn't
-explicitly documented by MSDN, this ABI is believed to be stable because
-MSVC generates binaries that use this offset directly. The only caveat
-is that `TlsAlloc()` must be called as early in the runtime init as
-possible, to ensure an index less than 64 is returned.
+When Windows and MacOS aren't in the support vector, then the above
+assembly rewriting pass can be avoided entirely, and the binary can
+simply use the TLS opcodes that GCC and Clang generate for Linux.
 
 ### Thread Information Block (TIB)
 

ape/start.S

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "ape/ape.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #ifdef __aarch64__
 
@@ -61,6 +61,16 @@ netbsd.ident:
 4:	.size	netbsd.ident,.-netbsd.ident
 	.type	netbsd.ident,@object
 	.balign	4
+freebsd.ident:
+	.long	2f-1f
+	.long	4f-3f
+	.long	1 // NT_FREEBSD_ABI_TAG
+1:	.asciz	"FreeBSD"
+2:	.balign	4
+3:	.long	1300000 // v13.0+ c. 2020
+4:	.size	freebsd.ident,.-freebsd.ident
+	.type	freebsd.ident,@object
+	.balign	4
 ape.ident:
 	.long	2f-1f
 	.long	4f-3f

ape/systemcall.S

@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Invokes system call.
 //

build/bootstrap/gcc-only-flags.txt

@@ -5,6 +5,7 @@
 -Wa,-msse2avx
 -Werror=maybe-uninitialized
 -Wno-literal-suffix
+-Wno-prio-ctor-dtor
 -Wno-unused-but-set-variable
 -Wunsafe-loop-optimizations
 -fbranch-target-load-optimize

build/config.mk

@@ -14,7 +14,6 @@ ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CCFLAGS += -O2 $(BACKTRACES)
 CONFIG_CPPFLAGS += -DSYSDEBUG
-TARGET_ARCH ?= -msse3
 endif
 ifeq ($(MODE), x86_64)
 ENABLE_FTRACE = 1
@@ -64,7 +63,6 @@ ENABLE_FTRACE = 1
 CONFIG_CCFLAGS += $(BACKTRACES) -O
 CONFIG_CPPFLAGS += -DSYSDEBUG -DDWARFLESS
 CONFIG_LDFLAGS += -S
-TARGET_ARCH ?= -msse3
 endif
 
 # Optimized Mode
@@ -84,7 +82,7 @@ ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG
 CONFIG_CCFLAGS += $(BACKTRACES) -O3 -fmerge-all-constants
-TARGET_ARCH ?= -march=native
+CONFIG_TARGET_ARCH ?= -march=native
 endif
 
 # Optimized Linux Mode
@@ -98,11 +96,22 @@ endif
 #   - Turns off support for other operating systems
 #
 ifeq ($(MODE), optlinux)
+TLSCC =
 CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
 CONFIG_CCFLAGS += -O3 -fmerge-all-constants
 CONFIG_COPTS += -mred-zone
-TARGET_ARCH ?= -march=native
+CONFIG_TARGET_ARCH ?= -mavx
+endif
+ifeq ($(MODE), x86_64-optlinux)
+TLSCC =
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
+CONFIG_CCFLAGS += -O3 -fmerge-all-constants
+CONFIG_TARGET_ARCH ?= -mavx
+endif
+ifeq ($(MODE), aarch64-optlinux)
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
+CONFIG_CCFLAGS += -O3 -fmerge-all-constants
 endif
 
 # Release Mode
@@ -123,7 +132,6 @@ endif
 ifeq ($(MODE), rel)
 CONFIG_CPPFLAGS += -DNDEBUG -DDWARFLESS
 CONFIG_CCFLAGS += $(BACKTRACES) -O2
-TARGET_ARCH ?= -msse3
 PYFLAGS += -O1
 endif
 
@@ -139,19 +147,33 @@ endif
 ifeq ($(MODE), dbg)
 ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
-CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__
-CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O0 -fno-inline
-CONFIG_COPTS += -fsanitize=undefined
-TARGET_ARCH ?= -msse3
+OVERRIDE_CFLAGS += -O0
+OVERRIDE_CXXFLAGS += -O0
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__ -Wno-unused-variable -Wno-unused-but-set-variable
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG
+CONFIG_COPTS += -fsanitize=undefined -fno-data-sections
+OVERRIDE_CCFLAGS += -fno-pie
+QUOTA ?= -C64 -L300
+endif
+ifeq ($(MODE), x86_64-dbg)
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g -ggdb
+OVERRIDE_CFLAGS += -O0
+OVERRIDE_CXXFLAGS += -O0
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__ -Wno-unused-variable -Wno-unused-but-set-variable
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG
+CONFIG_COPTS += -fsanitize=undefined -fno-data-sections
 OVERRIDE_CCFLAGS += -fno-pie
 QUOTA ?= -C64 -L300
 endif
 ifeq ($(MODE), aarch64-dbg)
 ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
-CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__
-CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O0 -fno-inline -fdce
-CONFIG_COPTS += -fsanitize=undefined
+OVERRIDE_CFLAGS += -O0 -fdce
+OVERRIDE_CXXFLAGS += -O0 -fdce
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__ -Wno-unused-variable -Wno-unused-but-set-variable
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG
+CONFIG_COPTS += -fsanitize=undefined -fno-data-sections
 QUOTA ?= -C64 -L300
 endif
 
@@ -167,10 +189,18 @@ endif
 #
 ifeq ($(MODE), sysv)
 ENABLE_FTRACE = 1
-CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CCFLAGS += $(BACKTRACES) -O2
 CONFIG_CPPFLAGS += -DSYSDEBUG -DSUPPORT_VECTOR=121
-TARGET_ARCH ?= -msse3
+endif
+ifeq ($(MODE), x86_64-sysv)
+ENABLE_FTRACE = 1
+CONFIG_CCFLAGS += $(BACKTRACES) -O2
+CONFIG_CPPFLAGS += -DSYSDEBUG -DSUPPORT_VECTOR=121
+endif
+ifeq ($(MODE), aarch64-sysv)
+ENABLE_FTRACE = 1
+CONFIG_CCFLAGS += $(BACKTRACES) -O2
+CONFIG_CPPFLAGS += -DSYSDEBUG -DSUPPORT_VECTOR=121
 endif
 
 # Tiny Mode
@@ -188,8 +218,7 @@ endif
 ifeq ($(MODE), tiny)
 CONFIG_CPPFLAGS +=			\
 	-DTINY				\
-	-DNDEBUG			\
-	-DTRUSTWORTHY
+	-DNDEBUG
 CONFIG_CCFLAGS +=			\
 	-Os				\
 	-fno-align-functions		\
@@ -200,8 +229,6 @@ CONFIG_CCFLAGS +=			\
 	-momit-leaf-frame-pointer	\
 	-foptimize-sibling-calls	\
 	-DDWARFLESS
-TARGET_ARCH ?=				\
-	-msse3
 PYFLAGS +=				\
 	-O2				\
 	-B
@@ -209,8 +236,7 @@ endif
 ifeq ($(MODE), x86_64-tiny)
 CONFIG_CPPFLAGS +=			\
 	-DTINY				\
-	-DNDEBUG			\
-	-DTRUSTWORTHY
+	-DNDEBUG
 CONFIG_CCFLAGS +=			\
 	-Os				\
 	-fno-align-functions		\
@@ -221,8 +247,6 @@ CONFIG_CCFLAGS +=			\
 	-momit-leaf-frame-pointer	\
 	-foptimize-sibling-calls	\
 	-DDWARFLESS
-TARGET_ARCH ?=				\
-	-msse3
 PYFLAGS +=				\
 	-O2				\
 	-B
@@ -231,8 +255,7 @@ ifeq ($(MODE), aarch64-tiny)
 # TODO(jart): -mcmodel=tiny
 CONFIG_CPPFLAGS +=			\
 	-DTINY				\
-	-DNDEBUG			\
-	-DTRUSTWORTHY
+	-DNDEBUG
 CONFIG_CCFLAGS +=			\
 	-Os				\
 	-fno-align-functions		\
@@ -262,10 +285,37 @@ endif
 #   - YOLO
 #
 ifeq ($(MODE), tinylinux)
+TLSCC =
+CONFIG_CPPFLAGS +=			\
+	-DTINY				\
+	-DNDEBUG			\
+	-DSUPPORT_VECTOR=1		\
+	-DDWARFLESS
+CONFIG_CCFLAGS +=			\
+	-Os				\
+	-fno-align-functions		\
+	-fno-align-jumps		\
+	-fno-align-labels		\
+	-fno-align-loops
+endif
+ifeq ($(MODE), x86_64-tinylinux)
+TLSCC =
+CONFIG_CPPFLAGS +=			\
+	-DTINY				\
+	-DNDEBUG			\
+	-DSUPPORT_VECTOR=1		\
+	-DDWARFLESS
+CONFIG_CCFLAGS +=			\
+	-Os				\
+	-fno-align-functions		\
+	-fno-align-jumps		\
+	-fno-align-labels		\
+	-fno-align-loops
+endif
+ifeq ($(MODE), aarch64-tinylinux)
 CONFIG_CPPFLAGS +=			\
 	-DTINY				\
 	-DNDEBUG			\
-	-DTRUSTWORTHY			\
 	-DSUPPORT_VECTOR=1		\
 	-DDWARFLESS
 CONFIG_CCFLAGS +=			\
@@ -274,8 +324,6 @@ CONFIG_CCFLAGS +=			\
 	-fno-align-jumps		\
 	-fno-align-labels		\
 	-fno-align-loops
-TARGET_ARCH ?=				\
-	-msse3
 endif
 
 # Linux+BSD Tiny Mode
@@ -293,10 +341,10 @@ endif
 #   - YOLO
 #
 ifeq ($(MODE), tinylinuxbsd)
+TLSCC =
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
-	-DTRUSTWORTHY		\
 	-DSUPPORT_VECTOR=113	\
 	-DDWARFLESS
 CONFIG_CCFLAGS +=		\
@@ -305,8 +353,6 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-TARGET_ARCH ?=			\
-	-msse3
 endif
 
 # Unix Tiny Mode
@@ -326,7 +372,6 @@ ifeq ($(MODE), tinysysv)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
-	-DTRUSTWORTHY		\
 	-DSUPPORT_VECTOR=121	\
 	-DDWARFLESS
 CONFIG_CCFLAGS +=		\
@@ -335,8 +380,6 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-TARGET_ARCH ?=			\
-	-msse3
 endif
 
 # Tiny Metallic Unix Mode
@@ -356,7 +399,6 @@ ifeq ($(MODE), tinynowin)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
-	-DTRUSTWORTHY		\
 	-DSUPPORT_VECTOR=251	\
 	-DDWARFLESS
 CONFIG_CCFLAGS +=		\
@@ -365,8 +407,6 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-TARGET_ARCH ?=			\
-	-msse3
 endif
 
 # no x87 instructions mode
@@ -388,7 +428,6 @@ ENABLE_FTRACE = 1
 CONFIG_COPTS += -mlong-double-64
 CONFIG_CCFLAGS += $(BACKTRACES) -O2
 CONFIG_CPPFLAGS += -DSYSDEBUG -DNOX87
-TARGET_ARCH ?= -msse3
 endif
 
 # LLVM Mode
@@ -400,8 +439,7 @@ endif
 # The rest of the monorepo may not work with llvm.
 #
 ifeq ($(MODE), llvm)
-.STRICT = 0
-TARGET_ARCH ?= -msse3
+.SANDBOXED = 0
 CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O2
 AS = clang
 CC = clang
@@ -441,10 +479,9 @@ endif
 # like objconv to convert them to COFF or MachO. Then use ANSI mode to
 # rollup one header file that'll enable linkage with minimal issues.
 ifeq ($(MODE), ansi)
-CONFIG_CFLAGS += -std=c11
+CONFIG_CFLAGS += -std=c23
 #CONFIG_CPPFLAGS += -ansi
-CONFIG_CXXFLAGS += -std=c++11
-TARGET_ARCH ?= -msse3
+CONFIG_CXXFLAGS += -std=c++23
 endif
 
 ifneq ($(ENABLE_FTRACE),)
@@ -482,7 +519,7 @@ endif
 ifeq ($(ARCH), aarch64)
 # this flag causes gcc to generate functions like this
 #
-#       nop nop nop nop nop nop
+#       nop nop nop nop nop nop nop nop
 #     func:
 #       nop
 #       ...
@@ -499,6 +536,10 @@ ifeq ($(ARCH), aarch64)
 #       b   -5
 #       ...
 #
-CONFIG_CCFLAGS += -fpatchable-function-entry=7,6
+# we only need -fpatchable-function-entry=7,6 but we round up to 32
+# bytes so we don't break function alignment.
+CONFIG_CCFLAGS += -fpatchable-function-entry=9,8
 endif
 endif
+
+TARGET_ARCH ?= $(CONFIG_TARGET_ARCH)

build/definitions.mk

@@ -53,11 +53,7 @@
 #     OVERRIDE_FOO set ~/.cosmo.mk and target-specific (use rarely)
 #
 
-ifeq ($(LANDLOCKMAKE_VERSION),)
 TMPSAFE = $(join $(TMPDIR)/,$(subst /,_,$@)).tmp
-else
-TMPSAFE = $(TMPDIR)/
-endif
 
 BACKTRACES =								\
 	-fno-schedule-insns2						\
@@ -92,11 +88,9 @@ DEFAULT_COPTS ?=							\
 	-fno-gnu-unique							\
 	-fstrict-aliasing						\
 	-fstrict-overflow						\
-	-fno-semantic-interposition					\
-	-fno-dwarf2-cfi-asm						\
-	-fno-unwind-tables						\
-	-fno-asynchronous-unwind-tables
+	-fno-semantic-interposition
 
+ifneq ($(TLSCC),)
 ifeq ($(ARCH), x86_64)
 # Microsoft says "[a]ny memory below the stack beyond the red zone
 # [note: Windows defines the x64 red zone size as 0] is considered
@@ -106,6 +100,7 @@ DEFAULT_COPTS +=							\
 	-mno-red-zone							\
 	-mno-tls-direct-seg-refs
 endif
+endif
 
 ifeq ($(ARCH), aarch64)
 #
@@ -115,14 +110,10 @@ ifeq ($(ARCH), aarch64)
 # - Cosmopolitan Libc uses x28 for thread-local storage because Apple
 #   forbids us from using tpidr_el0 too.
 #
-# - Cosmopolitan currently lacks an implementation of the runtime
-#   libraries needed by the -moutline-atomics flag
-#
 DEFAULT_COPTS +=							\
 	-ffixed-x18							\
 	-ffixed-x28							\
-	-fsigned-char							\
-	-mno-outline-atomics
+	-fsigned-char
 endif
 
 MATHEMATICAL =								\
@@ -139,12 +130,10 @@ DEFAULT_CPPFLAGS +=							\
 	-isystem libc/isystem
 
 DEFAULT_CFLAGS =							\
-	-std=gnu2x
+	-std=gnu23
 
 DEFAULT_CXXFLAGS =							\
-	-std=gnu++20							\
-	-fno-rtti							\
-	-fno-exceptions							\
+	-std=gnu++23							\
 	-fuse-cxa-atexit						\
 	-Wno-int-in-bool-context					\
 	-Wno-narrowing							\

build/download-cosmocc.sh

@@ -99,3 +99,8 @@ rm -f cosmocc.zip cosmocc.zip.sha256sum
 # commit output directory
 cd "${OLDPWD}" || die
 mv "${OUTPUT_TMP}" "${OUTPUT_DIR}" || die
+
+# update current symlink
+BASE=$(basename "${OUTPUT_DIR}")
+DIR=$(dirname "${OUTPUT_DIR}")
+ln -sfn "$BASE" "$DIR/current"

build/objdump

@@ -6,14 +6,14 @@ if [ -n "$OBJDUMP" ]; then
 fi
 
 find_objdump() {
-  if [ -x .cosmocc/3.3.5/bin/$1-linux-cosmo-objdump ]; then
-    OBJDUMP=.cosmocc/3.3.5/bin/$1-linux-cosmo-objdump
-  elif [ -x .cosmocc/3.3.5/bin/$1-linux-musl-objdump ]; then
-    OBJDUMP=.cosmocc/3.3.5/bin/$1-linux-musl-objdump
-  elif [ -x "$COSMO/.cosmocc/3.3.5/bin/$1-linux-cosmo-objdump" ]; then
-    OBJDUMP="$COSMO/.cosmocc/3.3.5/bin/$1-linux-cosmo-objdump"
-  elif [ -x "$COSMO/.cosmocc/3.3.5/bin/$1-linux-musl-objdump" ]; then
-    OBJDUMP="$COSMO/.cosmocc/3.3.5/bin/$1-linux-musl-objdump"
+  if [ -x .cosmocc/3.9.2/bin/$1-linux-cosmo-objdump ]; then
+    OBJDUMP=.cosmocc/3.9.2/bin/$1-linux-cosmo-objdump
+  elif [ -x .cosmocc/3.9.2/bin/$1-linux-musl-objdump ]; then
+    OBJDUMP=.cosmocc/3.9.2/bin/$1-linux-musl-objdump
+  elif [ -x "$COSMO/.cosmocc/3.9.2/bin/$1-linux-cosmo-objdump" ]; then
+    OBJDUMP="$COSMO/.cosmocc/3.9.2/bin/$1-linux-cosmo-objdump"
+  elif [ -x "$COSMO/.cosmocc/3.9.2/bin/$1-linux-musl-objdump" ]; then
+    OBJDUMP="$COSMO/.cosmocc/3.9.2/bin/$1-linux-musl-objdump"
   else
     echo "error: toolchain not found (try running 'cosmocc --update' or 'make' in the cosmo monorepo)" >&2
     exit 1

build/online.mk

@@ -23,8 +23,7 @@
 #   - tool/build/runitd.c
 
 .PRECIOUS: o/$(MODE)/%.ok
-o/$(MODE)/%.ok: private .PLEDGE = stdio rpath wpath cpath proc fattr inet dns
-o/$(MODE)/%.ok: private .UNVEIL += r:/etc/resolv.conf
+o/$(MODE)/%.ok: private .PLEDGE = fattr inet dns
 o/$(MODE)/%.ok:					\
 		o/$(MODE)/tool/build/runit	\
 		o/$(MODE)/tool/build/runitd	\

build/rules.mk

@@ -145,16 +145,7 @@ o/%.zip.o: o/%
 o/$(MODE)/%.zip.o: %
 	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
 
-o/$(MODE)/%.zip.o: %
-	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
-
-# an issue with sandboxing arises when creating directory entries in the
-# zip file. we need the trailing slash (e.g. o//foo/.zip.o) but Landlock
-# Make avoids sandboxing directory names that have a trailing slash (so
-# they can be used to watch for deleted files, without creating overly
-# broad unveiling). such rules need to be written more explicitly.
-o/$(MODE)%/.zip.o: %
-	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.zip.o: private .SANDBOXED = 0
 
 ################################################################################
 # STRICT HEADER CHECKING
@@ -163,43 +154,43 @@ o/$(MODE)%/.zip.o: %
 # and it would be too costly in terms of make latency to have every
 # header file depend on $(HDRS) and $(INCS).
 
-o/%.h.ok: private .UNSANDBOXED = 1
+o/%.h.ok: private .SANDBOXED = 0
 o/%.h.ok: %.h
 	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
 
-o/$(MODE)/%.h.ok: private .UNSANDBOXED = 1
+o/$(MODE)/%.h.ok: private .SANDBOXED = 0
 o/$(MODE)/%.h.ok: %.h
 	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
 
-o/$(MODE)/%.hh.ok: private .UNSANDBOXED = 1
+o/$(MODE)/%.hh.ok: private .SANDBOXED = 0
 o/$(MODE)/%.hh.ok: %.hh
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
-o/%.okk: .UNSANDBOXED = 1
+o/%.okk: .SANDBOXED = 0
 o/%.okk: %
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
-o/$(MODE)/%.okk: private .UNSANDBOXED = 1
+o/$(MODE)/%.okk: private .SANDBOXED = 0
 o/$(MODE)/%.okk: %
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
 ################################################################################
 # EMACS ASSEMBLY GENERATION
 
-o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-gcc.asm: private .SANDBOXED = 0
 o/$(MODE)/%-gcc.asm: %.c
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
 
-o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-gcc.asm: private .SANDBOXED = 0
 o/$(MODE)/%-gcc.asm: %.cc
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<
 
-o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-clang.asm: private .SANDBOXED = 0
 o/$(MODE)/%-clang.asm: %.c
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
 
 # TODO(jart): Make intrinsics support Clang.
 o/$(MODE)/%-clang.asm: CC = $(CLANG)
-o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
+o/$(MODE)/%-clang.asm: private .SANDBOXED = 0
 o/$(MODE)/%-clang.asm: %.cc
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<

build/run

@@ -4,5 +4,5 @@ UNAMES=$(uname -s)
 if [ x"$UNAMES" = x"Darwin" ] && [ x"$UNAMEM" = x"arm64" ]; then
   exec ape "$@"
 else
-  exec "$@"
+  exec rusage "$@"
 fi

compile_flags.txt

@@ -0,0 +1,10 @@
+-nostdinc
+-iquote
+.
+-isystem
+libc/isystem
+-include
+libc/integral/normalize.inc
+-D_COSMO_SOURCE
+-DMODE="aarch64"
+-Wno-unknown-pragmas

ctl/conditional.h

@@ -17,6 +17,9 @@ struct conditional<false, T, F>
     typedef F type;
 };
 
+template<bool B, typename T, typename F>
+using conditional_t = typename conditional<B, T, F>::type;
+
 } // namespace ctl
 
 #endif // CTL_CONDITIONAL_H_

ctl/is_void.h

@@ -19,6 +19,9 @@ template<typename _Tp>
 struct is_void : public is_void_<typename ctl::remove_cv<_Tp>::type>::type
 {};
 
+template<typename T>
+inline constexpr bool is_void_v = is_void<T>::value;
+
 } // namespace ctl
 
 #endif // CTL_IS_VOID_H_

ctl/istream.h

@@ -6,7 +6,7 @@
 
 namespace ctl {
 
-struct string;
+class string;
 
 class istream : public ios
 {

ctl/new.h

@@ -4,7 +4,7 @@
 #define COSMOPOLITAN_CTL_NEW_H_
 
 #ifndef TINY
-__static_yoink("__demangle");
+__static_yoink("cosmo_demangle");
 #endif
 
 namespace ctl {

ctl/set.h

@@ -241,8 +241,9 @@ class set
       private:
         friend class set;
         node_type* node_;
+        node_type* root_;
 
-        explicit reverse_iterator(node_type* node) : node_(node)
+        explicit reverse_iterator(node_type* node, node_type* root) : node_(node), root_(root)
         {
         }
     };
@@ -347,17 +348,17 @@ class set
 
     reverse_iterator rbegin()
     {
-        return reverse_iterator(rightmost(root_));
+        return reverse_iterator(rightmost(root_), root_);
     }
 
     const_reverse_iterator rbegin() const
     {
-        return const_reverse_iterator(rightmost(root_));
+        return const_reverse_iterator(rightmost(root_), root_);
     }
 
     const_reverse_iterator crbegin() const
     {
-        return const_reverse_iterator(rightmost(root_));
+        return const_reverse_iterator(rightmost(root_), root_);
     }
 
     iterator end() noexcept
@@ -377,17 +378,17 @@ class set
 
     reverse_iterator rend()
     {
-        return reverse_iterator(nullptr);
+        return reverse_iterator(nullptr, root_);
     }
 
     const_reverse_iterator rend() const
     {
-        return const_reverse_iterator(nullptr);
+        return const_reverse_iterator(nullptr, root_);
     }
 
     const_reverse_iterator crend() const
     {
-        return const_reverse_iterator(nullptr);
+        return const_reverse_iterator(nullptr, root_);
     }
 
     void clear() noexcept

ctl/shared_ptr.h

@@ -0,0 +1,618 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_SHARED_PTR_H_
+#define CTL_SHARED_PTR_H_
+
+#include "exception.h"
+#include "is_base_of.h"
+#include "is_constructible.h"
+#include "is_convertible.h"
+#include "remove_extent.h"
+#include "unique_ptr.h"
+
+// XXX currently needed to use placement-new syntax (move to cxx.inc?)
+void*
+operator new(size_t, void*) noexcept;
+
+namespace ctl {
+
+class bad_weak_ptr : public exception
+{
+  public:
+    const char* what() const noexcept override
+    {
+        return "ctl::bad_weak_ptr";
+    }
+};
+
+namespace __ {
+
+template<typename T>
+struct ptr_ref
+{
+    using type = T&;
+};
+
+template<>
+struct ptr_ref<void>
+{
+    using type = void;
+};
+
+static inline __attribute__((always_inline)) void
+incref(size_t* r) noexcept
+{
+#ifdef NDEBUG
+    __atomic_fetch_add(r, 1, __ATOMIC_RELAXED);
+#else
+    ssize_t refs = __atomic_fetch_add(r, 1, __ATOMIC_RELAXED);
+    if (refs < 0)
+        __builtin_trap();
+#endif
+}
+
+static inline __attribute__((always_inline)) bool
+decref(size_t* r) noexcept
+{
+    if (!__atomic_fetch_sub(r, 1, __ATOMIC_RELEASE)) {
+        __atomic_thread_fence(__ATOMIC_ACQUIRE);
+        return true;
+    }
+    return false;
+}
+
+class shared_ref
+{
+  public:
+    constexpr shared_ref() noexcept = default;
+    shared_ref(const shared_ref&) = delete;
+    shared_ref& operator=(const shared_ref&) = delete;
+
+    virtual ~shared_ref() = default;
+
+    void keep_shared() noexcept
+    {
+        incref(&shared);
+    }
+
+    void drop_shared() noexcept
+    {
+        if (decref(&shared)) {
+            dispose();
+            drop_weak();
+        }
+    }
+
+    void keep_weak() noexcept
+    {
+        incref(&weak);
+    }
+
+    void drop_weak() noexcept
+    {
+        if (decref(&weak)) {
+            delete this;
+        }
+    }
+
+    size_t use_count() const noexcept
+    {
+        return __atomic_load_n(&shared, __ATOMIC_RELAXED) + 1;
+    }
+
+    size_t weak_count() const noexcept
+    {
+        return __atomic_load_n(&weak, __ATOMIC_RELAXED);
+    }
+
+  private:
+    virtual void dispose() noexcept = 0;
+
+    size_t shared = 0;
+    size_t weak = 0;
+};
+
+template<typename T, typename D>
+class shared_pointer : public shared_ref
+{
+  public:
+    static shared_pointer* make(T* const p, D d)
+    {
+        return make(unique_ptr<T, D>(p, move(d)));
+    }
+
+    static shared_pointer* make(unique_ptr<T, D> p)
+    {
+        return new shared_pointer(p.release(), move(p.get_deleter()));
+    }
+
+  private:
+    shared_pointer(T* const p, D d) noexcept : p(p), d(move(d))
+    {
+    }
+
+    void dispose() noexcept override
+    {
+        move(d)(p);
+    }
+
+    T* const p;
+    [[no_unique_address]] D d;
+};
+
+template<typename T>
+class shared_emplace : public shared_ref
+{
+  public:
+    union
+    {
+        T t;
+    };
+
+    ~shared_emplace() override
+    {
+    }
+
+    template<typename... Args>
+    void construct(Args&&... args)
+    {
+        ::new (&t) T(forward<Args>(args)...);
+    }
+
+    static unique_ptr<shared_emplace> make()
+    {
+        return unique_ptr(new shared_emplace());
+    }
+
+  private:
+    explicit constexpr shared_emplace() noexcept
+    {
+    }
+
+    void dispose() noexcept override
+    {
+        t.~T();
+    }
+};
+
+template<typename T, typename U>
+concept shared_ptr_compatible = is_convertible_v<U*, T*>;
+
+} // namespace __
+
+template<typename T>
+class weak_ptr;
+
+template<typename T>
+class shared_ptr
+{
+  public:
+    using element_type = remove_extent_t<T>;
+    using weak_type = weak_ptr<T>;
+
+    constexpr shared_ptr() noexcept = default;
+    constexpr shared_ptr(nullptr_t) noexcept
+    {
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    explicit shared_ptr(U* const p) : shared_ptr(p, default_delete<U>())
+    {
+    }
+
+    template<typename U, typename D>
+        requires __::shared_ptr_compatible<T, U>
+    shared_ptr(U*, D);
+
+    template<typename U>
+    shared_ptr(const shared_ptr<U>& r, element_type* p) noexcept
+      : p(p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_shared();
+    }
+
+    template<typename U>
+    shared_ptr(shared_ptr<U>&& r, element_type* p) noexcept : p(p), rc(r.rc)
+    {
+        r.p = nullptr;
+        r.rc = nullptr;
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    shared_ptr(const shared_ptr<U>& r) noexcept : p(r.p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_shared();
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    shared_ptr(shared_ptr<U>&& r) noexcept : p(r.p), rc(r.rc)
+    {
+        r.p = nullptr;
+        r.rc = nullptr;
+    }
+
+    shared_ptr(const shared_ptr& r) noexcept : p(r.p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_shared();
+    }
+
+    shared_ptr(shared_ptr&& r) noexcept : p(r.p), rc(r.rc)
+    {
+        r.p = nullptr;
+        r.rc = nullptr;
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    explicit shared_ptr(const weak_ptr<U>& r) : p(r.p), rc(r.rc)
+    {
+        if (r.expired()) {
+            throw bad_weak_ptr();
+        }
+        rc->keep_shared();
+    }
+
+    template<typename U, typename D>
+        requires __::shared_ptr_compatible<T, U>
+    shared_ptr(unique_ptr<U, D>&& r)
+      : p(r.p), rc(__::shared_pointer<U, D>::make(move(r)))
+    {
+    }
+
+    ~shared_ptr()
+    {
+        if (rc)
+            rc->drop_shared();
+    }
+
+    shared_ptr& operator=(shared_ptr r) noexcept
+    {
+        swap(r);
+        return *this;
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    shared_ptr& operator=(shared_ptr<U> r) noexcept
+    {
+        shared_ptr<T>(move(r)).swap(*this);
+        return *this;
+    }
+
+    void reset() noexcept
+    {
+        shared_ptr().swap(*this);
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    void reset(U* const p2)
+    {
+        shared_ptr<T>(p2).swap(*this);
+    }
+
+    template<typename U, typename D>
+        requires __::shared_ptr_compatible<T, U>
+    void reset(U* const p2, D d)
+    {
+        shared_ptr<T>(p2, d).swap(*this);
+    }
+
+    void swap(shared_ptr& r) noexcept
+    {
+        using ctl::swap;
+        swap(p, r.p);
+        swap(rc, r.rc);
+    }
+
+    element_type* get() const noexcept
+    {
+        return p;
+    }
+
+    typename __::ptr_ref<T>::type operator*() const noexcept
+    {
+        if (!p)
+            __builtin_trap();
+        return *p;
+    }
+
+    T* operator->() const noexcept
+    {
+        if (!p)
+            __builtin_trap();
+        return p;
+    }
+
+    long use_count() const noexcept
+    {
+        return rc ? rc->use_count() : 0;
+    }
+
+    explicit operator bool() const noexcept
+    {
+        return p;
+    }
+
+    template<typename U>
+    bool owner_before(const shared_ptr<U>& r) const noexcept
+    {
+        return rc < r.rc;
+    }
+
+    template<typename U>
+    bool owner_before(const weak_ptr<U>& r) const noexcept
+    {
+        return rc < r.rc;
+    }
+
+  private:
+    template<typename U>
+    friend class weak_ptr;
+
+    template<typename U>
+    friend class shared_ptr;
+
+    template<typename U, typename... Args>
+    friend shared_ptr<U> make_shared(Args&&... args);
+
+    element_type* p = nullptr;
+    __::shared_ref* rc = nullptr;
+};
+
+template<typename T>
+class weak_ptr
+{
+  public:
+    using element_type = remove_extent_t<T>;
+
+    constexpr weak_ptr() noexcept = default;
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    weak_ptr(const shared_ptr<U>& r) noexcept : p(r.p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_weak();
+    }
+
+    weak_ptr(const weak_ptr& r) noexcept : p(r.p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_weak();
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    weak_ptr(const weak_ptr<U>& r) noexcept : p(r.p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_weak();
+    }
+
+    weak_ptr(weak_ptr&& r) noexcept : p(r.p), rc(r.rc)
+    {
+        r.p = nullptr;
+        r.rc = nullptr;
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    weak_ptr(weak_ptr<U>&& r) noexcept : p(r.p), rc(r.rc)
+    {
+        r.p = nullptr;
+        r.rc = nullptr;
+    }
+
+    ~weak_ptr()
+    {
+        if (rc)
+            rc->drop_weak();
+    }
+
+    long use_count() const noexcept
+    {
+        return rc ? rc->use_count() : 0;
+    }
+
+    bool expired() const noexcept
+    {
+        return !use_count();
+    }
+
+    void reset() noexcept
+    {
+        weak_ptr().swap(*this);
+    }
+
+    void swap(weak_ptr& r) noexcept
+    {
+        using ctl::swap;
+        swap(p, r.p);
+        swap(rc, r.rc);
+    }
+
+    weak_ptr& operator=(weak_ptr r) noexcept
+    {
+        swap(r);
+        return *this;
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    weak_ptr& operator=(weak_ptr<U> r) noexcept
+    {
+        weak_ptr<T>(move(r)).swap(*this);
+    }
+
+    shared_ptr<T> lock() const noexcept
+    {
+        if (expired())
+            return nullptr;
+        shared_ptr<T> r;
+        r.p = p;
+        r.rc = rc;
+        if (rc)
+            rc->keep_shared();
+        return r;
+    }
+
+    template<typename U>
+    bool owner_before(const weak_ptr<U>& r) const noexcept
+    {
+        return rc < r.rc;
+    }
+
+    template<typename U>
+    bool owner_before(const shared_ptr<U>& r) const noexcept
+    {
+        return rc < r.rc;
+    }
+
+  private:
+    template<typename U>
+    friend class shared_ptr;
+
+    template<typename U, typename... Args>
+    friend shared_ptr<U> make_shared(Args&&...);
+
+    element_type* p = nullptr;
+    __::shared_ref* rc = nullptr;
+};
+
+template<typename T>
+class enable_shared_from_this
+{
+  public:
+    shared_ptr<T> shared_from_this()
+    {
+        return shared_ptr<T>(weak_this);
+    }
+    shared_ptr<T const> shared_from_this() const
+    {
+        return shared_ptr<T>(weak_this);
+    }
+
+    weak_ptr<T> weak_from_this()
+    {
+        return weak_this;
+    }
+    weak_ptr<T const> weak_from_this() const
+    {
+        return weak_this;
+    }
+
+  protected:
+    constexpr enable_shared_from_this() noexcept = default;
+    enable_shared_from_this(const enable_shared_from_this& r) noexcept
+    {
+    }
+    ~enable_shared_from_this() = default;
+
+    enable_shared_from_this& operator=(
+      const enable_shared_from_this& r) noexcept
+    {
+        return *this;
+    }
+
+  private:
+    template<typename U, typename... Args>
+    friend shared_ptr<U> make_shared(Args&&...);
+
+    template<typename U>
+    friend class shared_ptr;
+
+    weak_ptr<T> weak_this;
+};
+
+template<typename T>
+template<typename U, typename D>
+    requires __::shared_ptr_compatible<T, U>
+shared_ptr<T>::shared_ptr(U* const p, D d)
+  : p(p), rc(__::shared_pointer<U, D>::make(p, move(d)))
+{
+    if constexpr (is_base_of_v<enable_shared_from_this<U>, U>) {
+        p->weak_this = *this;
+    }
+}
+
+// Our make_shared supports passing a weak self reference as the first parameter
+// to your constructor, e.g.:
+//
+//     struct Tree : ctl::weak_self_base
+//     {
+//         ctl::shared_ptr<Tree> l, r;
+//         ctl::weak_ptr<Tree> parent;
+//         Tree(weak_ptr<Tree> const& self, auto&& l2, auto&& r2)
+//           : l(ctl::forward<decltype(l2)>(l2)),
+//             r(ctl::forward<decltype(r2)>(r2))
+//         {
+//             if (l) l->parent = self;
+//             if (r) r->parent = self;
+//         }
+//     };
+//
+//     int main() {
+//         auto t = ctl::make_shared<Tree>(
+//             ctl::make_shared<Tree>(nullptr, nullptr), nullptr);
+//         return t->l->parent.lock().get() == t.get() ? 0 : 1;
+//     }
+//
+// As shown, passing the parameter at object construction time lets you complete
+// object construction without needing a separate Init method. But because we go
+// off spec as far as the STL is concerned, there is a potential ambiguity where
+// you might have a constructor with a weak_ptr first parameter that is intended
+// to be something other than a self-reference. So this feature is opt-in by way
+// of inheriting from the following struct.
+struct weak_self_base
+{};
+
+template<typename T, typename... Args>
+shared_ptr<T>
+make_shared(Args&&... args)
+{
+    unique_ptr rc = __::shared_emplace<T>::make();
+    if constexpr (is_base_of_v<weak_self_base, T> &&
+                  is_constructible_v<T, const weak_ptr<T>&, Args...>) {
+        // A __::shared_ref has a virtual weak reference that is owned by all of
+        // the shared references. We can avoid some unnecessary refcount changes
+        // by "borrowing" that reference and passing it to the constructor, then
+        // promoting it to a shared reference by swapping it with the shared_ptr
+        // that we return.
+        weak_ptr<T> w;
+        w.p = &rc->t;
+        w.rc = rc.get();
+        try {
+            rc->construct(const_cast<const weak_ptr<T>&>(w),
+                          forward<Args>(args)...);
+        } catch (...) {
+            w.p = nullptr;
+            w.rc = nullptr;
+            throw;
+        }
+        rc.release();
+        shared_ptr<T> r;
+        swap(r.p, w.p);
+        swap(r.rc, w.rc);
+        return r;
+    } else {
+        rc->construct(forward<Args>(args)...);
+        shared_ptr<T> r;
+        r.p = &rc->t;
+        r.rc = rc.release();
+        if constexpr (is_base_of_v<enable_shared_from_this<T>, T>) {
+            r->weak_this = r;
+        }
+        return r;
+    }
+}
+
+} // namespace ctl
+
+#endif // CTL_SHARED_PTR_H_

ctl/sort.cc

@@ -0,0 +1,38 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2026 Justin Alexander Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "sort.h"
+#include "libc/mem/alg.h"
+
+namespace ctl {
+namespace detail {
+
+// This lives out of line so that programs calling ctl::sort() only need
+// to depend on ctl, rather than on whichever library qsort_r() is in.
+void
+sort_r(void* a,
+       size_t n,
+       size_t es,
+       int (*cmp)(const void*, const void*, void*),
+       void* arg)
+{
+    qsort_r(a, n, es, cmp, arg);
+}
+
+} // namespace detail
+} // namespace ctl

ctl/sort.h

@@ -2,23 +2,54 @@
 // vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
 #ifndef CTL_SORT_H_
 #define CTL_SORT_H_
+#include "is_same.h"
 #include "iterator_traits.h"
 #include "less.h"
-#include "partition.h"
+#include "new.h"
+#include "utility.h"
 
 namespace ctl {
 
 namespace detail {
 
-template<typename RandomIt, typename Compare>
 void
-quicksort(RandomIt first, RandomIt last, Compare comp)
+sort_r(void*, size_t, size_t, int (*)(const void*, const void*, void*), void*);
+
+template<typename T, typename Compare>
+int
+sort_compare(const T& x, const T& y, Compare& comp)
 {
-    if (first < last) {
-        auto pivot = ctl::partition(first, last, comp);
-        quicksort(first, pivot, comp);
-        quicksort(pivot + 1, last, comp);
-    }
+    if (comp(x, y))
+        return -1;
+    if (comp(y, x))
+        return 1;
+    return 0;
+}
+
+template<typename T, typename Compare>
+int
+sort_direct(const void* a, const void* b, void* arg)
+{
+    return sort_compare(*static_cast<const T*>(a),
+                        *static_cast<const T*>(b),
+                        *static_cast<Compare*>(arg));
+}
+
+template<typename RandomIt, typename Compare>
+struct sort_context
+{
+    RandomIt first;
+    Compare& comp;
+};
+
+template<typename RandomIt, typename Compare>
+int
+sort_indirect(const void* a, const void* b, void* arg)
+{
+    auto* ctx = static_cast<sort_context<RandomIt, Compare>*>(arg);
+    return sort_compare(ctx->first[*static_cast<const size_t*>(a)],
+                        ctx->first[*static_cast<const size_t*>(b)],
+                        ctx->comp);
 }
 
 } // namespace detail
@@ -27,7 +58,38 @@ template<typename RandomIt, typename Compare>
 void
 sort(RandomIt first, RandomIt last, Compare comp)
 {
-    detail::quicksort(first, last, comp);
+    using T = typename ctl::iterator_traits<RandomIt>::value_type;
+    size_t n = last - first;
+    if (n < 2)
+        return;
+    if constexpr (ctl::is_same_v<RandomIt, T*> && __is_trivially_copyable(T)) {
+        detail::sort_r(
+          first, n, sizeof(T), detail::sort_direct<T, Compare>, &comp);
+        return;
+    }
+    size_t* idx = new size_t[n];
+    for (size_t i = 0; i < n; ++i)
+        idx[i] = i;
+    detail::sort_context<RandomIt, Compare> ctx{ first, comp };
+    detail::sort_r(
+      idx, n, sizeof(size_t), detail::sort_indirect<RandomIt, Compare>, &ctx);
+    for (size_t i = 0; i < n; ++i) {
+        if (idx[i] == i)
+            continue;
+        T tmp(ctl::move(first[i]));
+        size_t j = i;
+        for (;;) {
+            size_t k = idx[j];
+            idx[j] = j;
+            if (k == i) {
+                first[j] = ctl::move(tmp);
+                break;
+            }
+            first[j] = ctl::move(first[k]);
+            j = k;
+        }
+    }
+    delete[] idx;
 }
 
 template<typename RandomIt>

ctl/string.cc

@@ -21,6 +21,9 @@
 #include <__atomic/fence.h>
 #include <stdckdint.h>
 
+#include "libc/mem/mem.h"
+#include "libc/str/str.h"
+
 namespace ctl {
 
 void
@@ -274,7 +277,7 @@ size_t
 string::find(const char ch, const size_t pos) const noexcept
 {
     char* q;
-    if ((q = (char*)memchr(data(), ch, size())))
+    if (pos < size() && (q = (char*)memchr(data() + pos, ch, size() - pos)))
         return q - data();
     return npos;
 }
@@ -380,4 +383,72 @@ string::erase(const size_t pos, size_t count) noexcept
     return *this;
 }
 
+void
+string::append(const ctl::string_view& s, size_t pos, size_t count) noexcept
+{
+    append(s.substr(pos, count));
+}
+
+size_t
+string::find_last_of(char c, size_t pos) const noexcept
+{
+    const char* b = data();
+    size_t n = size();
+    if (pos > n)
+        pos = n;
+    const char* p = (const char*)memrchr(b, c, pos);
+    return p ? p - b : npos;
+}
+
+size_t
+string::find_last_of(ctl::string_view set, size_t pos) const noexcept
+{
+    if (empty() || set.empty())
+        return npos;
+    bool lut[256] = {};
+    for (char c : set)
+        lut[c & 255] = true;
+    const char* b = data();
+    size_t last = size() - 1;
+    if (pos > last)
+        pos = last;
+    for (;;) {
+        if (lut[b[pos] & 255])
+            return pos;
+        if (!pos)
+            return npos;
+        --pos;
+    }
+}
+
+size_t
+string::find_first_of(char c, size_t pos) const noexcept
+{
+    size_t n = size();
+    if (pos >= n)
+        return npos;
+    const char* b = data();
+    const char* p = (const char*)memchr(b + pos, c, n - pos);
+    return p ? p - b : npos;
+}
+
+size_t
+string::find_first_of(ctl::string_view set, size_t pos) const noexcept
+{
+    if (set.empty())
+        return npos;
+    bool lut[256] = {};
+    for (char c : set)
+        lut[c & 255] = true;
+    const char* b = data();
+    size_t n = size();
+    for (;;) {
+        if (pos >= n)
+            return npos;
+        if (lut[b[pos] & 255])
+            return pos;
+        ++pos;
+    }
+}
+
 } // namespace ctl

ctl/string.h

@@ -125,6 +125,7 @@ class string
     void append(char, size_t) noexcept;
     void append(unsigned long) noexcept;
     void append(const void*, size_t) noexcept;
+    void append(const ctl::string_view&, size_t, size_t = npos) noexcept;
     string& insert(size_t, ctl::string_view) noexcept;
     string& erase(size_t = 0, size_t = npos) noexcept;
     string substr(size_t = 0, size_t = npos) const noexcept;
@@ -136,6 +137,10 @@ class string
     bool starts_with(ctl::string_view) const noexcept;
     size_t find(char, size_t = 0) const noexcept;
     size_t find(ctl::string_view, size_t = 0) const noexcept;
+    size_t find_first_of(char, size_t = 0) const noexcept;
+    size_t find_first_of(ctl::string_view, size_t = 0) const noexcept;
+    size_t find_last_of(char, size_t = npos) const noexcept;
+    size_t find_last_of(ctl::string_view, size_t = npos) const noexcept;
 
     void swap(string& s) noexcept
     {
@@ -302,7 +307,7 @@ class string
         append(ch);
     }
 
-    void append(const ctl::string_view s) noexcept
+    void append(const ctl::string_view& s) noexcept
     {
         append(s.p, s.n);
     }

ctl/string_view.cc

@@ -29,7 +29,7 @@ size_t
 string_view::find(const char ch, const size_t pos) const noexcept
 {
     char* q;
-    if (n && (q = (char*)memchr(p, ch, n)))
+    if (pos < n && (q = (char*)memchr(p + pos, ch, n - pos)))
         return q - p;
     return npos;
 }
@@ -108,4 +108,66 @@ string_view::starts_with(const string_view s) const noexcept
     return !memcmp(p, s.p, s.n);
 }
 
+size_t
+string_view::find_last_of(char c, size_t pos) const noexcept
+{
+    const char* b = data();
+    size_t n = size();
+    if (pos > n)
+        pos = n;
+    const char* p = (const char*)memrchr(b, c, pos);
+    return p ? p - b : npos;
+}
+
+size_t
+string_view::find_last_of(ctl::string_view set, size_t pos) const noexcept
+{
+    if (empty() || set.empty())
+        return npos;
+    bool lut[256] = {};
+    for (char c : set)
+        lut[c & 255] = true;
+    const char* b = data();
+    size_t last = size() - 1;
+    if (pos > last)
+        pos = last;
+    for (;;) {
+        if (lut[b[pos] & 255])
+            return pos;
+        if (!pos)
+            return npos;
+        --pos;
+    }
+}
+
+size_t
+string_view::find_first_of(char c, size_t pos) const noexcept
+{
+    size_t n = size();
+    if (pos >= n)
+        return npos;
+    const char* b = data();
+    const char* p = (const char*)memchr(b + pos, c, n - pos);
+    return p ? p - b : npos;
+}
+
+size_t
+string_view::find_first_of(ctl::string_view set, size_t pos) const noexcept
+{
+    if (set.empty())
+        return npos;
+    bool lut[256] = {};
+    for (char c : set)
+        lut[c & 255] = true;
+    const char* b = data();
+    size_t n = size();
+    for (;;) {
+        if (pos >= n)
+            return npos;
+        if (lut[b[pos] & 255])
+            return pos;
+        ++pos;
+    }
+}
+
 } // namespace ctl

ctl/string_view.h

@@ -45,6 +45,10 @@ struct string_view
     string_view substr(size_t = 0, size_t = npos) const noexcept;
     size_t find(char, size_t = 0) const noexcept;
     size_t find(string_view, size_t = 0) const noexcept;
+    size_t find_first_of(char, size_t = 0) const noexcept;
+    size_t find_first_of(ctl::string_view, size_t = 0) const noexcept;
+    size_t find_last_of(char, size_t = npos) const noexcept;
+    size_t find_last_of(ctl::string_view, size_t = npos) const noexcept;
 
     constexpr string_view& operator=(const string_view s) noexcept
     {
@@ -109,12 +113,12 @@ struct string_view
         return p[n - 1];
     }
 
-    constexpr const_iterator begin() noexcept
+    constexpr const_iterator begin() const noexcept
     {
         return p;
     }
 
-    constexpr const_iterator end() noexcept
+    constexpr const_iterator end() const noexcept
     {
         return p + n;
     }

dsp/BUILD.mk

@@ -2,7 +2,9 @@
 #── vi: set noet ft=make ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
 
 .PHONY:		o/$(MODE)/dsp
-o/$(MODE)/dsp:	o/$(MODE)/dsp/core	\
+o/$(MODE)/dsp:	o/$(MODE)/dsp/audio	\
+		o/$(MODE)/dsp/core	\
 		o/$(MODE)/dsp/mpeg	\
 		o/$(MODE)/dsp/scale	\
+		o/$(MODE)/dsp/prog	\
 		o/$(MODE)/dsp/tty

dsp/audio/BUILD.mk

@@ -0,0 +1,56 @@
+#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
+#── vi: set noet ft=make ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
+
+PKGS += DSP_AUDIO
+
+DSP_AUDIO_ARTIFACTS += DSP_AUDIO_A
+DSP_AUDIO = $(DSP_AUDIO_A_DEPS) $(DSP_AUDIO_A)
+DSP_AUDIO_A = o/$(MODE)/dsp/audio/audio.a
+DSP_AUDIO_A_FILES := $(wildcard dsp/audio/*)
+DSP_AUDIO_A_HDRS = $(filter %.h,$(DSP_AUDIO_A_FILES)) dsp/audio/cosmoaudio/cosmoaudio.h
+DSP_AUDIO_A_SRCS = $(filter %.c,$(DSP_AUDIO_A_FILES))
+
+DSP_AUDIO_A_DATA =				\
+	dsp/audio/cosmoaudio/miniaudio.h	\
+	dsp/audio/cosmoaudio/cosmoaudio.c	\
+	dsp/audio/cosmoaudio/cosmoaudio.h	\
+	dsp/audio/cosmoaudio/cosmoaudio.dll	\
+
+DSP_AUDIO_A_OBJS =				\
+	$(DSP_AUDIO_A_SRCS:%.c=o/$(MODE)/%.o)	\
+	$(DSP_AUDIO_A_DATA:%=o/$(MODE)/%.zip.o)	\
+
+DSP_AUDIO_A_CHECKS =				\
+	$(DSP_AUDIO_A).pkg			\
+	$(DSP_AUDIO_A_HDRS:%=o/$(MODE)/%.ok)
+
+DSP_AUDIO_A_DIRECTDEPS =			\
+	LIBC_CALLS				\
+	LIBC_DLOPEN				\
+	LIBC_INTRIN				\
+	LIBC_NEXGEN32E				\
+	LIBC_STR				\
+	LIBC_SYSV				\
+	LIBC_PROC				\
+	LIBC_THREAD				\
+
+DSP_AUDIO_A_DEPS :=				\
+	$(call uniq,$(foreach x,$(DSP_AUDIO_A_DIRECTDEPS),$($(x))))
+
+$(DSP_AUDIO_A):	dsp/audio/			\
+		$(DSP_AUDIO_A).pkg		\
+		$(DSP_AUDIO_A_OBJS)
+
+$(DSP_AUDIO_A).pkg:				\
+		$(DSP_AUDIO_A_OBJS)		\
+		$(foreach x,$(DSP_AUDIO_A_DIRECTDEPS),$($(x)_A).pkg)
+
+DSP_AUDIO_LIBS = $(foreach x,$(DSP_AUDIO_ARTIFACTS),$($(x)))
+DSP_AUDIO_SRCS = $(foreach x,$(DSP_AUDIO_ARTIFACTS),$($(x)_SRCS))
+DSP_AUDIO_HDRS = $(foreach x,$(DSP_AUDIO_ARTIFACTS),$($(x)_HDRS))
+DSP_AUDIO_CHECKS = $(foreach x,$(DSP_AUDIO_ARTIFACTS),$($(x)_CHECKS))
+DSP_AUDIO_OBJS = $(foreach x,$(DSP_AUDIO_ARTIFACTS),$($(x)_OBJS))
+$(DSP_AUDIO_OBJS): $(BUILD_FILES) dsp/audio/BUILD.mk
+
+.PHONY: o/$(MODE)/dsp/audio
+o/$(MODE)/dsp/audio: $(DSP_AUDIO_CHECKS)

dsp/audio/audio.c

@@ -0,0 +1,358 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "dsp/audio/cosmoaudio/cosmoaudio.h"
+#include "dsp/audio/describe.h"
+#include "libc/calls/blockcancel.internal.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/struct/stat.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/dce.h"
+#include "libc/dlopen/dlfcn.h"
+#include "libc/errno.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/limits.h"
+#include "libc/macros.h"
+#include "libc/proc/posix_spawn.h"
+#include "libc/runtime/runtime.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/o.h"
+#include "libc/temp.h"
+#include "libc/thread/thread.h"
+
+#define COSMOAUDIO_MINIMUM_VERISON 1
+
+#define COSMOAUDIO_DSO_NAME "cosmoaudio." STRINGIFY(COSMOAUDIO_MINIMUM_VERISON)
+
+__static_yoink("dsp/audio/cosmoaudio/miniaudio.h");
+__static_yoink("dsp/audio/cosmoaudio/cosmoaudio.h");
+__static_yoink("dsp/audio/cosmoaudio/cosmoaudio.c");
+__static_yoink("dsp/audio/cosmoaudio/cosmoaudio.dll");
+
+static const struct Source {
+  const char *zip;
+  const char *name;
+} srcs[] = {
+    {"/zip/dsp/audio/cosmoaudio/miniaudio.h", "miniaudio.h"},
+    {"/zip/dsp/audio/cosmoaudio/cosmoaudio.h", "cosmoaudio.h"},
+    {"/zip/dsp/audio/cosmoaudio/cosmoaudio.c", "cosmoaudio.c"},  // must last
+};
+
+static struct {
+  pthread_once_t once;
+  typeof(cosmoaudio_open) *open;
+  typeof(cosmoaudio_close) *close;
+  typeof(cosmoaudio_write) *write;
+  typeof(cosmoaudio_flush) *flush;
+  typeof(cosmoaudio_read) *read;
+  typeof(cosmoaudio_poll) *poll;
+} g_audio;
+
+static const char *cosmoaudio_tmp_dir(void) {
+  const char *tmpdir;
+  if (!(tmpdir = getenv("TMPDIR")) || !*tmpdir)
+    if (!(tmpdir = getenv("HOME")) || !*tmpdir)
+      tmpdir = ".";
+  return tmpdir;
+}
+
+static bool cosmoaudio_app_dir(char *path, size_t size) {
+  strlcpy(path, cosmoaudio_tmp_dir(), size);
+  strlcat(path, "/.cosmo/", size);
+  if (makedirs(path, 0755))
+    return false;
+  return true;
+}
+
+static bool cosmoaudio_dso_path(char *path, size_t size) {
+  if (!cosmoaudio_app_dir(path, size))
+    return false;
+  strlcat(path, COSMOAUDIO_DSO_NAME, size);
+  if (IsWindows()) {
+    strlcat(path, ".dll", size);
+  } else if (IsXnu()) {
+    strlcat(path, ".dylib", size);
+  } else {
+    strlcat(path, ".so", size);
+  }
+  return true;
+}
+
+static bool cosmoaudio_extract(const char *zip, const char *to) {
+  int fdin, fdout;
+  char stage[PATH_MAX];
+  strlcpy(stage, to, sizeof(stage));
+  if (strlcat(stage, ".XXXXXX", sizeof(stage)) >= sizeof(stage)) {
+    errno = ENAMETOOLONG;
+    return false;
+  }
+  if ((fdout = mkostemp(stage, O_CLOEXEC)) == -1)
+    return false;
+  if ((fdin = open(zip, O_RDONLY | O_CLOEXEC)) == -1) {
+    close(fdout);
+    unlink(stage);
+    return false;
+  }
+  if (copyfd(fdin, fdout, -1) == -1) {
+    close(fdin);
+    close(fdout);
+    unlink(stage);
+    return false;
+  }
+  if (close(fdout)) {
+    close(fdin);
+    unlink(stage);
+    return false;
+  }
+  if (close(fdin)) {
+    unlink(stage);
+    return false;
+  }
+  if (rename(stage, to)) {
+    unlink(stage);
+    return false;
+  }
+  return true;
+}
+
+static bool cosmoaudio_build(const char *dso) {
+
+  // extract sauce
+  char src[PATH_MAX];
+  for (int i = 0; i < sizeof(srcs) / sizeof(*srcs); ++i) {
+    if (!cosmoaudio_app_dir(src, PATH_MAX))
+      return false;
+    strlcat(src, srcs[i].name, sizeof(src));
+    if (!cosmoaudio_extract(srcs[i].zip, src))
+      return false;
+  }
+
+  // create temporary name for compiled dso
+  // it'll ensure build operation is atomic
+  int fd;
+  char tmpdso[PATH_MAX];
+  strlcpy(tmpdso, dso, sizeof(tmpdso));
+  strlcat(tmpdso, ".XXXXXX", sizeof(tmpdso));
+  if ((fd = mkostemp(tmpdso, O_CLOEXEC)) != -1) {
+    close(fd);
+  } else {
+    return false;
+  }
+
+  // build cosmoaudio with host c compiler
+  char *args[] = {
+      "cc",                                       //
+      "-w",                                       //
+      "-I.",                                      //
+      "-O2",                                      //
+      "-fPIC",                                    //
+      "-shared",                                  //
+      "-pthread",                                 //
+      "-DNDEBUG",                                 //
+      IsAarch64() ? "-ffixed-x28" : "-DIGNORE1",  //
+      src,                                        //
+      "-o",                                       //
+      tmpdso,                                     //
+      "-lm",                                      //
+      IsNetbsd() ? 0 : "-ldl",                    //
+      NULL,
+  };
+  int pid, ws;
+  errno_t err = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
+  if (err)
+    return false;
+  while (waitpid(pid, &ws, 0) == -1)
+    if (errno != EINTR)
+      return false;
+  if (ws)
+    return false;
+
+  // move dso to its final destination
+  if (rename(tmpdso, dso))
+    return false;
+
+  return true;
+}
+
+static void *cosmoaudio_dlopen(const char *name) {
+  void *handle;
+  if ((handle = cosmo_dlopen(name, RTLD_NOW))) {
+    typeof(cosmoaudio_version) *version;
+    if ((version = cosmo_dlsym(handle, "cosmoaudio_version")))
+      if (version() >= COSMOAUDIO_MINIMUM_VERISON)
+        return handle;
+    cosmo_dlclose(handle);
+  }
+  return 0;
+}
+
+static void cosmoaudio_setup_impl(void) {
+  void *handle;
+  if (IsOpenbsd())
+    return;  // no dlopen support yet
+  if (IsXnu() && !IsXnuSilicon())
+    return;  // no dlopen support yet
+  if (!(handle = cosmoaudio_dlopen(COSMOAUDIO_DSO_NAME ".so")) &&
+      !(handle = cosmoaudio_dlopen("lib" COSMOAUDIO_DSO_NAME ".so")) &&
+      !(handle = cosmoaudio_dlopen("cosmoaudio.so")) &&
+      !(handle = cosmoaudio_dlopen("libcosmoaudio.so"))) {
+    char dso[PATH_MAX];
+    if (!cosmoaudio_dso_path(dso, sizeof(dso)))
+      return;
+    if ((handle = cosmoaudio_dlopen(dso)))
+      goto WeAreGood;
+    if (IsWindows()) {
+      if (cosmoaudio_extract("/zip/dsp/audio/cosmoaudio/cosmoaudio.dll", dso)) {
+        if ((handle = cosmoaudio_dlopen(dso))) {
+          goto WeAreGood;
+        } else {
+          return;
+        }
+      }
+    }
+    if (!cosmoaudio_build(dso))
+      return;
+    if (!(handle = cosmoaudio_dlopen(dso)))
+      return;
+  }
+WeAreGood:
+  g_audio.open = cosmo_dlsym(handle, "cosmoaudio_open");
+  g_audio.close = cosmo_dlsym(handle, "cosmoaudio_close");
+  g_audio.write = cosmo_dlsym(handle, "cosmoaudio_write");
+  g_audio.flush = cosmo_dlsym(handle, "cosmoaudio_flush");
+  g_audio.read = cosmo_dlsym(handle, "cosmoaudio_read");
+  g_audio.poll = cosmo_dlsym(handle, "cosmoaudio_poll");
+}
+
+static void cosmoaudio_setup(void) {
+  BLOCK_CANCELATION;
+  cosmoaudio_setup_impl();
+  ALLOW_CANCELATION;
+}
+
+static void cosmoaudio_init(void) {
+  pthread_once(&g_audio.once, cosmoaudio_setup);
+}
+
+COSMOAUDIO_ABI int cosmoaudio_open(
+    struct CosmoAudio **out_ca, const struct CosmoAudioOpenOptions *options) {
+  int status;
+  char sbuf[32];
+  char dbuf[256];
+  cosmoaudio_init();
+  if (g_audio.open) {
+    BLOCK_SIGNALS;
+    status = g_audio.open(out_ca, options);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  STRACE("cosmoaudio_open([%p], %s) → %s",
+         out_ca ? *out_ca : (struct CosmoAudio *)-1,
+         cosmoaudio_describe_open_options(dbuf, sizeof(dbuf), options),
+         cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}
+
+COSMOAUDIO_ABI int cosmoaudio_close(struct CosmoAudio *ca) {
+  int status;
+  char sbuf[32];
+  if (g_audio.close) {
+    BLOCK_SIGNALS;
+    status = g_audio.close(ca);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  STRACE("cosmoaudio_close(%p) → %s", ca,
+         cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}
+
+COSMOAUDIO_ABI int cosmoaudio_write(struct CosmoAudio *ca, const float *data,
+                                    int frames) {
+  int status;
+  char sbuf[32];
+  if (g_audio.write) {
+    BLOCK_SIGNALS;
+    status = g_audio.write(ca, data, frames);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  if (frames <= 0 || frames >= 160)
+    DATATRACE("cosmoaudio_write(%p, %p, %d) → %s", ca, data, frames,
+              cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}
+
+COSMOAUDIO_ABI int cosmoaudio_read(struct CosmoAudio *ca, float *data,
+                                   int frames) {
+  int status;
+  char sbuf[32];
+  if (g_audio.read) {
+    BLOCK_SIGNALS;
+    status = g_audio.read(ca, data, frames);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  if (frames <= 0 || frames >= 160)
+    DATATRACE("cosmoaudio_read(%p, %p, %d) → %s", ca, data, frames,
+              cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}
+
+COSMOAUDIO_ABI int cosmoaudio_flush(struct CosmoAudio *ca) {
+  int status;
+  char sbuf[32];
+  if (g_audio.flush) {
+    BLOCK_SIGNALS;
+    status = g_audio.flush(ca);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  DATATRACE("cosmoaudio_flush(%p) → %s", ca,
+            cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}
+
+COSMOAUDIO_ABI int cosmoaudio_poll(struct CosmoAudio *ca,
+                                   int *in_out_readFrames,
+                                   int *in_out_writeFrames) {
+  int status;
+  char sbuf[32];
+  char fbuf[2][20];
+  if (g_audio.poll) {
+    BLOCK_SIGNALS;
+    status = g_audio.poll(ca, in_out_readFrames, in_out_writeFrames);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  DATATRACE("cosmoaudio_poll(%p, %s, %s) → %s", ca,
+            cosmoaudio_describe_poll_frames(fbuf[0], sizeof(fbuf[0]),
+                                            in_out_readFrames),
+            cosmoaudio_describe_poll_frames(fbuf[1], sizeof(fbuf[1]),
+                                            in_out_writeFrames),
+            cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}

dsp/audio/cosmoaudio/.gitignore

@@ -0,0 +1,3 @@
+*.o
+/Debug
+/Release

dsp/audio/cosmoaudio/Makefile.msvc

@@ -0,0 +1,87 @@
+# Makefile for MSVC x64 Command Line Developer Tools
+#
+#     nmake /f Makefile.msvc check
+#     nmake /f Makefile.msvc MODE=debug check
+#
+# Note: MSVC 2019 makes the DLL 64kb smaller than MSVC 2022.
+
+# Compiler and linker
+CC=cl
+LINK=link
+
+# Build mode (can be overridden from command line)
+!IFNDEF MODE
+MODE=release
+!ENDIF
+
+# Library dependencies.
+TEST_LIBS=OneCore.lib
+
+# Compiler flags
+CFLAGS_COMMON=/nologo /W4 /Gy /EHsc
+CFLAGS_DEBUG=/Od /Zi /MDd /D_DEBUG
+CFLAGS_RELEASE=/O2 /MT /DNDEBUG
+
+!IF "$(MODE)"=="debug"
+CFLAGS=$(CFLAGS_COMMON) $(CFLAGS_DEBUG)
+LDFLAGS=/DEBUG
+OUT_DIR=Debug
+!ELSE
+CFLAGS=$(CFLAGS_COMMON) $(CFLAGS_RELEASE) /GL
+LDFLAGS=/RELEASE /OPT:REF /OPT:ICF /LTCG /INCREMENTAL:NO
+OUT_DIR=Release
+!ENDIF
+
+# Additional flags for DLL
+DLL_CFLAGS=$(CFLAGS) /D_USRDLL /D_WINDLL
+
+# Linker flags
+LDFLAGS=/NOLOGO /SUBSYSTEM:CONSOLE $(LDFLAGS)
+
+# Output file names
+DLL_TARGET=$(OUT_DIR)\cosmoaudio.dll
+TEST_TARGET=$(OUT_DIR)\test.exe
+
+# Source files
+DLL_SOURCES=cosmoaudio.c
+TEST_SOURCES=test.c
+
+# Object files
+DLL_OBJECTS=$(OUT_DIR)\cosmoaudio.obj
+TEST_OBJECTS=$(OUT_DIR)\test.obj
+
+# Default target
+all: $(OUT_DIR) $(DLL_TARGET) $(TEST_TARGET)
+
+# Create output directory
+$(OUT_DIR):
+    if not exist $(OUT_DIR) mkdir $(OUT_DIR)
+
+# Rule to build the DLL
+$(DLL_TARGET): $(OUT_DIR) $(DLL_OBJECTS)
+    $(LINK) /DLL $(LDFLAGS) /OUT:$(DLL_TARGET) $(DLL_OBJECTS)
+
+# Rule to build the test program
+$(TEST_TARGET): $(OUT_DIR) $(TEST_OBJECTS) $(DLL_TARGET)
+    $(LINK) $(LDFLAGS) /OUT:$(TEST_TARGET) $(TEST_OBJECTS) $(DLL_TARGET:.dll=.lib) $(TEST_LIBS)
+
+# Rules to compile .c files to .obj files with header dependencies
+{.}.c{$(OUT_DIR)}.obj:
+    $(CC) $(DLL_CFLAGS) /c /Fo$(OUT_DIR)\ $<
+
+$(OUT_DIR)\test.obj: $(OUT_DIR) test.c cosmoaudio.h
+    $(CC) $(CFLAGS) /c /Fo$(OUT_DIR)\ test.c
+
+$(OUT_DIR)\cosmoaudio.obj: $(OUT_DIR) cosmoaudio.c miniaudio.h cosmoaudio.h
+    $(CC) $(DLL_CFLAGS) /c /Fo$(OUT_DIR)\ cosmoaudio.c
+
+# Clean target
+clean:
+    if exist $(OUT_DIR) rmdir /s /q $(OUT_DIR)
+
+# Run tests (now called 'check')
+check: $(TEST_TARGET)
+    $(TEST_TARGET)
+
+# Phony targets
+.PHONY: all clean check

dsp/audio/cosmoaudio/cosmoaudio.c

@@ -0,0 +1,519 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#define COSMOAUDIO_BUILD
+#include "cosmoaudio.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MA_DEBUG_OUTPUT
+#define MA_DR_MP3_NO_STDIO
+#define MA_NO_DECODING
+#define MA_NO_ENCODING
+#define MA_NO_ENGINE
+#define MA_NO_GENERATION
+#define MA_NO_NODE_GRAPH
+#define MA_NO_RESOURCE_MANAGER
+#define MA_STATIC
+
+#define MINIAUDIO_IMPLEMENTATION
+#include "miniaudio.h"
+
+struct CosmoAudio {
+  enum CosmoAudioDeviceType deviceType;
+  ma_uint32 outputBufferFrames;
+  ma_uint32 inputBufferFrames;
+  int sampleRate;
+  int channels;
+  int isLeft;
+  ma_context context;
+  ma_device device;
+  ma_pcm_rb output;
+  ma_pcm_rb input;
+  ma_event event;
+  ma_log log;
+};
+
+static int read_ring_buffer(ma_log* log, ma_pcm_rb* rb, float* pOutput,
+                            ma_uint32 frameCount, ma_uint32 channels) {
+  ma_result result;
+  ma_uint32 framesRead;
+  ma_uint32 framesToRead;
+  for (framesRead = 0; framesRead < frameCount; framesRead += framesToRead) {
+    framesToRead = frameCount - framesRead;
+    void* pMappedBuffer;
+    result = ma_pcm_rb_acquire_read(rb, &framesToRead, &pMappedBuffer);
+    if (result != MA_SUCCESS) {
+      ma_log_postf(log, MA_LOG_LEVEL_WARNING,
+                   "ma_pcm_rb_acquire_read failed: %s\n",
+                   ma_result_description(result));
+      return COSMOAUDIO_ERROR;
+    }
+    if (!framesToRead)
+      break;
+    memcpy(pOutput + framesRead * channels, pMappedBuffer,
+           framesToRead * channels * sizeof(float));
+    result = ma_pcm_rb_commit_read(rb, framesToRead);
+    if (result != MA_SUCCESS) {
+      if (result == MA_AT_END) {
+        framesRead += framesToRead;
+        break;
+      }
+      ma_log_postf(log, MA_LOG_LEVEL_WARNING,
+                   "ma_pcm_rb_commit_read failed: %s\n",
+                   ma_result_description(result));
+      return COSMOAUDIO_ERROR;
+    }
+  }
+  return framesRead;
+}
+
+static int write_ring_buffer(ma_log* log, ma_pcm_rb* rb, const float* pInput,
+                             ma_uint32 frameCount, ma_uint32 channels) {
+  ma_result result;
+  ma_uint32 framesWritten;
+  ma_uint32 framesToWrite;
+  for (framesWritten = 0; framesWritten < frameCount;
+       framesWritten += framesToWrite) {
+    framesToWrite = frameCount - framesWritten;
+    void* pMappedBuffer;
+    result = ma_pcm_rb_acquire_write(rb, &framesToWrite, &pMappedBuffer);
+    if (result != MA_SUCCESS) {
+      ma_log_postf(log, MA_LOG_LEVEL_WARNING,
+                   "ma_pcm_rb_acquire_write failed: %s\n",
+                   ma_result_description(result));
+      return COSMOAUDIO_ERROR;
+    }
+    if (!framesToWrite)
+      break;
+    memcpy(pMappedBuffer, pInput + framesWritten * channels,
+           framesToWrite * channels * sizeof(float));
+    result = ma_pcm_rb_commit_write(rb, framesToWrite);
+    if (result != MA_SUCCESS) {
+      if (result == MA_AT_END) {
+        framesWritten += framesToWrite;
+        break;
+      }
+      ma_log_postf(log, MA_LOG_LEVEL_WARNING,
+                   "ma_pcm_rb_commit_write failed: %s\n",
+                   ma_result_description(result));
+      return COSMOAUDIO_ERROR;
+    }
+  }
+  return framesWritten;
+}
+
+static void data_callback_f32(ma_device* pDevice, float* pOutput,
+                              const float* pInput, ma_uint32 frameCount) {
+  struct CosmoAudio* ca = (struct CosmoAudio*)pDevice->pUserData;
+  if (ca->deviceType & kCosmoAudioDeviceTypePlayback) {
+    //
+    // "By default, miniaudio will pre-silence the data callback's
+    //  output buffer. If you know that you will always write valid data
+    //  to the output buffer you can disable pre-silencing by setting
+    //  the noPreSilence config option in the device config to true."
+    //
+    //          —Quoth miniaudio documentation § 16.1. Low Level API
+    //
+    if (ca->isLeft) {
+      int framesCopied = read_ring_buffer(&ca->log, &ca->output, pOutput,
+                                          frameCount, ca->channels);
+      if (framesCopied < (int)frameCount)
+        ca->isLeft = 0;
+    } else {
+      // TODO(jart): Maybe we should stretch the audio too short?
+      int frameOffset;
+      int availableFrames = ma_pcm_rb_available_read(&ca->output);
+      if (availableFrames >= (int)frameCount) {
+        frameOffset = 0;
+      } else {
+        frameOffset = frameCount - availableFrames;
+        frameCount = availableFrames;
+      }
+      read_ring_buffer(&ca->log, &ca->output,
+                       pOutput + frameOffset * ca->channels, frameCount,
+                       ca->channels);
+      ca->isLeft = 1;
+    }
+  }
+  if (ca->deviceType & kCosmoAudioDeviceTypeCapture)
+    write_ring_buffer(&ca->log, &ca->input, pInput, frameCount, ca->channels);
+  ma_event_signal(&ca->event);
+}
+
+static void data_callback(ma_device* pDevice, void* pOutput, const void* pInput,
+                          ma_uint32 frameCount) {
+  data_callback_f32(pDevice, (float*)pOutput, (const float*)pInput, frameCount);
+}
+
+/**
+ * Returns current version of cosmo audio library.
+ */
+COSMOAUDIO_ABI int cosmoaudio_version(void) {
+  return 1;
+}
+
+/**
+ * Opens access to speaker and microphone.
+ *
+ * @param out_ca will receive pointer to allocated CosmoAudio object,
+ *     which must be freed by caller with cosmoaudio_close(); if this
+ *     function fails, then this will receive a NULL pointer value so
+ *     that cosmoaudio_close(), cosmoaudio_write() etc. can be called
+ *     without crashing if no error checking is performed
+ * @return 0 on success, or negative error code on failure
+ */
+COSMOAUDIO_ABI int cosmoaudio_open(  //
+    struct CosmoAudio** out_ca,      //
+    const struct CosmoAudioOpenOptions* options) {
+
+  // Validate arguments.
+  if (!out_ca)
+    return COSMOAUDIO_EINVAL;
+  *out_ca = NULL;
+  if (!options)
+    return COSMOAUDIO_EINVAL;
+  if (options->sizeofThis < (int)sizeof(struct CosmoAudioOpenOptions))
+    return COSMOAUDIO_EINVAL;
+  if (options->bufferFrames < 0)
+    return COSMOAUDIO_EINVAL;
+  if (options->sampleRate < 8000)
+    return COSMOAUDIO_EINVAL;
+  if (options->channels < 1)
+    return COSMOAUDIO_EINVAL;
+  if (!options->deviceType)
+    return COSMOAUDIO_EINVAL;
+  if (options->deviceType &
+      ~(kCosmoAudioDeviceTypePlayback | kCosmoAudioDeviceTypeCapture))
+    return COSMOAUDIO_EINVAL;
+
+  // Allocate cosmo audio object.
+  struct CosmoAudio* ca;
+  ca = (struct CosmoAudio*)calloc(1, sizeof(struct CosmoAudio));
+  if (!ca)
+    return COSMOAUDIO_ERROR;
+  ca->channels = options->channels;
+  ca->sampleRate = options->sampleRate;
+  ca->deviceType = options->deviceType;
+
+  // Create win32-style condition variable.
+  if (ma_event_init(&ca->event) != MA_SUCCESS) {
+    free(ca);
+    return COSMOAUDIO_ERROR;
+  }
+
+  // Create audio log.
+  if (ma_log_init(NULL, &ca->log) != MA_SUCCESS) {
+    ma_event_uninit(&ca->event);
+    free(ca);
+    return COSMOAUDIO_ERROR;
+  }
+  if (!options->debugLog)
+    ca->log.callbackCount = 0;
+
+  // Create audio context.
+  ma_context_config contextConfig = ma_context_config_init();
+  contextConfig.pLog = &ca->log;
+  if (ma_context_init(NULL, 0, &contextConfig, &ca->context) != MA_SUCCESS) {
+    ma_event_uninit(&ca->event);
+    ma_log_uninit(&ca->log);
+    free(ca);
+    return COSMOAUDIO_ERROR;
+  }
+
+  // Initialize device.
+  ma_result result;
+  ma_device_config deviceConfig;
+  deviceConfig = ma_device_config_init(ca->deviceType);
+  deviceConfig.sampleRate = ca->sampleRate;
+  if (ca->deviceType & kCosmoAudioDeviceTypeCapture) {
+    deviceConfig.capture.channels = ca->channels;
+    deviceConfig.capture.format = ma_format_f32;
+    deviceConfig.capture.shareMode = ma_share_mode_shared;
+  }
+  if (ca->deviceType & kCosmoAudioDeviceTypePlayback) {
+    deviceConfig.playback.channels = ca->channels;
+    deviceConfig.playback.format = ma_format_f32;
+  }
+  deviceConfig.dataCallback = data_callback;
+  deviceConfig.pUserData = ca;
+  result = ma_device_init(&ca->context, &deviceConfig, &ca->device);
+  if (result != MA_SUCCESS) {
+    ma_context_uninit(&ca->context);
+    ma_event_uninit(&ca->event);
+    ma_log_uninit(&ca->log);
+    free(ca);
+    return COSMOAUDIO_ERROR;
+  }
+
+  // Initialize the speaker ring buffer.
+  int period = ca->device.playback.internalPeriodSizeInFrames;
+  if (!options->bufferFrames) {
+    ca->outputBufferFrames = period * 10;
+  } else if (options->bufferFrames < period * 2) {
+    ca->outputBufferFrames = period * 2;
+  } else {
+    ca->outputBufferFrames = options->bufferFrames;
+  }
+  if (ca->deviceType & kCosmoAudioDeviceTypePlayback) {
+    result = ma_pcm_rb_init(ma_format_f32, ca->channels, ca->outputBufferFrames,
+                            NULL, NULL, &ca->output);
+    if (result != MA_SUCCESS) {
+      ma_device_uninit(&ca->device);
+      ma_context_uninit(&ca->context);
+      ma_event_uninit(&ca->event);
+      ma_log_uninit(&ca->log);
+      free(ca);
+      return COSMOAUDIO_ERROR;
+    }
+    ma_pcm_rb_set_sample_rate(&ca->output, ca->sampleRate);
+  }
+
+  // Initialize the microphone ring buffer.
+  period = ca->device.capture.internalPeriodSizeInFrames;
+  if (!options->bufferFrames) {
+    ca->inputBufferFrames = period * 10;
+  } else if (options->bufferFrames < period * 2) {
+    ca->inputBufferFrames = period * 2;
+  } else {
+    ca->inputBufferFrames = options->bufferFrames;
+  }
+  if (ca->deviceType & kCosmoAudioDeviceTypeCapture) {
+    result = ma_pcm_rb_init(ma_format_f32, ca->channels, ca->inputBufferFrames,
+                            NULL, NULL, &ca->input);
+    if (result != MA_SUCCESS) {
+      ma_device_uninit(&ca->device);
+      if (ca->deviceType & kCosmoAudioDeviceTypePlayback)
+        ma_pcm_rb_uninit(&ca->output);
+      ma_context_uninit(&ca->context);
+      ma_event_uninit(&ca->event);
+      ma_log_uninit(&ca->log);
+      free(ca);
+      return COSMOAUDIO_ERROR;
+    }
+    ma_pcm_rb_set_sample_rate(&ca->output, ca->sampleRate);
+  }
+
+  // Start audio playback.
+  if (ma_device_start(&ca->device) != MA_SUCCESS) {
+    ma_device_uninit(&ca->device);
+    if (ca->deviceType & kCosmoAudioDeviceTypePlayback)
+      ma_pcm_rb_uninit(&ca->output);
+    if (ca->deviceType & kCosmoAudioDeviceTypeCapture)
+      ma_pcm_rb_uninit(&ca->input);
+    ma_context_uninit(&ca->context);
+    ma_event_uninit(&ca->event);
+    ma_log_uninit(&ca->log);
+    free(ca);
+    return COSMOAUDIO_ERROR;
+  }
+
+  *out_ca = ca;
+  return COSMOAUDIO_SUCCESS;
+}
+
+/**
+ * Closes audio device and frees all associated resources.
+ *
+ * This function is non-blocking and will drop buffered audio. In
+ * playback mode, you need to call cosmoaudio_flush() to ensure data
+ * supplied by cosmoaudio_write() gets played on your speaker.
+ *
+ * Calling this function twice on the same object will result in
+ * undefined behavior. Even if this function fails, the `ca` will be
+ * freed to the greatest extent possible.
+ *
+ * @param ca is CosmoAudio object returned earlier by cosmoaudio_open()
+ * @return 0 on success, or negative error code on failure
+ */
+COSMOAUDIO_ABI int cosmoaudio_close(struct CosmoAudio* ca) {
+  if (!ca)
+    return COSMOAUDIO_EINVAL;
+  ma_device_uninit(&ca->device);  // do this first
+  if (ca->deviceType & kCosmoAudioDeviceTypePlayback)
+    ma_pcm_rb_uninit(&ca->output);
+  if (ca->deviceType & kCosmoAudioDeviceTypeCapture)
+    ma_pcm_rb_uninit(&ca->input);
+  ma_context_uninit(&ca->context);
+  ma_event_uninit(&ca->event);
+  ma_log_uninit(&ca->log);
+  free(ca);
+  return COSMOAUDIO_SUCCESS;
+}
+
+/**
+ * Writes raw audio data to speaker.
+ *
+ * The data is written to a ring buffer in real-time, which is then
+ * played back very soon on the audio device. This has tolerence for
+ * a certain amount of buffering, but expects that this function is
+ * repeatedly called at a regular time interval. The caller should
+ * have its own sleep loop for this purpose.
+ *
+ * This function never blocks. Programs that don't have their own timer
+ * can use cosmoaudio_poll() to wait until audio may be written.
+ *
+ * For any given CosmoAudio object, it's assumed that only a single
+ * thread will call this function.
+ *
+ * @param ca is CosmoAudio object returned earlier by cosmoaudio_open()
+ * @param data is pointer to raw audio samples, expected to be in the range
+ *     -1.0 to 1.0, where channels are interleaved
+ * @param frames is the number of frames (i.e. number of samples divided by
+ *     number of channels) from `data` to write to audio device
+ * @return number of frames written, or negative error code on failure
+ */
+COSMOAUDIO_ABI int cosmoaudio_write(struct CosmoAudio* ca, const float* data,
+                                    int frames) {
+  if (!ca)
+    return COSMOAUDIO_EINVAL;
+  if (frames < 0)
+    return COSMOAUDIO_EINVAL;
+  if (!(ca->deviceType & kCosmoAudioDeviceTypePlayback))
+    return COSMOAUDIO_EINVAL;
+  if (1u + frames > ca->outputBufferFrames)
+    return COSMOAUDIO_ENOBUF;
+  if (!frames)
+    return 0;
+  if (!data)
+    return COSMOAUDIO_EINVAL;
+  return write_ring_buffer(&ca->log, &ca->output, data, frames, ca->channels);
+}
+
+/**
+ * Reads raw audio data from microphone.
+ *
+ * The data is read from a ring buffer in real-time, which is then
+ * played back on the audio device. This has tolerence for a certain
+ * amount of buffering (based on the `bufferFrames` parameter passed to
+ * cosmoaudio_open(), which by default assumes this function will be
+ * called at at a regular time interval.
+ *
+ * This function never blocks. Programs that don't have their own timer
+ * can use cosmoaudio_poll() to wait until audio may be read.
+ *
+ * For any given CosmoAudio object, it's assumed that only a single
+ * thread will call this function.
+ *
+ * @param ca is CosmoAudio object returned earlier by cosmoaudio_open()
+ * @param data is pointer to raw audio samples, expected to be in the range
+ *     -1.0 to 1.0, where channels are interleaved
+ * @param frames is the number of frames (i.e. number of samples divided by
+ *     number of channels) from `data` to read from microphone
+ * @return number of frames read, or negative error code on failure
+ */
+COSMOAUDIO_ABI int cosmoaudio_read(struct CosmoAudio* ca, float* data,
+                                   int frames) {
+  if (!ca)
+    return COSMOAUDIO_EINVAL;
+  if (frames < 0)
+    return COSMOAUDIO_EINVAL;
+  if (!(ca->deviceType & kCosmoAudioDeviceTypeCapture))
+    return COSMOAUDIO_EINVAL;
+  if (!frames)
+    return 0;
+  if (!data)
+    return COSMOAUDIO_EINVAL;
+  return read_ring_buffer(&ca->log, &ca->input, data, frames, ca->channels);
+}
+
+/**
+ * Waits until it's possible to read/write audio.
+ *
+ * This function is uninterruptible. All signals are masked throughout
+ * the duration of time this function may block, including cancelation
+ * signals, because this is not a cancelation point. Cosmopolitan Libc
+ * applies this masking in its dlopen wrapper.
+ *
+ * @param ca is CosmoAudio object returned earlier by cosmoaudio_open()
+ * @param in_out_readFrames if non-NULL specifies how many frames of
+ *     capture data be immediately readable by cosmoaudio_read() before
+ *     this can return; it must not exceed the buffer size; on return
+ *     this will be set to the actual number of frames in the buffer;
+ *     if the caller supplies a zero then this call is a non-blocking
+ *     way to query buffer sizes
+ * @param in_out_writeFrames if non-NULL specifies how many frames of
+ *     capture data be immediately writable by cosmoaudio_write() before
+ *     this can return; it must not exceed the buffer size; on return
+ *     this will be set to the actual number of frames in the buffer;
+ *     if the caller supplies a zero then this call is a non-blocking
+ *     way to query buffer sizes
+ * @return 0 on success, or negative error code on error
+ */
+COSMOAUDIO_ABI int cosmoaudio_poll(struct CosmoAudio* ca,
+                                   int* in_out_readFrames,
+                                   int* in_out_writeFrames) {
+  if (!ca)
+    return COSMOAUDIO_EINVAL;
+  if (!in_out_readFrames && !in_out_writeFrames)
+    return COSMOAUDIO_EINVAL;
+  if (in_out_readFrames && !(ca->deviceType & kCosmoAudioDeviceTypeCapture))
+    return COSMOAUDIO_EINVAL;
+  if (in_out_writeFrames && !(ca->deviceType & kCosmoAudioDeviceTypePlayback))
+    return COSMOAUDIO_EINVAL;
+  if (in_out_readFrames && 1u + *in_out_readFrames > ca->inputBufferFrames)
+    return COSMOAUDIO_ENOBUF;
+  if (in_out_writeFrames && 1u + *in_out_writeFrames > ca->outputBufferFrames)
+    return COSMOAUDIO_ENOBUF;
+  for (;;) {
+    int done = 1;
+    ma_uint32 readable = 0;
+    ma_uint32 writable = 0;
+    if (in_out_readFrames) {
+      readable = ma_pcm_rb_available_read(&ca->input);
+      done &= readable >= (ma_uint32)*in_out_readFrames;
+    }
+    if (in_out_writeFrames) {
+      writable = ma_pcm_rb_available_write(&ca->output);
+      done &= writable >= (ma_uint32)*in_out_writeFrames;
+    }
+    if (done) {
+      if (in_out_readFrames)
+        *in_out_readFrames = readable;
+      if (in_out_writeFrames)
+        *in_out_writeFrames = writable;
+      return COSMOAUDIO_SUCCESS;
+    }
+    if (ma_event_wait(&ca->event) != MA_SUCCESS)
+      return COSMOAUDIO_ERROR;
+  }
+}
+
+/**
+ * Waits for written samples to be sent to device.
+ *
+ * This function is only valid to call in playback or duplex mode.
+ *
+ * This function is uninterruptible. All signals are masked throughout
+ * the duration of time this function may block, including cancelation
+ * signals, because this is not a cancelation point. Cosmopolitan Libc
+ * applies this masking in its dlopen wrapper.
+ *
+ * @param ca is CosmoAudio object returned earlier by cosmoaudio_open()
+ * @return 0 on success, or negative error code on failure
+ */
+COSMOAUDIO_ABI int cosmoaudio_flush(struct CosmoAudio* ca) {
+  if (!ca)
+    return COSMOAUDIO_EINVAL;
+  if (!(ca->deviceType & kCosmoAudioDeviceTypePlayback))
+    return COSMOAUDIO_EINVAL;
+  for (;;) {
+    if (!ma_pcm_rb_available_read(&ca->output))
+      return COSMOAUDIO_SUCCESS;
+    if (ma_event_wait(&ca->event) != MA_SUCCESS)
+      return COSMOAUDIO_ERROR;
+  }
+}

dsp/audio/cosmoaudio/cosmoaudio.h

@@ -0,0 +1,104 @@
+#ifndef COSMOAUDIO_H_
+#define COSMOAUDIO_H_
+
+#ifdef _MSC_VER
+#define COSMOAUDIO_ABI
+#ifdef COSMOAUDIO_BUILD
+#define COSMOAUDIO_API __declspec(dllexport)
+#else
+#define COSMOAUDIO_API __declspec(dllimport)
+#endif
+#else
+#define COSMOAUDIO_API
+#ifdef __x86_64__
+#define COSMOAUDIO_ABI __attribute__((__ms_abi__, __visibility__("default")))
+#else
+#define COSMOAUDIO_ABI __attribute__((__visibility__("default")))
+#endif
+#endif
+
+#define COSMOAUDIO_SUCCESS -0  // no error or nothing written
+#define COSMOAUDIO_ERROR   -1  // unspecified error
+#define COSMOAUDIO_EINVAL  -2  // invalid parameters passed to api
+#define COSMOAUDIO_ELINK   -3  // loading cosmoaudio dso failed
+#define COSMOAUDIO_ENOBUF  -4  // invalid buffering parameters
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct CosmoAudio;
+
+enum CosmoAudioDeviceType {
+  kCosmoAudioDeviceTypePlayback = 1,
+  kCosmoAudioDeviceTypeCapture = 2,
+  kCosmoAudioDeviceTypeDuplex =
+      kCosmoAudioDeviceTypePlayback | kCosmoAudioDeviceTypeCapture,
+};
+
+struct CosmoAudioOpenOptions {
+
+  // This field must be set to sizeof(struct CosmoAudioOpenOptions) or
+  // cosmoaudio_open() will return COSMOAUDIO_EINVAL.
+  int sizeofThis;
+
+  // Whether you want this object to open the speaker or microphone.
+  // Please note that asking for microphone access may cause some OSes
+  // like MacOS to show a popup asking the user for permission.
+  enum CosmoAudioDeviceType deviceType;
+
+  // The sample rate can be 44100 for CD quality, 8000 for telephone
+  // quality, etc. Values below 8000 are currently not supported.
+  int sampleRate;
+
+  // The number of audio channels in each interleaved frame. Should be 1
+  // for mono or 2 for stereo.
+  int channels;
+
+  // Number of frames in each ring buffer. A frame consists of a PCM
+  // sample for each channel. Set to 0 for default. If this is less than
+  // the device period size times two, it'll be increased to that value.
+  int bufferFrames;
+
+  // Enables debug logging if non-zero.
+  int debugLog;
+};
+
+COSMOAUDIO_API int cosmoaudio_version(void) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_open(              //
+    struct CosmoAudio **out_ca,                  //
+    const struct CosmoAudioOpenOptions *options  //
+    ) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_close(  //
+    struct CosmoAudio *ca             //
+    ) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_write(  //
+    struct CosmoAudio *ca,            //
+    const float *samples,             //
+    int frameCount                    //
+    ) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_flush(  //
+    struct CosmoAudio *ca             //
+    ) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_read(  //
+    struct CosmoAudio *ca,           //
+    float *out_samples,              //
+    int frameCount                   //
+    ) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_poll(  //
+    struct CosmoAudio *ca,           //
+    int *in_out_readFrames,          //
+    int *in_out_writeFrames          //
+    ) COSMOAUDIO_ABI;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* COSMOAUDIO_H_ */

dsp/audio/cosmoaudio/miniaudio.h

@@ -0,0 +1 @@
+../../../third_party/miniaudio/miniaudio.h

dsp/audio/cosmoaudio/test.c

@@ -0,0 +1,76 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "cosmoaudio.h"
+
+#define SAMPLING_RATE 44100
+#define WAVE_INTERVAL 440
+#define CHANNELS      2
+
+#ifndef M_PIf
+#define M_PIf 3.14159265358979323846f
+#endif
+
+int main() {
+
+  struct CosmoAudioOpenOptions cao = {0};
+  cao.sizeofThis = sizeof(struct CosmoAudioOpenOptions);
+  cao.deviceType = kCosmoAudioDeviceTypePlayback;
+  cao.sampleRate = SAMPLING_RATE;
+  cao.channels = CHANNELS;
+
+  int status;
+  struct CosmoAudio *ca;
+  status = cosmoaudio_open(&ca, &cao);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to open audio: %d\n", status);
+    return 1;
+  }
+
+  float buf[256 * CHANNELS];
+  for (int g = 0; g < SAMPLING_RATE;) {
+    int frames = 1;
+    status = cosmoaudio_poll(ca, NULL, &frames);
+    if (status != COSMOAUDIO_SUCCESS) {
+      fprintf(stderr, "failed to poll output: %d\n", status);
+      return 2;
+    }
+    if (frames > 256)
+      frames = 256;
+    if (frames > SAMPLING_RATE - g)
+      frames = SAMPLING_RATE - g;
+    for (int f = 0; f < frames; ++f) {
+      float t = (float)g++ / SAMPLING_RATE;
+      float s = sinf(2 * M_PIf * WAVE_INTERVAL * t);
+      for (int c = 0; c < CHANNELS; c++)
+        buf[f * CHANNELS + c] = s * .3f;
+    }
+    status = cosmoaudio_write(ca, buf, frames);
+    if (status != frames) {
+      fprintf(stderr, "failed to write output: %d\n", status);
+      return 3;
+    }
+  }
+
+  status = cosmoaudio_flush(ca);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to flush output: %d\n", status);
+    return 4;
+  }
+
+  status = cosmoaudio_close(ca);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to close audio: %d\n", status);
+    return 5;
+  }
+}

dsp/audio/describe.c

@@ -0,0 +1,121 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "dsp/audio/describe.h"
+#include "dsp/audio/cosmoaudio/cosmoaudio.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/macros.h"
+
+#define append(...) o += ksnprintf(buf + o, n - o, __VA_ARGS__)
+
+const char *cosmoaudio_describe_status(char *buf, int n, int status) {
+  switch (status) {
+    case COSMOAUDIO_SUCCESS:
+      return "COSMOAUDIO_SUCCESS";
+    case COSMOAUDIO_ERROR:
+      return "COSMOAUDIO_ERROR";
+    case COSMOAUDIO_EINVAL:
+      return "COSMOAUDIO_EINVAL";
+    case COSMOAUDIO_ELINK:
+      return "COSMOAUDIO_ELINK";
+    case COSMOAUDIO_ENOBUF:
+      return "COSMOAUDIO_ENOBUF";
+    default:
+      ksnprintf(buf, n, "%d", status);
+      return buf;
+  }
+}
+
+const char *cosmoaudio_describe_open_options(
+    char *buf, int n, const struct CosmoAudioOpenOptions *options) {
+  int o = 0;
+  char b128[128];
+  bool gotsome = false;
+  if (!options)
+    return "NULL";
+  if (kisdangerous(options)) {
+    ksnprintf(buf, n, "%p", options);
+    return buf;
+  }
+  append("{");
+
+  if (options->sampleRate) {
+    if (gotsome)
+      append(", ");
+    append(".sampleRate=%d", options->sampleRate);
+    gotsome = true;
+  }
+
+  if (options->channels) {
+    if (gotsome)
+      append(", ");
+    append(".channels=%d", options->channels);
+    gotsome = true;
+  }
+
+  if (options->deviceType) {
+    if (gotsome)
+      append(", ");
+    static struct DescribeFlags kDeviceType[] = {
+        {kCosmoAudioDeviceTypeDuplex, "Duplex"},      //
+        {kCosmoAudioDeviceTypeCapture, "Capture"},    //
+        {kCosmoAudioDeviceTypePlayback, "Playback"},  //
+    };
+    append(".deviceType=%s",
+           _DescribeFlags(b128, 128, kDeviceType, ARRAYLEN(kDeviceType),
+                          "kCosmoAudioDeviceType", options->deviceType));
+    gotsome = true;
+  }
+
+  if (options->bufferFrames) {
+    if (gotsome)
+      append(", ");
+    append(".bufferFrames=%d", options->bufferFrames);
+    gotsome = true;
+  }
+
+  if (options->debugLog) {
+    if (gotsome)
+      append(", ");
+    append(".debugLog=%d", options->debugLog);
+    gotsome = true;
+  }
+
+  if (options->sizeofThis) {
+    if (gotsome)
+      append(", ");
+    append(".sizeofThis=%d", options->sizeofThis);
+    gotsome = true;
+  }
+
+  append("}");
+  return buf;
+}
+
+const char *cosmoaudio_describe_poll_frames(char *buf, int n,
+                                            int *in_out_frames) {
+  if (!in_out_frames)
+    return "NULL";
+  if (kisdangerous(in_out_frames)) {
+    ksnprintf(buf, n, "%p", in_out_frames);
+    return buf;
+  }
+  ksnprintf(buf, n, "[%d]", *in_out_frames);
+  return buf;
+}

dsp/audio/describe.h

@@ -0,0 +1,12 @@
+#ifndef COSMOPOLITAN_DSP_AUDIO_DESCRIBE_H_
+#define COSMOPOLITAN_DSP_AUDIO_DESCRIBE_H_
+#include "dsp/audio/cosmoaudio/cosmoaudio.h"
+COSMOPOLITAN_C_START_
+
+const char *cosmoaudio_describe_status(char *, int, int);
+const char *cosmoaudio_describe_open_options(
+    char *, int, const struct CosmoAudioOpenOptions *);
+const char *cosmoaudio_describe_poll_frames(char *, int, int *);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_DSP_AUDIO_DESCRIBE_H_ */

dsp/core/c161.h

@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_CORE_C161_H_
 #define COSMOPOLITAN_DSP_CORE_C161_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #define EXTRA_SHARP 2
 

dsp/core/c161s.h

@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_DSP_CORE_C161S_H_
 #define COSMOPOLITAN_DSP_CORE_C161S_H_
 #include "dsp/core/c161.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 __funline signed char C161S(signed char al, signed char bl, signed char cl) {
   short ax, bx, cx;

dsp/core/core.h

@@ -9,14 +9,13 @@ int mulaw(int);
 int unmulaw(int);
 void *double2byte(long, const void *, double, double) vallocesque;
 void *byte2double(long, const void *, double, double) vallocesque;
-void *dct(float[restrict hasatleast 8][8], unsigned, float, float, float, float,
-          float);
-void *dctjpeg(float[restrict hasatleast 8][8], unsigned);
+void *dct(float[hasatleast 8][8], unsigned, float, float, float, float, float);
+void *dctjpeg(float[hasatleast 8][8], unsigned);
 double det3(const double[3][3]) nosideeffect;
-void *inv3(double[restrict 3][3], const double[restrict 3][3], double);
-void *matmul3(double[restrict 3][3], const double[3][3], const double[3][3]);
-void *vmatmul3(double[restrict 3], const double[3], const double[3][3]);
-void *matvmul3(double[restrict 3], const double[3][3], const double[3]);
+void *inv3(double[3][3], const double[3][3], double);
+void *matmul3(double[3][3], const double[3][3], const double[3][3]);
+void *vmatmul3(double[3], const double[3], const double[3][3]);
+void *matvmul3(double[3], const double[3][3], const double[3]);
 double rgb2stdtv(double) pureconst;
 double rgb2lintv(double) pureconst;
 double rgb2stdpc(double, double) pureconst;

dsp/core/dct.c

@@ -65,8 +65,8 @@
  *
  * @cost ~100ns
  */
-void *dct(float M[restrict hasatleast 8][8], unsigned stride, float c0,
-          float c1, float c2, float c3, float c4) {
+void *dct(float M[hasatleast 8][8], unsigned stride, float c0, float c1,
+          float c2, float c3, float c4) {
   unsigned y, x;
   for (y = 0; y < stride * 8; y += stride) {
     DCT(M[y][0], M[y][1], M[y][2], M[y][3], M[y][4], M[y][5], M[y][6], M[y][7],
@@ -79,7 +79,7 @@ void *dct(float M[restrict hasatleast 8][8], unsigned stride, float c0,
   return M;
 }
 
-void *dctjpeg(float M[restrict hasatleast 8][8], unsigned stride) {
+void *dctjpeg(float M[hasatleast 8][8], unsigned stride) {
   return dct(M, stride, .707106781f, .382683433f, .541196100f, 1.306562965f,
              .707106781f);
 }

dsp/core/double2byte.c

@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/core/core.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/mem.h"
 

dsp/core/float2short.c

@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/str/str.h"
 

dsp/core/getintegercoefficients.c

@@ -20,7 +20,7 @@
 #include "libc/assert.h"
 #include "libc/dce.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/str/str.h"
 

dsp/core/getintegercoefficients8.c

@@ -19,7 +19,7 @@
 #include "dsp/core/core.h"
 #include "dsp/core/q.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/str/str.h"
 

dsp/core/half.h

@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_CORE_HALF_H_
 #define COSMOPOLITAN_DSP_CORE_HALF_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 /**
  * Divides integer in half w/ rounding.

dsp/core/inv3.c

@@ -30,7 +30,7 @@
  * @define 𝐀⁻¹=𝐁 such that 𝐀×𝐁=𝐁×𝐀=𝐈ₙ
  * @see det3()
  */
-void *inv3(double B[restrict 3][3], const double A[restrict 3][3], double d) {
+void *inv3(double B[3][3], const double A[3][3], double d) {
   d = d ? 1 / d : NAN;
   B[0][0] = (A[1][1] * A[2][2] - A[2][1] * A[1][2]) * d;
   B[0][1] = (A[2][1] * A[0][2] - A[0][1] * A[2][2]) * d;

dsp/core/ks8.h

@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_CORE_KS8_H_
 #define COSMOPOLITAN_DSP_CORE_KS8_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 /**
  * Performs 16-bit scaled rounded madd w/ eight coefficients or fewer.

dsp/core/kss8.h

@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_DSP_CORE_KSS8_H_
 #define COSMOPOLITAN_DSP_CORE_KSS8_H_
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 /**
  * Performs 16-bit scaled rounded saturated madd w/ eight coefficients or fewer.

dsp/core/matmul3.c

@@ -22,8 +22,7 @@
 /**
  * Multiplies 3×3 matrices.
  */
-void *matmul3(double R[restrict 3][3], const double A[3][3],
-              const double B[3][3]) {
+void *matmul3(double R[3][3], const double A[3][3], const double B[3][3]) {
   int i, j, k;
   memset(R, 0, sizeof(double) * 3 * 3);
   for (i = 0; i < 3; ++i) {

dsp/core/matvmul3.c

@@ -23,7 +23,7 @@
  *
  * @see vmatmul3() for noncommutative corollary
  */
-void *matvmul3(double R[restrict 3], const double M[3][3], const double V[3]) {
+void *matvmul3(double R[3], const double M[3][3], const double V[3]) {
   R[0] = V[0] * M[0][0] + V[1] * M[0][1] + V[2] * M[0][2];
   R[1] = V[0] * M[1][0] + V[1] * M[1][1] + V[2] * M[1][2];
   R[2] = V[0] * M[2][0] + V[1] * M[2][1] + V[2] * M[2][2];

dsp/core/q.h

@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_DSP_CORE_Q_H_
 #define COSMOPOLITAN_DSP_CORE_Q_H_
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 
 /**

dsp/core/sad16x8n.c

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/core/core.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "third_party/aarch64/arm_neon.internal.h"
 #include "third_party/intel/emmintrin.internal.h"
 

dsp/core/vmatmul3.c

@@ -23,7 +23,7 @@
  *
  * @see matvmul3() for noncommutative corollary
  */
-void *vmatmul3(double R[restrict 3], const double V[3], const double M[3][3]) {
+void *vmatmul3(double R[3], const double V[3], const double M[3][3]) {
   R[0] = V[0] * M[0][0] + V[1] * M[1][0] + V[2] * M[2][0];
   R[1] = V[0] * M[0][1] + V[1] * M[1][1] + V[2] * M[2][1];
   R[2] = V[0] * M[0][2] + V[1] * M[1][2] + V[2] * M[2][2];

dsp/mpeg/.clang-format

@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: Never

dsp/mpeg/BUILD.mk

@@ -25,18 +25,13 @@ DSP_MPEG_A_CHECKS =				\
 
 DSP_MPEG_A_DIRECTDEPS =				\
 	LIBC_CALLS				\
-	LIBC_FMT				\
 	LIBC_INTRIN				\
-	LIBC_LOG				\
-	LIBC_LOG				\
 	LIBC_MEM				\
 	LIBC_NEXGEN32E				\
-	LIBC_RUNTIME				\
 	LIBC_STDIO				\
 	LIBC_STR				\
-	LIBC_SYSV				\
 	LIBC_TINYMATH				\
-	THIRD_PARTY_COMPILER_RT
+	THIRD_PARTY_COMPILER_RT			\
 
 DSP_MPEG_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(DSP_MPEG_A_DIRECTDEPS),$($(x))))
@@ -49,9 +44,10 @@ $(DSP_MPEG_A).pkg:				\
 		$(DSP_MPEG_A_OBJS)		\
 		$(foreach x,$(DSP_MPEG_A_DIRECTDEPS),$($(x)_A).pkg)
 
-o/$(MODE)/dsp/mpeg/clamp4int256-k8.o: private	\
+o/$(MODE)/dsp/mpeg/pl_mpeg.o: private		\
 		CFLAGS +=			\
-			-Os
+			-ffunction-sections	\
+			-fdata-sections
 
 DSP_MPEG_LIBS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)))
 DSP_MPEG_SRCS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_SRCS))

dsp/mpeg/README.cosmo

@@ -0,0 +1,17 @@
+DESCRIPTION
+
+  pl_mpeg lets you decode .mpg files
+
+ORIGIN
+
+  https://github.com/phoboslab/pl_mpeg/
+  9e40dd6536269d788728e32c39bfacf2ab7a0866
+
+LICENSE
+
+  MIT
+
+LOCAL CHANGES
+
+  - Added API for extracting pixel aspect ratio
+    https://github.com/phoboslab/pl_mpeg/pull/42

dsp/mpeg/README.md

@@ -0,0 +1,68 @@
+# PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer
+
+Single-file MIT licensed library for C/C++
+
+See [pl_mpeg.h](https://github.com/phoboslab/pl_mpeg/blob/master/pl_mpeg.h) for
+the documentation.
+
+
+## Why?
+
+This is meant as a simple way to get video playback into your app or game. Other
+solutions, such as ffmpeg require huge libraries and a lot of glue code.
+
+MPEG1 is an old and inefficient codec, but it's still good enough for many use
+cases. All patents related to MPEG1 and MP2 have expired, so it's completely
+free now.
+
+This library does not make use of any SIMD instructions, but because of
+the relative simplicity of the codec it still manages to decode 4k60fps video
+on a single CPU core (on my i7-6700k at least).
+
+## Compilation on Linux
+
+Use a GCC invocation like the following to build the example `pl_mpeg_player`
+program:
+
+```shell
+gcc -o pl_mpeg_player pl_mpeg_player.c $(pkg-config --cflags --libs sdl2 glew)
+```
+
+## Example Usage
+
+- [pl_mpeg_extract_frames.c](https://github.com/phoboslab/pl_mpeg/blob/master/pl_mpeg_extract_frames.c)
+extracts all frames from a video and saves them as PNG.
+ - [pl_mpeg_player.c](https://github.com/phoboslab/pl_mpeg/blob/master/pl_mpeg_player.c)
+implements a video player using SDL2 and OpenGL for rendering.
+
+
+
+## Encoding for PL_MPEG
+
+Most [MPEG-PS](https://en.wikipedia.org/wiki/MPEG_program_stream) (`.mpg`) files
+containing MPEG1 Video ("mpeg1") and MPEG1 Audio Layer II ("mp2") streams should
+work with PL_MPEG. Note that `.mpg` files can also contain MPEG2 Video, which is
+not supported by this library.
+
+You can encode video in a suitable format using ffmpeg:
+
+```
+ffmpeg -i input.mp4 -c:v mpeg1video -q:v 0 -c:a mp2 -format mpeg output.mpg
+```
+
+`-q:v` sets a fixed video quality with a variable bitrate, where `0` is the
+highest. You may use `-b:v` to set a fixed bitrate instead; e.g.
+`-b:v 2000k` for 2000 kbit/s. Please refer to the
+[ffmpeg documentation](http://ffmpeg.org/ffmpeg.html#Options) for more details.
+
+If you just want to quickly test the library, try this file:
+
+https://phoboslab.org/files/bjork-all-is-full-of-love.mpg
+
+
+## Limitations
+
+- no error reporting. PL_MPEG will silently ignore any invalid data.
+- the pts (presentation time stamp) for packets in the MPEG-PS container is
+ignored. This may cause sync issues with some files.
+- bugs, probably.

dsp/mpeg/README.txt

@@ -1,92 +0,0 @@
-PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer
-Dominic Szablewski - https://phoboslab.org
-
--- Synopsis
-
-// This function gets called for each decoded video frame
-void my_video_callback(plm_t *plm, plm_frame_t *frame, void *user) {
-	// Do something with frame->y.data, frame->cr.data, frame->cb.data
-}
-
-// This function gets called for each decoded audio frame
-void my_audio_callback(plm_t *plm, plm_samples_t *frame, void *user) {
-	// Do something with samples->interleaved
-}
-
-// Load a .mpg (MPEG Program Stream) file
-plm_t *plm = plm_create_with_filename("some-file.mpg");
-
-// Install the video & audio decode callbacks
-plm_set_video_decode_callback(plm, my_video_callback, my_data);
-plm_set_audio_decode_callback(plm, my_audio_callback, my_data);
-
-
-// Decode
-do {
-	plm_decode(plm, time_since_last_call);
-} while (!plm_has_ended(plm));
-
-// All done
-plm_destroy(plm);
-
-
-
--- Documentation
-
-This library provides several interfaces to load, demux and decode MPEG video
-and audio data. A high-level API combines the demuxer, video & audio decoders
-in an easy to use wrapper.
-
-Lower-level APIs for accessing the demuxer, video decoder and audio decoder,
-as well as providing different data sources are also available.
-
-Interfaces are written in an object orientet style, meaning you create object
-instances via various different constructor functions (plm_*create()),
-do some work on them and later dispose them via plm_*destroy().
-
-plm_*		-- the high-level interface, combining demuxer and decoders
-plm_buffer_* -- the data source used by all interfaces
-plm_demux_*  -- the MPEG-PS demuxer
-plm_video_*  -- the MPEG1 Video ("mpeg1") decoder
-plm_audio_*  -- the MPEG1 Audio Layer II ("mp2") decoder
-
-
-This library uses malloc(), realloc() and free() to manage memory. Typically
-all allocation happens up-front when creating the interface. However, the
-default buffer size may be too small for certain inputs. In these cases plmpeg
-will realloc() the buffer with a larger size whenever needed. You can configure
-the default buffer size by defining PLM_BUFFER_DEFAULT_SIZE *before*
-including this library.
-
-With the high-level interface you have two options to decode video & audio:
-
-1) Use plm_decode() and just hand over the delta time since the last call.
-It will decode everything needed and call your callbacks (specified through
-plm_set_{video|audio}_decode_callback()) any number of times.
-
-2) Use plm_decode_video() and plm_decode_audio() to decode exactly one
-frame of video or audio data at a time. How you handle the synchronization of
-both streams is up to you.
-
-If you only want to decode video *or* audio through these functions, you should
-disable the other stream (plm_set_{video|audio}_enabled(false))
-
-
-Video data is decoded into a struct with all 3 planes (Y, Cr, Cb) stored in
-separate buffers. You can either convert this to RGB on the CPU (slow) via the
-plm_frame_to_rgb() function or do it on the GPU with the following matrix:
-
-mat4 rec601 = mat4(
-	1.16438,  0.00000,  1.59603, -0.87079,
-	1.16438, -0.39176, -0.81297,  0.52959,
-	1.16438,  2.01723,  0.00000, -1.08139,
-	0, 0, 0, 1
-);
-gl_FragColor = vec4(y, cb, cr, 1.0) * rec601;
-
-Audio data is decoded into a struct with either one single float array with the
-samples for the left and right channel interleaved, or if the
-PLM_AUDIO_SEPARATE_CHANNELS is defined *before* including this library, into
-two separate float arrays - one for each channel.
-
-See below for detailed the API documentation.

dsp/mpeg/blockset.h

@@ -1,20 +0,0 @@
-#ifndef COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_
-#define COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_
-
-#define PLM_BLOCK_SET(DEST, DEST_INDEX, DEST_WIDTH, SOURCE_INDEX, \
-                      SOURCE_WIDTH, BLOCK_SIZE, OP)               \
-  do {                                                            \
-    int dest_scan = DEST_WIDTH - BLOCK_SIZE;                      \
-    int source_scan = SOURCE_WIDTH - BLOCK_SIZE;                  \
-    for (int y = 0; y < BLOCK_SIZE; y++) {                        \
-      for (int x = 0; x < BLOCK_SIZE; x++) {                      \
-        DEST[DEST_INDEX] = OP;                                    \
-        SOURCE_INDEX++;                                           \
-        DEST_INDEX++;                                             \
-      }                                                           \
-      SOURCE_INDEX += source_scan;                                \
-      DEST_INDEX += dest_scan;                                    \
-    }                                                             \
-  } while (false)
-
-#endif /* COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_ */

dsp/mpeg/buffer.c

@@ -1,153 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=4 sw=4 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  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 OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/buffer.h"
-#include "dsp/mpeg/mpeg.h"
-#include "libc/calls/calls.h"
-#include "libc/log/check.h"
-#include "libc/mem/mem.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/madv.h"
-__static_yoink("pl_mpeg_notice");
-
-/* clang-format off */
-// -----------------------------------------------------------------------------
-// plm_buffer implementation
-
-plm_buffer_t *plm_buffer_create_with_filename(const char *filename) {
-	FILE *fh = fopen(filename, "rb");
-	if (!fh) {
-		return NULL;
-	}
-	fadvise(fileno(fh), 0, 0, MADV_SEQUENTIAL);
-	return plm_buffer_create_with_file(fh, true);
-}
-
-plm_buffer_t *plm_buffer_create_with_file(FILE *fh, int close_when_done) {
-	plm_buffer_t *b;
-	b = plm_buffer_create_with_capacity(PLM_BUFFER_DEFAULT_SIZE);
-	b->fh = fh;
-	b->close_when_done = close_when_done;
-	b->mode = PLM_BUFFER_MODE_FILE;
-	plm_buffer_set_load_callback(b, plm_buffer_load_file_callback, NULL);
-	return b;
-}
-
-plm_buffer_t *plm_buffer_create_with_memory(unsigned char *bytes, size_t length, int free_when_done) {
-	plm_buffer_t *b;
-	b = memalign(_Alignof(plm_buffer_t), sizeof(plm_buffer_t));
-	memset(b, 0, sizeof(plm_buffer_t));
-	b->capacity = length;
-	b->length = length;
-	b->free_when_done = free_when_done;
-	b->bytes = bytes;
-	b->mode = PLM_BUFFER_MODE_FIXED_MEM;
-	return b;
-}
-
-plm_buffer_t * plm_buffer_create_with_capacity(size_t capacity) {
-	plm_buffer_t *b;
-	b = memalign(_Alignof(plm_buffer_t), sizeof(plm_buffer_t));
-	memset(b, 0, sizeof(plm_buffer_t));
-	b->capacity = capacity;
-	b->free_when_done = true;
-	b->bytes = (unsigned char *)malloc(capacity);
-	b->mode = PLM_BUFFER_MODE_DYNAMIC_MEM;
-	return b;
-}
-
-void plm_buffer_destroy(plm_buffer_t *self) {
-	if (self->fh && self->close_when_done) {
-		fclose(self->fh);
-	}
-	if (self->free_when_done) {
-		free(self->bytes);
-	}
-	free(self);
-}
-
-size_t plm_buffer_write(plm_buffer_t *self, unsigned char *bytes, size_t length) {
-	if (self->mode == PLM_BUFFER_MODE_FIXED_MEM) {
-		return 0;
-	}
-	// This should be a ring buffer, but instead it just shifts all unread data
-	// to the beginning of the buffer and appends new data at the end. Seems
-	// to be good enough.
-	plm_buffer_discard_read_bytes(self);
-	// Do we have to resize to fit the new data?
-	size_t bytes_available = self->capacity - self->length;
-	if (bytes_available < length) {
-		size_t new_size = self->capacity;
-		do {
-			new_size *= 2;
-		} while (new_size - self->length < length);
-		self->bytes = (unsigned char *)realloc(self->bytes, new_size);
-		self->capacity = new_size;
-	}
-	memcpy(self->bytes + self->length, bytes, length);
-	self->length += length;
-	return length;
-}
-
-void plm_buffer_set_load_callback(plm_buffer_t *self, plm_buffer_load_callback fp, void *user) {
-	self->load_callback = fp;
-	self->load_callback_user_data = user;
-}
-
-void plm_buffer_rewind(plm_buffer_t *self) {
-	if (self->fh) {
-		fseek(self->fh, 0, SEEK_SET);
-		self->length = 0;
-	}
-	if (self->mode != PLM_BUFFER_MODE_FIXED_MEM) {
-		self->length = 0;
-	}
-	self->bit_index = 0;
-}
-
-void plm_buffer_discard_read_bytes(plm_buffer_t *self) {
-	size_t byte_pos = self->bit_index >> 3;
-	if (byte_pos == self->length) {
-		self->bit_index = 0;
-		self->length = 0;
-	}
-	else if (byte_pos > 0) {
-		memmove(self->bytes, self->bytes + byte_pos, self->length - byte_pos);
-		self->bit_index -= byte_pos << 3;
-		self->length -= byte_pos;
-	}
-}
-
-void plm_buffer_load_file_callback(plm_buffer_t *self, void *user) {
-	plm_buffer_discard_read_bytes(self);
-	unsigned bytes_available = self->capacity - self->length;
-	unsigned bytes_read = fread(self->bytes + self->length, 1, bytes_available, self->fh);
-	self->length += bytes_read;
-}

dsp/mpeg/buffer.h

@@ -1,160 +0,0 @@
-#ifndef COSMOPOLITAN_DSP_MPEG_BUFFER_H_
-#define COSMOPOLITAN_DSP_MPEG_BUFFER_H_
-#include "dsp/mpeg/mpeg.h"
-COSMOPOLITAN_C_START_
-
-enum plm_buffer_mode {
-  PLM_BUFFER_MODE_FILE,
-  PLM_BUFFER_MODE_FIXED_MEM,
-  PLM_BUFFER_MODE_DYNAMIC_MEM
-};
-
-typedef struct plm_buffer_t {
-  unsigned bit_index;
-  unsigned capacity;
-  unsigned length;
-  int free_when_done;
-  int close_when_done;
-  FILE *fh;
-  plm_buffer_load_callback load_callback;
-  void *load_callback_user_data;
-  unsigned char *bytes;
-  enum plm_buffer_mode mode;
-} plm_buffer_t;
-
-typedef struct {
-  int16_t index;
-  int16_t value;
-} plm_vlc_t;
-
-typedef struct {
-  int16_t index;
-  uint16_t value;
-} plm_vlc_uint_t;
-
-/* bool plm_buffer_has(plm_buffer_t *, size_t); */
-/* int plm_buffer_read(plm_buffer_t *, int); */
-/* void plm_buffer_align(plm_buffer_t *); */
-/* void plm_buffer_skip(plm_buffer_t *, size_t); */
-/* int plm_buffer_skip_bytes(plm_buffer_t *, unsigned char); */
-/* int plm_buffer_next_start_code(plm_buffer_t *); */
-/* int plm_buffer_find_start_code(plm_buffer_t *, int); */
-/* int plm_buffer_no_start_code(plm_buffer_t *); */
-/* int16_t plm_buffer_read_vlc(plm_buffer_t *, const plm_vlc_t *); */
-/* uint16_t plm_buffer_read_vlc_uint(plm_buffer_t *, const plm_vlc_uint_t *); */
-
-void plm_buffer_discard_read_bytes(plm_buffer_t *);
-relegated void plm_buffer_load_file_callback(plm_buffer_t *, void *);
-
-forceinline bool plm_buffer_has(plm_buffer_t *b, size_t bits) {
-  unsigned have;
-  have = b->length;
-  have <<= 3;
-  have -= b->bit_index;
-  if (bits <= have) {
-    return true;
-  } else {
-    if (b->load_callback) {
-      b->load_callback(b, b->load_callback_user_data);
-      return ((b->length << 3) - b->bit_index) >= bits;
-    } else {
-      return false;
-    }
-  }
-}
-
-forceinline int plm_buffer_read(plm_buffer_t *self, int count) {
-  if (!plm_buffer_has(self, count))
-    return 0;
-  int value = 0;
-  while (count) {
-    int current_byte = self->bytes[self->bit_index >> 3];
-    int remaining = 8 - (self->bit_index & 7);         // Remaining bits in byte
-    int read = remaining < count ? remaining : count;  // Bits in self run
-    int shift = remaining - read;
-    int mask = (0xff >> (8 - read));
-    value = (value << read) | ((current_byte & (mask << shift)) >> shift);
-    self->bit_index += read;
-    count -= read;
-  }
-  return value;
-}
-
-forceinline void plm_buffer_align(plm_buffer_t *self) {
-  self->bit_index = ((self->bit_index + 7) >> 3) << 3;
-}
-
-forceinline void plm_buffer_skip(plm_buffer_t *self, size_t count) {
-  if (plm_buffer_has(self, count)) {
-    self->bit_index += count;
-  }
-}
-
-forceinline int plm_buffer_skip_bytes(plm_buffer_t *self, unsigned char v) {
-  unsigned skipped;
-  plm_buffer_align(self);
-  skipped = 0;
-  while (plm_buffer_has(self, 8)) {
-    if (v == self->bytes[self->bit_index >> 3]) {
-      self->bit_index += 8;
-      ++skipped;
-    } else {
-      break;
-    }
-  }
-  return skipped;
-}
-
-forceinline int plm_buffer_next_start_code(plm_buffer_t *self) {
-  plm_buffer_align(self);
-  while (plm_buffer_has(self, (5 << 3))) {
-    size_t byte_index = (self->bit_index) >> 3;
-    if (self->bytes[byte_index] == 0x00 &&
-        self->bytes[byte_index + 1] == 0x00 &&
-        self->bytes[byte_index + 2] == 0x01) {
-      self->bit_index = (byte_index + 4) << 3;
-      return self->bytes[byte_index + 3];
-    }
-    self->bit_index += 8;
-  }
-  self->bit_index = (self->length << 3);
-  return -1;
-}
-
-forceinline int plm_buffer_find_start_code(plm_buffer_t *self, int code) {
-  int current = 0;
-  while (true) {
-    current = plm_buffer_next_start_code(self);
-    if (current == code || current == -1) {
-      return current;
-    }
-  }
-  return -1;
-}
-
-forceinline int plm_buffer_no_start_code(plm_buffer_t *self) {
-  if (!plm_buffer_has(self, (5 << 3))) {
-    return false;
-  }
-  size_t byte_index = ((self->bit_index + 7) >> 3);
-  return !(self->bytes[byte_index] == 0x00 &&
-           self->bytes[byte_index + 1] == 0x00 &&
-           self->bytes[byte_index + 2] == 0x01);
-}
-
-forceinline int16_t plm_buffer_read_vlc(plm_buffer_t *self,
-                                        const plm_vlc_t *table) {
-  plm_vlc_t state = {0, 0};
-  do {
-    state = table[state.index + plm_buffer_read(self, 1)];
-  } while (state.index > 0);
-  return state.value;
-}
-
-forceinline uint16_t plm_buffer_read_vlc_uint(plm_buffer_t *self,
-                                              const plm_vlc_uint_t *table) {
-  return (uint16_t)plm_buffer_read_vlc(self, (plm_vlc_t *)table);
-}
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_DSP_MPEG_BUFFER_H_ */

dsp/mpeg/clamp4int256-core.S

@@ -1,30 +0,0 @@
-/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
-
-clamp4int256$core:
-	.leafprologue
-	pxor	%xmm1,%xmm1
-	pmaxsd	%xmm1,%xmm0
-	pminsd	0f(%rip),%xmm0
-	.leafepilogue
-	.endfn	clamp4int256$core,globl
-
-	.rodata.cst16
-0:	.long	255,255,255,255

dsp/mpeg/demux.c

@@ -1,203 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=4 sw=4 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  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 OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/demux.h"
-#include "dsp/mpeg/buffer.h"
-#include "dsp/mpeg/mpeg.h"
-#include "libc/mem/mem.h"
-#include "libc/str/str.h"
-__static_yoink("pl_mpeg_notice");
-
-/* clang-format off */
-// ----------------------------------------------------------------------------
-// plm_demux implementation
-
-plm_demux_t *plm_demux_create(plm_buffer_t *buffer, int destroy_when_done) {
-	plm_demux_t *self = (plm_demux_t *)malloc(sizeof(plm_demux_t));
-	memset(self, 0, sizeof(plm_demux_t));
-
-	self->buffer = buffer;
-	self->destroy_buffer_when_done = destroy_when_done;
-
-	if (plm_buffer_find_start_code(self->buffer, START_PACK) != -1) {
-		plm_demux_decode_pack_header(self);
-	}
-	if (plm_buffer_find_start_code(self->buffer, START_SYSTEM) != -1) {
-		plm_demux_decode_system_header(self);
-	}
-	return self;
-}
-
-void plm_demux_destroy(plm_demux_t *self) {
-	if (self->destroy_buffer_when_done) {
-		plm_buffer_destroy(self->buffer);
-	}
-	free(self);
-}
-
-int plm_demux_get_num_video_streams(plm_demux_t *self) {
-	return self->num_video_streams;
-}
-
-int plm_demux_get_num_audio_streams(plm_demux_t *self) {
-	return self->num_audio_streams;
-}
-
-void plm_demux_rewind(plm_demux_t *self) {
-	plm_buffer_rewind(self->buffer);
-}
-
-plm_packet_t *plm_demux_decode(plm_demux_t *self) {
-	if (self->current_packet.length) {
-		size_t bits_till_next_packet = self->current_packet.length << 3;
-		if (!plm_buffer_has(self->buffer, bits_till_next_packet)) {
-			return NULL;
-		}
-		plm_buffer_skip(self->buffer, bits_till_next_packet);
-		self->current_packet.length = 0;
-	}
-
-	if (!self->has_pack_header) {
-		if (plm_buffer_find_start_code(self->buffer, START_PACK) != -1) {
-			plm_demux_decode_pack_header(self);
-		}
-		else {
-			return NULL;
-		}
-	}
-
-	if (!self->has_system_header) {
-		if (plm_buffer_find_start_code(self->buffer, START_SYSTEM) != -1) {
-			plm_demux_decode_system_header(self);
-		}
-		else {
-			return NULL;
-		}
-	}
-
-	// pending packet just waiting for data?
-	if (self->next_packet.length) {
-		return plm_demux_get_packet(self);
-	}
-
-	int code;
-	do {
-		code = plm_buffer_next_start_code(self->buffer);
-		if (
-			code == PLM_DEMUX_PACKET_VIDEO_1 ||
-			code == PLM_DEMUX_PACKET_PRIVATE ||
-			(code >= PLM_DEMUX_PACKET_AUDIO_1 && code <= PLM_DEMUX_PACKET_AUDIO_4)
-		) {
-			return plm_demux_decode_packet(self, code);
-		}
-	} while (code != -1);
-
-	return NULL;
-}
-
-double plm_demux_read_time(plm_demux_t *self) {
-	int64_t clock = plm_buffer_read(self->buffer, 3) << 30;
-	plm_buffer_skip(self->buffer, 1);
-	clock |= plm_buffer_read(self->buffer, 15) << 15;
-	plm_buffer_skip(self->buffer, 1);
-	clock |= plm_buffer_read(self->buffer, 15);
-	plm_buffer_skip(self->buffer, 1);
-	return (double)clock / 90000.0;
-}
-
-void plm_demux_decode_pack_header(plm_demux_t *self) {
-	if (plm_buffer_read(self->buffer, 4) != 0x02) {
-		return; // invalid
-	}
-	self->system_clock_ref = plm_demux_read_time(self);
-	plm_buffer_skip(self->buffer, 1);
-	plm_buffer_skip(self->buffer, 22); // mux_rate * 50
-	plm_buffer_skip(self->buffer, 1);
-
-	self->has_pack_header = true;
-}
-
-void plm_demux_decode_system_header(plm_demux_t *self) {
-	plm_buffer_skip(self->buffer, 16); // header_length
-	plm_buffer_skip(self->buffer, 24); // rate bound
-	self->num_audio_streams = plm_buffer_read(self->buffer, 6);
-	plm_buffer_skip(self->buffer, 5); // misc flags
-	self->num_video_streams = plm_buffer_read(self->buffer, 5);
-
-	self->has_system_header = true;
-}
-
-plm_packet_t *plm_demux_decode_packet(plm_demux_t *self, int start_code) {
-	if (!plm_buffer_has(self->buffer, 8 << 3)) {
-		return NULL;
-	}
-
-	self->next_packet.type = start_code;
-	self->next_packet.length = plm_buffer_read(self->buffer, 16);
-	self->next_packet.length -= plm_buffer_skip_bytes(self->buffer, 0xff); // stuffing
-
-	// skip P-STD
-	if (plm_buffer_read(self->buffer, 2) == 0x01) {
-		plm_buffer_skip(self->buffer, 16);
-		self->next_packet.length -= 2;
-	}
-
-	int pts_dts_marker = plm_buffer_read(self->buffer, 2);
-	if (pts_dts_marker == 0x03) {
-		self->next_packet.pts = plm_demux_read_time(self);
-		plm_buffer_skip(self->buffer, 40); // skip dts
-		self->next_packet.length -= 10;
-	}
-	else if (pts_dts_marker == 0x02) {
-		self->next_packet.pts = plm_demux_read_time(self);
-		self->next_packet.length -= 5;
-	}
-	else if (pts_dts_marker == 0x00) {
-		self->next_packet.pts = 0;
-		plm_buffer_skip(self->buffer, 4);
-		self->next_packet.length -= 1;
-	}
-	else {
-		return NULL; // invalid
-	}
-
-	return plm_demux_get_packet(self);
-}
-
-plm_packet_t *plm_demux_get_packet(plm_demux_t *self) {
-	if (!plm_buffer_has(self->buffer, self->next_packet.length << 3)) {
-		return NULL;
-	}
-	self->current_packet.data = self->buffer->bytes + (self->buffer->bit_index >> 3);
-	self->current_packet.length = self->next_packet.length;
-	self->current_packet.type = self->next_packet.type;
-	self->current_packet.pts = self->next_packet.pts;
-	self->next_packet.length = 0;
-	return &self->current_packet;
-}

dsp/mpeg/demux.h

@@ -1,29 +0,0 @@
-#ifndef COSMOPOLITAN_DSP_MPEG_DEMUX_H_
-#define COSMOPOLITAN_DSP_MPEG_DEMUX_H_
-#include "dsp/mpeg/mpeg.h"
-COSMOPOLITAN_C_START_
-
-#define START_PACK   0xBA
-#define START_END    0xB9
-#define START_SYSTEM 0xBB
-
-typedef struct plm_demux_t {
-  plm_buffer_t *buffer;
-  int destroy_buffer_when_done;
-  double system_clock_ref;
-  int has_pack_header;
-  int has_system_header;
-  int num_audio_streams;
-  int num_video_streams;
-  plm_packet_t current_packet;
-  plm_packet_t next_packet;
-} plm_demux_t;
-
-double plm_demux_read_time(plm_demux_t *self);
-void plm_demux_decode_pack_header(plm_demux_t *self);
-void plm_demux_decode_system_header(plm_demux_t *self);
-plm_packet_t *plm_demux_decode_packet(plm_demux_t *self, int start_code);
-plm_packet_t *plm_demux_get_packet(plm_demux_t *self);
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_DSP_MPEG_DEMUX_H_ */

dsp/mpeg/idct.c

@@ -1,101 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set et ft=c ts=4 sw=4 fenc=utf-8                                     :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  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 OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/core/half.h"
-__static_yoink("pl_mpeg_notice");
-
-/**
- * Computes Fixed-Point 8x8 Inverse Discrete Cosine Transform.
- *
- * @note discovered by Nasir Ahmed
- */
-void plm_video_idct(int block[8][8]) {
-  int i, t1, t2, m0;
-  int b1, b3, b4, b6, b7;
-  int y3, y4, y5, y6, y7;
-  int x0, x1, x2, x3, x4;
-
-  for (i = 0; i < 8; ++i) {
-    b1 = block[4][i];
-    b3 = block[2][i] + block[6][i];
-    b4 = block[5][i] - block[3][i];
-    t1 = block[1][i] + block[7][i];
-    t2 = block[3][i] + block[5][i];
-    b6 = block[1][i] - block[7][i];
-    b7 = t1 + t2;
-    m0 = block[0][i];
-    x4 = ((b6 * 473 - b4 * 196 + 128) >> 8) - b7;
-    x0 = x4 - (((t1 - t2) * 362 + 128) >> 8);
-    x1 = m0 - b1;
-    x2 = (((block[2][i] - block[6][i]) * 362 + 128) >> 8) - b3;
-    x3 = m0 + b1;
-    y3 = x1 + x2;
-    y4 = x3 + b3;
-    y5 = x1 - x2;
-    y6 = x3 - b3;
-    y7 = -x0 - ((b4 * 473 + b6 * 196 + 128) >> 8);
-    block[0][i] = b7 + y4;
-    block[1][i] = x4 + y3;
-    block[2][i] = y5 - x0;
-    block[3][i] = y6 - y7;
-    block[4][i] = y6 + y7;
-    block[5][i] = x0 + y5;
-    block[6][i] = y3 - x4;
-    block[7][i] = y4 - b7;
-  }
-
-  for (i = 0; i < 8; ++i) {
-    b1 = block[i][4];
-    b3 = block[i][2] + block[i][6];
-    b4 = block[i][5] - block[i][3];
-    t1 = block[i][1] + block[i][7];
-    t2 = block[i][3] + block[i][5];
-    b6 = block[i][1] - block[i][7];
-    b7 = t1 + t2;
-    m0 = block[i][0];
-    x4 = ((b6 * 473 - b4 * 196 + 128) >> 8) - b7;
-    x0 = x4 - (((t1 - t2) * 362 + 128) >> 8);
-    x1 = m0 - b1;
-    x2 = (((block[i][2] - block[i][6]) * 362 + 128) >> 8) - b3;
-    x3 = m0 + b1;
-    y3 = x1 + x2;
-    y4 = x3 + b3;
-    y5 = x1 - x2;
-    y6 = x3 - b3;
-    y7 = -x0 - ((b4 * 473 + b6 * 196 + 128) >> 8);
-    block[i][0] = (b7 + y4 + 128) >> 8;
-    block[i][1] = (x4 + y3 + 128) >> 8;
-    block[i][2] = (y5 - x0 + 128) >> 8;
-    block[i][3] = (y6 - y7 + 128) >> 8;
-    block[i][4] = (y6 + y7 + 128) >> 8;
-    block[i][5] = (x0 + y5 + 128) >> 8;
-    block[i][6] = (y3 - x4 + 128) >> 8;
-    block[i][7] = (y4 - b7 + 128) >> 8;
-  }
-}

dsp/mpeg/idct.h

@@ -1,8 +0,0 @@
-#ifndef COSMOPOLITAN_DSP_MPEG_IDCT_H_
-#define COSMOPOLITAN_DSP_MPEG_IDCT_H_
-COSMOPOLITAN_C_START_
-
-void plm_video_idct(int *);
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_DSP_MPEG_IDCT_H_ */

dsp/mpeg/macroblock.c

@@ -1,172 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set et ft=c ts=4 sw=4 fenc=utf-8                                     :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  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 OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/mpeg.h"
-#include "dsp/mpeg/video.h"
-#include "libc/log/check.h"
-
-forceinline void plm_video_process_macroblock(plm_video_t *self,
-                                              uint8_t *restrict d,
-                                              uint8_t *restrict s, int motion_h,
-                                              int motion_v, bool interpolate,
-                                              unsigned BW) {
-  unsigned si, di, max_address;
-  int y, x, dest_scan, source_scan, dw, hp, vp, odd_h, odd_v;
-  dw = self->mb_width * BW;
-  hp = motion_h >> 1;
-  vp = motion_v >> 1;
-  odd_h = (motion_h & 1) == 1;
-  odd_v = (motion_v & 1) == 1;
-  si = ((self->mb_row * BW) + vp) * dw + (self->mb_col * BW) + hp;
-  di = (self->mb_row * dw + self->mb_col) * BW;
-  max_address = (dw * (self->mb_height * BW - BW + 1) - BW);
-  if (si > max_address || di > max_address)
-    return;
-  d += di;
-  s += si;
-  switch (((interpolate << 2) | (odd_h << 1) | (odd_v)) & 7) {
-    case 0:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          *d++ = *s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 1:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          *d++ = (s[0] + s[dw] + 1) >> 1;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 2:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          *d++ = (s[0] + s[1] + 1) >> 1;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 3:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          *d++ = (s[0] + s[1] + s[dw] + s[dw + 1] + 2) >> 2;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 4:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          d[0] = (d[0] + (s[0]) + 1) >> 1;
-          d++;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 5:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          d[0] = (d[0] + ((s[0] + s[dw] + 1) >> 1) + 1) >> 1;
-          d++;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 6:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          d[0] = (d[0] + ((s[0] + s[1] + 1) >> 1) + 1) >> 1;
-          d++;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 7:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          d[0] = (d[0] + ((s[0] + s[1] + s[dw] + s[dw + 1] + 2) >> 2) + 1) >> 1;
-          d++;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    default:
-      break;
-  }
-}
-
-void plm_video_process_macroblock_8(plm_video_t *self, uint8_t *restrict d,
-                                    uint8_t *restrict s, int motion_h,
-                                    int motion_v, bool interpolate) {
-  DCHECK_ALIGNED(8, d);
-  DCHECK_ALIGNED(8, s);
-  plm_video_process_macroblock(self, d, s, motion_h, motion_v, interpolate, 8);
-}
-
-void plm_video_process_macroblock_16(plm_video_t *self, uint8_t *restrict d,
-                                     uint8_t *restrict s, int motion_h,
-                                     int motion_v, bool interpolate) {
-  DCHECK_ALIGNED(16, d);
-  DCHECK_ALIGNED(16, s);
-  plm_video_process_macroblock(self, d, s, motion_h, motion_v, interpolate, 16);
-}

dsp/mpeg/mp2.c

@@ -1,769 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=4 sw=4 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  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 OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/buffer.h"
-#include "dsp/mpeg/mpeg.h"
-#include "libc/log/log.h"
-#include "libc/mem/mem.h"
-#include "libc/str/str.h"
-
-/* clang-format off */
-// -----------------------------------------------------------------------------
-// plm_audio implementation
-
-// Based on kjmp2 by Martin J. Fiedler
-// http://keyj.emphy.de/kjmp2/
-
-#define PLM_AUDIO_FRAME_SYNC 0x7ff
-
-#define PLM_AUDIO_MPEG_2_5 0x0
-#define PLM_AUDIO_MPEG_2 0x2
-#define PLM_AUDIO_MPEG_1 0x3
-
-#define PLM_AUDIO_LAYER_III 0x1
-#define PLM_AUDIO_LAYER_II 0x2
-#define PLM_AUDIO_LAYER_I 0x3
-
-#define PLM_AUDIO_MODE_STEREO 0x0
-#define PLM_AUDIO_MODE_JOINT_STEREO 0x1
-#define PLM_AUDIO_MODE_DUAL_CHANNEL 0x2
-#define PLM_AUDIO_MODE_MONO 0x3
-
-static const unsigned short PLM_AUDIO_SAMPLE_RATE[] = {
-	44100, 48000, 32000, 0, // MPEG-1
-	22050, 24000, 16000, 0  // MPEG-2
-};
-
-static const short PLM_AUDIO_BIT_RATE[] = {
-	32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, // MPEG-1
-	 8, 16, 24, 32, 40, 48,  56,  64,  80,  96, 112, 128, 144, 160  // MPEG-2
-};
-
-static const int PLM_AUDIO_SCALEFACTOR_BASE[] = {
-	0x02000000, 0x01965FEA, 0x01428A30
-};
-
-static const float PLM_AUDIO_SYNTHESIS_WINDOW[] = {
-	     0.0,     -0.5,     -0.5,     -0.5,     -0.5,     -0.5,
-	    -0.5,     -1.0,     -1.0,     -1.0,     -1.0,     -1.5,
-	    -1.5,     -2.0,     -2.0,     -2.5,     -2.5,     -3.0,
-	    -3.5,     -3.5,     -4.0,     -4.5,     -5.0,     -5.5,
-	    -6.5,     -7.0,     -8.0,     -8.5,     -9.5,    -10.5,
-	   -12.0,    -13.0,    -14.5,    -15.5,    -17.5,    -19.0,
-	   -20.5,    -22.5,    -24.5,    -26.5,    -29.0,    -31.5,
-	   -34.0,    -36.5,    -39.5,    -42.5,    -45.5,    -48.5,
-	   -52.0,    -55.5,    -58.5,    -62.5,    -66.0,    -69.5,
-	   -73.5,    -77.0,    -80.5,    -84.5,    -88.0,    -91.5,
-	   -95.0,    -98.0,   -101.0,   -104.0,    106.5,    109.0,
-	   111.0,    112.5,    113.5,    114.0,    114.0,    113.5,
-	   112.0,    110.5,    107.5,    104.0,    100.0,     94.5,
-	    88.5,     81.5,     73.0,     63.5,     53.0,     41.5,
-	    28.5,     14.5,     -1.0,    -18.0,    -36.0,    -55.5,
-	   -76.5,    -98.5,   -122.0,   -147.0,   -173.5,   -200.5,
-	  -229.5,   -259.5,   -290.5,   -322.5,   -355.5,   -389.5,
-	  -424.0,   -459.5,   -495.5,   -532.0,   -568.5,   -605.0,
-	  -641.5,   -678.0,   -714.0,   -749.0,   -783.5,   -817.0,
-	  -849.0,   -879.5,   -908.5,   -935.0,   -959.5,   -981.0,
-	 -1000.5,  -1016.0,  -1028.5,  -1037.5,  -1042.5,  -1043.5,
-	 -1040.0,  -1031.5,   1018.5,   1000.0,    976.0,    946.5,
-	   911.0,    869.5,    822.0,    767.5,    707.0,    640.0,
-	   565.5,    485.0,    397.0,    302.5,    201.0,     92.5,
-	   -22.5,   -144.0,   -272.5,   -407.0,   -547.5,   -694.0,
-	  -846.0,  -1003.0,  -1165.0,  -1331.5,  -1502.0,  -1675.5,
-	 -1852.5,  -2031.5,  -2212.5,  -2394.0,  -2576.5,  -2758.5,
-	 -2939.5,  -3118.5,  -3294.5,  -3467.5,  -3635.5,  -3798.5,
-	 -3955.0,  -4104.5,  -4245.5,  -4377.5,  -4499.0,  -4609.5,
-	 -4708.0,  -4792.5,  -4863.5,  -4919.0,  -4958.0,  -4979.5,
-	 -4983.0,  -4967.5,  -4931.5,  -4875.0,  -4796.0,  -4694.5,
-	 -4569.5,  -4420.0,  -4246.0,  -4046.0,  -3820.0,  -3567.0,
-	  3287.0,   2979.5,   2644.0,   2280.5,   1888.0,   1467.5,
-	  1018.5,    541.0,     35.0,   -499.0,  -1061.0,  -1650.0,
-	 -2266.5,  -2909.0,  -3577.0,  -4270.0,  -4987.5,  -5727.5,
-	 -6490.0,  -7274.0,  -8077.5,  -8899.5,  -9739.0, -10594.5,
-	-11464.5, -12347.0, -13241.0, -14144.5, -15056.0, -15973.5,
-	-16895.5, -17820.0, -18744.5, -19668.0, -20588.0, -21503.0,
-	-22410.5, -23308.5, -24195.0, -25068.5, -25926.5, -26767.0,
-	-27589.0, -28389.0, -29166.5, -29919.0, -30644.5, -31342.0,
-	-32009.5, -32645.0, -33247.0, -33814.5, -34346.0, -34839.5,
-	-35295.0, -35710.0, -36084.5, -36417.5, -36707.5, -36954.0,
-	-37156.5, -37315.0, -37428.0, -37496.0,  37519.0,  37496.0,
-	 37428.0,  37315.0,  37156.5,  36954.0,  36707.5,  36417.5,
-	 36084.5,  35710.0,  35295.0,  34839.5,  34346.0,  33814.5,
-	 33247.0,  32645.0,  32009.5,  31342.0,  30644.5,  29919.0,
-	 29166.5,  28389.0,  27589.0,  26767.0,  25926.5,  25068.5,
-	 24195.0,  23308.5,  22410.5,  21503.0,  20588.0,  19668.0,
-	 18744.5,  17820.0,  16895.5,  15973.5,  15056.0,  14144.5,
-	 13241.0,  12347.0,  11464.5,  10594.5,   9739.0,   8899.5,
-	  8077.5,   7274.0,   6490.0,   5727.5,   4987.5,   4270.0,
-	  3577.0,   2909.0,   2266.5,   1650.0,   1061.0,    499.0,
-	   -35.0,   -541.0,  -1018.5,  -1467.5,  -1888.0,  -2280.5,
-	 -2644.0,  -2979.5,   3287.0,   3567.0,   3820.0,   4046.0,
-	  4246.0,   4420.0,   4569.5,   4694.5,   4796.0,   4875.0,
-	  4931.5,   4967.5,   4983.0,   4979.5,   4958.0,   4919.0,
-	  4863.5,   4792.5,   4708.0,   4609.5,   4499.0,   4377.5,
-	  4245.5,   4104.5,   3955.0,   3798.5,   3635.5,   3467.5,
-	  3294.5,   3118.5,   2939.5,   2758.5,   2576.5,   2394.0,
-	  2212.5,   2031.5,   1852.5,   1675.5,   1502.0,   1331.5,
-	  1165.0,   1003.0,    846.0,    694.0,    547.5,    407.0,
-	   272.5,    144.0,     22.5,    -92.5,   -201.0,   -302.5,
-	  -397.0,   -485.0,   -565.5,   -640.0,   -707.0,   -767.5,
-	  -822.0,   -869.5,   -911.0,   -946.5,   -976.0,  -1000.0,
-	  1018.5,   1031.5,   1040.0,   1043.5,   1042.5,   1037.5,
-	  1028.5,   1016.0,   1000.5,    981.0,    959.5,    935.0,
-	   908.5,    879.5,    849.0,    817.0,    783.5,    749.0,
-	   714.0,    678.0,    641.5,    605.0,    568.5,    532.0,
-	   495.5,    459.5,    424.0,    389.5,    355.5,    322.5,
-	   290.5,    259.5,    229.5,    200.5,    173.5,    147.0,
-	   122.0,     98.5,     76.5,     55.5,     36.0,     18.0,
-		1.0,    -14.5,    -28.5,    -41.5,    -53.0,    -63.5,
-	   -73.0,    -81.5,    -88.5,    -94.5,   -100.0,   -104.0,
-	  -107.5,   -110.5,   -112.0,   -113.5,   -114.0,   -114.0,
-	  -113.5,   -112.5,   -111.0,   -109.0,    106.5,    104.0,
-	   101.0,     98.0,     95.0,     91.5,     88.0,     84.5,
-	    80.5,     77.0,     73.5,     69.5,     66.0,     62.5,
-	    58.5,     55.5,     52.0,     48.5,     45.5,     42.5,
-	    39.5,     36.5,     34.0,     31.5,     29.0,     26.5,
-	    24.5,     22.5,     20.5,     19.0,     17.5,     15.5,
-	    14.5,     13.0,     12.0,     10.5,      9.5,      8.5,
-	     8.0,      7.0,      6.5,      5.5,      5.0,      4.5,
-	     4.0,      3.5,      3.5,      3.0,      2.5,      2.5,
-	     2.0,      2.0,      1.5,      1.5,      1.0,      1.0,
-	     1.0,      1.0,      0.5,      0.5,      0.5,      0.5,
-	     0.5,      0.5
-};
-
-// Quantizer lookup, step 1: bitrate classes
-static const uint8_t PLM_AUDIO_QUANT_LUT_STEP_1[2][16] = {
-	// 32, 48, 56, 64, 80, 96,112,128,160,192,224,256,320,384 <- bitrate
-	{ 0,  0,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2 }, // mono
-	// 16, 24, 28, 32, 40, 48, 56, 64, 80, 96,112,128,160,192 <- bitrate / chan
-	{ 0,  0,  0,  0,  0,  0,  1,  1,  1,  2,  2,  2,  2,  2 } // stereo
-};
-
-// Quantizer lookup, step 2: bitrate class, sample rate -> B2 table idx, sblimit
-static const uint8_t PLM_AUDIO_QUANT_TAB_A = (27 | 64);   // Table 3-B.2a: high-rate, sblimit = 27
-static const uint8_t PLM_AUDIO_QUANT_TAB_B = (30 | 64);   // Table 3-B.2b: high-rate, sblimit = 30
-static const uint8_t PLM_AUDIO_QUANT_TAB_C = 8;           // Table 3-B.2c:  low-rate, sblimit =  8
-static const uint8_t PLM_AUDIO_QUANT_TAB_D = 12;          // Table 3-B.2d:  low-rate, sblimit = 12
-
-static const uint8_t QUANT_LUT_STEP_2[3][3] = {
-	//             44.1 kHz,               48 kHz,                 32 kHz
-	{ PLM_AUDIO_QUANT_TAB_C, PLM_AUDIO_QUANT_TAB_C, PLM_AUDIO_QUANT_TAB_D }, // 32 - 48 kbit/sec/ch
-	{ PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_A }, // 56 - 80 kbit/sec/ch
-	{ PLM_AUDIO_QUANT_TAB_B, PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_B }  // 96+	 kbit/sec/ch
-};
-
-// Quantizer lookup, step 3: B2 table, subband -> nbal, row index
-// (upper 4 bits: nbal, lower 4 bits: row index)
-static const uint8_t PLM_AUDIO_QUANT_LUT_STEP_3[3][32] = {
-	// Low-rate table (3-B.2c and 3-B.2d)
-	{
-		0x44,0x44,
-		0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34
-	},
-	// High-rate table (3-B.2a and 3-B.2b)
-	{
-		0x43,0x43,0x43,
-		0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,
-		0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,
-		0x20,0x20,0x20,0x20,0x20,0x20,0x20
-	},
-	// MPEG-2 LSR table (B.2 in ISO 13818-3)
-	{
-		0x45,0x45,0x45,0x45,
-		0x34,0x34,0x34,0x34,0x34,0x34,0x34,
-		0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,
-		0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24
-	}
-};
-
-// Quantizer lookup, step 4: table row, allocation[] value -> quant table index
-static const uint8_t PLM_AUDIO_QUANT_LUT_STEP4[6][16] = {
-	{ 0, 1, 2, 17 },
-	{ 0, 1, 2,  3, 4, 5, 6, 17 },
-	{ 0, 1, 2,  3, 4, 5, 6,  7,  8,  9, 10, 11, 12, 13, 14, 17 },
-	{ 0, 1, 3,  5, 6, 7, 8,  9, 10, 11, 12, 13, 14, 15, 16, 17 },
-	{ 0, 1, 2,  4, 5, 6, 7,  8,  9, 10, 11, 12, 13, 14, 15, 17 },
-	{ 0, 1, 2,  3, 4, 5, 6,  7,  8,  9, 10, 11, 12, 13, 14, 15 }
-};
-
-typedef struct plm_quantizer_spec_t {
-	unsigned short levels;
-	unsigned char group;
-	unsigned char bits;
-} plm_quantizer_spec_t;
-
-static const plm_quantizer_spec_t PLM_AUDIO_QUANT_TAB[] = {
-	{     3, 1,  5 },  //  1
-	{     5, 1,  7 },  //  2
-	{     7, 0,  3 },  //  3
-	{     9, 1, 10 },  //  4
-	{    15, 0,  4 },  //  5
-	{    31, 0,  5 },  //  6
-	{    63, 0,  6 },  //  7
-	{   127, 0,  7 },  //  8
-	{   255, 0,  8 },  //  9
-	{   511, 0,  9 },  // 10
-	{  1023, 0, 10 },  // 11
-	{  2047, 0, 11 },  // 12
-	{  4095, 0, 12 },  // 13
-	{  8191, 0, 13 },  // 14
-	{ 16383, 0, 14 },  // 15
-	{ 32767, 0, 15 },  // 16
-	{ 65535, 0, 16 }   // 17
-};
-
-struct plm_audio_t {
-	double time;
-	int samples_decoded;
-	int samplerate_index;
-	int bitrate_index;
-	int version;
-	int layer;
-	int mode;
-	int bound;
-	int v_pos;
-	int next_frame_data_size;
-	plm_buffer_t *buffer;
-	int destroy_buffer_when_done;
-	const plm_quantizer_spec_t *allocation[2][32];
-	uint8_t scale_factor_info[2][32];
-	int scale_factor[2][32][3];
-	int sample[2][32][3];
-	plm_samples_t samples;
-	float D[1024];
-	float V[1024];
-	float U[32];
-} forcealign(64);
-
-typedef plm_audio_t plm_audio_t;
-
-int plm_audio_decode_header(plm_audio_t *self);
-void plm_audio_decode_frame(plm_audio_t *self);
-const plm_quantizer_spec_t *plm_audio_read_allocation(plm_audio_t *self, int sb, int tab3);
-void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part);
-void plm_audio_matrix_transform(int s[32][3], int ss, float *d, int dp);
-
-plm_audio_t *plm_audio_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) {
-	plm_audio_t *self = (plm_audio_t *)memalign(_Alignof(plm_audio_t), sizeof(plm_audio_t));
-	memset(self, 0, sizeof(plm_audio_t));
-
-	self->samples.count = PLM_AUDIO_SAMPLES_PER_FRAME;
-	self->buffer = buffer;
-	self->destroy_buffer_when_done = destroy_when_done;
-	self->samplerate_index = 3; // indicates 0 samplerate
-
-	memcpy(self->D, PLM_AUDIO_SYNTHESIS_WINDOW, 512 * sizeof(float));
-	memcpy(self->D + 512, PLM_AUDIO_SYNTHESIS_WINDOW, 512 * sizeof(float));
-
-	// Decode first header
-	if (plm_buffer_has(self->buffer, 48)) {
-		self->next_frame_data_size = plm_audio_decode_header(self);
-	}
-
-	return self;
-}
-
-void plm_audio_destroy(plm_audio_t *self) {
-	if (self->destroy_buffer_when_done) {
-		plm_buffer_destroy(self->buffer);
-	}
-	free(self);
-}
-
-int plm_audio_get_samplerate(plm_audio_t *self) {
-	return PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
-}
-
-double plm_audio_get_time(plm_audio_t *self) {
-	return self->time;
-}
-
-void plm_audio_rewind(plm_audio_t *self) {
-	plm_buffer_rewind(self->buffer);
-	self->time = 0;
-	self->samples_decoded = 0;
-	self->next_frame_data_size = 0;
-
-	// TODO: needed?
-	memset(self->V, 0, sizeof(self->V));
-	memset(self->U, 0, sizeof(self->U));
-}
-
-plm_samples_t *plm_audio_decode(plm_audio_t *self) {
-	DEBUGF("%s", "plm_audio_decode");
-	// Do we have at least enough information to decode the frame header?
-	if (!self->next_frame_data_size) {
-		if (!plm_buffer_has(self->buffer, 48)) {
-			return NULL;
-		}
-		self->next_frame_data_size = plm_audio_decode_header(self);
-	}
-
-	if (
-		self->next_frame_data_size == 0 ||
-		!plm_buffer_has(self->buffer, self->next_frame_data_size << 3)
-	) {
-		return NULL;
-	}
-
-	plm_audio_decode_frame(self);
-	self->next_frame_data_size = 0;
-
-	self->samples.time = self->time;
-
-	self->samples_decoded += PLM_AUDIO_SAMPLES_PER_FRAME;
-	self->time = (double)self->samples_decoded /
-		(double)PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
-
-	return &self->samples;
-}
-
-int plm_audio_decode_header(plm_audio_t *self) {
-	// Check for valid header: syncword OK, MPEG-Audio Layer 2
-	plm_buffer_skip_bytes(self->buffer, 0x00);
-
-	int sync = plm_buffer_read(self->buffer, 11);
-	self->version = plm_buffer_read(self->buffer, 2);
-	self->layer = plm_buffer_read(self->buffer, 2);
-	int hasCRC = !plm_buffer_read(self->buffer, 1);
-
-	if (
-		sync != PLM_AUDIO_FRAME_SYNC ||
-		self->version != PLM_AUDIO_MPEG_1 ||
-		self->layer != PLM_AUDIO_LAYER_II
-	) {
-		return false; // Invalid header or unsupported version
-	}
-
-	self->bitrate_index = plm_buffer_read(self->buffer, 4) - 1;
-	if (self->bitrate_index > 13) {
-		return false;  // Invalid bit rate or 'free format'
-	}
-
-	self->samplerate_index = plm_buffer_read(self->buffer, 2);
-	if (self->samplerate_index == 3) {
-		return false; // Invalid sample rate
-	}
-
-	if (self->version == PLM_AUDIO_MPEG_2) {
-		self->samplerate_index += 4;
-		self->bitrate_index += 14;
-	}
-	int padding = plm_buffer_read(self->buffer, 1);
-	plm_buffer_skip(self->buffer, 1); // f_private
-	self->mode = plm_buffer_read(self->buffer, 2);
-
-	// Parse the mode_extension, set up the stereo bound
-	self->bound = 0;
-	if (self->mode == PLM_AUDIO_MODE_JOINT_STEREO) {
-		self->bound = (plm_buffer_read(self->buffer, 2) + 1) << 2;
-	}
-	else {
-		plm_buffer_skip(self->buffer, 2);
-		self->bound = (self->mode == PLM_AUDIO_MODE_MONO) ? 0 : 32;
-	}
-
-	// Discard the last 4 bits of the header and the CRC value, if present
-	plm_buffer_skip(self->buffer, 4);
-	if (hasCRC) {
-		plm_buffer_skip(self->buffer, 16);
-	}
-
-	// Compute frame size, check if we have enough data to decode the whole
-	// frame.
-	int bitrate = PLM_AUDIO_BIT_RATE[self->bitrate_index];
-	int samplerate = PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
-	int frame_size = (144000 * bitrate / samplerate) + padding;
-	return frame_size - (hasCRC ? 6 : 4);
-}
-
-void plm_audio_decode_frame(plm_audio_t *self) {
-	// Prepare the quantizer table lookups
-	int tab3 = 0;
-	int sblimit = 0;
-	if (self->version == PLM_AUDIO_MPEG_2) {
-		// MPEG-2 (LSR)
-		tab3 = 2;
-		sblimit = 30;
-	}
-	else {
-		// MPEG-1
-		int tab1 = (self->mode == PLM_AUDIO_MODE_MONO) ? 0 : 1;
-		int tab2 = PLM_AUDIO_QUANT_LUT_STEP_1[tab1][self->bitrate_index];
-		tab3 = QUANT_LUT_STEP_2[tab2][self->samplerate_index];
-		sblimit = tab3 & 63;
-		tab3 >>= 6;
-	}
-
-	if (self->bound > sblimit) {
-		self->bound = sblimit;
-	}
-
-	// Read the allocation information
-	for (int sb = 0; sb < self->bound; sb++) {
-		self->allocation[0][sb] = plm_audio_read_allocation(self, sb, tab3);
-		self->allocation[1][sb] = plm_audio_read_allocation(self, sb, tab3);
-	}
-
-	for (int sb = self->bound; sb < sblimit; sb++) {
-		self->allocation[0][sb] =
-			self->allocation[1][sb] =
-			plm_audio_read_allocation(self, sb, tab3);
-	}
-
-	// Read scale factor selector information
-	int channels = (self->mode == PLM_AUDIO_MODE_MONO) ? 1 : 2;
-	for (int sb = 0; sb < sblimit; sb++) {
-		for (int ch = 0; ch < channels; ch++) {
-			if (self->allocation[ch][sb]) {
-				self->scale_factor_info[ch][sb] = plm_buffer_read(self->buffer, 2);
-			}
-		}
-		if (self->mode == PLM_AUDIO_MODE_MONO) {
-			self->scale_factor_info[1][sb] = self->scale_factor_info[0][sb];
-		}
-	}
-
-	// Read scale factors
-	for (int sb = 0; sb < sblimit; sb++) {
-		for (int ch = 0; ch < channels; ch++) {
-			if (self->allocation[ch][sb]) {
-				int *sf = self->scale_factor[ch][sb];
-				switch (self->scale_factor_info[ch][sb]) {
-				case 0:
-					sf[0] = plm_buffer_read(self->buffer, 6);
-					sf[1] = plm_buffer_read(self->buffer, 6);
-					sf[2] = plm_buffer_read(self->buffer, 6);
-					break;
-				case 1:
-					sf[0] =
-						sf[1] = plm_buffer_read(self->buffer, 6);
-					sf[2] = plm_buffer_read(self->buffer, 6);
-					break;
-				case 2:
-					sf[0] =
-						sf[1] =
-						sf[2] = plm_buffer_read(self->buffer, 6);
-					break;
-				case 3:
-					sf[0] = plm_buffer_read(self->buffer, 6);
-					sf[1] =
-						sf[2] = plm_buffer_read(self->buffer, 6);
-					break;
-				}
-			}
-		}
-		if (self->mode == PLM_AUDIO_MODE_MONO) {
-			self->scale_factor[1][sb][0] = self->scale_factor[0][sb][0];
-			self->scale_factor[1][sb][1] = self->scale_factor[0][sb][1];
-			self->scale_factor[1][sb][2] = self->scale_factor[0][sb][2];
-		}
-	}
-
-	// Coefficient input and reconstruction
-	int out_pos = 0;
-	for (int part = 0; part < 3; part++) {
-		for (int granule = 0; granule < 4; granule++) {
-
-			// Read the samples
-			for (int sb = 0; sb < self->bound; sb++) {
-				plm_audio_read_samples(self, 0, sb, part);
-				plm_audio_read_samples(self, 1, sb, part);
-			}
-			for (int sb = self->bound; sb < sblimit; sb++) {
-				plm_audio_read_samples(self, 0, sb, part);
-				self->sample[1][sb][0] = self->sample[0][sb][0];
-				self->sample[1][sb][1] = self->sample[0][sb][1];
-				self->sample[1][sb][2] = self->sample[0][sb][2];
-			}
-			for (int sb = sblimit; sb < 32; sb++) {
-				self->sample[0][sb][0] = 0;
-				self->sample[0][sb][1] = 0;
-				self->sample[0][sb][2] = 0;
-				self->sample[1][sb][0] = 0;
-				self->sample[1][sb][1] = 0;
-				self->sample[1][sb][2] = 0;
-			}
-
-			// Synthesis loop
-			for (int p = 0; p < 3; p++) {
-				// Shifting step
-				self->v_pos = (self->v_pos - 64) & 1023;
-
-				for (int ch = 0; ch < 2; ch++) {
-					plm_audio_matrix_transform(self->sample[ch], p, self->V, self->v_pos);
-
-					// Build U, windowing, calculate output
-					memset(self->U, 0, sizeof(self->U));
-
-					int d_index = 512 - (self->v_pos >> 1);
-					int v_index = (self->v_pos % 128) >> 1;
-					while (v_index < 1024) {
-						for (int i = 0; i < 32; ++i) {
-							self->U[i] += self->D[d_index++] * self->V[v_index++];
-						}
-
-						v_index += 128 - 32;
-						d_index += 64 - 32;
-					}
-
-					d_index -= (512 - 32);
-					v_index = (128 - 32 + 1024) - v_index;
-					while (v_index < 1024) {
-						for (int i = 0; i < 32; ++i) {
-							self->U[i] += self->D[d_index++] * self->V[v_index++];
-						}
-
-						v_index += 128 - 32;
-						d_index += 64 - 32;
-					}
-
-					// Output samples
-					#ifdef PLM_AUDIO_SEPARATE_CHANNELS
-						float *out_channel = ch == 0
-							? self->samples.left
-							: self->samples.right;
-						for (int j = 0; j < 32; j++) {
-							out_channel[out_pos + j] = self->U[j] / 2147418112.0f;
-						}
-					#else
-						for (int j = 0; j < 32; j++) {
-							self->samples.interleaved[((out_pos + j) << 1) + ch] =
-								self->U[j] / 2147418112.0f;
-						}
-					#endif
-				} // End of synthesis channel loop
-				out_pos += 32;
-			} // End of synthesis sub-block loop
-
-		} // Decoding of the granule finished
-	}
-
-	plm_buffer_align(self->buffer);
-}
-
-const plm_quantizer_spec_t *plm_audio_read_allocation(plm_audio_t *self, int sb, int tab3) {
-	int tab4 = PLM_AUDIO_QUANT_LUT_STEP_3[tab3][sb];
-	int qtab = PLM_AUDIO_QUANT_LUT_STEP4[tab4 & 15][plm_buffer_read(self->buffer, tab4 >> 4)];
-	return qtab ? (&PLM_AUDIO_QUANT_TAB[qtab - 1]) : 0;
-}
-
-void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part) {
-	const plm_quantizer_spec_t *q = self->allocation[ch][sb];
-	int sf = self->scale_factor[ch][sb][part];
-	int *sample = self->sample[ch][sb];
-	int val = 0;
-
-	if (!q) {
-		// No bits allocated for this subband
-		sample[0] = sample[1] = sample[2] = 0;
-		return;
-	}
-
-	// Resolve scalefactor
-	if (sf == 63) {
-		sf = 0;
-	}
-	else {
-		int shift = (sf / 3) | 0;
-		sf = (PLM_AUDIO_SCALEFACTOR_BASE[sf % 3] + ((1u << shift) >> 1)) >> shift;
-	}
-
-	// Decode samples
-	int adj = q->levels;
-	if (q->group) {
-		// Decode grouped samples
-		val = plm_buffer_read(self->buffer, q->bits);
-		sample[0] = val % adj;
-		val /= adj;
-		sample[1] = val % adj;
-		sample[2] = val / adj;
-	}
-	else {
-		// Decode direct samples
-		sample[0] = plm_buffer_read(self->buffer, q->bits);
-		sample[1] = plm_buffer_read(self->buffer, q->bits);
-		sample[2] = plm_buffer_read(self->buffer, q->bits);
-	}
-
-	// Postmultiply samples
-	int scale = 65536 / (adj + 1);
-	adj = ((adj + 1) >> 1) - 1;
-
-	val = (adj - sample[0]) * scale;
-	sample[0] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
-
-	val = (adj - sample[1]) * scale;
-	sample[1] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
-
-	val = (adj - sample[2]) * scale;
-	sample[2] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
-}
-
-void plm_audio_matrix_transform(int s[32][3], int ss, float *d, int dp) {
-	float t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12,
-		t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24,
-		t25, t26, t27, t28, t29, t30, t31, t32, t33;
-
-	t01 = (float)(s[0][ss] + s[31][ss]); t02 = (float)(s[0][ss] - s[31][ss]) * 0.500602998235f;
-	t03 = (float)(s[1][ss] + s[30][ss]); t04 = (float)(s[1][ss] - s[30][ss]) * 0.505470959898f;
-	t05 = (float)(s[2][ss] + s[29][ss]); t06 = (float)(s[2][ss] - s[29][ss]) * 0.515447309923f;
-	t07 = (float)(s[3][ss] + s[28][ss]); t08 = (float)(s[3][ss] - s[28][ss]) * 0.53104259109f;
-	t09 = (float)(s[4][ss] + s[27][ss]); t10 = (float)(s[4][ss] - s[27][ss]) * 0.553103896034f;
-	t11 = (float)(s[5][ss] + s[26][ss]); t12 = (float)(s[5][ss] - s[26][ss]) * 0.582934968206f;
-	t13 = (float)(s[6][ss] + s[25][ss]); t14 = (float)(s[6][ss] - s[25][ss]) * 0.622504123036f;
-	t15 = (float)(s[7][ss] + s[24][ss]); t16 = (float)(s[7][ss] - s[24][ss]) * 0.674808341455f;
-	t17 = (float)(s[8][ss] + s[23][ss]); t18 = (float)(s[8][ss] - s[23][ss]) * 0.744536271002f;
-	t19 = (float)(s[9][ss] + s[22][ss]); t20 = (float)(s[9][ss] - s[22][ss]) * 0.839349645416f;
-	t21 = (float)(s[10][ss] + s[21][ss]); t22 = (float)(s[10][ss] - s[21][ss]) * 0.972568237862f;
-	t23 = (float)(s[11][ss] + s[20][ss]); t24 = (float)(s[11][ss] - s[20][ss]) * 1.16943993343f;
-	t25 = (float)(s[12][ss] + s[19][ss]); t26 = (float)(s[12][ss] - s[19][ss]) * 1.48416461631f;
-	t27 = (float)(s[13][ss] + s[18][ss]); t28 = (float)(s[13][ss] - s[18][ss]) * 2.05778100995f;
-	t29 = (float)(s[14][ss] + s[17][ss]); t30 = (float)(s[14][ss] - s[17][ss]) * 3.40760841847f;
-	t31 = (float)(s[15][ss] + s[16][ss]); t32 = (float)(s[15][ss] - s[16][ss]) * 10.1900081235f;
-
-	t33 = t01 + t31; t31 = (t01 - t31) * 0.502419286188f;
-	t01 = t03 + t29; t29 = (t03 - t29) * 0.52249861494f;
-	t03 = t05 + t27; t27 = (t05 - t27) * 0.566944034816f;
-	t05 = t07 + t25; t25 = (t07 - t25) * 0.64682178336f;
-	t07 = t09 + t23; t23 = (t09 - t23) * 0.788154623451f;
-	t09 = t11 + t21; t21 = (t11 - t21) * 1.06067768599f;
-	t11 = t13 + t19; t19 = (t13 - t19) * 1.72244709824f;
-	t13 = t15 + t17; t17 = (t15 - t17) * 5.10114861869f;
-	t15 = t33 + t13; t13 = (t33 - t13) * 0.509795579104f;
-	t33 = t01 + t11; t01 = (t01 - t11) * 0.601344886935f;
-	t11 = t03 + t09; t09 = (t03 - t09) * 0.899976223136f;
-	t03 = t05 + t07; t07 = (t05 - t07) * 2.56291544774f;
-	t05 = t15 + t03; t15 = (t15 - t03) * 0.541196100146f;
-	t03 = t33 + t11; t11 = (t33 - t11) * 1.30656296488f;
-	t33 = t05 + t03; t05 = (t05 - t03) * 0.707106781187f;
-	t03 = t15 + t11; t15 = (t15 - t11) * 0.707106781187f;
-	t03 += t15;
-	t11 = t13 + t07; t13 = (t13 - t07) * 0.541196100146f;
-	t07 = t01 + t09; t09 = (t01 - t09) * 1.30656296488f;
-	t01 = t11 + t07; t07 = (t11 - t07) * 0.707106781187f;
-	t11 = t13 + t09; t13 = (t13 - t09) * 0.707106781187f;
-	t11 += t13; t01 += t11;
-	t11 += t07; t07 += t13;
-	t09 = t31 + t17; t31 = (t31 - t17) * 0.509795579104f;
-	t17 = t29 + t19; t29 = (t29 - t19) * 0.601344886935f;
-	t19 = t27 + t21; t21 = (t27 - t21) * 0.899976223136f;
-	t27 = t25 + t23; t23 = (t25 - t23) * 2.56291544774f;
-	t25 = t09 + t27; t09 = (t09 - t27) * 0.541196100146f;
-	t27 = t17 + t19; t19 = (t17 - t19) * 1.30656296488f;
-	t17 = t25 + t27; t27 = (t25 - t27) * 0.707106781187f;
-	t25 = t09 + t19; t19 = (t09 - t19) * 0.707106781187f;
-	t25 += t19;
-	t09 = t31 + t23; t31 = (t31 - t23) * 0.541196100146f;
-	t23 = t29 + t21; t21 = (t29 - t21) * 1.30656296488f;
-	t29 = t09 + t23; t23 = (t09 - t23) * 0.707106781187f;
-	t09 = t31 + t21; t31 = (t31 - t21) * 0.707106781187f;
-	t09 += t31;	t29 += t09;	t09 += t23;	t23 += t31;
-	t17 += t29;	t29 += t25;	t25 += t09;	t09 += t27;
-	t27 += t23;	t23 += t19; t19 += t31;
-	t21 = t02 + t32; t02 = (t02 - t32) * 0.502419286188f;
-	t32 = t04 + t30; t04 = (t04 - t30) * 0.52249861494f;
-	t30 = t06 + t28; t28 = (t06 - t28) * 0.566944034816f;
-	t06 = t08 + t26; t08 = (t08 - t26) * 0.64682178336f;
-	t26 = t10 + t24; t10 = (t10 - t24) * 0.788154623451f;
-	t24 = t12 + t22; t22 = (t12 - t22) * 1.06067768599f;
-	t12 = t14 + t20; t20 = (t14 - t20) * 1.72244709824f;
-	t14 = t16 + t18; t16 = (t16 - t18) * 5.10114861869f;
-	t18 = t21 + t14; t14 = (t21 - t14) * 0.509795579104f;
-	t21 = t32 + t12; t32 = (t32 - t12) * 0.601344886935f;
-	t12 = t30 + t24; t24 = (t30 - t24) * 0.899976223136f;
-	t30 = t06 + t26; t26 = (t06 - t26) * 2.56291544774f;
-	t06 = t18 + t30; t18 = (t18 - t30) * 0.541196100146f;
-	t30 = t21 + t12; t12 = (t21 - t12) * 1.30656296488f;
-	t21 = t06 + t30; t30 = (t06 - t30) * 0.707106781187f;
-	t06 = t18 + t12; t12 = (t18 - t12) * 0.707106781187f;
-	t06 += t12;
-	t18 = t14 + t26; t26 = (t14 - t26) * 0.541196100146f;
-	t14 = t32 + t24; t24 = (t32 - t24) * 1.30656296488f;
-	t32 = t18 + t14; t14 = (t18 - t14) * 0.707106781187f;
-	t18 = t26 + t24; t24 = (t26 - t24) * 0.707106781187f;
-	t18 += t24; t32 += t18;
-	t18 += t14; t26 = t14 + t24;
-	t14 = t02 + t16; t02 = (t02 - t16) * 0.509795579104f;
-	t16 = t04 + t20; t04 = (t04 - t20) * 0.601344886935f;
-	t20 = t28 + t22; t22 = (t28 - t22) * 0.899976223136f;
-	t28 = t08 + t10; t10 = (t08 - t10) * 2.56291544774f;
-	t08 = t14 + t28; t14 = (t14 - t28) * 0.541196100146f;
-	t28 = t16 + t20; t20 = (t16 - t20) * 1.30656296488f;
-	t16 = t08 + t28; t28 = (t08 - t28) * 0.707106781187f;
-	t08 = t14 + t20; t20 = (t14 - t20) * 0.707106781187f;
-	t08 += t20;
-	t14 = t02 + t10; t02 = (t02 - t10) * 0.541196100146f;
-	t10 = t04 + t22; t22 = (t04 - t22) * 1.30656296488f;
-	t04 = t14 + t10; t10 = (t14 - t10) * 0.707106781187f;
-	t14 = t02 + t22; t02 = (t02 - t22) * 0.707106781187f;
-	t14 += t02;	t04 += t14;	t14 += t10;	t10 += t02;
-	t16 += t04;	t04 += t08;	t08 += t14;	t14 += t28;
-	t28 += t10;	t10 += t20;	t20 += t02;	t21 += t16;
-	t16 += t32;	t32 += t04;	t04 += t06;	t06 += t08;
-	t08 += t18;	t18 += t14;	t14 += t30;	t30 += t28;
-	t28 += t26;	t26 += t10;	t10 += t12;	t12 += t20;
-	t20 += t24;	t24 += t02;
-
-	d[dp + 48] = -t33;
-	d[dp + 49] = d[dp + 47] = -t21;
-	d[dp + 50] = d[dp + 46] = -t17;
-	d[dp + 51] = d[dp + 45] = -t16;
-	d[dp + 52] = d[dp + 44] = -t01;
-	d[dp + 53] = d[dp + 43] = -t32;
-	d[dp + 54] = d[dp + 42] = -t29;
-	d[dp + 55] = d[dp + 41] = -t04;
-	d[dp + 56] = d[dp + 40] = -t03;
-	d[dp + 57] = d[dp + 39] = -t06;
-	d[dp + 58] = d[dp + 38] = -t25;
-	d[dp + 59] = d[dp + 37] = -t08;
-	d[dp + 60] = d[dp + 36] = -t11;
-	d[dp + 61] = d[dp + 35] = -t18;
-	d[dp + 62] = d[dp + 34] = -t09;
-	d[dp + 63] = d[dp + 33] = -t14;
-	d[dp + 32] = -t05;
-	d[dp + 0] = t05; d[dp + 31] = -t30;
-	d[dp + 1] = t30; d[dp + 30] = -t27;
-	d[dp + 2] = t27; d[dp + 29] = -t28;
-	d[dp + 3] = t28; d[dp + 28] = -t07;
-	d[dp + 4] = t07; d[dp + 27] = -t26;
-	d[dp + 5] = t26; d[dp + 26] = -t23;
-	d[dp + 6] = t23; d[dp + 25] = -t10;
-	d[dp + 7] = t10; d[dp + 24] = -t15;
-	d[dp + 8] = t15; d[dp + 23] = -t12;
-	d[dp + 9] = t12; d[dp + 22] = -t19;
-	d[dp + 10] = t19; d[dp + 21] = -t20;
-	d[dp + 11] = t20; d[dp + 20] = -t13;
-	d[dp + 12] = t13; d[dp + 19] = -t24;
-	d[dp + 13] = t24; d[dp + 18] = -t31;
-	d[dp + 14] = t31; d[dp + 17] = -t02;
-	d[dp + 15] = t02; d[dp + 16] = 0.0;
-};
-