.gitignore

@@ -12,9 +12,17 @@ __pycache__
 # editor crud
 .vscode
 *swp
+*~
 
 # Python
 .venv
+/venv/
 
 # sphinx
 docs/_build/
+
+/tools/mypy.sh
+
+# bl00mbox docs
+components/bl00mbox/docs/
+components/bl00mbox/public/

.gitlab-ci.yml

@@ -5,11 +5,12 @@ stages:
 
 variables:
   GIT_SUBMODULE_STRATEGY: recursive
+  GIT_DEPTH: 0
 
 default:
   # built via:
   #     docker load < $(nix-build nix/docker-image.nix)
-  image: registry.k0.hswaw.net/q3k/flow3r-build:v4ljgs5czzm6j79m7r30vw6xz6990kkv
+  image: registry.gitlab.com/flow3r-badge/flow3r-build:238576xsg79mjr2bkqg106qisvd3b5q9
 
 clang-tidy:
   stage: check
@@ -21,21 +22,6 @@ clang-tidy:
     reports:
       codequality: cqual.json
 
-mypy:
-  stage: check
-  variables:
-    MYPYPATH: python_payload/mypystubs
-  script:
-    - "set +e +o pipefail"
-    - "bash tools/mypy.sh; result=$?"
-    - "python3 tools/codequal-report.py mypy warnings.txt > cqual.json"
-    - "set -e -o pipefail"
-    - "[ $result == 0 ]"
-  artifacts:
-    when: always
-    reports:
-      codequality: cqual.json
-
 format:
   stage: check
   script:
@@ -46,29 +32,62 @@ format:
 build:
   stage: build
   script:
-    - idf.py -g c23 build
+    - idf.py -g c23 build size
+  artifacts:
+    expose_as: 'firmware'
+    paths: ['build/flow3r.bin']
+    expire_in: 5 hours
+
+build_recovery:
+  stage: build
+  script:
+    - cd recovery
+    - idf.py build size
   artifacts:
-    expose_as: 'C23 ELF'
-    paths: ['build/flow3r.elf']
+    expose_as: 'Recovery'
+    paths: ['recovery/build/flow3r-recovery.bin', 'recovery/build/partition_table/partition-table.bin', 'recovery/build/bootloader/bootloader.bin']
     expire_in: 5 hours
 
 simulate:
   stage: build
   script:
-    - python3 sim/run.py screenshot
+    - python3 sim/run.py --screenshot
   artifacts:
-    expose_as: 'Smulator Screenshot'
+    expose_as: 'Simulator Screenshot'
     paths: ['flow3r.png']
     expire_in: 5 hours
 
 pages:
   stage: deploy
-  only:
-    - main
+  rules:
+    - if: $CI_COMMIT_BRANCH == "main"
   script:
+    - git tag | xargs git tag -d
+    - git checkout origin/main
+    - git checkout -b dev
+    - git branch --all
+    - git branch --all | sed -e 's/..//' | grep '^remotes/origin/release/' | while read b; do git checkout -b "v${b#remotes/origin/release/}" "$b"; done
+    - git checkout dev
+    - git branch
+    - mkdir public
     - cd docs
-    - make html
-    - mv _build/html ../public
+    - make versionedhtml
+    - cp -r _build/$(git branch --sort=version:refname | tail -n1 | sed -e 's/..//')/* _build/
+    - python redirects.py
+    - cp -r _build/* ../public/
+    - find ../public/
   artifacts:
     paths: ['public']
     expire_in: 1d
+
+dist:
+  stage: deploy
+  variables:
+    # Force a full clone to make version machinery work.
+    GIT_STRATEGY: clone
+  rules:
+    - if: $CI_COMMIT_TAG
+  script:
+    - bash tools/dist.sh
+  artifacts:
+    paths: ['dist']

CHANGELOG.md

+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [Unreleased]
+
+## [1.4.0] - 2024-12-24
+### Summary
+
+- documentation reworked and expanded
+- primary context menu: can be opened at any time to view help texts, open the audio mixer or force-exit an application.
+- help viewer: applications can provide context-sensitive help texts to make it easier to figure them out and reduce
+  the load on appilcation writers to explain everything on a small screen.
+- audio mixer: set levels of bl00mbox channels and mute/unmute them. Muted channels don't use CPU.
+- secondary context menu: can be opened in an application menu to delete apps, set them as autostart or mark them as
+  favorite to sort them to the top of menus
+- new preloaded apps: violin, wobbler, mp3 player
+- major rework of captouch driver features
+- added `st3m.ui.widgets` module for easier app integration of user inputs (for example, captouch gestures)
+- bl00mbox can now run channel-specific micropython callbacks whenever the channel is rendered, allowing
+  for much more flexible backgrounded music applications
+
+### Added
+- system: unregistered apps are marked as "new"
+- system: new category "Demos" for things that focus on being technical examples rather than being use case oriented
+- gdb: micropython REPL available while debugging
+- micropython: added `indent` keyword to `json.dumps`/`json.dump`
+- apps: added overrides for OS button
+- apps: added `get_help()` method to provide context sensitive help texts to users
+- settings: Touch UI (default off) activates preview for captouch menu navigation
+- media: support for more (most) mp3 tag types
+- gr33nhouse: sort by application type
+- captouch: no more silent captouch calibration, driver saves persistent calibration file and guides user through manual
+  calibration when none is found.
+- captouch: petals can be turned off run with reduced output to increase data rate
+- captouch: unfiltered data log is accessible
+- captouch: added `PetalLog` helper class for data processing
+- bl00mbox: added .delete() method for various objects, added destructors for better garbabe collection behavior
+- bl00mbox: added RMS volume collection option and provide volume normalization guidelines in flo3r docs
+
+### Changed
+- settings: "Enable WiFi on Boot" option is now "Always-On Wi-Fi" (but is functionally identical), should help reduce confusion about Wi-Fi turning off automatically
+- captouch: normalized positional output in new `.pos`/`.raw_pos` attributes, deprecated old `.position` API
+- captouch: normalized raw capacitance output in new `.raw_cap` attribute, deprecated old `.pressure` API
+- captouch: removed all abstractions that indicate petal pads without replacement,
+  i.e. `InputController.petals[x].ccw` or `InputState.petals[x].raw`
+
+### Fixed
+- updat3r: Improved version comparison logic, making the "you are up to date :)" logic work
+- captouch: petal 5 fully functional
+- bl00mbox: a whole lot of bugs and performance issues (but not all :P)
+
+## [1.3.0] - 2023-11-26
+### Summary
+- Wifi connection UI
+- Media framework
+- SD card works reliably
+- Performance improvements
+- Backend improvements
+- Wider micropython API
+- Improved preloaded applications
+- ...and many bugfixes!
+
+### Added
+- Added the `Audio Passthrough` app for toggling audio passthrough through
+  line-in/mic to speaker or lineout.
+- Added the `w1f1` app for managing wifi access to Settings, incorporates
+  an in-progress cap-touch multi-tap keyboard (`k3yboard`).
+- Added the `Scalar` app in `Music` category for playing scales.
+- Added the `Mandelbrot` app, which illustrates how one can do direct
+  framebuffer access and control 8bpp palettized modes from python.
+- Added configuration of audio adjustments and startup dB level to `settings.json`.
+- Added configuration of wifi credentials + hostname via `settings.json`
+- Added support for apps to set wifi state automatically (configurable in
+  settings: `Let apps change WiFi`)
+- Added task profiler which prints over serial (configurable in
+  settings: `Debug: ftop`)
+- Added an error screen to the `Nick` app when `nick.json` is invalid.
+- Added `urequests` and `uos` support in the simulator.
+- Added audio/video media framework, and `Wurzelitzer` app as a small jukebox
+  frontend - currently supporting mp3 audio, mpeg1 video, GIF and protracker
+  .mod files.
+- Added exporting of built firmwares as part of CI.
+- Added basic implementation of `os.statvfs()` to fetch full/available
+  disk space on flash and SD.
+- Added `set_position` and `scroll_to` methods to `ScrollController`
+- graphics: sprite sheet support for `ctx.image()`
+- graphics: `ctx.parse()` for parsing SVG-path-data/ctx-protocol.
+- graphics: 1,2,4,8,16,24 and 32 bits-per-pixel graphics modes.
+- graphics: direct framebuffer access.
+- graphics: palette setting in 1,2,4 and 8bpp graphics modes.
+- graphics: flags for 2x 3x and 4x pixel doubling, low-latency and direct-ctx modes.
+- graphics: experimental smart redraw mode
+- graphics: clipped and composited overlay buffer
+- graphics: allow a graphics state depth of up to 10 (`ctx.save()` `ctx.restore()`)
+- graphics: virtual framebuffer with scrolling
+- battery: Main menu shows a charge percentage estimate based on real battery characterization
+- Added basic media playback in the `fil3s` app.
+- Added a delete button to `fil3s`/Files app to allow for deleting files,
+  folders and apps on-device.
+- Added new menu categories, `Media` and `Games`, and made category handling more robust
+  to correctly handle introducing new categories in the future.
+- Added configuration UI for audio, appearance and graphics settings.
+- Added configurable LED patterns for the main menu.
+- Added "restore defaults" option in the settings menu.
+- Added wah modulation in `Otamatone`.
+- Added several API functions for `ViewManager` to make complex view handling in apps
+  easier and robust.
+- Added firmware update app, `updat3r`.
+- Added storage information in `About` app.
+- Added audio equalization for built-in speakers.
+- Added a function to retrieve scope data for manual drawing/processing.
+- Added I2C scanner app.
+- Added sensor demo app.
+- Added `CONFIG_DEBUG_GDB_ENABLED` flag for easy debugging over USB JTAG.
+- Added saving/restoring state to several apps.
+- Added variable sequence length support in `gay drums`.
+
+### Changed
+- Changed the st3m\_tar logic to only update files on flash after an update
+  if they've been changed, greatly improving start times after an update.
+- Flashing flow3r through idf.py now automatically restarts it.
+- Switched the REPL/fatal/disk restart button to the OS shoulder button (right
+  shoulder button, unless swapped in settings).
+- Improved performance of the `gr33nhouse` app list by not rendering hidden
+  entries and scrolling ones too long to fit on screen.
+- Changed the audio adjustment logic, and added support for holding down the
+  shoulder to keep increasing/decreasing level.
+- Improved download reliability of the `gr33nhouse` app by adding chunked
+  downloads, some `gc.collect()` calls, progress bar and an error screen.
+- Settings are now automatically loaded and saved when entering and leaving
+  the settings page.
+- Moved the `Clouds` app to the `Badge` menu and updated it to use IMU data.
+- Added a more sane commandline interface to the simulator.
+- More stub functions for the simulator.
+- Improved performance of system menus by not rendering hidden entries.
+- Added visualization of state, instead of an audio scope in UI of `harmonic
+  demo` and `melodic demo`.
+- The system provided scope is now always stroked.
+- Improved BPM tap accuracy in `gay drums`.
+- Some shell code rewritten to avoid the expensive calls `ctx.start_group()` and
+  `ctx.end_group()`.
+- Overlay graphics gets rendered to a separate framebuffer, of which a clipped rectangle
+  is composited during scan-out. The python overlay code has been adapted to keep track
+  of which parts of overlay need refresh.
+- Slightly lower AA quality; for a 3x performance boost in the
+  worst-case scanline rasterization code path.
+- The entry section in `flow3r.toml` can now be omitted if the Application
+  class is called `App`.
+- disabled support for compositing group API in ctx, where used global\_alpha on
+  its own did was responsible for it seeming to work.
+- Split the `settings.py` file into two, creating `settings_menu.py` to hold
+  UI-related code and allow `settings` to be used import loops without
+  in many cases.
+- When running apps through REPL mode (with `mpremote` etc), multi-view apps
+  are now properly handled and don't restart whenever OS shoulder is pressed.
+- A multitude of built-in apps now scroll names to fit the screen.
+- Apps are now sorted and deduplicated by display name, not by folder name.
+- Improved handedness in buttons.
+- `harmonic demo` turned into a fully-featured `chord organ`
+- `menu` key in `flow3r.toml` has been replaced with `category`. The old key can still
+  be used to maintain backwards compatibility with older firmwares.
+- Backported recent improvements for micropython's garbage collection to make it faster.
+- `shoegaze` can now use chords configured in `chord organ`.
+- Changed the priority of additional threads spawned by micropython to be equal to its
+  main thread's priority.
+- Apps that require Wi-Fi connection can directly take the user to Wi-Fi settings.
+- Changed the default app installation directory on flash to `/flash/apps`.
+- `gr33nhouse` now installs apps on SD card if available.
+- Increased the frequency of LED animations.
+- Changed the way LED colors are blended when using slew rates lower than 255 to be
+  more in line with color perception.
+- Rearranged system menu.
+- Made system indicator icons bigger.
+- Removed CCCamp's Wi-Fi settings from the default config.
+- Made InputState and parts of InputController lazily evaluated.
+- bl00mbox: allow circular signal dependencies
+- bl00mbox: several plugins and patches deprecated and replaced with updated
+  versions, see https://gitlab.com/moon2embeddedaudio/bl00mbox/-/blob/main/README.md
+
+### Fixed
+- Fixed `tiny sampler` keeping the microphone active after app exit.
+- Fixed missing `include/` dir on builds on Darwin.
+- Fixed the `time` module in the simulator being broken for apps trying to use it.
+- Fixed wrong petal ordering in the simulator.
+- Fixed simulator not exiting when closed.
+- Fixed `Comic Mono` missing in the simulator.
+- Fixed initialization orientation of display and transform initialization for
+  ctx contexts, (this enables arbitrary transformations to images and gradients.)
+- Fixed broken anti-aliasing for compressed side of curved strokes.
+- Fixed cleanup at exit for firmware apps
+- Fixed sampler start bug in bl00mbox
+- Fixed reset of graphics subsystem upon entering REPL / using mpremote.
+- Fixed multitude of issues with transition animations.
+- Fixed lost captouch and button presses when they're shorter than a think cycle.
+- Fixed `ScrollController`'s handling of high delta values.
+- Fixed many crashes in `fil3s` app.
+- Fixed a crash in `CapScrollController`.
+- Fixed gamma LUT setting for LEDs.
+- Fixed bl00mbox channels leaking on micropython's soft reboot.
+- Fixed importing bl00mbox's fake stub in the simulator.
+- Performance fixes for bl00mbox.
+- Fixed troubles with deleting files on some SD cards (like the bundled one).
+- Fixed the default I2C1 pins in micropython's I2C interface.
+- Fixed large files being truncated when installing apps via `gr33nhouse`.
+- Fixed LED color handling in the simulator.
+- Fixed flickering .down property of Pressable when going through REPEATED state.
+
+
+## [1.2.0] - 2023-08-18
+### Added
+- Added a WiFi status indicator icon.
+- Added a battery status indicator icon.
+- Added support for loading apps from `/sd/apps` and `/flash/apps`.
+- Added an error screen when apps fail to start.
+- Added Python/st3m API to access battery charge status.
+- Added the ability to always hide icons (*System* ➜ *Settings* ➜ *Show Icons*).
+
+### Fixed
+- File descriptor leak on app load.  This would lead to the OS crashing when
+  too many apps are installed.
+
+
+## [1.1.1] - 2023-08-17
+### Fixed
+- Crash on WiFi startup
+
+
+## [1.1.0] - 2023-08-17
+
+### Added
+- Added _Comic Mono_ font.
+- Added a setting for automatically connecting to Camp WiFi.
+- Added a *System* ➜ *Get Apps* App for downloading apps directly from <https://flow3r.garden/apps/>.
+- Added `ApplicationContext.bundle_path` so apps can find out what directory
+  they live in.  This should be used for loading app assets from the correct
+  path.
+- Added TLS support for MicroPython.
+- Added modules for `.tar.gz` extraction.
+- Added `aioble` module (Bluetooth Low Energy).
+- Added line-in support to bl00mbox.
+- Added pronoun support in the Nick app.
+- Added color options in the Nick app.
+- Added IMU-based rotation in the Nick app.
+
+### Changed
+- `ctx.get_font_name()` now raises an exception for unknown fonts.
+- Raised max concurrent texture limit to 32.
+
+### Fixed
+- Fixed PNG without alpha and JPEG support by enabling `CTX_FORMAT_RGB8`.
+- Fixed image cache eviction by introducing a ctx frameclock.
+- Fixed incorrect merging of settings dicts in `st3m.settings`.
+- Fixed some USB problems.
+- Fixed sound filenames not working when they start with `/flash/` or `/sd/`.
+- Fixed syntax errors in `flow3r.toml` crashing the menu.
+
+
+## [1.0.0] - 2023-08-13
+
+Initial Release
+
+
+[unreleased]: https://git.flow3r.garden/flow3r/flow3r-firmware/-/compare/v1.4.0...main
+[1.4.0]: https://git.flow3r.garden/flow3r/flow3r-firmware/-/compare/v1.3.0...v1.4.0
+[1.3.0]: https://git.flow3r.garden/flow3r/flow3r-firmware/-/compare/v1.2.0...v1.3.0
+[1.2.0]: https://git.flow3r.garden/flow3r/flow3r-firmware/-/compare/v1.1.1...v1.2.0
+[1.1.1]: https://git.flow3r.garden/flow3r/flow3r-firmware/-/compare/v1.1.0...v1.1.1
+[1.1.0]: https://git.flow3r.garden/flow3r/flow3r-firmware/-/compare/v1.0.0...v1.1.0
+[1.0.0]: https://git.flow3r.garden/flow3r/flow3r-firmware/-/tags/v1.0.0
+

CMakeLists.txt

@@ -11,9 +11,11 @@ project(flow3r)
 # generally don't want doubles, doubles on ESP32 bad.
 idf_component_get_property(st3m_lib st3m COMPONENT_LIB)
 idf_component_get_property(flow3r_bsp_lib flow3r_bsp COMPONENT_LIB)
+idf_component_get_property(bl00mbox_lib bl00mbox COMPONENT_LIB)
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
     target_compile_options(${st3m_lib} PRIVATE -cl-single-precision-constant -Wdouble-promotion)
     target_compile_options(${flow3r_bsp_lib} PRIVATE -cl-single-precision-constant -Wdouble-promotion)
+    target_compile_options(${bl00mbox_lib} PRIVATE -Wno-error=unknown-pragmas)
 else()
     target_compile_options(${st3m_lib} PRIVATE -fsingle-precision-constant -Wdouble-promotion)
     target_compile_options(${flow3r_bsp_lib} PRIVATE -fsingle-precision-constant -Wdouble-promotion)

COPYING

+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

components/audio_mod/CMakeLists.txt

+idf_component_register(
+    SRCS
+        audio_mod.c
+    INCLUDE_DIRS
+        .
+        ../ctx
+        ../st3m
+)

components/audio_mod/audio_mod.c

+#ifndef __clang__
+#pragma GCC optimize("O2")
+#endif
+
+#include <fcntl.h>
+#include <st3m_audio.h>
+#include <st3m_media.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "ctx.h"
+
+#define POCKETMOD_IMPLEMENTATION
+#include "pocketmod.h"
+
+typedef struct {
+    st3m_media control;
+    pocketmod_context pocketmod;
+    uint8_t *data;
+    size_t size;
+    char *path;
+    float scroll_pos;
+} mod_state;
+
+static void mod_draw(st3m_media *media, Ctx *ctx) {
+    mod_state *self = (void *)media;
+
+    ctx_rectangle(ctx, -120, -120, 240, 240);
+    ctx_gray(ctx, 0);
+    ctx_fill(ctx);
+    // ctx_arc(ctx, 0, 0, 10, 10);
+    ctx_rgb(ctx, 1.0, 1.0, 1.0);
+    ctx_font_size(ctx, 20);
+    char buf[100];
+    sprintf(buf, "pat:%i/%i line:%i", self->pocketmod.pattern,
+            self->pocketmod.num_patterns, self->pocketmod.line);
+    ctx_text_align(ctx, CTX_TEXT_ALIGN_CENTER);
+    ctx_move_to(ctx, 0, -20);
+    ctx_text(ctx, buf);
+    ctx_fill(ctx);
+
+    ctx_font_size(ctx, 14);
+    int xpos = 0;
+    int str_width = ctx_text_width(ctx, self->path);
+    if (str_width > 220) {
+        xpos = ctx_sinf(self->scroll_pos) * (str_width - 220) / 2;
+    }
+    ctx_move_to(ctx, xpos, 14);
+    ctx_gray(ctx, 0.6);
+    ctx_text(ctx, self->path);
+}
+
+static void mod_think(st3m_media *media, float ms_elapsed) {
+    mod_state *self = (void *)media;
+    if (self->control.paused) return;
+
+    if (self->control.seek == 0) {
+        pocketmod_init(&self->pocketmod, self->data, self->size, 48000);
+        self->control.seek = -1;
+    }
+
+    int samples_needed = (ms_elapsed / 1000.0) * 48000;
+    if (samples_needed > 1000) samples_needed = 1000;
+
+    float rendered[samples_needed * 2];
+    int rend = pocketmod_render(&self->pocketmod, rendered, sizeof(rendered));
+    st3m_pcm_queue_float(48000, 2, rend / (sizeof(float) * 2), rendered);
+
+    if (self->control.duration == 0) {
+        self->control.duration = self->pocketmod.num_patterns + 1;
+    }
+    if (self->pocketmod.pattern >= self->control.duration)
+        self->control.duration = self->pocketmod.pattern + 1;
+    self->control.position = self->pocketmod.pattern;
+    if (self->pocketmod.loop_count)
+        self->control.duration = self->control.position;
+
+    self->scroll_pos += ms_elapsed / 1000.0;
+}
+
+static void mod_destroy(st3m_media *media) {
+    mod_state *self = (void *)media;
+    if (self->data) free(self->data);
+    if (self->path) free(self->path);
+    free(self);
+}
+
+static int file_get_contents(const char *path, uint8_t **contents,
+                             size_t *length) {
+    FILE *file;
+    long size;
+    long remaining;
+    uint8_t *buffer;
+    file = fopen(path, "rb");
+    if (!file) {
+        return -1;
+    }
+    fseek(file, 0, SEEK_END);
+    size = remaining = ftell(file);
+
+    if (length) {
+        *length = size;
+    }
+    rewind(file);
+    buffer = malloc(size + 2);
+    if (!buffer) {
+        fclose(file);
+        return -1;
+    }
+    remaining -= fread(buffer, 1, remaining, file);
+    if (remaining) {
+        fclose(file);
+        free(buffer);
+        return -1;
+    }
+    fclose(file);
+    *contents = (unsigned char *)buffer;
+    buffer[size] = 0;
+    return 0;
+}
+
+st3m_media *st3m_media_load_mod(const char *path) {
+    mod_state *self = (mod_state *)malloc(sizeof(mod_state));
+    memset(self, 0, sizeof(mod_state));
+    self->control.draw = mod_draw;
+    self->control.think = mod_think;
+    self->control.destroy = mod_destroy;
+    self->control.has_audio = true;
+    file_get_contents(path, &self->data, &self->size);
+    if (!self->data ||
+        !pocketmod_init(&self->pocketmod, self->data, self->size, 48000)) {
+        if (self->data) free(self->data);
+        free(self);
+        return NULL;
+    }
+    self->path = strdup(path);
+    self->scroll_pos = 0;
+    return (st3m_media *)self;
+}

components/audio_mod/pocketmod.h

+/* See end of file for license */
+
+#ifndef POCKETMOD_H_INCLUDED
+#define POCKETMOD_H_INCLUDED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct pocketmod_context pocketmod_context;
+int pocketmod_init(pocketmod_context *c, const void *data, int size, int rate);
+int pocketmod_render(pocketmod_context *c, void *buffer, int size);
+int pocketmod_loop_count(pocketmod_context *c);
+
+#ifndef POCKETMOD_MAX_CHANNELS
+#define POCKETMOD_MAX_CHANNELS 32
+#endif
+
+#ifndef POCKETMOD_MAX_SAMPLES
+#define POCKETMOD_MAX_SAMPLES 31
+#endif
+
+typedef struct {
+    signed char *data;   /* Sample data buffer                      */
+    unsigned int length; /* Data length (in bytes)                  */
+} _pocketmod_sample;
+
+typedef struct {
+    unsigned char dirty;       /* Pitch/volume dirty flags                */
+    unsigned char sample;      /* Sample number (0..31)                   */
+    unsigned char volume;      /* Base volume without tremolo (0..64)     */
+    unsigned char balance;     /* Stereo balance (0..255)                 */
+    unsigned short period;     /* Note period (113..856)                  */
+    unsigned short delayed;    /* Delayed note period (113..856)          */
+    unsigned short target;     /* Target period (for tone portamento)     */
+    unsigned char finetune;    /* Note finetune (0..15)                   */
+    unsigned char loop_count;  /* E6x loop counter                        */
+    unsigned char loop_line;   /* E6x target line                         */
+    unsigned char lfo_step;    /* Vibrato/tremolo LFO step counter        */
+    unsigned char lfo_type[2]; /* LFO type for vibrato/tremolo            */
+    unsigned char effect;      /* Current effect (0x0..0xf or 0xe0..0xef) */
+    unsigned char param;       /* Raw effect parameter value              */
+    unsigned char param3;      /* Parameter memory for 3xx                */
+    unsigned char param4;      /* Parameter memory for 4xy                */
+    unsigned char param7;      /* Parameter memory for 7xy                */
+    unsigned char param9;      /* Parameter memory for 9xx                */
+    unsigned char paramE1;     /* Parameter memory for E1x                */
+    unsigned char paramE2;     /* Parameter memory for E2x                */
+    unsigned char paramEA;     /* Parameter memory for EAx                */
+    unsigned char paramEB;     /* Parameter memory for EBx                */
+    unsigned char real_volume; /* Volume (with tremolo adjustment)        */
+    float position;            /* Position in sample data buffer          */
+    float increment;           /* Position increment per output sample    */
+} _pocketmod_chan;
+
+struct pocketmod_context {
+    /* Read-only song data */
+    _pocketmod_sample samples[POCKETMOD_MAX_SAMPLES];
+    unsigned char *source;      /* Pointer to source MOD data              */
+    unsigned char *order;       /* Pattern order table                     */
+    unsigned char *patterns;    /* Start of pattern data                   */
+    unsigned char length;       /* Patterns in the order (1..128)          */
+    unsigned char reset;        /* Pattern to loop back to (0..127)        */
+    unsigned char num_patterns; /* Patterns in the file (1..128)           */
+    unsigned char num_samples;  /* Sample count (15 or 31)                 */
+    unsigned char num_channels; /* Channel count (1..32)                   */
+
+    /* Timing variables */
+    int samples_per_second; /* Sample rate (set by user)               */
+    int ticks_per_line;     /* A.K.A. song speed (initially 6)         */
+    float samples_per_tick; /* Depends on sample rate and BPM          */
+
+    /* Loop detection state */
+    unsigned char visited[16]; /* Bit mask of previously visited patterns */
+    int loop_count;            /* How many times the song has looped      */
+
+    /* Render state */
+    _pocketmod_chan channels[POCKETMOD_MAX_CHANNELS];
+    unsigned char pattern_delay; /* EEx pattern delay counter               */
+    unsigned int lfo_rng;        /* RNG used for the random LFO waveform    */
+
+    /* Position in song (from least to most granular) */
+    signed char pattern; /* Current pattern in order                */
+    signed char line;    /* Current line in pattern                 */
+    short tick;          /* Current tick in line                    */
+    float sample;        /* Current sample in tick                  */
+};
+
+#ifdef POCKETMOD_IMPLEMENTATION
+
+/* Memorize a parameter unless the new value is zero */
+#define POCKETMOD_MEM(dst, src)        \
+    do {                               \
+        (dst) = (src) ? (src) : (dst); \
+    } while (0)
+
+/* Same thing, but memorize each nibble separately */
+#define POCKETMOD_MEM2(dst, src)                               \
+    do {                                                       \
+        (dst) = (((src)&0x0f) ? ((src)&0x0f) : ((dst)&0x0f)) | \
+                (((src)&0xf0) ? ((src)&0xf0) : ((dst)&0xf0));  \
+    } while (0)
+
+/* Shortcut to sample metadata (sample must be nonzero) */
+#define POCKETMOD_SAMPLE(c, sample) ((c)->source + 12 + 30 * (sample))
+
+/* Channel dirty flags */
+#define POCKETMOD_PITCH 0x01
+#define POCKETMOD_VOLUME 0x02
+
+/* The size of one sample in bytes */
+#define POCKETMOD_SAMPLE_SIZE sizeof(float[2])
+
+/* Finetune adjustment table. Three octaves for each finetune setting. */
+static const signed char _pocketmod_finetune[16][36] = {
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { -6, -6, -5, -5, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -3, -2, -2,
+      -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0 },
+    { -12, -12, -10, -11, -8, -8, -7, -7, -6, -6, -6, -6,
+      -6,  -6,  -5,  -5,  -4, -4, -4, -3, -3, -3, -3, -2,
+      -3,  -3,  -2,  -3,  -3, -2, -2, -2, -2, -2, -2, -1 },
+    { -18, -17, -16, -16, -13, -12, -12, -11, -10, -10, -10, -9,
+      -9,  -9,  -8,  -8,  -7,  -6,  -6,  -5,  -5,  -5,  -5,  -4,
+      -5,  -4,  -3,  -4,  -4,  -3,  -3,  -3,  -3,  -2,  -2,  -2 },
+    { -24, -23, -21, -21, -18, -17, -16, -15, -14, -13, -13, -12,
+      -12, -12, -11, -10, -9,  -8,  -8,  -7,  -7,  -7,  -7,  -6,
+      -6,  -6,  -5,  -5,  -5,  -4,  -4,  -4,  -4,  -3,  -3,  -3 },
+    { -30, -29, -26, -26, -23, -21, -20, -19, -18, -17, -17, -16,
+      -15, -14, -13, -13, -11, -11, -10, -9,  -9,  -9,  -8,  -7,
+      -8,  -7,  -6,  -6,  -6,  -5,  -5,  -5,  -5,  -4,  -4,  -4 },
+    { -36, -34, -32, -31, -27, -26, -24, -23, -22, -21, -20, -19,
+      -18, -17, -16, -15, -14, -13, -12, -11, -11, -10, -10, -9,
+      -9,  -9,  -7,  -8,  -7,  -6,  -6,  -6,  -6,  -5,  -5,  -4 },
+    { -42, -40, -37, -36, -32, -30, -29, -27, -25, -24, -23, -22,
+      -21, -20, -18, -18, -16, -15, -14, -13, -13, -12, -12, -10,
+      -10, -10, -9,  -9,  -9,  -8,  -7,  -7,  -7,  -6,  -6,  -5 },
+    { 51, 48, 46, 42, 42, 38, 36, 34, 32, 30, 24, 27, 25, 24, 23, 21, 21, 19,
+      18, 17, 16, 15, 14, 14, 12, 12, 12, 10, 10, 10, 9,  8,  8,  8,  7,  7 },
+    { 44, 42, 40, 37, 37, 35, 32, 31, 29, 27, 25, 24, 22, 21, 20, 19, 18, 17,
+      16, 15, 15, 14, 13, 12, 11, 10, 10, 9,  9,  9,  8,  7,  7,  7,  6,  6 },
+    { 38, 36, 34, 32, 31, 30, 28, 27, 25, 24, 22, 21, 19, 18, 17, 16, 16, 15,
+      14, 13, 13, 12, 11, 11, 9,  9,  9,  8,  7,  7,  7,  6,  6,  6,  5,  5 },
+    { 31, 30, 29, 26, 26, 25, 24, 22, 21, 20, 18, 17, 16, 15, 14, 13, 13, 12,
+      12, 11, 11, 10, 9,  9,  8,  7,  8,  7,  6,  6,  6,  5,  5,  5,  5,  5 },
+    { 25, 24, 23, 21, 21, 20, 19, 18, 17, 16, 14, 14, 13, 12, 11, 10, 11, 10,
+      10, 9,  9,  8,  7,  7,  6,  6,  6,  5,  5,  5,  5,  4,  4,  4,  3,  4 },
+    { 19, 18, 17, 16, 16, 15, 15, 14, 13, 12, 11, 10, 9, 9, 9, 8, 8, 18,
+      7,  7,  7,  6,  5,  6,  5,  4,  5,  4,  4,  4,  4, 3, 3, 3, 3, 3 },
+    { 12, 12, 12, 10, 11, 11, 10, 10, 9, 8, 7, 7, 6, 6, 6, 5, 6, 5,
+      5,  5,  5,  4,  4,  4,  3,  3,  3, 3, 2, 3, 3, 2, 2, 2, 2, 2 },
+    { 6, 6, 6, 5, 6, 6, 6, 5, 5, 5, 4, 4, 3, 3, 3, 3, 3, 3,
+      3, 3, 3, 2, 2, 2, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
+};
+
+/* Min/max helper functions */
+static int _pocketmod_min(int x, int y) { return x < y ? x : y; }
+static int _pocketmod_max(int x, int y) { return x > y ? x : y; }
+
+/* Clamp a volume value to the 0..64 range */
+static int _pocketmod_clamp_volume(int x) {
+    x = _pocketmod_max(x, 0x00);
+    x = _pocketmod_min(x, 0x40);
+    return x;
+}
+
+/* Zero out a block of memory */
+static void _pocketmod_zero(void *data, int size) {
+    char *byte = data, *end = byte + size;
+    while (byte != end) {
+        *byte++ = 0;
+    }
+}
+
+/* Convert a period (at finetune = 0) to a note index in 0..35 */
+static int _pocketmod_period_to_note(int period) {
+    switch (period) {
+        case 856:
+            return 0;
+        case 808:
+            return 1;
+        case 762:
+            return 2;
+        case 720:
+            return 3;
+        case 678:
+            return 4;
+        case 640:
+            return 5;
+        case 604:
+            return 6;
+        case 570:
+            return 7;
+        case 538:
+            return 8;
+        case 508:
+            return 9;
+        case 480:
+            return 10;
+        case 453:
+            return 11;
+        case 428:
+            return 12;
+        case 404:
+            return 13;
+        case 381:
+            return 14;
+        case 360:
+            return 15;
+        case 339:
+            return 16;
+        case 320:
+            return 17;
+        case 302:
+            return 18;
+        case 285:
+            return 19;
+        case 269:
+            return 20;
+        case 254:
+            return 21;
+        case 240:
+            return 22;
+        case 226:
+            return 23;
+        case 214:
+            return 24;
+        case 202:
+            return 25;
+        case 190:
+            return 26;
+        case 180:
+            return 27;
+        case 170:
+            return 28;
+        case 160:
+            return 29;
+        case 151:
+            return 30;
+        case 143:
+            return 31;
+        case 135:
+            return 32;
+        case 127:
+            return 33;
+        case 120:
+            return 34;
+        case 113:
+            return 35;
+        default:
+            return 0;
+    }
+}
+
+/* Table-based sine wave oscillator */
+static int _pocketmod_sin(int step) {
+    /* round(sin(x * pi / 32) * 255) for x in 0..15 */
+    static const unsigned char sin[16] = { 0x00, 0x19, 0x32, 0x4a, 0x62, 0x78,
+                                           0x8e, 0xa2, 0xb4, 0xc5, 0xd4, 0xe0,
+                                           0xec, 0xf4, 0xfa, 0xfe };
+    int x = sin[step & 0x0f];
+    x = (step & 0x1f) < 0x10 ? x : 0xff - x;
+    return step < 0x20 ? x : -x;
+}
+
+/* Oscillators for vibrato/tremolo effects */
+static int _pocketmod_lfo(pocketmod_context *c, _pocketmod_chan *ch, int step) {
+    switch (ch->lfo_type[ch->effect == 7] & 3) {
+        case 0:
+            return _pocketmod_sin(step & 0x3f); /* Sine   */
+        case 1:
+            return 0xff - ((step & 0x3f) << 3); /* Saw    */
+        case 2:
+            return (step & 0x3f) < 0x20 ? 0xff : -0xff; /* Square */
+        case 3:
+            return (c->lfo_rng & 0x1ff) - 0xff; /* Random */
+        default:
+            return 0; /* Hush little compiler */
+    }
+}
+
+static void _pocketmod_update_pitch(pocketmod_context *c, _pocketmod_chan *ch) {
+    /* Don't do anything if the period is zero */
+    ch->increment = 0.0f;
+    if (ch->period) {
+        float period = ch->period;
+
+        /* Apply vibrato (if active) */
+        if (ch->effect == 0x4 || ch->effect == 0x6) {
+            int step = (ch->param4 >> 4) * ch->lfo_step;
+            int rate = ch->param4 & 0x0f;
+            period += _pocketmod_lfo(c, ch, step) * rate / 128.0f;
+
+            /* Apply arpeggio (if active) */
+        } else if (ch->effect == 0x0 && ch->param) {
+            static const float arpeggio[16] = {
+                /* 2^(X/12) for X in 0..15 */
+                1.000000f, 1.059463f, 1.122462f, 1.189207f,
+                1.259921f, 1.334840f, 1.414214f, 1.498307f,
+                1.587401f, 1.681793f, 1.781797f, 1.887749f,
+                2.000000f, 2.118926f, 2.244924f, 2.378414f
+            };
+            int step = (ch->param >> ((2 - c->tick % 3) << 2)) & 0x0f;
+            period /= arpeggio[step];
+        }
+
+        /* Calculate sample buffer position increment */
+        ch->increment = 3546894.6f / (period * c->samples_per_second);
+    }
+
+    /* Clear the pitch dirty flag */
+    ch->dirty &= ~POCKETMOD_PITCH;
+}
+
+static void _pocketmod_update_volume(pocketmod_context *c,
+                                     _pocketmod_chan *ch) {
+    int volume = ch->volume;
+    if (ch->effect == 0x7) {
+        int step = ch->lfo_step * (ch->param7 >> 4);
+        volume += _pocketmod_lfo(c, ch, step) * (ch->param7 & 0x0f) >> 6;
+    }
+    ch->real_volume = _pocketmod_clamp_volume(volume);
+    ch->dirty &= ~POCKETMOD_VOLUME;
+}
+
+static void _pocketmod_pitch_slide(_pocketmod_chan *ch, int amount) {
+    int max = 856 + _pocketmod_finetune[ch->finetune][0];
+    int min = 113 + _pocketmod_finetune[ch->finetune][35];
+    ch->period += amount;
+    ch->period = _pocketmod_max(ch->period, min);
+    ch->period = _pocketmod_min(ch->period, max);
+    ch->dirty |= POCKETMOD_PITCH;
+}
+
+static void _pocketmod_volume_slide(_pocketmod_chan *ch, int param) {
+    /* Undocumented quirk: If both x and y are nonzero, then the value of x */
+    /* takes precedence. (Yes, there are songs that rely on this behavior.) */
+    int change = (param & 0xf0) ? (param >> 4) : -(param & 0x0f);
+    ch->volume = _pocketmod_clamp_volume(ch->volume + change);
+    ch->dirty |= POCKETMOD_VOLUME;
+}
+
+static void _pocketmod_next_line(pocketmod_context *c) {
+    unsigned char(*data)[4];
+    int i, pos, pattern_break = -1;
+
+    /* When entering a new pattern order index, mark it as "visited" */
+    if (c->line == 0) {
+        c->visited[c->pattern >> 3] |= 1 << (c->pattern & 7);
+    }
+
+    /* Move to the next pattern if this was the last line */
+    if (++c->line == 64) {
+        if (++c->pattern == c->length) {
+            c->pattern = c->reset;
+        }
+        c->line = 0;
+    }
+
+    /* Find the pattern data for the current line */
+    pos = (c->order[c->pattern] * 64 + c->line) * c->num_channels * 4;
+    data = (unsigned char(*)[4])(c->patterns + pos);
+    for (i = 0; i < c->num_channels; i++) {
+        /* Decode columns */
+        int sample = (data[i][0] & 0xf0) | (data[i][2] >> 4);
+        int period = ((data[i][0] & 0x0f) << 8) | data[i][1];
+        int effect = ((data[i][2] & 0x0f) << 8) | data[i][3];
+
+        /* Memorize effect parameter values */
+        _pocketmod_chan *ch = &c->channels[i];
+        ch->effect = (effect >> 8) != 0xe ? (effect >> 8) : (effect >> 4);
+        ch->param = (effect >> 8) != 0xe ? (effect & 0xff) : (effect & 0x0f);
+
+        /* Set sample */
+        if (sample) {
+            if (sample <= POCKETMOD_MAX_SAMPLES) {
+                unsigned char *sample_data = POCKETMOD_SAMPLE(c, sample);
+                ch->sample = sample;
+                ch->finetune = sample_data[2] & 0x0f;
+                ch->volume = _pocketmod_min(sample_data[3], 0x40);
+                if (ch->effect != 0xED) {
+                    ch->dirty |= POCKETMOD_VOLUME;
+                }
+            } else {
+                ch->sample = 0;
+            }
+        }
+
+        /* Set note */
+        if (period) {
+            int note = _pocketmod_period_to_note(period);
+            period += _pocketmod_finetune[ch->finetune][note];
+            if (ch->effect != 0x3) {
+                if (ch->effect != 0xED) {
+                    ch->period = period;
+                    ch->dirty |= POCKETMOD_PITCH;
+                    ch->position = 0.0f;
+                    ch->lfo_step = 0;
+                } else {
+                    ch->delayed = period;
+                }
+            }
+        }
+
+        /* Handle pattern effects */
+        switch (ch->effect) {
+            /* Memorize parameters */
+            case 0x3:
+                POCKETMOD_MEM(ch->param3, ch->param); /* Fall through */
+            case 0x5:
+                POCKETMOD_MEM(ch->target, period);
+                break;
+            case 0x4:
+                POCKETMOD_MEM2(ch->param4, ch->param);
+                break;
+            case 0x7:
+                POCKETMOD_MEM2(ch->param7, ch->param);
+                break;
+            case 0xE1:
+                POCKETMOD_MEM(ch->paramE1, ch->param);
+                break;
+            case 0xE2:
+                POCKETMOD_MEM(ch->paramE2, ch->param);
+                break;
+            case 0xEA:
+                POCKETMOD_MEM(ch->paramEA, ch->param);
+                break;
+            case 0xEB:
+                POCKETMOD_MEM(ch->paramEB, ch->param);
+                break;
+
+            /* 8xx: Set stereo balance (nonstandard) */
+            case 0x8: {
+                ch->balance = ch->param;
+            } break;
+
+            /* 9xx: Set sample offset */
+            case 0x9: {
+                if (period != 0 || sample != 0) {
+                    ch->param9 = ch->param ? ch->param : ch->param9;
+                    ch->position = ch->param9 << 8;
+                }
+            } break;
+
+            /* Bxx: Jump to pattern */
+            case 0xB: {
+                c->pattern = ch->param < c->length ? ch->param : 0;
+                c->line = -1;
+            } break;
+
+            /* Cxx: Set volume */
+            case 0xC: {
+                ch->volume = _pocketmod_clamp_volume(ch->param);
+                ch->dirty |= POCKETMOD_VOLUME;
+            } break;
+
+            /* Dxy: Pattern break */
+            case 0xD: {
+                pattern_break = (ch->param >> 4) * 10 + (ch->param & 15);
+            } break;
+
+            /* E4x: Set vibrato waveform */
+            case 0xE4: {
+                ch->lfo_type[0] = ch->param;
+            } break;
+
+            /* E5x: Set sample finetune */
+            case 0xE5: {
+                ch->finetune = ch->param;
+                ch->dirty |= POCKETMOD_PITCH;
+            } break;
+
+            /* E6x: Pattern loop */
+            case 0xE6: {
+                if (ch->param) {
+                    if (!ch->loop_count) {
+                        ch->loop_count = ch->param;
+                        c->line = ch->loop_line;
+                    } else if (--ch->loop_count) {
+                        c->line = ch->loop_line;
+                    }
+                } else {
+                    ch->loop_line = c->line - 1;
+                }
+            } break;
+
+            /* E7x: Set tremolo waveform */
+            case 0xE7: {
+                ch->lfo_type[1] = ch->param;
+            } break;
+
+            /* E8x: Set stereo balance (nonstandard) */
+            case 0xE8: {
+                ch->balance = ch->param << 4;
+            } break;
+
+            /* EEx: Pattern delay */
+            case 0xEE: {
+                c->pattern_delay = ch->param;
+            } break;
+
+            /* Fxx: Set speed */
+            case 0xF: {
+                if (ch->param != 0) {
+                    if (ch->param < 0x20) {
+                        c->ticks_per_line = ch->param;
+                    } else {
+                        float rate = c->samples_per_second;
+                        c->samples_per_tick = rate / (0.4f * ch->param);
+                    }
+                }
+            } break;
+
+            default:
+                break;
+        }
+    }
+
+    /* Pattern breaks are handled here, so that only one jump happens even  */
+    /* when multiple Dxy commands appear on the same line. (You guessed it: */
+    /* There are songs that rely on this behavior!)                         */
+    if (pattern_break != -1) {
+        c->line = (pattern_break < 64 ? pattern_break : 0) - 1;
+        if (++c->pattern == c->length) {
+            c->pattern = c->reset;
+        }
+    }
+}
+
+static void _pocketmod_next_tick(pocketmod_context *c) {
+    int i;
+
+    /* Move to the next line if this was the last tick */
+    if (++c->tick == c->ticks_per_line) {
+        if (c->pattern_delay > 0) {
+            c->pattern_delay--;
+        } else {
+            _pocketmod_next_line(c);
+        }
+        c->tick = 0;
+    }
+
+    /* Make per-tick adjustments for all channels */
+    for (i = 0; i < c->num_channels; i++) {
+        _pocketmod_chan *ch = &c->channels[i];
+        int param = ch->param;
+
+        /* Advance the LFO random number generator */
+        c->lfo_rng = 0x0019660d * c->lfo_rng + 0x3c6ef35f;
+
+        /* Handle effects that may happen on any tick of a line */
+        switch (ch->effect) {
+            /* 0xy: Arpeggio */
+            case 0x0: {
+                ch->dirty |= POCKETMOD_PITCH;
+            } break;
+
+            /* E9x: Retrigger note every x ticks */
+            case 0xE9: {
+                if (!(param && c->tick % param)) {
+                    ch->position = 0.0f;
+                    ch->lfo_step = 0;
+                }
+            } break;
+
+            /* ECx: Cut note after x ticks */
+            case 0xEC: {
+                if (c->tick == param) {
+                    ch->volume = 0;
+                    ch->dirty |= POCKETMOD_VOLUME;
+                }
+            } break;
+
+            /* EDx: Delay note for x ticks */
+            case 0xED: {
+                if (c->tick == param && ch->sample) {
+                    ch->dirty |= POCKETMOD_VOLUME | POCKETMOD_PITCH;
+                    ch->period = ch->delayed;
+                    ch->position = 0.0f;
+                    ch->lfo_step = 0;
+                }
+            } break;
+
+            default:
+                break;
+        }
+
+        /* Handle effects that only happen on the first tick of a line */
+        if (c->tick == 0) {
+            switch (ch->effect) {
+                case 0xE1:
+                    _pocketmod_pitch_slide(ch, -ch->paramE1);
+                    break;
+                case 0xE2:
+                    _pocketmod_pitch_slide(ch, +ch->paramE2);
+                    break;
+                case 0xEA:
+                    _pocketmod_volume_slide(ch, ch->paramEA << 4);
+                    break;
+                case 0xEB:
+                    _pocketmod_volume_slide(ch, ch->paramEB & 15);
+                    break;
+                default:
+                    break;
+            }
+
+            /* Handle effects that are not applied on the first tick of a line
+             */
+        } else {
+            switch (ch->effect) {
+                /* 1xx: Portamento up */
+                case 0x1: {
+                    _pocketmod_pitch_slide(ch, -param);
+                } break;
+
+                /* 2xx: Portamento down */
+                case 0x2: {
+                    _pocketmod_pitch_slide(ch, +param);
+                } break;
+
+                /* 5xy: Volume slide + tone portamento */
+                case 0x5: {
+                    _pocketmod_volume_slide(ch, param);
+                } /* Fall through */
+
+                /* 3xx: Tone portamento */
+                case 0x3: {
+                    int rate = ch->param3;
+                    int order = ch->period < ch->target;
+                    int closer = ch->period + (order ? rate : -rate);
+                    int new_order = closer < ch->target;
+                    ch->period = new_order == order ? closer : ch->target;
+                    ch->dirty |= POCKETMOD_PITCH;
+                } break;
+
+                /* 6xy: Volume slide + vibrato */
+                case 0x6: {
+                    _pocketmod_volume_slide(ch, param);
+                } /* Fall through */
+
+                /* 4xy: Vibrato */
+                case 0x4: {
+                    ch->lfo_step++;
+                    ch->dirty |= POCKETMOD_PITCH;
+                } break;
+
+                /* 7xy: Tremolo */
+                case 0x7: {
+                    ch->lfo_step++;
+                    ch->dirty |= POCKETMOD_VOLUME;
+                } break;
+
+                /* Axy: Volume slide */
+                case 0xA: {
+                    _pocketmod_volume_slide(ch, param);
+                } break;
+
+                default:
+                    break;
+            }
+        }
+
+        /* Update channel volume/pitch if either is out of date */
+        if (ch->dirty & POCKETMOD_VOLUME) {
+            _pocketmod_update_volume(c, ch);
+        }
+        if (ch->dirty & POCKETMOD_PITCH) {
+            _pocketmod_update_pitch(c, ch);
+        }
+    }
+}
+
+static void _pocketmod_render_channel(pocketmod_context *c,
+                                      _pocketmod_chan *chan, float *output,
+                                      int samples_to_write) {
+    /* Gather some loop data */
+    _pocketmod_sample *sample = &c->samples[chan->sample - 1];
+    unsigned char *data = POCKETMOD_SAMPLE(c, chan->sample);
+    const int loop_start = ((data[4] << 8) | data[5]) << 1;
+    const int loop_length = ((data[6] << 8) | data[7]) << 1;
+    const int loop_end = loop_length > 2 ? loop_start + loop_length : 0xffffff;
+    const float sample_end = 1 + _pocketmod_min(loop_end, sample->length);
+
+    /* Calculate left/right levels */
+    const float volume = chan->real_volume / (float)(128 * 64 * 4);
+    const float level_l = volume * (1.0f - chan->balance / 255.0f);
+    const float level_r = volume * (0.0f + chan->balance / 255.0f);
+
+    /* Write samples */
+    int i, num;
+    do {
+        /* Calculate how many samples we can write in one go */
+        num = (sample_end - chan->position) / chan->increment;
+        num = _pocketmod_min(num, samples_to_write);
+
+        /* Resample and write 'num' samples */
+        for (i = 0; i < num; i++) {
+            int x0 = chan->position;
+#ifdef POCKETMOD_NO_INTERPOLATION
+            float s = sample->data[x0];
+#else
+            int x1 = x0 + 1 - loop_length * (x0 + 1 >= loop_end);
+            float t = chan->position - x0;
+            float s = (1.0f - t) * sample->data[x0] + t * sample->data[x1];
+#endif
+            chan->position += chan->increment;
+            *output++ += level_l * s;
+            *output++ += level_r * s;
+        }
+
+        /* Rewind the sample when reaching the loop point */
+        if (chan->position >= loop_end) {
+            chan->position -= loop_length;
+
+            /* Cut the sample if the end is reached */
+        } else if (chan->position >= sample->length) {
+            chan->position = -1.0f;
+            break;
+        }
+
+        samples_to_write -= num;
+    } while (num > 0);
+}
+
+static int _pocketmod_ident(pocketmod_context *c, unsigned char *data,
+                            int size) {
+    int i, j;
+
+    /* 31-instrument files are at least 1084 bytes long */
+    if (size >= 1084) {
+        /* The format tag is located at offset 1080 */
+        unsigned char *tag = data + 1080;
+
+        /* List of recognized format tags (possibly incomplete) */
+        static const struct {
+            char name[5];
+            char channels;
+        } tags[] = {
+            /* TODO: FLT8 intentionally omitted because I haven't been able */
+            /* to find a specimen to test its funky pattern pairing format  */
+            { "M.K.", 4 },  { "M!K!", 4 },  { "FLT4", 4 },  { "4CHN", 4 },
+            { "OKTA", 8 },  { "OCTA", 8 },  { "CD81", 8 },  { "FA08", 8 },
+            { "1CHN", 1 },  { "2CHN", 2 },  { "3CHN", 3 },  { "4CHN", 4 },
+            { "5CHN", 5 },  { "6CHN", 6 },  { "7CHN", 7 },  { "8CHN", 8 },
+            { "9CHN", 9 },  { "10CH", 10 }, { "11CH", 11 }, { "12CH", 12 },
+            { "13CH", 13 }, { "14CH", 14 }, { "15CH", 15 }, { "16CH", 16 },
+            { "17CH", 17 }, { "18CH", 18 }, { "19CH", 19 }, { "20CH", 20 },
+            { "21CH", 21 }, { "22CH", 22 }, { "23CH", 23 }, { "24CH", 24 },
+            { "25CH", 25 }, { "26CH", 26 }, { "27CH", 27 }, { "28CH", 28 },
+            { "29CH", 29 }, { "30CH", 30 }, { "31CH", 31 }, { "32CH", 32 }
+        };
+
+        /* Check the format tag to determine if this is a 31-sample MOD */
+        for (i = 0; i < (int)(sizeof(tags) / sizeof(*tags)); i++) {
+            if (tags[i].name[0] == tag[0] && tags[i].name[1] == tag[1] &&
+                tags[i].name[2] == tag[2] && tags[i].name[3] == tag[3]) {
+                c->num_channels = tags[i].channels;
+                c->length = data[950];
+                c->reset = data[951];
+                c->order = &data[952];
+                c->patterns = &data[1084];
+                c->num_samples = 31;
+                return 1;
+            }
+        }
+    }
+
+    /* A 15-instrument MOD has to be at least 600 bytes long */
+    if (size < 600) {
+        return 0;
+    }
+
+    /* Check that the song title only contains ASCII bytes (or null) */
+    for (i = 0; i < 20; i++) {
+        if (data[i] != '\0' && (data[i] < ' ' || data[i] > '~')) {
+            return 0;
+        }
+    }
+
+    /* Check that sample names only contain ASCII bytes (or null) */
+    for (i = 0; i < 15; i++) {
+        for (j = 0; j < 22; j++) {
+            char chr = data[20 + i * 30 + j];
+            if (chr != '\0' && (chr < ' ' || chr > '~')) {
+                return 0;
+            }
+        }
+    }
+
+    /* It looks like we have an older 15-instrument MOD */
+    c->length = data[470];
+    c->reset = data[471];
+    c->order = &data[472];
+    c->patterns = &data[600];
+    c->num_samples = 15;
+    c->num_channels = 4;
+    return 1;
+}
+
+int pocketmod_init(pocketmod_context *c, const void *data, int size, int rate) {
+    int i, remaining, header_bytes, pattern_bytes;
+    unsigned char *byte = (unsigned char *)c;
+    signed char *sample_data;
+
+    /* Check that arguments look more or less sane */
+    if (!c || !data || rate <= 0 || size <= 0) {
+        return 0;
+    }
+
+    /* Zero out the whole context and identify the MOD type */
+    _pocketmod_zero(c, sizeof(pocketmod_context));
+    c->source = (unsigned char *)data;
+    if (!_pocketmod_ident(c, c->source, size)) {
+        return 0;
+    }
+
+    /* Check that we are compiled with support for enough channels */
+    if (c->num_channels > POCKETMOD_MAX_CHANNELS) {
+        return 0;
+    }
+
+    /* Check that we have enough sample slots for this file */
+    if (POCKETMOD_MAX_SAMPLES < 31) {
+        byte = (unsigned char *)data + 20;
+        for (i = 0; i < c->num_samples; i++) {
+            unsigned int length = 2 * ((byte[22] << 8) | byte[23]);
+            if (i >= POCKETMOD_MAX_SAMPLES && length > 2) {
+                return 0; /* Can't fit this sample */
+            }
+            byte += 30;
+        }
+    }
+
+    /* Check that the song length is in valid range (1..128) */
+    if (c->length == 0 || c->length > 128) {
+        return 0;
+    }
+
+    /* Make sure that the reset pattern doesn't take us out of bounds */
+    if (c->reset >= c->length) {
+        c->reset = 0;
+    }
+
+    /* Count how many patterns there are in the file */
+    c->num_patterns = 0;
+    for (i = 0; i < 128 && c->order[i] < 128; i++) {
+        c->num_patterns = _pocketmod_max(c->num_patterns, c->order[i]);
+    }
+    pattern_bytes = 256 * c->num_channels * ++c->num_patterns;
+    header_bytes = (int)((char *)c->patterns - (char *)data);
+
+    /* Check that each pattern in the order is within file bounds */
+    for (i = 0; i < c->length; i++) {
+        if (header_bytes + 256 * c->num_channels * c->order[i] > size) {
+            return 0; /* Reading this pattern would be a buffer over-read! */
+        }
+    }
+
+    /* Check that the pattern data doesn't extend past the end of the file */
+    if (header_bytes + pattern_bytes > size) {
+        return 0;
+    }
+
+    /* Load sample payload data, truncating ones that extend outside the file */
+    remaining = size - header_bytes - pattern_bytes;
+    sample_data = (signed char *)data + header_bytes + pattern_bytes;
+    for (i = 0; i < c->num_samples; i++) {
+        unsigned char *data = POCKETMOD_SAMPLE(c, i + 1);
+        unsigned int length = ((data[0] << 8) | data[1]) << 1;
+        _pocketmod_sample *sample = &c->samples[i];
+        sample->data = sample_data;
+        sample->length = _pocketmod_min(length > 2 ? length : 0, remaining);
+        sample_data += sample->length;
+        remaining -= sample->length;
+    }
+
+    /* Set up ProTracker default panning for all channels */
+    for (i = 0; i < c->num_channels; i++) {
+        c->channels[i].balance = 0x80 + ((((i + 1) >> 1) & 1) ? 0x20 : -0x20);
+    }
+
+    /* Prepare to render from the start */
+    c->ticks_per_line = 6;
+    c->samples_per_second = rate;
+    c->samples_per_tick = rate / 50.0f;
+    c->lfo_rng = 0xbadc0de;
+    c->line = -1;
+    c->tick = c->ticks_per_line - 1;
+    _pocketmod_next_tick(c);
+    return 1;
+}
+
+int pocketmod_render(pocketmod_context *c, void *buffer, int buffer_size) {
+    int i, samples_rendered = 0;
+    int samples_remaining = buffer_size / POCKETMOD_SAMPLE_SIZE;
+    if (c && buffer) {
+        float(*output)[2] = (float(*)[2])buffer;
+        while (samples_remaining > 0) {
+            /* Calculate the number of samples left in this tick */
+            int num = (int)(c->samples_per_tick - c->sample);
+            num = _pocketmod_min(num + !num, samples_remaining);
+
+            /* Render and mix 'num' samples from each channel */
+            _pocketmod_zero(output, num * POCKETMOD_SAMPLE_SIZE);
+            for (i = 0; i < c->num_channels; i++) {
+                _pocketmod_chan *chan = &c->channels[i];
+                if (chan->sample != 0 && chan->position >= 0.0f) {
+                    _pocketmod_render_channel(c, chan, *output, num);
+                }
+            }
+            samples_remaining -= num;
+            samples_rendered += num;
+            output += num;
+
+            /* Advance song position by 'num' samples */
+            if ((c->sample += num) >= c->samples_per_tick) {
+                c->sample -= c->samples_per_tick;
+                _pocketmod_next_tick(c);
+
+                /* Stop if a new pattern was reached */
+                if (c->line == 0 && c->tick == 0) {
+                    /* Increment loop counter as needed */
+                    if (c->visited[c->pattern >> 3] & (1 << (c->pattern & 7))) {
+                        _pocketmod_zero(c->visited, sizeof(c->visited));
+                        c->loop_count++;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    return samples_rendered * POCKETMOD_SAMPLE_SIZE;
+}
+
+int pocketmod_loop_count(pocketmod_context *c) { return c->loop_count; }
+
+#endif /* #ifdef POCKETMOD_IMPLEMENTATION */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* #ifndef POCKETMOD_H_INCLUDED */
+
+/*******************************************************************************
+
+MIT License
+
+Copyright (c) 2018 rombankzero
+
+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.
+
+*******************************************************************************/

components/audio_mp3/CMakeLists.txt

+idf_component_register(
+    SRCS
+        audio_mp3.c
+    INCLUDE_DIRS
+        .
+        ../ctx
+        ../st3m
+)

components/audio_mp3/LICENSE

+CC0 1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific
+works ("Commons") that the public can reliably and without fear of later
+claims of infringement build upon, modify, incorporate in other works, reuse
+and redistribute as freely as possible in any form whatsoever and for any
+purposes, including without limitation commercial purposes. These owners may
+contribute to the Commons to promote the ideal of a free culture and the
+further production of creative, cultural and scientific works, or to gain
+reputation or greater distribution for their Work in part through the use and
+efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation
+of additional consideration or compensation, the person associating CC0 with a
+Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
+and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
+and publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not limited
+to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display, communicate,
+  and translate a Work;
+
+  ii. moral rights retained by the original author(s) and/or performer(s);
+
+  iii. publicity and privacy rights pertaining to a person's image or likeness
+  depicted in a Work;
+
+  iv. rights protecting against unfair competition in regards to a Work,
+  subject to the limitations in paragraph 4(a), below;
+
+  v. rights protecting the extraction, dissemination, use and reuse of data in
+  a Work;
+
+  vi. database rights (such as those arising under Directive 96/9/EC of the
+  European Parliament and of the Council of 11 March 1996 on the legal
+  protection of databases, and under any national implementation thereof,
+  including any amended or successor version of such directive); and
+
+  vii. other similar, equivalent or corresponding rights throughout the world
+  based on applicable law or treaty, and any national implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
+and Related Rights and associated claims and causes of action, whether now
+known or unknown (including existing as well as future claims and causes of
+action), in the Work (i) in all territories worldwide, (ii) for the maximum
+duration provided by applicable law or treaty (including future time
+extensions), (iii) in any current or future medium and for any number of
+copies, and (iv) for any purpose whatsoever, including without limitation
+commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
+the Waiver for the benefit of each member of the public at large and to the
+detriment of Affirmer's heirs and successors, fully intending that such Waiver
+shall not be subject to revocation, rescission, cancellation, termination, or
+any other legal or equitable action to disrupt the quiet enjoyment of the Work
+by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+judged legally invalid or ineffective under applicable law, then the Waiver
+shall be preserved to the maximum extent permitted taking into account
+Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
+is so judged Affirmer hereby grants to each affected person a royalty-free,
+non transferable, non sublicensable, non exclusive, irrevocable and
+unconditional license to exercise Affirmer's Copyright and Related Rights in
+the Work (i) in all territories worldwide, (ii) for the maximum duration
+provided by applicable law or treaty (including future time extensions), (iii)
+in any current or future medium and for any number of copies, and (iv) for any
+purpose whatsoever, including without limitation commercial, advertising or
+promotional purposes (the "License"). The License shall be deemed effective as
+of the date CC0 was applied by Affirmer to the Work. Should any part of the
+License for any reason be judged legally invalid or ineffective under
+applicable law, such partial invalidity or ineffectiveness shall not
+invalidate the remainder of the License, and in such case Affirmer hereby
+affirms that he or she will not (i) exercise any of his or her remaining
+Copyright and Related Rights in the Work or (ii) assert any associated claims
+and causes of action with respect to the Work, in either case contrary to
+Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+  a. No trademark or patent rights held by Affirmer are waived, abandoned,
+  surrendered, licensed or otherwise affected by this document.
+
+  b. Affirmer offers the Work as-is and makes no representations or warranties
+  of any kind concerning the Work, express, implied, statutory or otherwise,
+  including without limitation warranties of title, merchantability, fitness
+  for a particular purpose, non infringement, or the absence of latent or
+  other defects, accuracy, or the present or absence of errors, whether or not
+  discoverable, all to the greatest extent permissible under applicable law.
+
+  c. Affirmer disclaims responsibility for clearing rights of other persons
+  that may apply to the Work or any use thereof, including without limitation
+  any person's Copyright and Related Rights in the Work. Further, Affirmer
+  disclaims responsibility for obtaining any necessary consents, permissions
+  or other rights required for any use of the Work.
+
+  d. Affirmer understands and acknowledges that Creative Commons is not a
+  party to this document and has no duty or obligation with respect to this
+  CC0 or use of the Work.
+
+For more information, please see
+<http://creativecommons.org/publicdomain/zero/1.0/>
+

components/audio_mp3/audio_mp3.c

+#ifndef __clang__
+#pragma GCC optimize("O2")
+#endif
+
+#include <fcntl.h>
+#include <st3m_audio.h>
+#include <st3m_media.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "lwip/igmp.h"
+#include "lwip/ip4.h"
+#include "lwip/netdb.h"
+#include "lwip/sockets.h"
+
+#include "ctx.h"
+
+#define MINIMP3_NONSTANDARD_BUT_LOGICAL
+#define MINIMP3_NO_SIMD
+#define MINIMP3_IMPLEMENTATION
+#include "minimp3.h"
+
+typedef struct {
+    st3m_media control;
+    mp3dec_t mp3d;
+    char *path;
+    char *artist;
+    char *title;
+    int year;
+    int started;
+    int samplerate;
+    int channels;
+    uint8_t *data;
+    size_t size;
+    size_t count;
+
+    int pos;
+    int offset;
+    int buffer_size;
+
+    int file_size;
+    FILE *file;
+
+    int socket;
+
+    int in_buffering;
+    float scroll_pos;
+} mp3_state;
+
+static int has_data(mp3_state *mp3) {
+    if (mp3->file) return 1;
+    fd_set rfds;
+    struct timeval tv = { 0, 0 };
+    FD_ZERO(&rfds);
+    FD_SET(mp3->socket, &rfds);
+    if (select(mp3->socket + 1, &rfds, NULL, NULL, &tv) == 1)
+        return FD_ISSET(mp3->socket, &rfds);
+    return 0;
+}
+
+static void mp3_fetch_data(mp3_state *mp3) {
+    if (mp3->pos) {
+        memmove(mp3->data, &mp3->data[mp3->pos], mp3->count - mp3->pos);
+        mp3->offset += mp3->pos;
+        mp3->count -= mp3->pos;
+        mp3->pos = 0;
+    }
+
+    // if incoming data-buffer falls below 16kb - do a full buffer fill
+    if (!mp3->file && (mp3->count < 16 * 1024)) {
+        mp3->in_buffering = 1;
+    }
+
+    if ((mp3->size - mp3->count > 0) && has_data(mp3)) {
+        int desire_bytes = (mp3->size - mp3->count);
+        if (desire_bytes > 2048) desire_bytes = 2048;
+        if (desire_bytes) {
+            int read_bytes;
+            if (mp3->file)
+                read_bytes =
+                    fread(mp3->data + mp3->count, 1, desire_bytes, mp3->file);
+            else
+                read_bytes =
+                    read(mp3->socket, mp3->data + mp3->count, desire_bytes);
+            mp3->count += read_bytes;
+        }
+    }
+}
+
+static char *mp3_get_string(st3m_media *media, const char *key) {
+    mp3_state *self = (void *)media;
+    if (strcmp(key, "artist") == 0) {
+        return strdup(self->artist);
+    } else if (strcmp(key, "title") == 0) {
+        return strdup(self->title);
+    }
+    return NULL;
+}
+
+static void mp3_draw(st3m_media *media, Ctx *ctx) {
+    mp3_state *self = (void *)media;
+
+    ctx_rectangle(ctx, -120, -120, 240, 240);
+    ctx_gray(ctx, 0);
+    ctx_fill(ctx);
+    ctx_rgb(ctx, 1.0, 1.0, 1.0);
+    ctx_rectangle(ctx, -120, 0, 240, 1);
+    ctx_rectangle(ctx, -120 + self->offset * 240.0 / self->file_size, -32, 2,
+                  64);
+    ctx_fill(ctx);
+    ctx_font_size(ctx, 24);
+    ctx_text_align(ctx, CTX_TEXT_ALIGN_CENTER);
+
+    int xpos = 0;
+    int str_width = ctx_text_width(ctx, self->artist);
+    if (str_width > 200) {
+        xpos = ctx_sinf(self->scroll_pos) * (str_width - 200) / 2;
+    }
+    ctx_move_to(ctx, xpos, -40);
+    ctx_text(ctx, self->artist);
+
+    str_width = ctx_text_width(ctx, self->title);
+    xpos = 0;
+    if (str_width > 200) {
+        xpos = ctx_sinf(self->scroll_pos) * (str_width - 200) / 2;
+    }
+    ctx_move_to(ctx, xpos, 64);
+    ctx_text(ctx, self->title);
+
+    ctx_font_size(ctx, 14);
+    str_width = ctx_text_width(ctx, self->path);
+    xpos = 0;
+    if (str_width > 220) {
+        xpos = ctx_sinf(self->scroll_pos) * (str_width - 220) / 2;
+    }
+    ctx_move_to(ctx, xpos, 14);
+    ctx_gray(ctx, 0.6);
+    ctx_text(ctx, self->path);
+
+    if (!self->file) {
+        ctx_rectangle(ctx, -100, 65, self->count * 200.0 / self->size, 55);
+        if (self->in_buffering)
+            ctx_rgba(ctx, 0.8, 0.2, 0.0, 1.0);
+        else
+            ctx_gray(ctx, 0.2);
+        ctx_fill(ctx);
+    }
+}
+
+static void mp3_think(st3m_media *media, float ms_elapsed) {
+    mp3_state *self = (void *)media;
+
+    if (self->file && self->control.seek >= 0) {
+        if (self->control.seek > 1.0) {
+            self->control.seek = 1.0;
+        }
+        float seek = self->control.seek * self->control.duration;
+        fseek(self->file, seek, SEEK_SET);
+        self->offset = seek;
+        self->pos = 0;
+        self->count = 0;
+        self->control.time = 0;
+        self->control.position = self->offset;
+        self->control.seek = -1;
+        mp3dec_init(&self->mp3d);
+    }
+
+    mp3_fetch_data(self);
+
+    self->scroll_pos += ms_elapsed / 1000.0;
+
+    if (self->in_buffering) {
+        if (self->size - self->count > 0) return;
+        self->in_buffering = 0;
+    }
+
+    if (self->control.paused) return;
+
+    if (self->file) {
+        self->control.position = self->offset;
+        if (self->offset + 512 >= self->file_size)
+            self->control.position = self->file_size;
+    }
+
+    if (!self->started) {
+        self->started = 1;
+        mp3_think(media, 100);
+    }
+    int samples_needed = (((st3m_pcm_queue_length() - st3m_pcm_queued()) / 2)) /
+                         48000.0 * self->samplerate;
+
+    int samples;
+    mp3dec_frame_info_t info = {
+        0,
+    };
+    if (samples_needed > 0 &&
+        ((self->offset + 512 < self->file_size) || (!self->file))) {
+        do {
+            int16_t rendered[MINIMP3_MAX_SAMPLES_PER_FRAME];
+            samples =
+                mp3dec_decode_frame(&self->mp3d, self->data + self->pos,
+                                    self->count - self->pos, rendered, &info);
+            self->pos += info.frame_bytes;
+            if (samples) {
+                self->samplerate = info.hz;
+                self->channels = info.channels;
+                self->control.time += samples / (float)self->samplerate;
+                st3m_pcm_queue_s16(self->samplerate, self->channels, samples,
+                                   rendered);
+            } else if (info.frame_bytes) {
+                mp3_fetch_data(self);
+            } else {
+                break;
+            }
+            samples_needed -= (samples);
+        } while (samples_needed > 0);
+    }
+}
+
+static void mp3_destroy(st3m_media *media) {
+    mp3_state *self = (void *)media;
+    if (self->data) free(self->data);
+    if (self->file) fclose(self->file);
+    if (self->socket) {
+        shutdown(self->socket, SHUT_RDWR);
+        close(self->socket);
+    }
+    if (self->path) free(self->path);
+    if (self->title) free(self->title);
+    if (self->artist) free(self->artist);
+    free(self);
+}
+
+typedef struct {
+    char tag[3];
+    char title[30];
+    char artist[30];
+    char album[30];
+    char year[4];
+    char comment[30];
+    char genre[1];
+    char pad[128];
+} id3tag_t;
+
+st3m_media *st3m_media_load_mp3(const char *path) {
+    mp3_state *self = (mp3_state *)malloc(sizeof(mp3_state));
+    if (!self) return NULL;
+    memset(self, 0, sizeof(mp3_state));
+    self->control.draw = mp3_draw;
+    self->control.think = mp3_think;
+    self->control.destroy = mp3_destroy;
+    self->control.get_string = mp3_get_string;
+    self->control.has_audio = true;
+    self->samplerate = 44100;
+    self->buffer_size = 32 * 1024;
+    self->scroll_pos = 0;
+
+    if (!strncmp(path, "http://", 7)) {
+        int port = 80;
+        char *hostname = strdup(path + 7);
+        char *rest = NULL;
+        self->buffer_size = 96 * 1024;
+        rest = strchr(hostname, '/') + 1;
+        strchr(hostname, '/')[0] = 0;
+        if (strchr(hostname, ':')) {
+            port = atoi(strchr(hostname, ':') + 1);
+            strchr(hostname, ':')[0] = 0;
+        }
+
+        struct hostent *host;
+        struct sockaddr_in addr;
+        self->socket = socket(PF_INET, SOCK_STREAM, 0);
+        if (self->socket < 0) {
+            free(hostname);
+            mp3_destroy((st3m_media *)self);
+            return NULL;
+        }
+        int flag = 1;
+        setsockopt(self->socket, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int));
+        memset(&addr, 0, sizeof(addr));
+        addr.sin_family = AF_INET;
+        addr.sin_port = htons(port);
+        host = gethostbyname(hostname);
+        if (!host) {
+            mp3_destroy((st3m_media *)self);
+            free(hostname);
+            return NULL;
+        }
+        addr.sin_addr.s_addr = ((long unsigned int **)host->h_addr_list)[0][0];
+
+        if (connect(self->socket, (struct sockaddr *)&addr, sizeof(addr)) ==
+            0) {
+            char s[1024];
+            sprintf(s, "GET /%s HTTP/1.1\r\n", rest);
+            write(self->socket, s, strlen(s));
+            sprintf(s, "Range: bytes=0-\r\n");
+            write(self->socket, s, strlen(s));
+            if (hostname) {
+                sprintf(s, "Host: %s\r\n", hostname);
+                write(self->socket, s, strlen(s));
+            }
+            sprintf(s, "User-Agent: flow3r\r\n");
+            write(self->socket, s, strlen(s));
+            sprintf(s, "\r\n");
+            write(self->socket, s, strlen(s));
+            fsync(self->socket);
+
+            self->data = malloc(self->buffer_size);
+            self->size = self->buffer_size;
+
+            mp3dec_init(&self->mp3d);
+            self->control.duration = -1;
+            free(hostname);
+
+            if (!self->data) {
+                mp3_destroy((st3m_media *)self);
+                return NULL;
+            }
+
+            self->in_buffering = 1;
+            self->path = strdup(path);
+            return (st3m_media *)self;
+        }
+        free(hostname);
+
+        mp3_destroy((st3m_media *)self);
+        return NULL;
+    }
+    st3m_media_tags_t *tags = st3m_media_get_tags(path);
+    if (tags) {
+        if (tags->title) self->title = strdup(tags->title);
+        if (tags->artist) self->artist = strdup(tags->artist);
+        self->year = tags->year;
+        st3m_media_free_tags(tags);
+    }
+
+    self->file = fopen(path, "r");
+    if (!self->file) {
+        mp3_destroy((st3m_media *)self);
+        return NULL;
+    }
+    fseek(self->file, 0, SEEK_END);
+    self->file_size = ftell(self->file);
+
+    self->data = malloc(self->buffer_size);
+    if (!self->data) {
+        mp3_destroy((st3m_media *)self);
+        return NULL;
+    }
+    self->size = self->buffer_size;
+    mp3dec_init(&self->mp3d);
+    self->control.duration = self->file_size;
+
+    self->path = strdup(path);
+    if (!self->path) {
+        mp3_destroy((st3m_media *)self);
+        return NULL;
+    }
+
+    rewind(self->file);
+
+    return (st3m_media *)self;
+}
+
+static uint32_t id3v2_decode_size(char *start, bool syncsafe) {
+    uint32_t ret = 0;
+    if (syncsafe) {
+        for (int j = 0; j < 4; j++) {
+            ret += (start[3 - j] & 0b1111111) << (7 * j);
+        }
+    } else {
+        for (int j = 0; j < 4; j++) {
+            ret += start[3 - j] << (8 * j);
+        }
+    }
+    return ret;
+}
+
+static char *strndup_textframe(char *content, int len) {
+    char *ret;
+    if (content[0] == 1) {  // corrupt bytes should be assumed to be 0
+        // utf-16:
+        int string_start = 1;
+        bool byte_flip = false;
+        if (content[1] == ((char)0xFF) && content[2] == ((char)0xFE)) {
+            string_start += 2;
+        } else if (content[1] == ((char)0xFE) && content[2] == ((char)0xFF)) {
+            string_start += 2;
+            byte_flip = true;
+        }
+        int ascii_len =
+            (len - string_start) /
+            2;  // one extra byte is in there already, preventing round-downs
+        ret = malloc(ascii_len + 1);
+        if (!ret) return NULL;
+        ret[ascii_len] = 0;
+        for (int i = 0; i < ascii_len; i++) {
+            if (content[string_start + 2 * i + 1 - byte_flip]) {
+                ret[i] = '?';
+            } else {
+                ret[i] = content[string_start + 2 * i + byte_flip];
+            }
+        }
+    } else {
+        // iso-8859-1
+        ret = strndup(&content[1], len - 1);
+    }
+    int ret_len = strlen(ret);
+    // filter out high bit special chars
+    for (int i = 0; i < ret_len; i++) {
+        if (ret[i] & 0x80) ret[i] = '?';
+    }
+    return ret;
+}
+
+enum supported_tags { NONE, TITLE, ARTIST, ALBUM, TRACK_NUMBER, YEAR };
+
+st3m_media_tags_t *audio_mp3_get_tags(const char *path) {
+    // returns a new media_tags_t object with tag information
+    // retrieved from file at path (or NULL). freeing is up to the user.
+    FILE *file = fopen(path, "r");
+    if (!file) return NULL;
+    fseek(file, 0, SEEK_END);
+    int file_size = ftell(file);
+
+    st3m_media_tags_t *tags = calloc(1, sizeof(st3m_media_tags_t));
+    if (!tags) return NULL;
+
+    // ID3v1/ID3v1.1
+    fseek(file, file_size - 128, SEEK_SET);
+    id3tag_t id3;
+    fread(&id3, 128, 1, file);
+    if (id3.tag[0] == 'T' && id3.tag[1] == 'A' && id3.tag[2] == 'G') {
+        tags->title = strndup(id3.title, 30);
+        while (tags->title[strlen(tags->title) - 1] == ' ')
+            tags->title[strlen(tags->title) - 1] = 0;
+
+        tags->artist = strndup(id3.artist, 30);
+        while (tags->artist[strlen(tags->artist) - 1] == ' ')
+            tags->artist[strlen(tags->artist) - 1] = 0;
+
+        tags->album = strndup(id3.album, 30);
+        while (tags->album[strlen(tags->album) - 1] == ' ')
+            tags->album[strlen(tags->album) - 1] = 0;
+
+        tags->year = atoi(id3.year);
+
+        if (!id3.comment[28]) {
+            tags->track_number = id3.comment[29];
+        }
+        fclose(file);
+        return tags;
+    }
+
+    // ID3v2
+    fseek(file, 0, SEEK_SET);
+    char buf[10];
+    fread(buf, 10, 1, file);
+    if (buf[0] == 'I' && buf[1] == 'D' && buf[2] == '3') {
+        uint32_t frame_pos = 10;
+        uint8_t version = buf[3];
+        if (version < 2 || version > 4) {
+            fclose(file);
+            free(tags);
+            return NULL;
+        }
+        uint32_t tag_size = 10 + id3v2_decode_size(&buf[6], version >= 3);
+        if (buf[4] & 0b100000) {  // extended header
+            fread(buf, 10, 1, file);
+            frame_pos += id3v2_decode_size(&buf[0], version >= 3);
+        }
+        while (frame_pos < tag_size) {
+            uint32_t frame_size = 0;
+            fseek(file, frame_pos, SEEK_SET);
+            if (version > 2) {
+                fread(buf, 10, 1, file);
+                frame_size = id3v2_decode_size(&buf[4], version >= 4);
+                frame_pos += 10;
+            } else {
+                fread(buf, 6, 1, file);
+                frame_size = id3v2_decode_size(&buf[3], false);
+                frame_size >>= 8;
+                frame_pos += 6;
+            }
+#if 0
+            printf("\nframe pos: %lu, frame size: %lu, tag size: %lu\n", frame_pos, frame_size, tag_size);
+            char tag[5];
+            memcpy(tag, buf, 4);
+            tag[4] = 0;
+            printf("tag: %s\n", tag);
+#endif
+
+            if (frame_pos + frame_size > tag_size) break;
+
+            enum supported_tags frame_tag = NONE;
+            if (version > 2) {
+                if (strncmp(buf, "TIT2", 4) == 0) {
+                    frame_tag = TITLE;
+                } else if (strncmp(buf, "TPE1", 4) == 0) {
+                    frame_tag = ARTIST;
+                } else if (strncmp(buf, "TRCK", 4) == 0) {
+                    frame_tag = TRACK_NUMBER;
+                } else if (strncmp(buf, "TYER", 4) == 0) {
+                    frame_tag = YEAR;
+                } else if (strncmp(buf, "TALB", 4) == 0) {
+                    frame_tag = ALBUM;
+                }
+            } else {
+                if (strncmp(buf, "TT2", 3) == 0) {
+                    frame_tag = TITLE;
+                } else if (strncmp(buf, "TP1", 3) == 0) {
+                    frame_tag = ARTIST;
+                } else if (strncmp(buf, "TRK", 3) == 0) {
+                    frame_tag = TRACK_NUMBER;
+                } else if (strncmp(buf, "TYE", 3) == 0) {
+                    frame_tag = YEAR;
+                } else if (strncmp(buf, "TAL", 3) == 0) {
+                    frame_tag = ALBUM;
+                }
+            }
+            if (frame_tag == NONE) continue;
+
+            char *fbuf = malloc(
+                frame_size);  // putting it on heap bc task stack may overflow
+            if (!fbuf)
+                continue;  // earlier, don't wanna worried about limits here
+            if (fread(fbuf, 1, frame_size, file) != frame_size) {
+                free(fbuf);
+                break;
+            }
+
+            switch (frame_tag) {
+                case TITLE:
+                    tags->title = strndup_textframe(fbuf, frame_size);
+                    break;
+                case ARTIST:
+                    tags->artist = strndup_textframe(fbuf, frame_size);
+                    break;
+                case TRACK_NUMBER:;
+                    char *slashpos = strchr(fbuf, '/');
+                    if (slashpos) *slashpos = 0;
+                    tags->track_number = atoi(fbuf);
+                    break;
+                case YEAR:
+                    tags->year = atoi(fbuf);
+                    break;
+                case ALBUM:
+                    tags->album = strndup_textframe(fbuf, frame_size);
+                    break;
+                default:
+                    break;  // should never be reached, just to make compiler
+                            // happy
+            }
+            free(fbuf);
+            if (tags->title && tags->artist && tags->track_number &&
+                tags->year && tags->album)
+                break;
+            frame_pos += frame_size;
+        }
+        fclose(file);
+        return tags;
+    }
+
+    free(tags);
+    fclose(file);
+    return NULL;
+}

components/audio_mp3/minimp3.h

+#ifndef MINIMP3_H
+#define MINIMP3_H
+/*
+    https://github.com/lieff/minimp3
+    To the extent possible under law, the author(s) have dedicated all copyright
+   and related and neighboring rights to this software to the public domain
+   worldwide. This software is distributed without any warranty. See
+   <http://creativecommons.org/publicdomain/zero/1.0/>.
+*/
+#include <stdint.h>
+
+#define MINIMP3_MAX_SAMPLES_PER_FRAME (1152 * 2)
+
+typedef struct {
+    int frame_bytes, frame_offset, channels, hz, layer, bitrate_kbps;
+} mp3dec_frame_info_t;
+
+typedef struct _mp3dec_scratch_t mp3dec_scratch_t;
+
+typedef struct {
+    const uint8_t *buf;
+    int pos, limit;
+} bs_t;
+
+typedef struct {
+    const uint8_t *sfbtab;
+    uint16_t part_23_length, big_values, scalefac_compress;
+    uint8_t global_gain, block_type, mixed_block_flag, n_long_sfb, n_short_sfb;
+    uint8_t table_select[3], region_count[3], subblock_gain[3];
+    uint8_t preflag, scalefac_scale, count1_table, scfsi;
+} L3_gr_info_t;
+
+typedef struct {
+    float scf[3 * 64];
+    uint8_t total_bands, stereo_bands, bitalloc[64], scfcod[64];
+} L12_scale_info;
+
+#define MAX_BITRESERVOIR_BYTES 511
+#define MAX_FREE_FORMAT_FRAME_SIZE 2304 /* more than ISO spec's */
+#define MAX_L3_FRAME_PAYLOAD_BYTES \
+    MAX_FREE_FORMAT_FRAME_SIZE /* MUST be >= 320000/8/32000*1152 = 1440 */
+
+struct _mp3dec_scratch_t {
+    bs_t bs;
+    uint8_t maindata[MAX_BITRESERVOIR_BYTES + MAX_L3_FRAME_PAYLOAD_BYTES];
+    L3_gr_info_t gr_info[4];
+    float grbuf[2][576], scf[45], syn[18 + 15][2 * 32];
+    uint8_t ist_pos[2][39];
+};
+
+typedef struct {
+    float mdct_overlap[2][9 * 32], qmf_state[15 * 2 * 32];
+    int reserv, free_format_bytes;
+    unsigned char header[4], reserv_buf[511];
+    mp3dec_scratch_t scratch;
+    L12_scale_info sci;
+} mp3dec_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+void mp3dec_init(mp3dec_t *dec);
+#ifndef MINIMP3_FLOAT_OUTPUT
+typedef int16_t mp3d_sample_t;
+#else  /* MINIMP3_FLOAT_OUTPUT */
+typedef float mp3d_sample_t;
+void mp3dec_f32_to_s16(const float *in, int16_t *out, int num_samples);
+#endif /* MINIMP3_FLOAT_OUTPUT */
+int mp3dec_decode_frame(mp3dec_t *dec, const uint8_t *mp3, int mp3_bytes,
+                        mp3d_sample_t *pcm, mp3dec_frame_info_t *info);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* MINIMP3_H */
+#if defined(MINIMP3_IMPLEMENTATION) && !defined(_MINIMP3_IMPLEMENTATION_GUARD)
+#define _MINIMP3_IMPLEMENTATION_GUARD
+
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef MAX_FRAME_SYNC_MATCHES
+#define MAX_FRAME_SYNC_MATCHES 10
+#endif /* MAX_FRAME_SYNC_MATCHES */
+
+#define SHORT_BLOCK_TYPE 2
+#define STOP_BLOCK_TYPE 3
+#define MODE_MONO 3
+#define MODE_JOINT_STEREO 1
+#define HDR_SIZE 4
+#define HDR_IS_MONO(h) (((h[3]) & 0xC0) == 0xC0)
+#define HDR_IS_MS_STEREO(h) (((h[3]) & 0xE0) == 0x60)
+#define HDR_IS_FREE_FORMAT(h) (((h[2]) & 0xF0) == 0)
+#define HDR_IS_CRC(h) (!((h[1]) & 1))
+#define HDR_TEST_PADDING(h) ((h[2]) & 0x2)
+#define HDR_TEST_MPEG1(h) ((h[1]) & 0x8)
+#define HDR_TEST_NOT_MPEG25(h) ((h[1]) & 0x10)
+#define HDR_TEST_I_STEREO(h) ((h[3]) & 0x10)
+#define HDR_TEST_MS_STEREO(h) ((h[3]) & 0x20)
+#define HDR_GET_STEREO_MODE(h) (((h[3]) >> 6) & 3)
+#define HDR_GET_STEREO_MODE_EXT(h) (((h[3]) >> 4) & 3)
+#define HDR_GET_LAYER(h) (((h[1]) >> 1) & 3)
+#define HDR_GET_BITRATE(h) ((h[2]) >> 4)
+#define HDR_GET_SAMPLE_RATE(h) (((h[2]) >> 2) & 3)
+#define HDR_GET_MY_SAMPLE_RATE(h) \
+    (HDR_GET_SAMPLE_RATE(h) + (((h[1] >> 3) & 1) + ((h[1] >> 4) & 1)) * 3)
+#define HDR_IS_FRAME_576(h) ((h[1] & 14) == 2)
+#define HDR_IS_LAYER_1(h) ((h[1] & 6) == 6)
+
+#define BITS_DEQUANTIZER_OUT -1
+#define MAX_SCF (255 + BITS_DEQUANTIZER_OUT * 4 - 210)
+#define MAX_SCFI ((MAX_SCF + 3) & ~3)
+
+#define MINIMP3_MIN(a, b) ((a) > (b) ? (b) : (a))
+#define MINIMP3_MAX(a, b) ((a) < (b) ? (b) : (a))
+
+#if !defined(MINIMP3_NO_SIMD)
+
+#if !defined(MINIMP3_ONLY_SIMD) && (defined(_M_X64) || defined(__x86_64__) || \
+                                    defined(__aarch64__) || defined(_M_ARM64))
+/* x64 always have SSE2, arm64 always have neon, no need for generic code */
+#define MINIMP3_ONLY_SIMD
+#endif /* SIMD checks... */
+
+#if (defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))) || \
+    ((defined(__i386__) || defined(__x86_64__)) && defined(__SSE2__))
+#if defined(_MSC_VER)
+#include <intrin.h>
+#endif /* defined(_MSC_VER) */
+#include <immintrin.h>
+#define HAVE_SSE 1
+#define HAVE_SIMD 1
+#define VSTORE _mm_storeu_ps
+#define VLD _mm_loadu_ps
+#define VSET _mm_set1_ps
+#define VADD _mm_add_ps
+#define VSUB _mm_sub_ps
+#define VMUL _mm_mul_ps
+#define VMAC(a, x, y) _mm_add_ps(a, _mm_mul_ps(x, y))
+#define VMSB(a, x, y) _mm_sub_ps(a, _mm_mul_ps(x, y))
+#define VMUL_S(x, s) _mm_mul_ps(x, _mm_set1_ps(s))
+#define VREV(x) _mm_shuffle_ps(x, x, _MM_SHUFFLE(0, 1, 2, 3))
+typedef __m128 f4;
+#if defined(_MSC_VER) || defined(MINIMP3_ONLY_SIMD)
+#define minimp3_cpuid __cpuid
+#else /* defined(_MSC_VER) || defined(MINIMP3_ONLY_SIMD) */
+static __inline__ __attribute__((always_inline)) void minimp3_cpuid(
+    int CPUInfo[], const int InfoType) {
+#if defined(__PIC__)
+    __asm__ __volatile__(
+#if defined(__x86_64__)
+        "push %%rbx\n"
+        "cpuid\n"
+        "xchgl %%ebx, %1\n"
+        "pop  %%rbx\n"
+#else  /* defined(__x86_64__) */
+        "xchgl %%ebx, %1\n"
+        "cpuid\n"
+        "xchgl %%ebx, %1\n"
+#endif /* defined(__x86_64__) */
+        : "=a"(CPUInfo[0]), "=r"(CPUInfo[1]), "=c"(CPUInfo[2]), "=d"(CPUInfo[3])
+        : "a"(InfoType));
+#else  /* defined(__PIC__) */
+    __asm__ __volatile__("cpuid"
+                         : "=a"(CPUInfo[0]), "=b"(CPUInfo[1]), "=c"(CPUInfo[2]),
+                           "=d"(CPUInfo[3])
+                         : "a"(InfoType));
+#endif /* defined(__PIC__)*/
+}
+#endif /* defined(_MSC_VER) || defined(MINIMP3_ONLY_SIMD) */
+static int have_simd(void) {
+#ifdef MINIMP3_ONLY_SIMD
+    return 1;
+#else /* MINIMP3_ONLY_SIMD */
+    static int g_have_simd;
+    int CPUInfo[4];
+#ifdef MINIMP3_TEST
+    static int g_counter;
+    if (g_counter++ > 100) return 0;
+#endif /* MINIMP3_TEST */
+    if (g_have_simd) goto end;
+    minimp3_cpuid(CPUInfo, 0);
+    g_have_simd = 1;
+    if (CPUInfo[0] > 0) {
+        minimp3_cpuid(CPUInfo, 1);
+        g_have_simd = (CPUInfo[3] & (1 << 26)) + 1; /* SSE2 */
+    }
+end:
+    return g_have_simd - 1;
+#endif /* MINIMP3_ONLY_SIMD */
+}
+#elif defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64)
+#include <arm_neon.h>
+#define HAVE_SSE 0
+#define HAVE_SIMD 1
+#define VSTORE vst1q_f32
+#define VLD vld1q_f32
+#define VSET vmovq_n_f32
+#define VADD vaddq_f32
+#define VSUB vsubq_f32
+#define VMUL vmulq_f32
+#define VMAC(a, x, y) vmlaq_f32(a, x, y)
+#define VMSB(a, x, y) vmlsq_f32(a, x, y)
+#define VMUL_S(x, s) vmulq_f32(x, vmovq_n_f32(s))
+#define VREV(x) \
+    vcombine_f32(vget_high_f32(vrev64q_f32(x)), vget_low_f32(vrev64q_f32(x)))
+typedef float32x4_t f4;
+static int have_simd() { /* TODO: detect neon for !MINIMP3_ONLY_SIMD */
+    return 1;
+}
+#else /* SIMD checks... */
+#define HAVE_SSE 0
+#define HAVE_SIMD 0
+#ifdef MINIMP3_ONLY_SIMD
+#error MINIMP3_ONLY_SIMD used, but SSE/NEON not enabled
+#endif /* MINIMP3_ONLY_SIMD */
+#endif /* SIMD checks... */
+#else  /* !defined(MINIMP3_NO_SIMD) */
+#define HAVE_SIMD 0
+#endif /* !defined(MINIMP3_NO_SIMD) */
+
+#if defined(__ARM_ARCH) && (__ARM_ARCH >= 6) && !defined(__aarch64__) && \
+    !defined(_M_ARM64)
+#define HAVE_ARMV6 1
+static __inline__ __attribute__((always_inline)) int32_t minimp3_clip_int16_arm(
+    int32_t a) {
+    int32_t x = 0;
+    __asm__("ssat %0, #16, %1" : "=r"(x) : "r"(a));
+    return x;
+}
+#else
+#define HAVE_ARMV6 0
+#endif
+
+typedef struct {
+    uint8_t tab_offset, code_tab_width, band_count;
+} L12_subband_alloc_t;
+
+static void bs_init(bs_t *bs, const uint8_t *data, int bytes) {
+    bs->buf = data;
+    bs->pos = 0;
+    bs->limit = bytes * 8;
+}
+
+static uint32_t get_bits(bs_t *bs, int n) {
+    uint32_t next, cache = 0, s = bs->pos & 7;
+    int shl = n + s;
+    const uint8_t *p = bs->buf + (bs->pos >> 3);
+    if ((bs->pos += n) > bs->limit) return 0;
+    next = *p++ & (255 >> s);
+    while ((shl -= 8) > 0) {
+        cache |= next << shl;
+        next = *p++;
+    }
+    return cache | (next >> -shl);
+}
+
+static int hdr_valid(const uint8_t *h) {
+    return h[0] == 0xff && ((h[1] & 0xF0) == 0xf0 || (h[1] & 0xFE) == 0xe2) &&
+           (HDR_GET_LAYER(h) != 0) && (HDR_GET_BITRATE(h) != 15) &&
+           (HDR_GET_SAMPLE_RATE(h) != 3);
+}
+
+static int hdr_compare(const uint8_t *h1, const uint8_t *h2) {
+    return hdr_valid(h2) && ((h1[1] ^ h2[1]) & 0xFE) == 0 &&
+           ((h1[2] ^ h2[2]) & 0x0C) == 0 &&
+           !(HDR_IS_FREE_FORMAT(h1) ^ HDR_IS_FREE_FORMAT(h2));
+}
+
+static unsigned hdr_bitrate_kbps(const uint8_t *h) {
+    static const uint8_t halfrate[2][3][15] = {
+        { { 0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 72, 80 },
+          { 0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 72, 80 },
+          { 0, 16, 24, 28, 32, 40, 48, 56, 64, 72, 80, 88, 96, 112, 128 } },
+        { { 0, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160 },
+          { 0, 16, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192 },
+          { 0, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208,
+            224 } },
+    };
+    return 2 * halfrate[!!HDR_TEST_MPEG1(h)][HDR_GET_LAYER(h) - 1]
+                       [HDR_GET_BITRATE(h)];
+}
+
+static unsigned hdr_sample_rate_hz(const uint8_t *h) {
+    static const unsigned g_hz[3] = { 44100, 48000, 32000 };
+    return g_hz[HDR_GET_SAMPLE_RATE(h)] >> (int)!HDR_TEST_MPEG1(h) >>
+           (int)!HDR_TEST_NOT_MPEG25(h);
+}
+
+static unsigned hdr_frame_samples(const uint8_t *h) {
+    return HDR_IS_LAYER_1(h) ? 384 : (1152 >> (int)HDR_IS_FRAME_576(h));
+}
+
+static int hdr_frame_bytes(const uint8_t *h, int free_format_size) {
+    int frame_bytes = hdr_frame_samples(h) * hdr_bitrate_kbps(h) * 125 /
+                      hdr_sample_rate_hz(h);
+    if (HDR_IS_LAYER_1(h)) {
+        frame_bytes &= ~3; /* slot align */
+    }
+    return frame_bytes ? frame_bytes : free_format_size;
+}
+
+static int hdr_padding(const uint8_t *h) {
+    return HDR_TEST_PADDING(h) ? (HDR_IS_LAYER_1(h) ? 4 : 1) : 0;
+}
+
+#ifndef MINIMP3_ONLY_MP3
+static const L12_subband_alloc_t *L12_subband_alloc_table(const uint8_t *hdr,
+                                                          L12_scale_info *sci) {
+    const L12_subband_alloc_t *alloc;
+    int mode = HDR_GET_STEREO_MODE(hdr);
+    int nbands, stereo_bands = (mode == MODE_MONO) ? 0
+                               : (mode == MODE_JOINT_STEREO)
+                                   ? (HDR_GET_STEREO_MODE_EXT(hdr) << 2) + 4
+                                   : 32;
+
+    if (HDR_IS_LAYER_1(hdr)) {
+        static const L12_subband_alloc_t g_alloc_L1[] = { { 76, 4, 32 } };
+        alloc = g_alloc_L1;
+        nbands = 32;
+    } else if (!HDR_TEST_MPEG1(hdr)) {
+        static const L12_subband_alloc_t g_alloc_L2M2[] = { { 60, 4, 4 },
+                                                            { 44, 3, 7 },
+                                                            { 44, 2, 19 } };
+        alloc = g_alloc_L2M2;
+        nbands = 30;
+    } else {
+        static const L12_subband_alloc_t g_alloc_L2M1[] = {
+            { 0, 4, 3 }, { 16, 4, 8 }, { 32, 3, 12 }, { 40, 2, 7 }
+        };
+        int sample_rate_idx = HDR_GET_SAMPLE_RATE(hdr);
+        unsigned kbps = hdr_bitrate_kbps(hdr) >> (int)(mode != MODE_MONO);
+        if (!kbps) /* free-format */
+        {
+            kbps = 192;
+        }
+
+        alloc = g_alloc_L2M1;
+        nbands = 27;
+        if (kbps < 56) {
+            static const L12_subband_alloc_t g_alloc_L2M1_lowrate[] = {
+                { 44, 4, 2 }, { 44, 3, 10 }
+            };
+            alloc = g_alloc_L2M1_lowrate;
+            nbands = sample_rate_idx == 2 ? 12 : 8;
+        } else if (kbps >= 96 && sample_rate_idx != 1) {
+            nbands = 30;
+        }
+    }
+
+    sci->total_bands = (uint8_t)nbands;
+    sci->stereo_bands = (uint8_t)MINIMP3_MIN(stereo_bands, nbands);
+
+    return alloc;
+}
+
+static void L12_read_scalefactors(bs_t *bs, uint8_t *pba, uint8_t *scfcod,
+                                  int bands, float *scf) {
+    static const float g_deq_L12[18 * 3] = {
+#define DQ(x) 9.53674316e-07f / x, 7.56931807e-07f / x, 6.00777173e-07f / x
+        DQ(3),     DQ(7),     DQ(15),    DQ(31),   DQ(63),   DQ(127),
+        DQ(255),   DQ(511),   DQ(1023),  DQ(2047), DQ(4095), DQ(8191),
+        DQ(16383), DQ(32767), DQ(65535), DQ(3),    DQ(5),    DQ(9)
+    };
+    int i, m;
+    for (i = 0; i < bands; i++) {
+        float s = 0;
+        int ba = *pba++;
+        int mask = ba ? 4 + ((19 >> scfcod[i]) & 3) : 0;
+        for (m = 4; m; m >>= 1) {
+            if (mask & m) {
+                int b = get_bits(bs, 6);
+                s = g_deq_L12[ba * 3 - 6 + b % 3] * (1 << 21 >> b / 3);
+            }
+            *scf++ = s;
+        }
+    }
+}
+
+static void L12_read_scale_info(const uint8_t *hdr, bs_t *bs,
+                                L12_scale_info *sci) {
+    static const uint8_t g_bitalloc_code_tab[] = {
+        0,  17, 3,  4, 5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
+        0,  17, 18, 3, 19, 4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 16,
+        0,  17, 18, 3, 19, 4,  5,  16, 0,  17, 18, 16, 0,  17, 18, 19,
+        4,  5,  6,  7, 8,  9,  10, 11, 12, 13, 14, 15, 0,  17, 18, 3,
+        19, 4,  5,  6, 7,  8,  9,  10, 11, 12, 13, 14, 0,  2,  3,  4,
+        5,  6,  7,  8, 9,  10, 11, 12, 13, 14, 15, 16
+    };
+    const L12_subband_alloc_t *subband_alloc =
+        L12_subband_alloc_table(hdr, sci);
+
+    int i, k = 0, ba_bits = 0;
+    const uint8_t *ba_code_tab = g_bitalloc_code_tab;
+
+    for (i = 0; i < sci->total_bands; i++) {
+        uint8_t ba;
+        if (i == k) {
+            k += subband_alloc->band_count;
+            ba_bits = subband_alloc->code_tab_width;
+            ba_code_tab = g_bitalloc_code_tab + subband_alloc->tab_offset;
+            subband_alloc++;
+        }
+        ba = ba_code_tab[get_bits(bs, ba_bits)];
+        sci->bitalloc[2 * i] = ba;
+        if (i < sci->stereo_bands) {
+            ba = ba_code_tab[get_bits(bs, ba_bits)];
+        }
+        sci->bitalloc[2 * i + 1] = sci->stereo_bands ? ba : 0;
+    }
+
+    for (i = 0; i < 2 * sci->total_bands; i++) {
+        sci->scfcod[i] =
+            sci->bitalloc[i] ? HDR_IS_LAYER_1(hdr) ? 2 : get_bits(bs, 2) : 6;
+    }
+
+    L12_read_scalefactors(bs, sci->bitalloc, sci->scfcod, sci->total_bands * 2,
+                          sci->scf);
+
+    for (i = sci->stereo_bands; i < sci->total_bands; i++) {
+        sci->bitalloc[2 * i + 1] = 0;
+    }
+}
+
+static int L12_dequantize_granule(float *grbuf, bs_t *bs, L12_scale_info *sci,
+                                  int group_size) {
+    int i, j, k, choff = 576;
+    for (j = 0; j < 4; j++) {
+        float *dst = grbuf + group_size * j;
+        for (i = 0; i < 2 * sci->total_bands; i++) {
+            int ba = sci->bitalloc[i];
+            if (ba != 0) {
+                if (ba < 17) {
+                    int half = (1 << (ba - 1)) - 1;
+                    for (k = 0; k < group_size; k++) {
+                        dst[k] = (float)((int)get_bits(bs, ba) - half);
+                    }
+                } else {
+                    unsigned mod = (2 << (ba - 17)) + 1; /* 3, 5, 9 */
+                    unsigned code =
+                        get_bits(bs, mod + 2 - (mod >> 3)); /* 5, 7, 10 */
+                    for (k = 0; k < group_size; k++, code /= mod) {
+                        dst[k] = (float)((int)(code % mod - mod / 2));
+                    }
+                }
+            }
+            dst += choff;
+            choff = 18 - choff;
+        }
+    }
+    return group_size * 4;
+}
+
+static void L12_apply_scf_384(L12_scale_info *sci, const float *scf,
+                              float *dst) {
+    int i, k;
+    memcpy(dst + 576 + sci->stereo_bands * 18, dst + sci->stereo_bands * 18,
+           (sci->total_bands - sci->stereo_bands) * 18 * sizeof(float));
+    for (i = 0; i < sci->total_bands; i++, dst += 18, scf += 6) {
+        for (k = 0; k < 12; k++) {
+            dst[k + 0] *= scf[0];
+            dst[k + 576] *= scf[3];
+        }
+    }
+}
+#endif /* MINIMP3_ONLY_MP3 */
+
+static int L3_read_side_info(bs_t *bs, L3_gr_info_t *gr, const uint8_t *hdr) {
+    static const uint8_t g_scf_long[8][23] = {
+        { 6,  6,  6,  6,  6,  6,  8,  10, 12, 14, 16, 20,
+          24, 28, 32, 38, 46, 52, 60, 68, 58, 54, 0 },
+        { 12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32, 40,
+          48, 56, 64, 76, 90, 2,  2,  2,  2,  2,  0 },
+        { 6,  6,  6,  6,  6,  6,  8,  10, 12, 14, 16, 20,
+          24, 28, 32, 38, 46, 52, 60, 68, 58, 54, 0 },
+        { 6,  6,  6,  6,  6,  6,  8,  10, 12, 14, 16, 18,
+          22, 26, 32, 38, 46, 54, 62, 70, 76, 36, 0 },
+        { 6,  6,  6,  6,  6,  6,  8,  10, 12, 14, 16, 20,
+          24, 28, 32, 38, 46, 52, 60, 68, 58, 54, 0 },
+        { 4,  4,  4,  4,  4,  4,  6,  6,  8,  8,   10, 12,
+          16, 20, 24, 28, 34, 42, 50, 54, 76, 158, 0 },
+        { 4,  4,  4,  4,  4,  4,  6,  6,  6,  8,   10, 12,
+          16, 18, 22, 28, 34, 40, 46, 54, 54, 192, 0 },
+        { 4,  4,  4,  4,  4,  4,  6,  6,  8,   10, 12, 16,
+          20, 24, 30, 38, 46, 56, 68, 84, 102, 26, 0 }
+    };
+    static const uint8_t g_scf_short[8][40] = {
+        { 4,  4,  4,  4,  4,  4,  4,  4,  4,  6,  6,  6,  8,  8,
+          8,  10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24,
+          24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0 },
+        { 8,  8,  8,  8,  8,  8,  8,  8,  8,  12, 12, 12, 16, 16,
+          16, 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 36, 2,
+          2,  2,  2,  2,  2,  2,  2,  2,  26, 26, 26, 0 },
+        { 4,  4,  4,  4,  4,  4,  4,  4,  4,  6,  6,  6,  6,  6,
+          6,  8,  8,  8,  10, 10, 10, 14, 14, 14, 18, 18, 18, 26,
+          26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18, 0 },
+        { 4,  4,  4,  4,  4,  4,  4,  4,  4,  6,  6,  6,  8,  8,
+          8,  10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24,
+          24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12, 0 },
+        { 4,  4,  4,  4,  4,  4,  4,  4,  4,  6,  6,  6,  8,  8,
+          8,  10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24,
+          24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0 },
+        { 4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  6,  6,
+          6,  8,  8,  8,  10, 10, 10, 12, 12, 12, 14, 14, 14, 18,
+          18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56, 0 },
+        { 4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  6,  6,
+          6,  6,  6,  6,  10, 10, 10, 12, 12, 12, 14, 14, 14, 16,
+          16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66, 0 },
+        { 4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  6,  6,
+          6,  8,  8,  8,  12, 12, 12, 16, 16, 16, 20, 20, 20, 26,
+          26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12, 0 }
+    };
+    static const uint8_t g_scf_mixed[8][40] = {
+        { 6,  6,  6,  6,  6,  6,  6,  6,  6,  8,  8,  8,  10,
+          10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
+          24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0 },
+        { 12, 12, 12, 4,  4,  4,  8,  8,  8,  12, 12, 12, 16, 16,
+          16, 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 36, 2,
+          2,  2,  2,  2,  2,  2,  2,  2,  26, 26, 26, 0 },
+        { 6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  8,
+          8,  8,  10, 10, 10, 14, 14, 14, 18, 18, 18, 26, 26,
+          26, 32, 32, 32, 42, 42, 42, 18, 18, 18, 0 },
+        { 6,  6,  6,  6,  6,  6,  6,  6,  6,  8,  8,  8,  10,
+          10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
+          24, 32, 32, 32, 44, 44, 44, 12, 12, 12, 0 },
+        { 6,  6,  6,  6,  6,  6,  6,  6,  6,  8,  8,  8,  10,
+          10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
+          24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0 },
+        { 4,  4,  4,  4,  4,  4,  6,  6,  4,  4,  4,  6,  6,
+          6,  8,  8,  8,  10, 10, 10, 12, 12, 12, 14, 14, 14,
+          18, 18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56, 0 },
+        { 4,  4,  4,  4,  4,  4,  6,  6,  4,  4,  4,  6,  6,
+          6,  6,  6,  6,  10, 10, 10, 12, 12, 12, 14, 14, 14,
+          16, 16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66, 0 },
+        { 4,  4,  4,  4,  4,  4,  6,  6,  4,  4,  4,  6,  6,
+          6,  8,  8,  8,  12, 12, 12, 16, 16, 16, 20, 20, 20,
+          26, 26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12, 0 }
+    };
+
+    unsigned tables, scfsi = 0;
+    int main_data_begin, part_23_sum = 0;
+    int sr_idx = HDR_GET_MY_SAMPLE_RATE(hdr);
+    sr_idx -= (sr_idx != 0);
+    int gr_count = HDR_IS_MONO(hdr) ? 1 : 2;
+
+    if (HDR_TEST_MPEG1(hdr)) {
+        gr_count *= 2;
+        main_data_begin = get_bits(bs, 9);
+        scfsi = get_bits(bs, 7 + gr_count);
+    } else {
+        main_data_begin = get_bits(bs, 8 + gr_count) >> gr_count;
+    }
+
+    do {
+        if (HDR_IS_MONO(hdr)) {
+            scfsi <<= 4;
+        }
+        gr->part_23_length = (uint16_t)get_bits(bs, 12);
+        part_23_sum += gr->part_23_length;
+        gr->big_values = (uint16_t)get_bits(bs, 9);
+        if (gr->big_values > 288) {
+            return -1;
+        }
+        gr->global_gain = (uint8_t)get_bits(bs, 8);
+        gr->scalefac_compress =
+            (uint16_t)get_bits(bs, HDR_TEST_MPEG1(hdr) ? 4 : 9);
+        gr->sfbtab = g_scf_long[sr_idx];
+        gr->n_long_sfb = 22;
+        gr->n_short_sfb = 0;
+        if (get_bits(bs, 1)) {
+            gr->block_type = (uint8_t)get_bits(bs, 2);
+            if (!gr->block_type) {
+                return -1;
+            }
+            gr->mixed_block_flag = (uint8_t)get_bits(bs, 1);
+            gr->region_count[0] = 7;
+            gr->region_count[1] = 255;
+            if (gr->block_type == SHORT_BLOCK_TYPE) {
+                scfsi &= 0x0F0F;
+                if (!gr->mixed_block_flag) {
+                    gr->region_count[0] = 8;
+                    gr->sfbtab = g_scf_short[sr_idx];
+                    gr->n_long_sfb = 0;
+                    gr->n_short_sfb = 39;
+                } else {
+                    gr->sfbtab = g_scf_mixed[sr_idx];
+                    gr->n_long_sfb = HDR_TEST_MPEG1(hdr) ? 8 : 6;
+                    gr->n_short_sfb = 30;
+                }
+            }
+            tables = get_bits(bs, 10);
+            tables <<= 5;
+            gr->subblock_gain[0] = (uint8_t)get_bits(bs, 3);
+            gr->subblock_gain[1] = (uint8_t)get_bits(bs, 3);
+            gr->subblock_gain[2] = (uint8_t)get_bits(bs, 3);
+        } else {
+            gr->block_type = 0;
+            gr->mixed_block_flag = 0;
+            tables = get_bits(bs, 15);
+            gr->region_count[0] = (uint8_t)get_bits(bs, 4);
+            gr->region_count[1] = (uint8_t)get_bits(bs, 3);
+            gr->region_count[2] = 255;
+        }
+        gr->table_select[0] = (uint8_t)(tables >> 10);
+        gr->table_select[1] = (uint8_t)((tables >> 5) & 31);
+        gr->table_select[2] = (uint8_t)((tables)&31);
+        gr->preflag = HDR_TEST_MPEG1(hdr) ? get_bits(bs, 1)
+                                          : (gr->scalefac_compress >= 500);
+        gr->scalefac_scale = (uint8_t)get_bits(bs, 1);
+        gr->count1_table = (uint8_t)get_bits(bs, 1);
+        gr->scfsi = (uint8_t)((scfsi >> 12) & 15);
+        scfsi <<= 4;
+        gr++;
+    } while (--gr_count);
+
+    if (part_23_sum + bs->pos > bs->limit + main_data_begin * 8) {
+        return -1;
+    }
+
+    return main_data_begin;
+}
+
+static void L3_read_scalefactors(uint8_t *scf, uint8_t *ist_pos,
+                                 const uint8_t *scf_size,
+                                 const uint8_t *scf_count, bs_t *bitbuf,
+                                 int scfsi) {
+    int i, k;
+    for (i = 0; i < 4 && scf_count[i]; i++, scfsi *= 2) {
+        int cnt = scf_count[i];
+        if (scfsi & 8) {
+            memcpy(scf, ist_pos, cnt);
+        } else {
+            int bits = scf_size[i];
+            if (!bits) {
+                memset(scf, 0, cnt);
+                memset(ist_pos, 0, cnt);
+            } else {
+                int max_scf = (scfsi < 0) ? (1 << bits) - 1 : -1;
+                for (k = 0; k < cnt; k++) {
+                    int s = get_bits(bitbuf, bits);
+                    ist_pos[k] = (s == max_scf ? -1 : s);
+                    scf[k] = s;
+                }
+            }
+        }
+        ist_pos += cnt;
+        scf += cnt;
+    }
+    scf[0] = scf[1] = scf[2] = 0;
+}
+
+static float L3_ldexp_q2(float y, int exp_q2) {
+    static const float g_expfrac[4] = { 9.31322575e-10f, 7.83145814e-10f,
+                                        6.58544508e-10f, 5.53767716e-10f };
+    int e;
+    do {
+        e = MINIMP3_MIN(30 * 4, exp_q2);
+        y *= g_expfrac[e & 3] * (1 << 30 >> (e >> 2));
+    } while ((exp_q2 -= e) > 0);
+    return y;
+}
+
+static void L3_decode_scalefactors(const uint8_t *hdr, uint8_t *ist_pos,
+                                   bs_t *bs, const L3_gr_info_t *gr, float *scf,
+                                   int ch) {
+    static const uint8_t g_scf_partitions[3][28] = {
+        { 6, 5, 5, 5, 6, 5, 5, 5, 6, 5, 7, 3, 11, 10,
+          0, 0, 7, 7, 7, 0, 6, 6, 6, 3, 8, 8, 5,  0 },
+        { 8, 9, 6, 12, 6,  9, 9, 9,  6, 9, 12, 6,  15, 18,
+          0, 0, 6, 15, 12, 0, 6, 12, 9, 6, 6,  18, 9,  0 },
+        { 9, 9, 6,  12, 9,  9, 9,  9, 9, 9, 12, 6,  18, 18,
+          0, 0, 12, 12, 12, 0, 12, 9, 9, 6, 15, 12, 9,  0 }
+    };
+    const uint8_t *scf_partition =
+        g_scf_partitions[!!gr->n_short_sfb + !gr->n_long_sfb];
+    uint8_t scf_size[4], iscf[40];
+    int i, scf_shift = gr->scalefac_scale + 1, gain_exp, scfsi = gr->scfsi;
+    float gain;
+
+    if (HDR_TEST_MPEG1(hdr)) {
+        static const uint8_t g_scfc_decode[16] = {
+            0, 1, 2, 3, 12, 5, 6, 7, 9, 10, 11, 13, 14, 15, 18, 19
+        };
+        int part = g_scfc_decode[gr->scalefac_compress];
+        scf_size[1] = scf_size[0] = (uint8_t)(part >> 2);
+        scf_size[3] = scf_size[2] = (uint8_t)(part & 3);
+    } else {
+        static const uint8_t g_mod[6 * 4] = { 5, 5, 4, 4, 5, 5, 4, 1,
+                                              4, 3, 1, 1, 5, 6, 6, 1,
+                                              4, 4, 4, 1, 4, 3, 1, 1 };
+        int k, modprod, sfc, ist = HDR_TEST_I_STEREO(hdr) && ch;
+        sfc = gr->scalefac_compress >> ist;
+        for (k = ist * 3 * 4; sfc >= 0; sfc -= modprod, k += 4) {
+            for (modprod = 1, i = 3; i >= 0; i--) {
+                scf_size[i] = (uint8_t)(sfc / modprod % g_mod[k + i]);
+                modprod *= g_mod[k + i];
+            }
+        }
+        scf_partition += k;
+        scfsi = -16;
+    }
+    L3_read_scalefactors(iscf, ist_pos, scf_size, scf_partition, bs, scfsi);
+
+    if (gr->n_short_sfb) {
+        int sh = 3 - scf_shift;
+        for (i = 0; i < gr->n_short_sfb; i += 3) {
+            iscf[gr->n_long_sfb + i + 0] += gr->subblock_gain[0] << sh;
+            iscf[gr->n_long_sfb + i + 1] += gr->subblock_gain[1] << sh;
+            iscf[gr->n_long_sfb + i + 2] += gr->subblock_gain[2] << sh;
+        }
+    } else if (gr->preflag) {
+        static const uint8_t g_preamp[10] = { 1, 1, 1, 1, 2, 2, 3, 3, 3, 2 };
+        for (i = 0; i < 10; i++) {
+            iscf[11 + i] += g_preamp[i];
+        }
+    }
+
+    gain_exp = gr->global_gain + BITS_DEQUANTIZER_OUT * 4 - 210 -
+               (HDR_IS_MS_STEREO(hdr) ? 2 : 0);
+    gain = L3_ldexp_q2(1 << (MAX_SCFI / 4), MAX_SCFI - gain_exp);
+    for (i = 0; i < (int)(gr->n_long_sfb + gr->n_short_sfb); i++) {
+        scf[i] = L3_ldexp_q2(gain, iscf[i] << scf_shift);
+    }
+}
+
+static const float g_pow43[129 + 16] = {
+    0,           -1,          -2.519842f,  -4.326749f,  -6.349604f,
+    -8.549880f,  -10.902724f, -13.390518f, -16.000000f, -18.720754f,
+    -21.544347f, -24.463781f, -27.473142f, -30.567351f, -33.741992f,
+    -36.993181f, 0,           1,           2.519842f,   4.326749f,
+    6.349604f,   8.549880f,   10.902724f,  13.390518f,  16.000000f,
+    18.720754f,  21.544347f,  24.463781f,  27.473142f,  30.567351f,
+    33.741992f,  36.993181f,  40.317474f,  43.711787f,  47.173345f,
+    50.699631f,  54.288352f,  57.937408f,  61.644865f,  65.408941f,
+    69.227979f,  73.100443f,  77.024898f,  81.000000f,  85.024491f,
+    89.097188f,  93.216975f,  97.382800f,  101.593667f, 105.848633f,
+    110.146801f, 114.487321f, 118.869381f, 123.292209f, 127.755065f,
+    132.257246f, 136.798076f, 141.376907f, 145.993119f, 150.646117f,
+    155.335327f, 160.060199f, 164.820202f, 169.614826f, 174.443577f,
+    179.305980f, 184.201575f, 189.129918f, 194.090580f, 199.083145f,
+    204.107210f, 209.162385f, 214.248292f, 219.364564f, 224.510845f,
+    229.686789f, 234.892058f, 240.126328f, 245.389280f, 250.680604f,
+    256.000000f, 261.347174f, 266.721841f, 272.123723f, 277.552547f,
+    283.008049f, 288.489971f, 293.998060f, 299.532071f, 305.091761f,
+    310.676898f, 316.287249f, 321.922592f, 327.582707f, 333.267377f,
+    338.976394f, 344.709550f, 350.466646f, 356.247482f, 362.051866f,
+    367.879608f, 373.730522f, 379.604427f, 385.501143f, 391.420496f,
+    397.362314f, 403.326427f, 409.312672f, 415.320884f, 421.350905f,
+    427.402579f, 433.475750f, 439.570269f, 445.685987f, 451.822757f,
+    457.980436f, 464.158883f, 470.357960f, 476.577530f, 482.817459f,
+    489.077615f, 495.357868f, 501.658090f, 507.978156f, 514.317941f,
+    520.677324f, 527.056184f, 533.454404f, 539.871867f, 546.308458f,
+    552.764065f, 559.238575f, 565.731879f, 572.243870f, 578.774440f,
+    585.323483f, 591.890898f, 598.476581f, 605.080431f, 611.702349f,
+    618.342238f, 625.000000f, 631.675540f, 638.368763f, 645.079578f
+};
+
+static float L3_pow_43(int x) {
+    float frac;
+    int sign, mult = 256;
+
+    if (x < 129) {
+        return g_pow43[16 + x];
+    }
+
+    if (x < 1024) {
+        mult = 16;
+        x <<= 3;
+    }
+
+    sign = 2 * x & 64;
+    frac = (float)((x & 63) - sign) / ((x & ~63) + sign);
+    return g_pow43[16 + ((x + sign) >> 6)] *
+           (1.f + frac * ((4.f / 3) + frac * (2.f / 9))) * mult;
+}
+
+static void L3_huffman(float *dst, bs_t *bs, const L3_gr_info_t *gr_info,
+                       const float *scf, int layer3gr_limit) {
+    static const int16_t tabs[] = {
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+        0,     0,     785,   785,   785,   785,   784,   784,   784,   784,
+        513,   513,   513,   513,   513,   513,   513,   513,   256,   256,
+        256,   256,   256,   256,   256,   256,   256,   256,   256,   256,
+        256,   256,   256,   256,   -255,  1313,  1298,  1282,  785,   785,
+        785,   785,   784,   784,   784,   784,   769,   769,   769,   769,
+        256,   256,   256,   256,   256,   256,   256,   256,   256,   256,
+        256,   256,   256,   256,   256,   256,   290,   288,   -255,  1313,
+        1298,  1282,  769,   769,   769,   769,   529,   529,   529,   529,
+        529,   529,   529,   529,   528,   528,   528,   528,   528,   528,
+        528,   528,   512,   512,   512,   512,   512,   512,   512,   512,
+        290,   288,   -253,  -318,  -351,  -367,  785,   785,   785,   785,
+        784,   784,   784,   784,   769,   769,   769,   769,   256,   256,
+        256,   256,   256,   256,   256,   256,   256,   256,   256,   256,
+        256,   256,   256,   256,   819,   818,   547,   547,   275,   275,
+        275,   275,   561,   560,   515,   546,   289,   274,   288,   258,
+        -254,  -287,  1329,  1299,  1314,  1312,  1057,  1057,  1042,  1042,
+        1026,  1026,  784,   784,   784,   784,   529,   529,   529,   529,
+        529,   529,   529,   529,   769,   769,   769,   769,   768,   768,
+        768,   768,   563,   560,   306,   306,   291,   259,   -252,  -413,
+        -477,  -542,  1298,  -575,  1041,  1041,  784,   784,   784,   784,
+        769,   769,   769,   769,   256,   256,   256,   256,   256,   256,
+        256,   256,   256,   256,   256,   256,   256,   256,   256,   256,
+        -383,  -399,  1107,  1092,  1106,  1061,  849,   849,   789,   789,
+        1104,  1091,  773,   773,   1076,  1075,  341,   340,   325,   309,
+        834,   804,   577,   577,   532,   532,   516,   516,   832,   818,
+        803,   816,   561,   561,   531,   531,   515,   546,   289,   289,
+        288,   258,   -252,  -429,  -493,  -559,  1057,  1057,  1042,  1042,
+        529,   529,   529,   529,   529,   529,   529,   529,   784,   784,
+        784,   784,   769,   769,   769,   769,   512,   512,   512,   512,
+        512,   512,   512,   512,   -382,  1077,  -415,  1106,  1061,  1104,
+        849,   849,   789,   789,   1091,  1076,  1029,  1075,  834,   834,
+        597,   581,   340,   340,   339,   324,   804,   833,   532,   532,
+        832,   772,   818,   803,   817,   787,   816,   771,   290,   290,
+        290,   290,   288,   258,   -253,  -349,  -414,  -447,  -463,  1329,
+        1299,  -479,  1314,  1312,  1057,  1057,  1042,  1042,  1026,  1026,
+        785,   785,   785,   785,   784,   784,   784,   784,   769,   769,
+        769,   769,   768,   768,   768,   768,   -319,  851,   821,   -335,
+        836,   850,   805,   849,   341,   340,   325,   336,   533,   533,
+        579,   579,   564,   564,   773,   832,   578,   548,   563,   516,
+        321,   276,   306,   291,   304,   259,   -251,  -572,  -733,  -830,
+        -863,  -879,  1041,  1041,  784,   784,   784,   784,   769,   769,
+        769,   769,   256,   256,   256,   256,   256,   256,   256,   256,
+        256,   256,   256,   256,   256,   256,   256,   256,   -511,  -527,
+        -543,  1396,  1351,  1381,  1366,  1395,  1335,  1380,  -559,  1334,
+        1138,  1138,  1063,  1063,  1350,  1392,  1031,  1031,  1062,  1062,
+        1364,  1363,  1120,  1120,  1333,  1348,  881,   881,   881,   881,
+        375,   374,   359,   373,   343,   358,   341,   325,   791,   791,
+        1123,  1122,  -703,  1105,  1045,  -719,  865,   865,   790,   790,
+        774,   774,   1104,  1029,  338,   293,   323,   308,   -799,  -815,
+        833,   788,   772,   818,   803,   816,   322,   292,   307,   320,
+        561,   531,   515,   546,   289,   274,   288,   258,   -251,  -525,
+        -605,  -685,  -765,  -831,  -846,  1298,  1057,  1057,  1312,  1282,
+        785,   785,   785,   785,   784,   784,   784,   784,   769,   769,
+        769,   769,   512,   512,   512,   512,   512,   512,   512,   512,
+        1399,  1398,  1383,  1367,  1382,  1396,  1351,  -511,  1381,  1366,
+        1139,  1139,  1079,  1079,  1124,  1124,  1364,  1349,  1363,  1333,
+        882,   882,   882,   882,   807,   807,   807,   807,   1094,  1094,
+        1136,  1136,  373,   341,   535,   535,   881,   775,   867,   822,
+        774,   -591,  324,   338,   -671,  849,   550,   550,   866,   864,
+        609,   609,   293,   336,   534,   534,   789,   835,   773,   -751,
+        834,   804,   308,   307,   833,   788,   832,   772,   562,   562,
+        547,   547,   305,   275,   560,   515,   290,   290,   -252,  -397,
+        -477,  -557,  -622,  -653,  -719,  -735,  -750,  1329,  1299,  1314,
+        1057,  1057,  1042,  1042,  1312,  1282,  1024,  1024,  785,   785,
+        785,   785,   784,   784,   784,   784,   769,   769,   769,   769,
+        -383,  1127,  1141,  1111,  1126,  1140,  1095,  1110,  869,   869,
+        883,   883,   1079,  1109,  882,   882,   375,   374,   807,   868,
+        838,   881,   791,   -463,  867,   822,   368,   263,   852,   837,
+        836,   -543,  610,   610,   550,   550,   352,   336,   534,   534,
+        865,   774,   851,   821,   850,   805,   593,   533,   579,   564,
+        773,   832,   578,   578,   548,   548,   577,   577,   307,   276,
+        306,   291,   516,   560,   259,   259,   -250,  -2107, -2507, -2764,
+        -2909, -2974, -3007, -3023, 1041,  1041,  1040,  1040,  769,   769,
+        769,   769,   256,   256,   256,   256,   256,   256,   256,   256,
+        256,   256,   256,   256,   256,   256,   256,   256,   -767,  -1052,
+        -1213, -1277, -1358, -1405, -1469, -1535, -1550, -1582, -1614, -1647,
+        -1662, -1694, -1726, -1759, -1774, -1807, -1822, -1854, -1886, 1565,
+        -1919, -1935, -1951, -1967, 1731,  1730,  1580,  1717,  -1983, 1729,
+        1564,  -1999, 1548,  -2015, -2031, 1715,  1595,  -2047, 1714,  -2063,
+        1610,  -2079, 1609,  -2095, 1323,  1323,  1457,  1457,  1307,  1307,
+        1712,  1547,  1641,  1700,  1699,  1594,  1685,  1625,  1442,  1442,
+        1322,  1322,  -780,  -973,  -910,  1279,  1278,  1277,  1262,  1276,
+        1261,  1275,  1215,  1260,  1229,  -959,  974,   974,   989,   989,
+        -943,  735,   478,   478,   495,   463,   506,   414,   -1039, 1003,
+        958,   1017,  927,   942,   987,   957,   431,   476,   1272,  1167,
+        1228,  -1183, 1256,  -1199, 895,   895,   941,   941,   1242,  1227,
+        1212,  1135,  1014,  1014,  490,   489,   503,   487,   910,   1013,
+        985,   925,   863,   894,   970,   955,   1012,  847,   -1343, 831,
+        755,   755,   984,   909,   428,   366,   754,   559,   -1391, 752,
+        486,   457,   924,   997,   698,   698,   983,   893,   740,   740,
+        908,   877,   739,   739,   667,   667,   953,   938,   497,   287,
+        271,   271,   683,   606,   590,   712,   726,   574,   302,   302,
+        738,   736,   481,   286,   526,   725,   605,   711,   636,   724,
+        696,   651,   589,   681,   666,   710,   364,   467,   573,   695,
+        466,   466,   301,   465,   379,   379,   709,   604,   665,   679,
+        316,   316,   634,   633,   436,   436,   464,   269,   424,   394,
+        452,   332,   438,   363,   347,   408,   393,   448,   331,   422,
+        362,   407,   392,   421,   346,   406,   391,   376,   375,   359,
+        1441,  1306,  -2367, 1290,  -2383, 1337,  -2399, -2415, 1426,  1321,
+        -2431, 1411,  1336,  -2447, -2463, -2479, 1169,  1169,  1049,  1049,
+        1424,  1289,  1412,  1352,  1319,  -2495, 1154,  1154,  1064,  1064,
+        1153,  1153,  416,   390,   360,   404,   403,   389,   344,   374,
+        373,   343,   358,   372,   327,   357,   342,   311,   356,   326,
+        1395,  1394,  1137,  1137,  1047,  1047,  1365,  1392,  1287,  1379,
+        1334,  1364,  1349,  1378,  1318,  1363,  792,   792,   792,   792,
+        1152,  1152,  1032,  1032,  1121,  1121,  1046,  1046,  1120,  1120,
+        1030,  1030,  -2895, 1106,  1061,  1104,  849,   849,   789,   789,
+        1091,  1076,  1029,  1090,  1060,  1075,  833,   833,   309,   324,
+        532,   532,   832,   772,   818,   803,   561,   561,   531,   560,
+        515,   546,   289,   274,   288,   258,   -250,  -1179, -1579, -1836,
+        -1996, -2124, -2253, -2333, -2413, -2477, -2542, -2574, -2607, -2622,
+        -2655, 1314,  1313,  1298,  1312,  1282,  785,   785,   785,   785,
+        1040,  1040,  1025,  1025,  768,   768,   768,   768,   -766,  -798,
+        -830,  -862,  -895,  -911,  -927,  -943,  -959,  -975,  -991,  -1007,
+        -1023, -1039, -1055, -1070, 1724,  1647,  -1103, -1119, 1631,  1767,
+        1662,  1738,  1708,  1723,  -1135, 1780,  1615,  1779,  1599,  1677,
+        1646,  1778,  1583,  -1151, 1777,  1567,  1737,  1692,  1765,  1722,
+        1707,  1630,  1751,  1661,  1764,  1614,  1736,  1676,  1763,  1750,
+        1645,  1598,  1721,  1691,  1762,  1706,  1582,  1761,  1566,  -1167,
+        1749,  1629,  767,   766,   751,   765,   494,   494,   735,   764,
+        719,   749,   734,   763,   447,   447,   748,   718,   477,   506,
+        431,   491,   446,   476,   461,   505,   415,   430,   475,   445,
+        504,   399,   460,   489,   414,   503,   383,   474,   429,   459,
+        502,   502,   746,   752,   488,   398,   501,   473,   413,   472,
+        486,   271,   480,   270,   -1439, -1455, 1357,  -1471, -1487, -1503,
+        1341,  1325,  -1519, 1489,  1463,  1403,  1309,  -1535, 1372,  1448,
+        1418,  1476,  1356,  1462,  1387,  -1551, 1475,  1340,  1447,  1402,
+        1386,  -1567, 1068,  1068,  1474,  1461,  455,   380,   468,   440,
+        395,   425,   410,   454,   364,   467,   466,   464,   453,   269,
+        409,   448,   268,   432,   1371,  1473,  1432,  1417,  1308,  1460,
+        1355,  1446,  1459,  1431,  1083,  1083,  1401,  1416,  1458,  1445,
+        1067,  1067,  1370,  1457,  1051,  1051,  1291,  1430,  1385,  1444,
+        1354,  1415,  1400,  1443,  1082,  1082,  1173,  1113,  1186,  1066,
+        1185,  1050,  -1967, 1158,  1128,  1172,  1097,  1171,  1081,  -1983,
+        1157,  1112,  416,   266,   375,   400,   1170,  1142,  1127,  1065,
+        793,   793,   1169,  1033,  1156,  1096,  1141,  1111,  1155,  1080,
+        1126,  1140,  898,   898,   808,   808,   897,   897,   792,   792,
+        1095,  1152,  1032,  1125,  1110,  1139,  1079,  1124,  882,   807,
+        838,   881,   853,   791,   -2319, 867,   368,   263,   822,   852,
+        837,   866,   806,   865,   -2399, 851,   352,   262,   534,   534,
+        821,   836,   594,   594,   549,   549,   593,   593,   533,   533,
+        848,   773,   579,   579,   564,   578,   548,   563,   276,   276,
+        577,   576,   306,   291,   516,   560,   305,   305,   275,   259,
+        -251,  -892,  -2058, -2620, -2828, -2957, -3023, -3039, 1041,  1041,
+        1040,  1040,  769,   769,   769,   769,   256,   256,   256,   256,
+        256,   256,   256,   256,   256,   256,   256,   256,   256,   256,
+        256,   256,   -511,  -527,  -543,  -559,  1530,  -575,  -591,  1528,
+        1527,  1407,  1526,  1391,  1023,  1023,  1023,  1023,  1525,  1375,
+        1268,  1268,  1103,  1103,  1087,  1087,  1039,  1039,  1523,  -604,
+        815,   815,   815,   815,   510,   495,   509,   479,   508,   463,
+        507,   447,   431,   505,   415,   399,   -734,  -782,  1262,  -815,
+        1259,  1244,  -831,  1258,  1228,  -847,  -863,  1196,  -879,  1253,
+        987,   987,   748,   -767,  493,   493,   462,   477,   414,   414,
+        686,   669,   478,   446,   461,   445,   474,   429,   487,   458,
+        412,   471,   1266,  1264,  1009,  1009,  799,   799,   -1019, -1276,
+        -1452, -1581, -1677, -1757, -1821, -1886, -1933, -1997, 1257,  1257,
+        1483,  1468,  1512,  1422,  1497,  1406,  1467,  1496,  1421,  1510,
+        1134,  1134,  1225,  1225,  1466,  1451,  1374,  1405,  1252,  1252,
+        1358,  1480,  1164,  1164,  1251,  1251,  1238,  1238,  1389,  1465,
+        -1407, 1054,  1101,  -1423, 1207,  -1439, 830,   830,   1248,  1038,
+        1237,  1117,  1223,  1148,  1236,  1208,  411,   426,   395,   410,
+        379,   269,   1193,  1222,  1132,  1235,  1221,  1116,  976,   976,
+        1192,  1162,  1177,  1220,  1131,  1191,  963,   963,   -1647, 961,
+        780,   -1663, 558,   558,   994,   993,   437,   408,   393,   407,
+        829,   978,   813,   797,   947,   -1743, 721,   721,   377,   392,
+        844,   950,   828,   890,   706,   706,   812,   859,   796,   960,
+        948,   843,   934,   874,   571,   571,   -1919, 690,   555,   689,
+        421,   346,   539,   539,   944,   779,   918,   873,   932,   842,
+        903,   888,   570,   570,   931,   917,   674,   674,   -2575, 1562,
+        -2591, 1609,  -2607, 1654,  1322,  1322,  1441,  1441,  1696,  1546,
+        1683,  1593,  1669,  1624,  1426,  1426,  1321,  1321,  1639,  1680,
+        1425,  1425,  1305,  1305,  1545,  1668,  1608,  1623,  1667,  1592,
+        1638,  1666,  1320,  1320,  1652,  1607,  1409,  1409,  1304,  1304,
+        1288,  1288,  1664,  1637,  1395,  1395,  1335,  1335,  1622,  1636,
+        1394,  1394,  1319,  1319,  1606,  1621,  1392,  1392,  1137,  1137,
+        1137,  1137,  345,   390,   360,   375,   404,   373,   1047,  -2751,
+        -2767, -2783, 1062,  1121,  1046,  -2799, 1077,  -2815, 1106,  1061,
+        789,   789,   1105,  1104,  263,   355,   310,   340,   325,   354,
+        352,   262,   339,   324,   1091,  1076,  1029,  1090,  1060,  1075,
+        833,   833,   788,   788,   1088,  1028,  818,   818,   803,   803,
+        561,   561,   531,   531,   816,   771,   546,   546,   289,   274,
+        288,   258,   -253,  -317,  -381,  -446,  -478,  -509,  1279,  1279,
+        -811,  -1179, -1451, -1756, -1900, -2028, -2189, -2253, -2333, -2414,
+        -2445, -2511, -2526, 1313,  1298,  -2559, 1041,  1041,  1040,  1040,
+        1025,  1025,  1024,  1024,  1022,  1007,  1021,  991,   1020,  975,
+        1019,  959,   687,   687,   1018,  1017,  671,   671,   655,   655,
+        1016,  1015,  639,   639,   758,   758,   623,   623,   757,   607,
+        756,   591,   755,   575,   754,   559,   543,   543,   1009,  783,
+        -575,  -621,  -685,  -749,  496,   -590,  750,   749,   734,   748,
+        974,   989,   1003,  958,   988,   973,   1002,  942,   987,   957,
+        972,   1001,  926,   986,   941,   971,   956,   1000,  910,   985,
+        925,   999,   894,   970,   -1071, -1087, -1102, 1390,  -1135, 1436,
+        1509,  1451,  1374,  -1151, 1405,  1358,  1480,  1420,  -1167, 1507,
+        1494,  1389,  1342,  1465,  1435,  1450,  1326,  1505,  1310,  1493,
+        1373,  1479,  1404,  1492,  1464,  1419,  428,   443,   472,   397,
+        736,   526,   464,   464,   486,   457,   442,   471,   484,   482,
+        1357,  1449,  1434,  1478,  1388,  1491,  1341,  1490,  1325,  1489,
+        1463,  1403,  1309,  1477,  1372,  1448,  1418,  1433,  1476,  1356,
+        1462,  1387,  -1439, 1475,  1340,  1447,  1402,  1474,  1324,  1461,
+        1371,  1473,  269,   448,   1432,  1417,  1308,  1460,  -1711, 1459,
+        -1727, 1441,  1099,  1099,  1446,  1386,  1431,  1401,  -1743, 1289,
+        1083,  1083,  1160,  1160,  1458,  1445,  1067,  1067,  1370,  1457,
+        1307,  1430,  1129,  1129,  1098,  1098,  268,   432,   267,   416,
+        266,   400,   -1887, 1144,  1187,  1082,  1173,  1113,  1186,  1066,
+        1050,  1158,  1128,  1143,  1172,  1097,  1171,  1081,  420,   391,
+        1157,  1112,  1170,  1142,  1127,  1065,  1169,  1049,  1156,  1096,
+        1141,  1111,  1155,  1080,  1126,  1154,  1064,  1153,  1140,  1095,
+        1048,  -2159, 1125,  1110,  1137,  -2175, 823,   823,   1139,  1138,
+        807,   807,   384,   264,   368,   263,   868,   838,   853,   791,
+        867,   822,   852,   837,   866,   806,   865,   790,   -2319, 851,
+        821,   836,   352,   262,   850,   805,   849,   -2399, 533,   533,
+        835,   820,   336,   261,   578,   548,   563,   577,   532,   532,
+        832,   772,   562,   562,   547,   547,   305,   275,   560,   515,
+        290,   290,   288,   258
+    };
+    static const uint8_t tab32[] = { 130, 162, 193, 209, 44,  28,  76,
+                                     140, 9,   9,   9,   9,   9,   9,
+                                     9,   9,   190, 254, 222, 238, 126,
+                                     94,  157, 157, 109, 61,  173, 205 };
+    static const uint8_t tab33[] = { 252, 236, 220, 204, 188, 172, 156, 140,
+                                     124, 108, 92,  76,  60,  44,  28,  12 };
+    static const int16_t tabindex[2 * 16] = {
+        0,    32,   64,   98,   0,    132,  180,  218,  292,  364,  426,
+        538,  648,  746,  0,    1126, 1460, 1460, 1460, 1460, 1460, 1460,
+        1460, 1460, 1842, 1842, 1842, 1842, 1842, 1842, 1842, 1842
+    };
+    static const uint8_t g_linbits[] = { 0,  0,  0, 0, 0, 0, 0, 0, 0,  0, 0,
+                                         0,  0,  0, 0, 0, 1, 2, 3, 4,  6, 8,
+                                         10, 13, 4, 5, 6, 7, 8, 9, 11, 13 };
+
+#define PEEK_BITS(n) (bs_cache >> (32 - n))
+#define FLUSH_BITS(n)     \
+    {                     \
+        bs_cache <<= (n); \
+        bs_sh += (n);     \
+    }
+#define CHECK_BITS                                     \
+    while (bs_sh >= 0) {                               \
+        bs_cache |= (uint32_t)*bs_next_ptr++ << bs_sh; \
+        bs_sh -= 8;                                    \
+    }
+#define BSPOS ((bs_next_ptr - bs->buf) * 8 - 24 + bs_sh)
+
+    float one = 0.0f;
+    int ireg = 0, big_val_cnt = gr_info->big_values;
+    const uint8_t *sfb = gr_info->sfbtab;
+    const uint8_t *bs_next_ptr = bs->buf + bs->pos / 8;
+    uint32_t bs_cache =
+        (((bs_next_ptr[0] * 256u + bs_next_ptr[1]) * 256u + bs_next_ptr[2]) *
+             256u +
+         bs_next_ptr[3])
+        << (bs->pos & 7);
+    int pairs_to_decode, np, bs_sh = (bs->pos & 7) - 8;
+    bs_next_ptr += 4;
+
+    while (big_val_cnt > 0) {
+        int tab_num = gr_info->table_select[ireg];
+        int sfb_cnt = gr_info->region_count[ireg++];
+        const int16_t *codebook = tabs + tabindex[tab_num];
+        int linbits = g_linbits[tab_num];
+        if (linbits) {
+            do {
+                np = *sfb++ / 2;
+                pairs_to_decode = MINIMP3_MIN(big_val_cnt, np);
+                one = *scf++;
+                do {
+                    int j, w = 5;
+                    int leaf = codebook[PEEK_BITS(w)];
+                    while (leaf < 0) {
+                        FLUSH_BITS(w);
+                        w = leaf & 7;
+                        leaf = codebook[PEEK_BITS(w) - (leaf >> 3)];
+                    }
+                    FLUSH_BITS(leaf >> 8);
+
+                    for (j = 0; j < 2; j++, dst++, leaf >>= 4) {
+                        int lsb = leaf & 0x0F;
+                        if (lsb == 15) {
+                            lsb += PEEK_BITS(linbits);
+                            FLUSH_BITS(linbits);
+                            CHECK_BITS;
+                            *dst = one * L3_pow_43(lsb) *
+                                   ((int32_t)bs_cache < 0 ? -1 : 1);
+                        } else {
+                            *dst =
+                                g_pow43[16 + lsb - 16 * (bs_cache >> 31)] * one;
+                        }
+                        FLUSH_BITS(lsb ? 1 : 0);
+                    }
+                    CHECK_BITS;
+                } while (--pairs_to_decode);
+            } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
+        } else {
+            do {
+                np = *sfb++ / 2;
+                pairs_to_decode = MINIMP3_MIN(big_val_cnt, np);
+                one = *scf++;
+                do {
+                    int j, w = 5;
+                    int leaf = codebook[PEEK_BITS(w)];
+                    while (leaf < 0) {
+                        FLUSH_BITS(w);
+                        w = leaf & 7;
+                        leaf = codebook[PEEK_BITS(w) - (leaf >> 3)];
+                    }
+                    FLUSH_BITS(leaf >> 8);
+
+                    for (j = 0; j < 2; j++, dst++, leaf >>= 4) {
+                        int lsb = leaf & 0x0F;
+                        *dst = g_pow43[16 + lsb - 16 * (bs_cache >> 31)] * one;
+                        FLUSH_BITS(lsb ? 1 : 0);
+                    }
+                    CHECK_BITS;
+                } while (--pairs_to_decode);
+            } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
+        }
+    }
+
+    for (np = 1 - big_val_cnt;; dst += 4) {
+        const uint8_t *codebook_count1 =
+            (gr_info->count1_table) ? tab33 : tab32;
+        int leaf = codebook_count1[PEEK_BITS(4)];
+        if (!(leaf & 8)) {
+            leaf = codebook_count1[(leaf >> 3) +
+                                   (bs_cache << 4 >> (32 - (leaf & 3)))];
+        }
+        FLUSH_BITS(leaf & 7);
+        if (BSPOS > layer3gr_limit) {
+            break;
+        }
+#define RELOAD_SCALEFACTOR \
+    if (!--np) {           \
+        np = *sfb++ / 2;   \
+        if (!np) break;    \
+        one = *scf++;      \
+    }
+#define DEQ_COUNT1(s)                                  \
+    if (leaf & (128 >> s)) {                           \
+        dst[s] = ((int32_t)bs_cache < 0) ? -one : one; \
+        FLUSH_BITS(1)                                  \
+    }
+        RELOAD_SCALEFACTOR;
+        DEQ_COUNT1(0);
+        DEQ_COUNT1(1);
+        RELOAD_SCALEFACTOR;
+        DEQ_COUNT1(2);
+        DEQ_COUNT1(3);
+        CHECK_BITS;
+    }
+
+    bs->pos = layer3gr_limit;
+}
+
+static void L3_midside_stereo(float *left, int n) {
+    int i = 0;
+    float *right = left + 576;
+#if HAVE_SIMD
+    if (have_simd()) {
+        for (; i < n - 3; i += 4) {
+            f4 vl = VLD(left + i);
+            f4 vr = VLD(right + i);
+            VSTORE(left + i, VADD(vl, vr));
+            VSTORE(right + i, VSUB(vl, vr));
+        }
+#ifdef __GNUC__
+        /* Workaround for spurious -Waggressive-loop-optimizations warning from
+         * gcc. For more info see: https://github.com/lieff/minimp3/issues/88
+         */
+        if (__builtin_constant_p(n % 4 == 0) && n % 4 == 0) return;
+#endif
+    }
+#endif /* HAVE_SIMD */
+    for (; i < n; i++) {
+        float a = left[i];
+        float b = right[i];
+        left[i] = a + b;
+        right[i] = a - b;
+    }
+}
+
+static void L3_intensity_stereo_band(float *left, int n, float kl, float kr) {
+    int i;
+    for (i = 0; i < n; i++) {
+        left[i + 576] = left[i] * kr;
+        left[i] = left[i] * kl;
+    }
+}
+
+static void L3_stereo_top_band(const float *right, const uint8_t *sfb,
+                               int nbands, int max_band[3]) {
+    int i, k;
+
+    max_band[0] = max_band[1] = max_band[2] = -1;
+
+    for (i = 0; i < nbands; i++) {
+        for (k = 0; k < sfb[i]; k += 2) {
+            if (right[k] != 0 || right[k + 1] != 0) {
+                max_band[i % 3] = i;
+                break;
+            }
+        }
+        right += sfb[i];
+    }
+}
+
+static void L3_stereo_process(float *left, const uint8_t *ist_pos,
+                              const uint8_t *sfb, const uint8_t *hdr,
+                              int max_band[3], int mpeg2_sh) {
+    static const float g_pan[7 * 2] = {
+        0,    1,    0.21132487f, 0.78867513f, 0.36602540f, 0.63397460f,
+        0.5f, 0.5f, 0.63397460f, 0.36602540f, 0.78867513f, 0.21132487f,
+        1,    0
+    };
+    unsigned i, max_pos = HDR_TEST_MPEG1(hdr) ? 7 : 64;
+
+    for (i = 0; sfb[i]; i++) {
+        unsigned ipos = ist_pos[i];
+        if ((int)i > max_band[i % 3] && ipos < max_pos) {
+            float kl, kr, s = HDR_TEST_MS_STEREO(hdr) ? 1.41421356f : 1;
+            if (HDR_TEST_MPEG1(hdr)) {
+                kl = g_pan[2 * ipos];
+                kr = g_pan[2 * ipos + 1];
+            } else {
+                kl = 1;
+                kr = L3_ldexp_q2(1, (ipos + 1) >> 1 << mpeg2_sh);
+                if (ipos & 1) {
+                    kl = kr;
+                    kr = 1;
+                }
+            }
+            L3_intensity_stereo_band(left, sfb[i], kl * s, kr * s);
+        } else if (HDR_TEST_MS_STEREO(hdr)) {
+            L3_midside_stereo(left, sfb[i]);
+        }
+        left += sfb[i];
+    }
+}
+
+static void L3_intensity_stereo(float *left, uint8_t *ist_pos,
+                                const L3_gr_info_t *gr, const uint8_t *hdr) {
+    int max_band[3], n_sfb = gr->n_long_sfb + gr->n_short_sfb;
+    int i, max_blocks = gr->n_short_sfb ? 3 : 1;
+
+    L3_stereo_top_band(left + 576, gr->sfbtab, n_sfb, max_band);
+    if (gr->n_long_sfb) {
+        max_band[0] = max_band[1] = max_band[2] =
+            MINIMP3_MAX(MINIMP3_MAX(max_band[0], max_band[1]), max_band[2]);
+    }
+    for (i = 0; i < max_blocks; i++) {
+        int default_pos = HDR_TEST_MPEG1(hdr) ? 3 : 0;
+        int itop = n_sfb - max_blocks + i;
+        int prev = itop - max_blocks;
+        ist_pos[itop] = max_band[i] >= prev ? default_pos : ist_pos[prev];
+    }
+    L3_stereo_process(left, ist_pos, gr->sfbtab, hdr, max_band,
+                      gr[1].scalefac_compress & 1);
+}
+
+static void L3_reorder(float *grbuf, float *scratch, const uint8_t *sfb) {
+    int i, len;
+    float *src = grbuf, *dst = scratch;
+
+    for (; 0 != (len = *sfb); sfb += 3, src += 2 * len) {
+        for (i = 0; i < len; i++, src++) {
+            *dst++ = src[0 * len];
+            *dst++ = src[1 * len];
+            *dst++ = src[2 * len];
+        }
+    }
+    memcpy(grbuf, scratch, (dst - scratch) * sizeof(float));
+}
+
+static void L3_antialias(float *grbuf, int nbands) {
+    static const float g_aa[2][8] = {
+        { 0.85749293f, 0.88174200f, 0.94962865f, 0.98331459f, 0.99551782f,
+          0.99916056f, 0.99989920f, 0.99999316f },
+        { 0.51449576f, 0.47173197f, 0.31337745f, 0.18191320f, 0.09457419f,
+          0.04096558f, 0.01419856f, 0.00369997f }
+    };
+
+    for (; nbands > 0; nbands--, grbuf += 18) {
+        int i = 0;
+#if HAVE_SIMD
+        if (have_simd())
+            for (; i < 8; i += 4) {
+                f4 vu = VLD(grbuf + 18 + i);
+                f4 vd = VLD(grbuf + 14 - i);
+                f4 vc0 = VLD(g_aa[0] + i);
+                f4 vc1 = VLD(g_aa[1] + i);
+                vd = VREV(vd);
+                VSTORE(grbuf + 18 + i, VSUB(VMUL(vu, vc0), VMUL(vd, vc1)));
+                vd = VADD(VMUL(vu, vc1), VMUL(vd, vc0));
+                VSTORE(grbuf + 14 - i, VREV(vd));
+            }
+#endif /* HAVE_SIMD */
+#ifndef MINIMP3_ONLY_SIMD
+        for (; i < 8; i++) {
+            float u = grbuf[18 + i];
+            float d = grbuf[17 - i];
+            grbuf[18 + i] = u * g_aa[0][i] - d * g_aa[1][i];
+            grbuf[17 - i] = u * g_aa[1][i] + d * g_aa[0][i];
+        }
+#endif /* MINIMP3_ONLY_SIMD */
+    }
+}
+
+static void L3_dct3_9(float *y) {
+    float s0, s1, s2, s3, s4, s5, s6, s7, s8, t0, t2, t4;
+
+    s0 = y[0];
+    s2 = y[2];
+    s4 = y[4];
+    s6 = y[6];
+    s8 = y[8];
+    t0 = s0 + s6 * 0.5f;
+    s0 -= s6;
+    t4 = (s4 + s2) * 0.93969262f;
+    t2 = (s8 + s2) * 0.76604444f;
+    s6 = (s4 - s8) * 0.17364818f;
+    s4 += s8 - s2;
+
+    s2 = s0 - s4 * 0.5f;
+    y[4] = s4 + s0;
+    s8 = t0 - t2 + s6;
+    s0 = t0 - t4 + t2;
+    s4 = t0 + t4 - s6;
+
+    s1 = y[1];
+    s3 = y[3];
+    s5 = y[5];
+    s7 = y[7];
+
+    s3 *= 0.86602540f;
+    t0 = (s5 + s1) * 0.98480775f;
+    t4 = (s5 - s7) * 0.34202014f;
+    t2 = (s1 + s7) * 0.64278761f;
+    s1 = (s1 - s5 - s7) * 0.86602540f;
+
+    s5 = t0 - s3 - t2;
+    s7 = t4 - s3 - t0;
+    s3 = t4 + s3 - t2;
+
+    y[0] = s4 - s7;
+    y[1] = s2 + s1;
+    y[2] = s0 - s3;
+    y[3] = s8 + s5;
+    y[5] = s8 - s5;
+    y[6] = s0 + s3;
+    y[7] = s2 - s1;
+    y[8] = s4 + s7;
+}
+
+static void L3_imdct36(float *grbuf, float *overlap, const float *window,
+                       int nbands) {
+    int i, j;
+    static const float g_twid9[18] = { 0.73727734f, 0.79335334f, 0.84339145f,
+                                       0.88701083f, 0.92387953f, 0.95371695f,
+                                       0.97629601f, 0.99144486f, 0.99904822f,
+                                       0.67559021f, 0.60876143f, 0.53729961f,
+                                       0.46174861f, 0.38268343f, 0.30070580f,
+                                       0.21643961f, 0.13052619f, 0.04361938f };
+
+    for (j = 0; j < nbands; j++, grbuf += 18, overlap += 9) {
+        float co[9], si[9];
+        co[0] = -grbuf[0];
+        si[0] = grbuf[17];
+        for (i = 0; i < 4; i++) {
+            si[8 - 2 * i] = grbuf[4 * i + 1] - grbuf[4 * i + 2];
+            co[1 + 2 * i] = grbuf[4 * i + 1] + grbuf[4 * i + 2];
+            si[7 - 2 * i] = grbuf[4 * i + 4] - grbuf[4 * i + 3];
+            co[2 + 2 * i] = -(grbuf[4 * i + 3] + grbuf[4 * i + 4]);
+        }
+        L3_dct3_9(co);
+        L3_dct3_9(si);
+
+        si[1] = -si[1];
+        si[3] = -si[3];
+        si[5] = -si[5];
+        si[7] = -si[7];
+
+        i = 0;
+
+#if HAVE_SIMD
+        if (have_simd())
+            for (; i < 8; i += 4) {
+                f4 vovl = VLD(overlap + i);
+                f4 vc = VLD(co + i);
+                f4 vs = VLD(si + i);
+                f4 vr0 = VLD(g_twid9 + i);
+                f4 vr1 = VLD(g_twid9 + 9 + i);
+                f4 vw0 = VLD(window + i);
+                f4 vw1 = VLD(window + 9 + i);
+                f4 vsum = VADD(VMUL(vc, vr1), VMUL(vs, vr0));
+                VSTORE(overlap + i, VSUB(VMUL(vc, vr0), VMUL(vs, vr1)));
+                VSTORE(grbuf + i, VSUB(VMUL(vovl, vw0), VMUL(vsum, vw1)));
+                vsum = VADD(VMUL(vovl, vw1), VMUL(vsum, vw0));
+                VSTORE(grbuf + 14 - i, VREV(vsum));
+            }
+#endif /* HAVE_SIMD */
+        for (; i < 9; i++) {
+            float ovl = overlap[i];
+            float sum = co[i] * g_twid9[9 + i] + si[i] * g_twid9[0 + i];
+            overlap[i] = co[i] * g_twid9[0 + i] - si[i] * g_twid9[9 + i];
+            grbuf[i] = ovl * window[0 + i] - sum * window[9 + i];
+            grbuf[17 - i] = ovl * window[9 + i] + sum * window[0 + i];
+        }
+    }
+}
+
+static void L3_idct3(float x0, float x1, float x2, float *dst) {
+    float m1 = x1 * 0.86602540f;
+    float a1 = x0 - x2 * 0.5f;
+    dst[1] = x0 + x2;
+    dst[0] = a1 + m1;
+    dst[2] = a1 - m1;
+}
+
+static void L3_imdct12(float *x, float *dst, float *overlap) {
+    static const float g_twid3[6] = { 0.79335334f, 0.92387953f, 0.99144486f,
+                                      0.60876143f, 0.38268343f, 0.13052619f };
+    float co[3], si[3];
+    int i;
+
+    L3_idct3(-x[0], x[6] + x[3], x[12] + x[9], co);
+    L3_idct3(x[15], x[12] - x[9], x[6] - x[3], si);
+    si[1] = -si[1];
+
+    for (i = 0; i < 3; i++) {
+        float ovl = overlap[i];
+        float sum = co[i] * g_twid3[3 + i] + si[i] * g_twid3[0 + i];
+        overlap[i] = co[i] * g_twid3[0 + i] - si[i] * g_twid3[3 + i];
+        dst[i] = ovl * g_twid3[2 - i] - sum * g_twid3[5 - i];
+        dst[5 - i] = ovl * g_twid3[5 - i] + sum * g_twid3[2 - i];
+    }
+}
+
+static void L3_imdct_short(float *grbuf, float *overlap, int nbands) {
+    for (; nbands > 0; nbands--, overlap += 9, grbuf += 18) {
+        float tmp[18];
+        memcpy(tmp, grbuf, sizeof(tmp));
+        memcpy(grbuf, overlap, 6 * sizeof(float));
+        L3_imdct12(tmp, grbuf + 6, overlap + 6);
+        L3_imdct12(tmp + 1, grbuf + 12, overlap + 6);
+        L3_imdct12(tmp + 2, overlap, overlap + 6);
+    }
+}
+
+static void L3_change_sign(float *grbuf) {
+    int b, i;
+    for (b = 0, grbuf += 18; b < 32; b += 2, grbuf += 36)
+        for (i = 1; i < 18; i += 2) grbuf[i] = -grbuf[i];
+}
+
+static void L3_imdct_gr(float *grbuf, float *overlap, unsigned block_type,
+                        unsigned n_long_bands) {
+    static const float g_mdct_window[2][18] = {
+        { 0.99904822f, 0.99144486f, 0.97629601f, 0.95371695f, 0.92387953f,
+          0.88701083f, 0.84339145f, 0.79335334f, 0.73727734f, 0.04361938f,
+          0.13052619f, 0.21643961f, 0.30070580f, 0.38268343f, 0.46174861f,
+          0.53729961f, 0.60876143f, 0.67559021f },
+        { 1, 1, 1, 1, 1, 1, 0.99144486f, 0.92387953f, 0.79335334f, 0, 0, 0, 0,
+          0, 0, 0.13052619f, 0.38268343f, 0.60876143f }
+    };
+    if (n_long_bands) {
+        L3_imdct36(grbuf, overlap, g_mdct_window[0], n_long_bands);
+        grbuf += 18 * n_long_bands;
+        overlap += 9 * n_long_bands;
+    }
+    if (block_type == SHORT_BLOCK_TYPE)
+        L3_imdct_short(grbuf, overlap, 32 - n_long_bands);
+    else
+        L3_imdct36(grbuf, overlap, g_mdct_window[block_type == STOP_BLOCK_TYPE],
+                   32 - n_long_bands);
+}
+
+static void L3_save_reservoir(mp3dec_t *h, mp3dec_scratch_t *s) {
+    int pos = (s->bs.pos + 7) / 8u;
+    int remains = s->bs.limit / 8u - pos;
+    if (remains > MAX_BITRESERVOIR_BYTES) {
+        pos += remains - MAX_BITRESERVOIR_BYTES;
+        remains = MAX_BITRESERVOIR_BYTES;
+    }
+    if (remains > 0) {
+        memmove(h->reserv_buf, s->maindata + pos, remains);
+    }
+    h->reserv = remains;
+}
+
+static int L3_restore_reservoir(mp3dec_t *h, bs_t *bs, mp3dec_scratch_t *s,
+                                int main_data_begin) {
+    int frame_bytes = (bs->limit - bs->pos) / 8;
+    int bytes_have = MINIMP3_MIN(h->reserv, main_data_begin);
+    memcpy(s->maindata,
+           h->reserv_buf + MINIMP3_MAX(0, h->reserv - main_data_begin),
+           MINIMP3_MIN(h->reserv, main_data_begin));
+    memcpy(s->maindata + bytes_have, bs->buf + bs->pos / 8, frame_bytes);
+    bs_init(&s->bs, s->maindata, bytes_have + frame_bytes);
+    return h->reserv >= main_data_begin;
+}
+
+static void L3_decode(mp3dec_t *h, mp3dec_scratch_t *s, L3_gr_info_t *gr_info,
+                      int nch) {
+    int ch;
+
+    for (ch = 0; ch < nch; ch++) {
+        int layer3gr_limit = s->bs.pos + gr_info[ch].part_23_length;
+        L3_decode_scalefactors(h->header, s->ist_pos[ch], &s->bs, gr_info + ch,
+                               s->scf, ch);
+        L3_huffman(s->grbuf[ch], &s->bs, gr_info + ch, s->scf, layer3gr_limit);
+    }
+
+    if (HDR_TEST_I_STEREO(h->header)) {
+        L3_intensity_stereo(s->grbuf[0], s->ist_pos[1], gr_info, h->header);
+    } else if (HDR_IS_MS_STEREO(h->header)) {
+        L3_midside_stereo(s->grbuf[0], 576);
+    }
+
+    for (ch = 0; ch < nch; ch++, gr_info++) {
+        int aa_bands = 31;
+        int n_long_bands = (gr_info->mixed_block_flag ? 2 : 0)
+                           << (int)(HDR_GET_MY_SAMPLE_RATE(h->header) == 2);
+
+        if (gr_info->n_short_sfb) {
+            aa_bands = n_long_bands - 1;
+            L3_reorder(s->grbuf[ch] + n_long_bands * 18, s->syn[0],
+                       gr_info->sfbtab + gr_info->n_long_sfb);
+        }
+
+        L3_antialias(s->grbuf[ch], aa_bands);
+        L3_imdct_gr(s->grbuf[ch], h->mdct_overlap[ch], gr_info->block_type,
+                    n_long_bands);
+        L3_change_sign(s->grbuf[ch]);
+    }
+}
+
+static void mp3d_DCT_II(float *grbuf, int n) {
+    static const float g_sec[24] = {
+        10.19000816f, 0.50060302f, 0.50241929f, 3.40760851f, 0.50547093f,
+        0.52249861f,  2.05778098f, 0.51544732f, 0.56694406f, 1.48416460f,
+        0.53104258f,  0.64682180f, 1.16943991f, 0.55310392f, 0.78815460f,
+        0.97256821f,  0.58293498f, 1.06067765f, 0.83934963f, 0.62250412f,
+        1.72244716f,  0.74453628f, 0.67480832f, 5.10114861f
+    };
+    int i, k = 0;
+#if HAVE_SIMD
+    if (have_simd())
+        for (; k < n; k += 4) {
+            f4 t[4][8], *x;
+            float *y = grbuf + k;
+
+            for (x = t[0], i = 0; i < 8; i++, x++) {
+                f4 x0 = VLD(&y[i * 18]);
+                f4 x1 = VLD(&y[(15 - i) * 18]);
+                f4 x2 = VLD(&y[(16 + i) * 18]);
+                f4 x3 = VLD(&y[(31 - i) * 18]);
+                f4 t0 = VADD(x0, x3);
+                f4 t1 = VADD(x1, x2);
+                f4 t2 = VMUL_S(VSUB(x1, x2), g_sec[3 * i + 0]);
+                f4 t3 = VMUL_S(VSUB(x0, x3), g_sec[3 * i + 1]);
+                x[0] = VADD(t0, t1);
+                x[8] = VMUL_S(VSUB(t0, t1), g_sec[3 * i + 2]);
+                x[16] = VADD(t3, t2);
+                x[24] = VMUL_S(VSUB(t3, t2), g_sec[3 * i + 2]);
+            }
+            for (x = t[0], i = 0; i < 4; i++, x += 8) {
+                f4 x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3], x4 = x[4],
+                   x5 = x[5], x6 = x[6], x7 = x[7], xt;
+                xt = VSUB(x0, x7);
+                x0 = VADD(x0, x7);
+                x7 = VSUB(x1, x6);
+                x1 = VADD(x1, x6);
+                x6 = VSUB(x2, x5);
+                x2 = VADD(x2, x5);
+                x5 = VSUB(x3, x4);
+                x3 = VADD(x3, x4);
+                x4 = VSUB(x0, x3);
+                x0 = VADD(x0, x3);
+                x3 = VSUB(x1, x2);
+                x1 = VADD(x1, x2);
+                x[0] = VADD(x0, x1);
+                x[4] = VMUL_S(VSUB(x0, x1), 0.70710677f);
+                x5 = VADD(x5, x6);
+                x6 = VMUL_S(VADD(x6, x7), 0.70710677f);
+                x7 = VADD(x7, xt);
+                x3 = VMUL_S(VADD(x3, x4), 0.70710677f);
+                x5 = VSUB(x5, VMUL_S(x7, 0.198912367f)); /* rotate by PI/8 */
+                x7 = VADD(x7, VMUL_S(x5, 0.382683432f));
+                x5 = VSUB(x5, VMUL_S(x7, 0.198912367f));
+                x0 = VSUB(xt, x6);
+                xt = VADD(xt, x6);
+                x[1] = VMUL_S(VADD(xt, x7), 0.50979561f);
+                x[2] = VMUL_S(VADD(x4, x3), 0.54119611f);
+                x[3] = VMUL_S(VSUB(x0, x5), 0.60134488f);
+                x[5] = VMUL_S(VADD(x0, x5), 0.89997619f);
+                x[6] = VMUL_S(VSUB(x4, x3), 1.30656302f);
+                x[7] = VMUL_S(VSUB(xt, x7), 2.56291556f);
+            }
+
+            if (k > n - 3) {
+#if HAVE_SSE
+#define VSAVE2(i, v) _mm_storel_pi((__m64 *)(void *)&y[i * 18], v)
+#else /* HAVE_SSE */
+#define VSAVE2(i, v) vst1_f32((float32_t *)&y[i * 18], vget_low_f32(v))
+#endif /* HAVE_SSE */
+                for (i = 0; i < 7; i++, y += 4 * 18) {
+                    f4 s = VADD(t[3][i], t[3][i + 1]);
+                    VSAVE2(0, t[0][i]);
+                    VSAVE2(1, VADD(t[2][i], s));
+                    VSAVE2(2, VADD(t[1][i], t[1][i + 1]));
+                    VSAVE2(3, VADD(t[2][1 + i], s));
+                }
+                VSAVE2(0, t[0][7]);
+                VSAVE2(1, VADD(t[2][7], t[3][7]));
+                VSAVE2(2, t[1][7]);
+                VSAVE2(3, t[3][7]);
+            } else {
+#define VSAVE4(i, v) VSTORE(&y[i * 18], v)
+                for (i = 0; i < 7; i++, y += 4 * 18) {
+                    f4 s = VADD(t[3][i], t[3][i + 1]);
+                    VSAVE4(0, t[0][i]);
+                    VSAVE4(1, VADD(t[2][i], s));
+                    VSAVE4(2, VADD(t[1][i], t[1][i + 1]));
+                    VSAVE4(3, VADD(t[2][1 + i], s));
+                }
+                VSAVE4(0, t[0][7]);
+                VSAVE4(1, VADD(t[2][7], t[3][7]));
+                VSAVE4(2, t[1][7]);
+                VSAVE4(3, t[3][7]);
+            }
+        }
+    else
+#endif /* HAVE_SIMD */
+#ifdef MINIMP3_ONLY_SIMD
+    {
+    }  /* for HAVE_SIMD=1, MINIMP3_ONLY_SIMD=1 case we do not need non-intrinsic
+          "else" branch */
+#else  /* MINIMP3_ONLY_SIMD */
+    for (; k < n; k++) {
+        float t[4][8], *x, *y = grbuf + k;
+
+        for (x = t[0], i = 0; i < 8; i++, x++) {
+            float x0 = y[i * 18];
+            float x1 = y[(15 - i) * 18];
+            float x2 = y[(16 + i) * 18];
+            float x3 = y[(31 - i) * 18];
+            float t0 = x0 + x3;
+            float t1 = x1 + x2;
+            float t2 = (x1 - x2) * g_sec[3 * i + 0];
+            float t3 = (x0 - x3) * g_sec[3 * i + 1];
+            x[0] = t0 + t1;
+            x[8] = (t0 - t1) * g_sec[3 * i + 2];
+            x[16] = t3 + t2;
+            x[24] = (t3 - t2) * g_sec[3 * i + 2];
+        }
+        for (x = t[0], i = 0; i < 4; i++, x += 8) {
+            float x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3], x4 = x[4],
+                  x5 = x[5], x6 = x[6], x7 = x[7], xt;
+            xt = x0 - x7;
+            x0 += x7;
+            x7 = x1 - x6;
+            x1 += x6;
+            x6 = x2 - x5;
+            x2 += x5;
+            x5 = x3 - x4;
+            x3 += x4;
+            x4 = x0 - x3;
+            x0 += x3;
+            x3 = x1 - x2;
+            x1 += x2;
+            x[0] = x0 + x1;
+            x[4] = (x0 - x1) * 0.70710677f;
+            x5 = x5 + x6;
+            x6 = (x6 + x7) * 0.70710677f;
+            x7 = x7 + xt;
+            x3 = (x3 + x4) * 0.70710677f;
+            x5 -= x7 * 0.198912367f; /* rotate by PI/8 */
+            x7 += x5 * 0.382683432f;
+            x5 -= x7 * 0.198912367f;
+            x0 = xt - x6;
+            xt += x6;
+            x[1] = (xt + x7) * 0.50979561f;
+            x[2] = (x4 + x3) * 0.54119611f;
+            x[3] = (x0 - x5) * 0.60134488f;
+            x[5] = (x0 + x5) * 0.89997619f;
+            x[6] = (x4 - x3) * 1.30656302f;
+            x[7] = (xt - x7) * 2.56291556f;
+        }
+        for (i = 0; i < 7; i++, y += 4 * 18) {
+            y[0 * 18] = t[0][i];
+            y[1 * 18] = t[2][i] + t[3][i] + t[3][i + 1];
+            y[2 * 18] = t[1][i] + t[1][i + 1];
+            y[3 * 18] = t[2][i + 1] + t[3][i] + t[3][i + 1];
+        }
+        y[0 * 18] = t[0][7];
+        y[1 * 18] = t[2][7] + t[3][7];
+        y[2 * 18] = t[1][7];
+        y[3 * 18] = t[3][7];
+    }
+#endif /* MINIMP3_ONLY_SIMD */
+}
+
+#ifndef MINIMP3_FLOAT_OUTPUT
+static int16_t mp3d_scale_pcm(float sample) {
+#if HAVE_ARMV6
+    int32_t s32 = (int32_t)(sample + .5f);
+    s32 -= (s32 < 0);
+    int16_t s = (int16_t)minimp3_clip_int16_arm(s32);
+#else
+    if (sample >= 32766.5) return (int16_t)32767;
+    if (sample <= -32767.5) return (int16_t)-32768;
+    int16_t s = (int16_t)(sample + .5f);
+    s -= (s < 0); /* away from zero, to be compliant */
+#endif
+    return s;
+}
+#else  /* MINIMP3_FLOAT_OUTPUT */
+static float mp3d_scale_pcm(float sample) { return sample * (1.f / 32768.f); }
+#endif /* MINIMP3_FLOAT_OUTPUT */
+
+static void mp3d_synth_pair(mp3d_sample_t *pcm, int nch, const float *z) {
+    float a;
+    a = (z[14 * 64] - z[0]) * 29;
+    a += (z[1 * 64] + z[13 * 64]) * 213;
+    a += (z[12 * 64] - z[2 * 64]) * 459;
+    a += (z[3 * 64] + z[11 * 64]) * 2037;
+    a += (z[10 * 64] - z[4 * 64]) * 5153;
+    a += (z[5 * 64] + z[9 * 64]) * 6574;
+    a += (z[8 * 64] - z[6 * 64]) * 37489;
+    a += z[7 * 64] * 75038;
+    pcm[0] = mp3d_scale_pcm(a);
+
+    z += 2;
+    a = z[14 * 64] * 104;
+    a += z[12 * 64] * 1567;
+    a += z[10 * 64] * 9727;
+    a += z[8 * 64] * 64019;
+    a += z[6 * 64] * -9975;
+    a += z[4 * 64] * -45;
+    a += z[2 * 64] * 146;
+    a += z[0 * 64] * -5;
+    pcm[16 * nch] = mp3d_scale_pcm(a);
+}
+
+static void mp3d_synth(float *xl, mp3d_sample_t *dstl, int nch, float *lins) {
+    int i;
+    float *xr = xl + 576 * (nch - 1);
+    mp3d_sample_t *dstr = dstl + (nch - 1);
+
+    static const float g_win[] = {
+        -1,     26,     -31,    208,    218,    401,    -519,   2063,   2000,
+        4788,   -5517,  7134,   5959,   35640,  -39336, 74992,  -1,     24,
+        -35,    202,    222,    347,    -581,   2080,   1952,   4425,   -5879,
+        7640,   5288,   33791,  -41176, 74856,  -1,     21,     -38,    196,
+        225,    294,    -645,   2087,   1893,   4063,   -6237,  8092,   4561,
+        31947,  -43006, 74630,  -1,     19,     -41,    190,    227,    244,
+        -711,   2085,   1822,   3705,   -6589,  8492,   3776,   30112,  -44821,
+        74313,  -1,     17,     -45,    183,    228,    197,    -779,   2075,
+        1739,   3351,   -6935,  8840,   2935,   28289,  -46617, 73908,  -1,
+        16,     -49,    176,    228,    153,    -848,   2057,   1644,   3004,
+        -7271,  9139,   2037,   26482,  -48390, 73415,  -2,     14,     -53,
+        169,    227,    111,    -919,   2032,   1535,   2663,   -7597,  9389,
+        1082,   24694,  -50137, 72835,  -2,     13,     -58,    161,    224,
+        72,     -991,   2001,   1414,   2330,   -7910,  9592,   70,     22929,
+        -51853, 72169,  -2,     11,     -63,    154,    221,    36,     -1064,
+        1962,   1280,   2006,   -8209,  9750,   -998,   21189,  -53534, 71420,
+        -2,     10,     -68,    147,    215,    2,      -1137,  1919,   1131,
+        1692,   -8491,  9863,   -2122,  19478,  -55178, 70590,  -3,     9,
+        -73,    139,    208,    -29,    -1210,  1870,   970,    1388,   -8755,
+        9935,   -3300,  17799,  -56778, 69679,  -3,     8,      -79,    132,
+        200,    -57,    -1283,  1817,   794,    1095,   -8998,  9966,   -4533,
+        16155,  -58333, 68692,  -4,     7,      -85,    125,    189,    -83,
+        -1356,  1759,   605,    814,    -9219,  9959,   -5818,  14548,  -59838,
+        67629,  -4,     7,      -91,    117,    177,    -106,   -1428,  1698,
+        402,    545,    -9416,  9916,   -7154,  12980,  -61289, 66494,  -5,
+        6,      -97,    111,    163,    -127,   -1498,  1634,   185,    288,
+        -9585,  9838,   -8540,  11455,  -62684, 65290
+    };
+    float *zlin = lins + 15 * 64;
+    const float *w = g_win;
+
+    zlin[4 * 15] = xl[18 * 16];
+    zlin[4 * 15 + 1] = xr[18 * 16];
+    zlin[4 * 15 + 2] = xl[0];
+    zlin[4 * 15 + 3] = xr[0];
+
+    zlin[4 * 31] = xl[1 + 18 * 16];
+    zlin[4 * 31 + 1] = xr[1 + 18 * 16];
+    zlin[4 * 31 + 2] = xl[1];
+    zlin[4 * 31 + 3] = xr[1];
+
+    mp3d_synth_pair(dstr, nch, lins + 4 * 15 + 1);
+    mp3d_synth_pair(dstr + 32 * nch, nch, lins + 4 * 15 + 64 + 1);
+    mp3d_synth_pair(dstl, nch, lins + 4 * 15);
+    mp3d_synth_pair(dstl + 32 * nch, nch, lins + 4 * 15 + 64);
+
+#if HAVE_SIMD
+    if (have_simd())
+        for (i = 14; i >= 0; i--) {
+#define VLOAD(k)                        \
+    f4 w0 = VSET(*w++);                 \
+    f4 w1 = VSET(*w++);                 \
+    f4 vz = VLD(&zlin[4 * i - 64 * k]); \
+    f4 vy = VLD(&zlin[4 * i - 64 * (15 - k)]);
+#define V0(k)                                          \
+    {                                                  \
+        VLOAD(k) b = VADD(VMUL(vz, w1), VMUL(vy, w0)); \
+        a = VSUB(VMUL(vz, w0), VMUL(vy, w1));          \
+    }
+#define V1(k)                                                   \
+    {                                                           \
+        VLOAD(k) b = VADD(b, VADD(VMUL(vz, w1), VMUL(vy, w0))); \
+        a = VADD(a, VSUB(VMUL(vz, w0), VMUL(vy, w1)));          \
+    }
+#define V2(k)                                                   \
+    {                                                           \
+        VLOAD(k) b = VADD(b, VADD(VMUL(vz, w1), VMUL(vy, w0))); \
+        a = VADD(a, VSUB(VMUL(vy, w1), VMUL(vz, w0)));          \
+    }
+            f4 a, b;
+            zlin[4 * i] = xl[18 * (31 - i)];
+            zlin[4 * i + 1] = xr[18 * (31 - i)];
+            zlin[4 * i + 2] = xl[1 + 18 * (31 - i)];
+            zlin[4 * i + 3] = xr[1 + 18 * (31 - i)];
+            zlin[4 * i + 64] = xl[1 + 18 * (1 + i)];
+            zlin[4 * i + 64 + 1] = xr[1 + 18 * (1 + i)];
+            zlin[4 * i - 64 + 2] = xl[18 * (1 + i)];
+            zlin[4 * i - 64 + 3] = xr[18 * (1 + i)];
+
+            V0(0)
+            V2(1)
+            V1(2)
+            V2(3)
+            V1(4)
+            V2(5)
+            V1(6)
+            V2(7)
+
+            {
+#ifndef MINIMP3_FLOAT_OUTPUT
+#if HAVE_SSE
+                static const f4 g_max = { 32767.0f, 32767.0f, 32767.0f,
+                                          32767.0f };
+                static const f4 g_min = { -32768.0f, -32768.0f, -32768.0f,
+                                          -32768.0f };
+                __m128i pcm8 = _mm_packs_epi32(
+                    _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(a, g_max), g_min)),
+                    _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(b, g_max), g_min)));
+                dstr[(15 - i) * nch] = _mm_extract_epi16(pcm8, 1);
+                dstr[(17 + i) * nch] = _mm_extract_epi16(pcm8, 5);
+                dstl[(15 - i) * nch] = _mm_extract_epi16(pcm8, 0);
+                dstl[(17 + i) * nch] = _mm_extract_epi16(pcm8, 4);
+                dstr[(47 - i) * nch] = _mm_extract_epi16(pcm8, 3);
+                dstr[(49 + i) * nch] = _mm_extract_epi16(pcm8, 7);
+                dstl[(47 - i) * nch] = _mm_extract_epi16(pcm8, 2);
+                dstl[(49 + i) * nch] = _mm_extract_epi16(pcm8, 6);
+#else  /* HAVE_SSE */
+                int16x4_t pcma, pcmb;
+                a = VADD(a, VSET(0.5f));
+                b = VADD(b, VSET(0.5f));
+                pcma = vqmovn_s32(
+                    vqaddq_s32(vcvtq_s32_f32(a),
+                               vreinterpretq_s32_u32(vcltq_f32(a, VSET(0)))));
+                pcmb = vqmovn_s32(
+                    vqaddq_s32(vcvtq_s32_f32(b),
+                               vreinterpretq_s32_u32(vcltq_f32(b, VSET(0)))));
+                vst1_lane_s16(dstr + (15 - i) * nch, pcma, 1);
+                vst1_lane_s16(dstr + (17 + i) * nch, pcmb, 1);
+                vst1_lane_s16(dstl + (15 - i) * nch, pcma, 0);
+                vst1_lane_s16(dstl + (17 + i) * nch, pcmb, 0);
+                vst1_lane_s16(dstr + (47 - i) * nch, pcma, 3);
+                vst1_lane_s16(dstr + (49 + i) * nch, pcmb, 3);
+                vst1_lane_s16(dstl + (47 - i) * nch, pcma, 2);
+                vst1_lane_s16(dstl + (49 + i) * nch, pcmb, 2);
+#endif /* HAVE_SSE */
+
+#else /* MINIMP3_FLOAT_OUTPUT */
+
+                static const f4 g_scale = { 1.0f / 32768.0f, 1.0f / 32768.0f,
+                                            1.0f / 32768.0f, 1.0f / 32768.0f };
+                a = VMUL(a, g_scale);
+                b = VMUL(b, g_scale);
+#if HAVE_SSE
+                _mm_store_ss(dstr + (15 - i) * nch,
+                             _mm_shuffle_ps(a, a, _MM_SHUFFLE(1, 1, 1, 1)));
+                _mm_store_ss(dstr + (17 + i) * nch,
+                             _mm_shuffle_ps(b, b, _MM_SHUFFLE(1, 1, 1, 1)));
+                _mm_store_ss(dstl + (15 - i) * nch,
+                             _mm_shuffle_ps(a, a, _MM_SHUFFLE(0, 0, 0, 0)));
+                _mm_store_ss(dstl + (17 + i) * nch,
+                             _mm_shuffle_ps(b, b, _MM_SHUFFLE(0, 0, 0, 0)));
+                _mm_store_ss(dstr + (47 - i) * nch,
+                             _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 3, 3, 3)));
+                _mm_store_ss(dstr + (49 + i) * nch,
+                             _mm_shuffle_ps(b, b, _MM_SHUFFLE(3, 3, 3, 3)));
+                _mm_store_ss(dstl + (47 - i) * nch,
+                             _mm_shuffle_ps(a, a, _MM_SHUFFLE(2, 2, 2, 2)));
+                _mm_store_ss(dstl + (49 + i) * nch,
+                             _mm_shuffle_ps(b, b, _MM_SHUFFLE(2, 2, 2, 2)));
+#else  /* HAVE_SSE */
+                vst1q_lane_f32(dstr + (15 - i) * nch, a, 1);
+                vst1q_lane_f32(dstr + (17 + i) * nch, b, 1);
+                vst1q_lane_f32(dstl + (15 - i) * nch, a, 0);
+                vst1q_lane_f32(dstl + (17 + i) * nch, b, 0);
+                vst1q_lane_f32(dstr + (47 - i) * nch, a, 3);
+                vst1q_lane_f32(dstr + (49 + i) * nch, b, 3);
+                vst1q_lane_f32(dstl + (47 - i) * nch, a, 2);
+                vst1q_lane_f32(dstl + (49 + i) * nch, b, 2);
+#endif /* HAVE_SSE */
+#endif /* MINIMP3_FLOAT_OUTPUT */
+            }
+        }
+    else
+#endif /* HAVE_SIMD */
+#ifdef MINIMP3_ONLY_SIMD
+    {
+    } /* for HAVE_SIMD=1, MINIMP3_ONLY_SIMD=1 case we do not need non-intrinsic
+         "else" branch */
+#else /* MINIMP3_ONLY_SIMD */
+    for (i = 14; i >= 0; i--) {
+#define LOAD(k)                        \
+    float w0 = *w++;                   \
+    float w1 = *w++;                   \
+    float *vz = &zlin[4 * i - k * 64]; \
+    float *vy = &zlin[4 * i - (15 - k) * 64];
+#define S0(k)                                                               \
+    {                                                                       \
+        int j;                                                              \
+        LOAD(k);                                                            \
+        for (j = 0; j < 4; j++)                                             \
+            b[j] = vz[j] * w1 + vy[j] * w0, a[j] = vz[j] * w0 - vy[j] * w1; \
+    }
+#define S1(k)                                                                 \
+    {                                                                         \
+        int j;                                                                \
+        LOAD(k);                                                              \
+        for (j = 0; j < 4; j++)                                               \
+            b[j] += vz[j] * w1 + vy[j] * w0, a[j] += vz[j] * w0 - vy[j] * w1; \
+    }
+#define S2(k)                                                                 \
+    {                                                                         \
+        int j;                                                                \
+        LOAD(k);                                                              \
+        for (j = 0; j < 4; j++)                                               \
+            b[j] += vz[j] * w1 + vy[j] * w0, a[j] += vy[j] * w1 - vz[j] * w0; \
+    }
+        float a[4], b[4];
+
+        zlin[4 * i] = xl[18 * (31 - i)];
+        zlin[4 * i + 1] = xr[18 * (31 - i)];
+        zlin[4 * i + 2] = xl[1 + 18 * (31 - i)];
+        zlin[4 * i + 3] = xr[1 + 18 * (31 - i)];
+        zlin[4 * (i + 16)] = xl[1 + 18 * (1 + i)];
+        zlin[4 * (i + 16) + 1] = xr[1 + 18 * (1 + i)];
+        zlin[4 * (i - 16) + 2] = xl[18 * (1 + i)];
+        zlin[4 * (i - 16) + 3] = xr[18 * (1 + i)];
+
+        S0(0)
+        S2(1)
+        S1(2)
+        S2(3)
+        S1(4)
+        S2(5)
+        S1(6)
+        S2(7)
+
+        dstr[(15 - i) * nch] = mp3d_scale_pcm(a[1]);
+        dstr[(17 + i) * nch] = mp3d_scale_pcm(b[1]);
+        dstl[(15 - i) * nch] = mp3d_scale_pcm(a[0]);
+        dstl[(17 + i) * nch] = mp3d_scale_pcm(b[0]);
+        dstr[(47 - i) * nch] = mp3d_scale_pcm(a[3]);
+        dstr[(49 + i) * nch] = mp3d_scale_pcm(b[3]);
+        dstl[(47 - i) * nch] = mp3d_scale_pcm(a[2]);
+        dstl[(49 + i) * nch] = mp3d_scale_pcm(b[2]);
+    }
+#endif /* MINIMP3_ONLY_SIMD */
+}
+
+static void mp3d_synth_granule(float *qmf_state, float *grbuf, int nbands,
+                               int nch, mp3d_sample_t *pcm, float *lins) {
+    int i;
+    for (i = 0; i < nch; i++) {
+        mp3d_DCT_II(grbuf + 576 * i, nbands);
+    }
+
+    memcpy(lins, qmf_state, sizeof(float) * 15 * 64);
+
+    for (i = 0; i < nbands; i += 2) {
+        mp3d_synth(grbuf + i, pcm + 32 * nch * i, nch, lins + i * 64);
+    }
+#ifndef MINIMP3_NONSTANDARD_BUT_LOGICAL
+    if (nch == 1) {
+        for (i = 0; i < 15 * 64; i += 2) {
+            qmf_state[i] = lins[nbands * 64 + i];
+        }
+    } else
+#endif /* MINIMP3_NONSTANDARD_BUT_LOGICAL */
+    {
+        memcpy(qmf_state, lins + nbands * 64, sizeof(float) * 15 * 64);
+    }
+}
+
+static int mp3d_match_frame(const uint8_t *hdr, int mp3_bytes,
+                            int frame_bytes) {
+    int i, nmatch;
+    for (i = 0, nmatch = 0; nmatch < MAX_FRAME_SYNC_MATCHES; nmatch++) {
+        i += hdr_frame_bytes(hdr + i, frame_bytes) + hdr_padding(hdr + i);
+        if (i + HDR_SIZE > mp3_bytes) return nmatch > 0;
+        if (!hdr_compare(hdr, hdr + i)) return 0;
+    }
+    return 1;
+}
+
+static int mp3d_find_frame(const uint8_t *mp3, int mp3_bytes,
+                           int *free_format_bytes, int *ptr_frame_bytes) {
+    int i, k;
+    for (i = 0; i < mp3_bytes - HDR_SIZE; i++, mp3++) {
+        if (hdr_valid(mp3)) {
+            int frame_bytes = hdr_frame_bytes(mp3, *free_format_bytes);
+            int frame_and_padding = frame_bytes + hdr_padding(mp3);
+
+            for (k = HDR_SIZE; !frame_bytes && k < MAX_FREE_FORMAT_FRAME_SIZE &&
+                               i + 2 * k < mp3_bytes - HDR_SIZE;
+                 k++) {
+                if (hdr_compare(mp3, mp3 + k)) {
+                    int fb = k - hdr_padding(mp3);
+                    int nextfb = fb + hdr_padding(mp3 + k);
+                    if (i + k + nextfb + HDR_SIZE > mp3_bytes ||
+                        !hdr_compare(mp3, mp3 + k + nextfb))
+                        continue;
+                    frame_and_padding = k;
+                    frame_bytes = fb;
+                    *free_format_bytes = fb;
+                }
+            }
+            if ((frame_bytes && i + frame_and_padding <= mp3_bytes &&
+                 mp3d_match_frame(mp3, mp3_bytes - i, frame_bytes)) ||
+                (!i && frame_and_padding == mp3_bytes)) {
+                *ptr_frame_bytes = frame_and_padding;
+                return i;
+            }
+            *free_format_bytes = 0;
+        }
+    }
+    *ptr_frame_bytes = 0;
+    return mp3_bytes;
+}
+
+void mp3dec_init(mp3dec_t *dec) { dec->header[0] = 0; }
+
+int mp3dec_decode_frame(mp3dec_t *dec, const uint8_t *mp3, int mp3_bytes,
+                        mp3d_sample_t *pcm, mp3dec_frame_info_t *info) {
+    int i = 0, igr, frame_size = 0, success = 1;
+    const uint8_t *hdr;
+    bs_t bs_frame[1];
+    if (mp3_bytes > 4 && dec->header[0] == 0xff &&
+        hdr_compare(dec->header, mp3)) {
+        frame_size =
+            hdr_frame_bytes(mp3, dec->free_format_bytes) + hdr_padding(mp3);
+        if (frame_size != mp3_bytes && (frame_size + HDR_SIZE > mp3_bytes ||
+                                        !hdr_compare(mp3, mp3 + frame_size))) {
+            frame_size = 0;
+        }
+    }
+    if (!frame_size) {
+        memset(dec, 0, sizeof(mp3dec_t));
+        i = mp3d_find_frame(mp3, mp3_bytes, &dec->free_format_bytes,
+                            &frame_size);
+        if (!frame_size || i + frame_size > mp3_bytes) {
+            info->frame_bytes = i;
+            return 0;
+        }
+    }
+
+    hdr = mp3 + i;
+    memcpy(dec->header, hdr, HDR_SIZE);
+    info->frame_bytes = i + frame_size;
+    info->frame_offset = i;
+    info->channels = HDR_IS_MONO(hdr) ? 1 : 2;
+    info->hz = hdr_sample_rate_hz(hdr);
+    info->layer = 4 - HDR_GET_LAYER(hdr);
+    info->bitrate_kbps = hdr_bitrate_kbps(hdr);
+
+    if (!pcm) {
+        return hdr_frame_samples(hdr);
+    }
+
+    bs_init(bs_frame, hdr + HDR_SIZE, frame_size - HDR_SIZE);
+    if (HDR_IS_CRC(hdr)) {
+        get_bits(bs_frame, 16);
+    }
+
+    if (info->layer == 3) {
+        int main_data_begin =
+            L3_read_side_info(bs_frame, dec->scratch.gr_info, hdr);
+        if (main_data_begin < 0 || bs_frame->pos > bs_frame->limit) {
+            mp3dec_init(dec);
+            return 0;
+        }
+        success =
+            L3_restore_reservoir(dec, bs_frame, &dec->scratch, main_data_begin);
+        if (success) {
+            for (igr = 0; igr < (HDR_TEST_MPEG1(hdr) ? 2 : 1);
+                 igr++, pcm += 576 * info->channels) {
+                memset(dec->scratch.grbuf[0], 0, 576 * 2 * sizeof(float));
+                L3_decode(dec, &dec->scratch,
+                          dec->scratch.gr_info + igr * info->channels,
+                          info->channels);
+                mp3d_synth_granule(dec->qmf_state, dec->scratch.grbuf[0], 18,
+                                   info->channels, pcm, dec->scratch.syn[0]);
+            }
+        }
+        L3_save_reservoir(dec, &dec->scratch);
+    } else {
+#ifdef MINIMP3_ONLY_MP3
+        return 0;
+#else  /* MINIMP3_ONLY_MP3 */
+        L12_read_scale_info(hdr, bs_frame, &dec->sci);
+
+        memset(dec->scratch.grbuf[0], 0, 576 * 2 * sizeof(float));
+        for (i = 0, igr = 0; igr < 3; igr++) {
+            if (12 == (i += L12_dequantize_granule(dec->scratch.grbuf[0] + i,
+                                                   bs_frame, &dec->sci,
+                                                   info->layer | 1))) {
+                i = 0;
+                L12_apply_scf_384(&dec->sci, dec->sci.scf + igr,
+                                  dec->scratch.grbuf[0]);
+                mp3d_synth_granule(dec->qmf_state, dec->scratch.grbuf[0], 12,
+                                   info->channels, pcm, dec->scratch.syn[0]);
+                memset(dec->scratch.grbuf[0], 0, 576 * 2 * sizeof(float));
+                pcm += 384 * info->channels;
+            }
+            if (bs_frame->pos > bs_frame->limit) {
+                mp3dec_init(dec);
+                return 0;
+            }
+        }
+#endif /* MINIMP3_ONLY_MP3 */
+    }
+    return success * hdr_frame_samples(dec->header);
+}
+
+#ifdef MINIMP3_FLOAT_OUTPUT
+void mp3dec_f32_to_s16(const float *in, int16_t *out, int num_samples) {
+    int i = 0;
+#if HAVE_SIMD
+    int aligned_count = num_samples & ~7;
+    for (; i < aligned_count; i += 8) {
+        static const f4 g_scale = { 32768.0f, 32768.0f, 32768.0f, 32768.0f };
+        f4 a = VMUL(VLD(&in[i]), g_scale);
+        f4 b = VMUL(VLD(&in[i + 4]), g_scale);
+#if HAVE_SSE
+        static const f4 g_max = { 32767.0f, 32767.0f, 32767.0f, 32767.0f };
+        static const f4 g_min = { -32768.0f, -32768.0f, -32768.0f, -32768.0f };
+        __m128i pcm8 = _mm_packs_epi32(
+            _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(a, g_max), g_min)),
+            _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(b, g_max), g_min)));
+        out[i] = _mm_extract_epi16(pcm8, 0);
+        out[i + 1] = _mm_extract_epi16(pcm8, 1);
+        out[i + 2] = _mm_extract_epi16(pcm8, 2);
+        out[i + 3] = _mm_extract_epi16(pcm8, 3);
+        out[i + 4] = _mm_extract_epi16(pcm8, 4);
+        out[i + 5] = _mm_extract_epi16(pcm8, 5);
+        out[i + 6] = _mm_extract_epi16(pcm8, 6);
+        out[i + 7] = _mm_extract_epi16(pcm8, 7);
+#else  /* HAVE_SSE */
+        int16x4_t pcma, pcmb;
+        a = VADD(a, VSET(0.5f));
+        b = VADD(b, VSET(0.5f));
+        pcma = vqmovn_s32(vqaddq_s32(
+            vcvtq_s32_f32(a), vreinterpretq_s32_u32(vcltq_f32(a, VSET(0)))));
+        pcmb = vqmovn_s32(vqaddq_s32(
+            vcvtq_s32_f32(b), vreinterpretq_s32_u32(vcltq_f32(b, VSET(0)))));
+        vst1_lane_s16(out + i, pcma, 0);
+        vst1_lane_s16(out + i + 1, pcma, 1);
+        vst1_lane_s16(out + i + 2, pcma, 2);
+        vst1_lane_s16(out + i + 3, pcma, 3);
+        vst1_lane_s16(out + i + 4, pcmb, 0);
+        vst1_lane_s16(out + i + 5, pcmb, 1);
+        vst1_lane_s16(out + i + 6, pcmb, 2);
+        vst1_lane_s16(out + i + 7, pcmb, 3);
+#endif /* HAVE_SSE */
+    }
+#endif /* HAVE_SIMD */
+    for (; i < num_samples; i++) {
+        float sample = in[i] * 32768.0f;
+        if (sample >= 32766.5)
+            out[i] = (int16_t)32767;
+        else if (sample <= -32767.5)
+            out[i] = (int16_t)-32768;
+        else {
+            int16_t s = (int16_t)(sample + .5f);
+            s -= (s < 0); /* away from zero, to be compliant */
+            out[i] = s;
+        }
+    }
+}
+#endif /* MINIMP3_FLOAT_OUTPUT */
+#endif /* MINIMP3_IMPLEMENTATION && !_MINIMP3_IMPLEMENTATION_GUARD */

components/bl00mbox/.clang-tidy

-Checks: '-clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,-clang-diagnostic-deprecated-declarations,-clang-diagnostic-incompatible-pointer-types,-clang-analyzer-core.NullDereference'
+Checks: '-*,clang-analyzer-osx.SecKeychainAPI'

components/bl00mbox/CMakeLists.txt

@@ -5,29 +5,40 @@ idf_component_register(
         bl00mbox.c
         bl00mbox_audio.c
         bl00mbox_user.c
+        bl00mbox_os.c
         bl00mbox_plugin_registry.c
         bl00mbox_radspa_requirements.c
-        plugins/osc_fm.c
-        plugins/env_adsr.c
-        plugins/ampliverter.c
-        plugins/sampler.c
-        plugins/delay.c
-        plugins/flanger.c
-        plugins/multipitch.c
-        plugins/sequencer.c
-        plugins/noise.c
-        plugins/noise_burst.c
-        plugins/distortion.c
-        plugins/lowpass.c
-        plugins/mixer.c
-        plugins/slew_rate_limiter.c
+        bl00mbox_containers.c
+        radspa/standard_plugin_lib/osc.c
+        radspa/standard_plugin_lib/osc_fm.c
+        radspa/standard_plugin_lib/env_adsr.c
+        radspa/standard_plugin_lib/ampliverter.c
+        radspa/standard_plugin_lib/sampler.c
+        radspa/standard_plugin_lib/delay.c
+        radspa/standard_plugin_lib/flanger.c
+        radspa/standard_plugin_lib/multipitch.c
+        radspa/standard_plugin_lib/trigger_merge.c
+        radspa/standard_plugin_lib/sequencer.c
+        radspa/standard_plugin_lib/noise.c
+        radspa/standard_plugin_lib/noise_burst.c
+        radspa/standard_plugin_lib/distortion.c
+        radspa/standard_plugin_lib/lowpass.c
+        radspa/standard_plugin_lib/filter.c
+        radspa/standard_plugin_lib/mixer.c
+        radspa/standard_plugin_lib/range_shifter.c
+        radspa/standard_plugin_lib/poly_squeeze.c
+        radspa/standard_plugin_lib/slew_rate_limiter.c
+        radspa/standard_plugin_lib/buffer.c
+        plugins/bl00mbox_specific/bl00mbox_line_in.c
+        plugins/bl00mbox_specific/bl00mbox_channel_plugin.c
         radspa/radspa_helpers.c
         extern/xoroshiro64star.c
     INCLUDE_DIRS
         include
         plugins
+        plugins/bl00mbox_specific
         radspa
+        radspa/standard_plugin_lib
         extern
-    REQUIRES
-        st3m
+        config
 )

components/bl00mbox/README.md

+# documentation
+
+https://moon2embeddedaudio.gitlab.io/bl00mbox/main/

components/bl00mbox/bl00mbox.c

@@ -2,10 +2,8 @@
 #include "bl00mbox.h"
 #include "bl00mbox_plugin_registry.h"
 #include "bl00mbox_audio.h"
-#include "st3m_audio.h"
 
 void bl00mbox_init(){
     bl00mbox_plugin_registry_init();
-    st3m_audio_set_player_function(bl00mbox_audio_render);
-    bl00mbox_channels_init();
+    bl00mbox_audio_init();
 }

components/bl00mbox/bl00mbox_audio.c

 //SPDX-License-Identifier: CC0-1.0
 #include "bl00mbox_audio.h"
+#include "bl00mbox_user.h"
+#include "bl00mbox_os.h"
+#include "bl00mbox_channel_plugin.h"
+#include <assert.h>
 
-static bool is_initialized = false;
-static bool bl00mbox_audio_run = true;
-void bl00mbox_audio_enable(){ bl00mbox_audio_run = true; }
-void bl00mbox_audio_disable(){ bl00mbox_audio_run = false; }
+static uint16_t full_buffer_len;
 
 static uint32_t render_pass_id;
 
-// fixed-length list of channels
-static bl00mbox_channel_t channels[BL00MBOX_CHANNELS];
-static int8_t last_chan_event = 0;
-// foregrounded channel is always rendered
-// note: regardless of settings the system channel 0 is always rendered
-static uint8_t bl00mbox_channel_foreground = 0;
-// channels may request being active while not being in foreground
-static bool bl00mbox_channel_background_mute_override[BL00MBOX_CHANNELS] = {false,};
-
-bool bl00mbox_channel_set_background_mute_override(uint8_t channel_index, bool enable){
-#ifdef BL00MBOX_BACKGROUND_MUTE_OVERRIDE_ENABLE
-    if(channel_index >= BL00MBOX_CHANNELS) return false;
-    bl00mbox_channel_background_mute_override[channel_index] = enable;
-    return true;
-#else
-    return false;
-#endif
-}
+int16_t * bl00mbox_line_in_interlaced = NULL;
+
+static bl00mbox_lock_t user_lock = NULL;
+// grab user_lock for r/w
+static bl00mbox_set_t * all_chans = NULL;
+// grab user_lock for r/w
+static bl00mbox_set_t * background_mute_override_chans = NULL;
+// grab user_lock for r/w
+static bl00mbox_channel_t * foreground_chan = NULL;
+
+// grab both user_lock and active_chans_lock for writing.
+// for user-side reading grab user_lock.
+// render task reads with active_chans_lock.
+static bl00mbox_array_t * active_chans = NULL;
+static bl00mbox_lock_t active_chans_lock = NULL;
+
+static void update_active_chans(){
+    // must be called after changing foreground_chan or background_mute_override_chans
+    // while _still_ holding user_lock but not active_chans_lock
+    size_t num_chans = background_mute_override_chans->len;
+    if(foreground_chan) num_chans++;
+    bl00mbox_array_t * new_active_chans = malloc(sizeof(bl00mbox_array_t) + num_chans * sizeof(void *));
+    if(new_active_chans){
+        size_t index = 0;
+        if(foreground_chan){
+            new_active_chans->elems[index] = foreground_chan;
+            index++;
+        }
+        bl00mbox_set_iter_t iter;
+        bl00mbox_set_iter_start(&iter, background_mute_override_chans);
+        bl00mbox_channel_t * chan;
+        while((chan = bl00mbox_set_iter_next(&iter))){
+            if(chan == foreground_chan) continue;
+            new_active_chans->elems[index] = chan; 
+            index++;
+        }
+        new_active_chans->len = index;
+    } else {
+        bl00mbox_log_error("out of memory");
+    }
 
-bool bl00mbox_channel_get_background_mute_override(uint8_t channel_index){
-    if(channel_index >= BL00MBOX_CHANNELS) return false;
-    return bl00mbox_channel_background_mute_override[channel_index];
+#ifdef BL00MBOX_DEBUG
+    if(new_active_chans) bl00mbox_log_error("active chans: %d", (int) new_active_chans->len);
+#endif
+    bl00mbox_array_t * previous_active_chans;
+    bl00mbox_take_lock(&active_chans_lock);
+    previous_active_chans = active_chans;
+    active_chans = new_active_chans;
+    bl00mbox_give_lock(&active_chans_lock);
+    free(previous_active_chans);
 }
 
-static void ** ptr_to_be_set_by_audio_task = NULL;
-static void * ptr_to_be_set_by_audio_task_target = NULL;
-// TODO: multicore thread safety on this boi
-static volatile bool ptr_set_request_pending = false;
-static uint64_t bl00mbox_audio_waitfor_timeout = 0ULL;
-
-bool bl00mbox_audio_waitfor_pointer_change(void ** ptr, void * new_val){
-    /// takes pointer to pointer that is to be set null
-    if(!is_initialized) return false;
-    ptr_to_be_set_by_audio_task = ptr;
-    ptr_to_be_set_by_audio_task_target = new_val;
-    ptr_set_request_pending = true;
-
-    volatile uint64_t timeout = 0; // cute
-    while(ptr_set_request_pending){
-        timeout++;
-        // TODO: nop
-        if(bl00mbox_audio_waitfor_timeout && (timeout = bl00mbox_audio_waitfor_timeout)){
-            return false;
+bl00mbox_array_t * bl00mbox_collect_channels(bool active){
+    bl00mbox_array_t * ret = NULL;
+    bl00mbox_take_lock(&user_lock);
+    if(active){
+        if(active_chans){
+            size_t ret_size = sizeof(bl00mbox_array_t);
+            ret_size += active_chans->len * sizeof(void *);
+            ret = malloc(ret_size);
+            if(ret) memcpy(ret, active_chans, ret_size);
+        } else {
+            ret = malloc(sizeof(bl00mbox_array_t));
+            if(ret) ret->len = 0;
         }
+    } else {
+        ret = bl00mbox_set_to_array(all_chans);
     }
-    return true;
+    bl00mbox_give_lock(&user_lock);
+    if(!ret) bl00mbox_log_error("out of memory");
+    return ret;
 }
 
-bool bl00mbox_audio_do_pointer_change(){
-    if(ptr_set_request_pending){
-        (* ptr_to_be_set_by_audio_task) = ptr_to_be_set_by_audio_task_target;
-        ptr_to_be_set_by_audio_task_target = NULL;
-        ptr_to_be_set_by_audio_task = NULL;
-        ptr_set_request_pending = false;
-        return true;
+void bl00mbox_channel_set_background_mute_override(bl00mbox_channel_t * chan, bool enable){
+    bl00mbox_take_lock(&user_lock);
+    chan->background_mute_override = enable;
+    bool update;
+    if(enable){
+        update = bl00mbox_set_add(background_mute_override_chans, chan);
+    } else {
+        update = bl00mbox_set_remove(background_mute_override_chans, chan);
     }
-    return false;
-}
-
-void bl00mbox_channel_event(uint8_t chan){
-    last_chan_event = chan;
-}
-
-bl00mbox_channel_t * bl00mbox_get_channel(uint8_t channel_index){
-    if(channel_index >= BL00MBOX_CHANNELS) return NULL;
-    return &(channels[channel_index]);
-}
-
-uint8_t bl00mbox_channel_get_foreground_index(){
-    return bl00mbox_channel_foreground;
+    if(update) update_active_chans();
+    bl00mbox_give_lock(&user_lock);
 }
 
-void bl00mbox_channel_set_foreground_index(uint8_t channel_index){
-    if(channel_index >= BL00MBOX_CHANNELS) return;
-    bl00mbox_channel_foreground = channel_index;
+bool bl00mbox_channel_get_foreground(bl00mbox_channel_t * chan){
+    return foreground_chan == chan;
 }
 
-bool bl00mbox_channel_get_free(uint8_t channel_index){
-    if(channel_index >= BL00MBOX_CHANNELS) return false;
-    return bl00mbox_get_channel(channel_index)->is_free;
+void bl00mbox_channel_set_foreground(bl00mbox_channel_t * chan, bool enable){
+    if(bl00mbox_channel_get_foreground(chan) == enable) return;
+    bl00mbox_take_lock(&user_lock);
+    foreground_chan = enable ? chan : NULL;
+    update_active_chans();
+    bl00mbox_give_lock(&user_lock);
 }
 
-bool bl00mbox_channel_set_free(uint8_t channel_index, bool free){
-    if(channel_index >= BL00MBOX_CHANNELS) return false;
-    bl00mbox_get_channel(channel_index)->is_free = free;
-    return true;
+void bl00mbox_channel_event(bl00mbox_channel_t * chan){
+#ifdef BL00MBOX_AUTO_FOREGROUNDING
+    bl00mbox_channel_set_foreground(chan, true);
+#endif
 }
 
-uint8_t bl00mbox_channel_get_free_index(){
-    uint8_t ret = 1;
-    for(; ret < BL00MBOX_CHANNELS; ret++){
-        if(bl00mbox_get_channel(ret)->is_free){
-            bl00mbox_get_channel(ret)->is_free = false;
-            break;
+bl00mbox_channel_t * bl00mbox_channel_create(){
+    bl00mbox_channel_t * chan = calloc(1, sizeof(bl00mbox_channel_t));
+    if(!chan) goto failed;
+    chan->volume = BL00MBOX_DEFAULT_CHANNEL_VOLUME;
+    chan->sys_gain = 4096;
+
+    // must be destroyed manually as it's not in the plugin list
+    chan->channel_plugin = bl00mbox_plugin_create_unlisted(chan, &bl00mbox_channel_plugin_desc, 0);
+    if(!chan->channel_plugin) goto failed;
+
+    if(!bl00mbox_create_lock(&chan->render_lock)) goto failed;
+
+    bl00mbox_take_lock(&user_lock);
+    if(!bl00mbox_set_add_skip_unique_check(all_chans, chan)) goto failed;
+    foreground_chan = chan;
+    update_active_chans();
+    bl00mbox_give_lock(&user_lock);
+    return chan;
+
+failed:
+    if(chan){
+        if(chan->channel_plugin){
+            // supress errors
+            chan->channel_plugin->parent_self_ref = &chan->channel_plugin;
+            bl00mbox_plugin_destroy(chan->channel_plugin);
         }
+        if(chan->render_lock) bl00mbox_delete_lock(&chan->render_lock);
+        free(chan);
     }
-    last_chan_event = ret;
-    return ret;
+    bl00mbox_log_error("channel allocation failed");
+    return NULL;
 }
 
-char * bl00mbox_channel_get_name(uint8_t channel_index){
-    if(channel_index >= BL00MBOX_CHANNELS) return NULL;
-    return bl00mbox_get_channel(channel_index)->name;
+void bl00mbox_channel_clear(bl00mbox_channel_t * chan){
+    // note: this does NOT destroy the channel_plugin as it is unlisted
+    bl00mbox_set_iter_t iter;
+    bl00mbox_set_iter_start(&iter, &chan->plugins);
+    bl00mbox_plugin_t * plugin;
+    while((plugin = bl00mbox_set_iter_next(&iter))){
+        bl00mbox_plugin_destroy(plugin);
+    }
+    chan->plugin_id = 0;
 }
 
-void bl00mbox_channel_set_name(uint8_t channel_index, char * new_name){
-    if(channel_index >= BL00MBOX_CHANNELS) return;
-    bl00mbox_channel_t * chan =  bl00mbox_get_channel(channel_index);
-    if(chan->name != NULL) free(chan->name);
-    chan->name = strdup(new_name);
-}
+void bl00mbox_channel_destroy(bl00mbox_channel_t * chan){
+    bl00mbox_channel_clear(chan);
 
-void bl00mbox_channels_init(){
-    for(uint8_t i = 0; i < BL00MBOX_CHANNELS; i++){
-        bl00mbox_channel_t * chan = bl00mbox_get_channel(i);
-        chan->volume = BL00MBOX_DEFAULT_CHANNEL_VOLUME;
-        chan->root_list = NULL;
-        chan->buds = NULL;
-        chan->connections = NULL;
-        chan->is_active = true;
-        chan->is_free = true;
-        chan->name = NULL;
+    // remove from all lists
+    bl00mbox_take_lock(&user_lock);
+    bool is_active = false;
+    if(foreground_chan == chan){
+        foreground_chan = NULL;
+        is_active = true;
     }
-    is_initialized = true;
-}
+    if(bl00mbox_set_remove(background_mute_override_chans, chan)){
+        is_active = true;
+    }
+    if(is_active) update_active_chans();
+    bl00mbox_set_remove(all_chans, chan);
+    bl00mbox_give_lock(&user_lock);
+
+    // remove from parent
+    if(* (chan->parent_self_ref) != chan){
+        bl00mbox_log_error("channel: parent_self_ref improper: channel %p, ref %p",
+                            chan, * (chan->parent_self_ref));
+    }
+    * (chan->parent_self_ref) = NULL;
 
-void bl00mbox_channel_enable(uint8_t chan){
-    if(chan >= (BL00MBOX_CHANNELS)) return;
-    bl00mbox_channel_t * ch = bl00mbox_get_channel(chan);
-    ch->is_active = true;
-}
+    // remove from weak parent
+    if(chan->weak_parent_self_ref){
+        if(* (chan->weak_parent_self_ref) != chan){
+            bl00mbox_log_error("channel: weak_parent_self_ref improper: channel %p, ref %p",
+                                chan, * (chan->weak_parent_self_ref));
+        }
+        * (chan->weak_parent_self_ref) = NULL;
+    }
 
-void bl00mbox_channel_disable(uint8_t chan){
-    if(chan >= (BL00MBOX_CHANNELS)) return;
-    bl00mbox_channel_t * ch = bl00mbox_get_channel(chan);
-    ch->is_active = false;
-}
+#ifdef BL00MBOX_DEBUG
+    if(chan->connections.len) bl00mbox_log_error("connections nonempty");
+    if(chan->roots.len) bl00mbox_log_error("roots nonempty");
+    if(chan->always_render.len) bl00mbox_log_error("always render nonempty");
+    if(chan->plugins.len) bl00mbox_log_error("plugins nonempty");
+    bl00mbox_wait();
+#endif
 
-void bl00mbox_channel_set_volume(uint8_t chan, uint16_t volume){
-    if(chan >= (BL00MBOX_CHANNELS)) return;
-    bl00mbox_channel_t * ch = bl00mbox_get_channel(chan);
-    ch->volume = volume < 32767 ? volume : 32767;
+    // be really sure that nobody else holds the lock. the renderer
+    // doesn't at this point, but if there's multiple tasks running
+    // clients there may be collisions.
+    // since the client api is generally not thread safe at this point
+    // it's okay, we can add the feature easily by just wrapping _all_
+    // client api in a lock at some point in the future.
+    bl00mbox_delete_lock(&chan->render_lock);
+
+    if(chan->channel_plugin) bl00mbox_plugin_destroy(chan->channel_plugin);
+    free(chan->render_plugins);
+    free(chan->render_buffers);
+    free(chan->name);
+    free(chan);
 }
 
-int16_t bl00mbox_channel_get_volume(uint8_t chan){
-    if(chan >= (BL00MBOX_CHANNELS)) return 0;
-    bl00mbox_channel_t * ch = bl00mbox_get_channel(chan);
-    return ch->volume;
+void bl00mbox_audio_plugin_render(bl00mbox_plugin_t * plugin){
+    if(plugin->render_pass_id == render_pass_id) return;
+#ifdef BL00MBOX_LOOPS_ENABLE
+    if(plugin->is_being_rendered) return;
+#endif
+    plugin->is_being_rendered = true;
+    plugin->rugin->render(plugin->rugin, full_buffer_len, render_pass_id);
+    plugin->render_pass_id = render_pass_id;
+    plugin->is_being_rendered = false;
 }
 
-void bl00mbox_audio_bud_render(bl00mbox_bud_t * bud, uint16_t num_samples){
-    if(bud->render_pass_id == render_pass_id) return;
-    bud->plugin->render(bud->plugin, num_samples, render_pass_id);
-    bud->render_pass_id = render_pass_id;
-}
+static bool _bl00mbox_audio_channel_render(bl00mbox_channel_t * chan, int16_t * out, bool adding){
+    chan->render_pass_id = render_pass_id;
 
-static void bl00mbox_audio_channel_render(bl00mbox_channel_t * chan, int16_t * out, uint16_t len, bool adding){
-    if(adding){
-        // ^ to make clang-tidy happy
-        // only to pass flow3r ci, omit before compliling
-        if(render_pass_id == chan->render_pass_id) return;
+    int32_t vol = radspa_mult_shift(chan->volume, chan->sys_gain);
+    if(!vol) return false; // don't render if muted
+
+    // render these even if nothing is plugged into mixer
+    if(chan->render_plugins){
+        for(size_t i = 0; i < chan->render_plugins->len; i++){
+            bl00mbox_audio_plugin_render(chan->render_plugins->elems[i]);
+        }
     }
 
-    chan->render_pass_id = render_pass_id;
+    bl00mbox_channel_plugin_update_values(chan->channel_plugin->rugin, render_pass_id);
 
-    bl00mbox_channel_root_t * root = chan->root_list;
+    if(!(chan->render_buffers && chan->render_buffers->len)) return false;
 
-    // early exit when no sources:
-    if((root == NULL) || (!chan->is_active)){
-        if(adding) return; // nothing to do
-        memset(out, 0, len*sizeof(int16_t)); // mute
-        return;
-    }
-    if(root == NULL) return; // more clang garbage, undo before compliling
 
-    int32_t acc[256];
-    bool first = true;
+    int32_t acc[full_buffer_len];
 
-    while(root != NULL){
-        bl00mbox_audio_bud_render(root->con->source_bud, len);
-        if(first){
-            for(uint16_t i = 0; i < len; i++){
-                acc[i] = root->con->buffer[i];
-            }
-        } else {
-            for(uint16_t i = 0; i < len; i++){ // replace this with proper ladspa-style adding function someday
-                acc[i] += root->con->buffer[i];
-            }
+    // first one non-adding
+    int16_t * buffer = chan->render_buffers->elems[0];
+    if(buffer[1] == -32768){
+        for(size_t i = 0; i < full_buffer_len; i++){
+            acc[i] = buffer[0];
+        }
+    } else {
+        for(size_t i = 0; i < full_buffer_len; i++){
+            acc[i] = buffer[i];
         }
-        first = false;
-        root = root->next;
     }
 
-    for(uint16_t i = 0; i < len; i++){
-        if(adding){
-            out[i] = radspa_add_sat(radspa_mult_shift(acc[i], chan->volume), out[i]);
+    // rest adding
+    for(size_t i = 1; i < chan->render_buffers->len; i++){
+        buffer = chan->render_buffers->elems[i];
+        if(buffer[1] == -32768){
+            if(buffer[0]){
+                for(size_t i = 0; i < full_buffer_len; i++){
+                    acc[i] += buffer[0];
+                }
+            }
         } else {
-            out[i] = radspa_mult_shift(acc[i], chan->volume);
+            for(size_t i = 0; i < full_buffer_len; i++){
+                acc[i] += buffer[i];
+            }
         }
     }
-}
 
-void bl00mbox_audio_render(int16_t * rx, int16_t * tx, uint16_t len){
-    if(!is_initialized){
-        memset(tx, 0, len*sizeof(int16_t)); // mute
-        return;
-    }
+    for(uint16_t i = 0; i < full_buffer_len; i++){
+        // flip around for rounding towards zero/mulsh boost
+        int invert = chan->dc < 0 ? -1 : 1;
+        chan->dc = chan->dc * invert;
+        chan->dc = ((uint64_t) chan->dc * (((1<<12) - 1)<<20)) >> 32;
+        chan->dc = chan->dc * invert;
 
-    bl00mbox_audio_do_pointer_change();
-    bl00mbox_channel_foreground = last_chan_event;
+        chan->dc += acc[i];
 
-    if(!bl00mbox_audio_run){
-        memset(tx, 0, len*sizeof(int16_t)); // mute
-        return;
+        acc[i] -= (chan->dc >> 12);
     }
+    if(adding){
+        for(uint16_t i = 0; i < full_buffer_len; i++){
+            out[i] = radspa_add_sat(radspa_gain(acc[i], vol), out[i]);
+        }
+    } else {
+        for(uint16_t i = 0; i < full_buffer_len; i++){
+            out[i] = radspa_gain(acc[i], vol);
+        }
+    }
+    if(chan->compute_rms){
+        for(uint16_t i = 0; i < full_buffer_len; i++){
+            int32_t sq = acc[i];
+            sq = (sq * sq) - chan->mean_square;
+            // always round down with negative sq so that decay always works.
+            // bitshift instead of div does that for us nicely.
+            // cannot underflow as ((-a) >> 11) can never be less than -a.
+            chan->mean_square += sq >> 11;
+        }
+    }
+    return true;
+}
 
-    render_pass_id++; // fresh pass, all relevant sources must be recomputed
-    uint16_t mono_len = len/2;
-    int16_t acc[mono_len];
-    // system channel always runs non-adding
-    bl00mbox_audio_channel_render(&(channels[0]), acc, mono_len, 0);
-
-    // re-rendering channels is ok, if render_pass_id didn't change it will just exit
-    bl00mbox_audio_channel_render(&(channels[bl00mbox_channel_foreground]), acc, mono_len, 1);
+static bool bl00mbox_audio_channel_render(bl00mbox_channel_t * chan, int16_t * out, bool adding){
+    if(render_pass_id == chan->render_pass_id) return false;
+    bl00mbox_take_lock(&chan->render_lock);
+    bool ret = _bl00mbox_audio_channel_render(chan, out, adding);
+    bl00mbox_give_lock(&chan->render_lock);
+    // null it out if nothing was rendered
+    chan->mean_square *= ret;
+    return ret;
+}
 
-    // TODO: scales poorly if there's many channels
-#ifdef BL00MBOX_BACKGROUND_MUTE_OVERRIDE_ENABLE
-    for(uint8_t i = 1; i < (BL00MBOX_CHANNELS); i++){
-        if(bl00mbox_channel_background_mute_override[i]){
-            bl00mbox_audio_channel_render(&(channels[i]), acc, mono_len, 1);
+void bl00mbox_audio_render(int16_t * rx, int16_t * tx, uint16_t len){
+    full_buffer_len = len/2;
+    bl00mbox_line_in_interlaced = rx;
+    int16_t acc[full_buffer_len];
+    bool acc_init = false;
+
+    bl00mbox_take_lock(&active_chans_lock);
+    render_pass_id++;
+    if(active_chans){
+        for(size_t i = 0; i < active_chans->len; i++){
+            acc_init = bl00mbox_audio_channel_render(active_chans->elems[i], acc, acc_init) || acc_init;
         }
     }
-#endif
-
-    for(uint16_t i = 0; i < mono_len; i++){
-        st3m_scope_write((acc[i])>>4);
+    bl00mbox_give_lock(&active_chans_lock);
 
-        tx[2*i] = acc[i];
-        tx[2*i+1] = acc[i];
+    if(acc_init){
+        for(uint16_t i = 0; i < full_buffer_len; i++){
+            tx[2*i] = acc[i];
+            tx[2*i+1] = acc[i];
+        }
+    } else {
+        memset(tx, 0, len * sizeof(int16_t));
     }
 }
 
-// TEMP
-void bl00mbox_player_function(int16_t * rx, int16_t * tx, uint16_t len){
-    bl00mbox_audio_render(rx, tx, len);
+void bl00mbox_audio_init(){
+    assert(bl00mbox_create_lock(&active_chans_lock));
+
+    // micropython objects are generally not thread safe, so for most of the user API we need
+    // not care about locking after they've been created. however, bl00mbox Channel objects may
+    // be created by different threads (i.e., thread API), so these sets must be fully thread safe.
+    assert(bl00mbox_create_lock(&user_lock));
+
+    all_chans = calloc(1, sizeof(bl00mbox_set_t));
+    assert(all_chans);
+
+    background_mute_override_chans = calloc(1, sizeof(bl00mbox_set_t));
+    assert(background_mute_override_chans);
 }

components/bl00mbox/bl00mbox_containers.c

+#include "bl00mbox_containers.h"
+
+static bool equals(void * some, void * other, bl00mbox_set_key_t key){
+    if(!key) return some == other;
+    return key(some, other);
+}
+
+static bool set_add_inner(bl00mbox_set_t * set, void * content){
+    bl00mbox_ll_t * ll = malloc(sizeof(bl00mbox_ll_t));
+    if(!ll) return false;
+    ll->content = content;
+    ll->next = set->start;
+    set->start = ll;
+    set->len++;
+    return true;
+}
+
+bool bl00mbox_set_contains(bl00mbox_set_t * set, void * content){
+    if(!content) return false; // NULL pointers can't be in set
+    if(!set->start) return false;
+    bl00mbox_ll_t * seek = set->start;
+    while(seek){
+        if(equals(seek->content, content, set->key)) break;
+        seek = seek->next;
+    }
+    return seek;
+}
+
+bool bl00mbox_set_add_skip_unique_check(bl00mbox_set_t * set, void * content){
+    if(!content) return false; // don't allow for NULL pointers in set
+#ifdef BL00MBOX_DEBUG
+    if(bl00mbox_set_contains(set, content)){
+        bl00mbox_log_error("set corrupted");
+        return false;
+    }
+#endif
+    return set_add_inner(set, content);
+}
+
+bool bl00mbox_set_add(bl00mbox_set_t * set, void * content){
+    if(bl00mbox_set_contains(set, content)) return false;
+    return set_add_inner(set, content);
+}
+
+bool bl00mbox_set_remove(bl00mbox_set_t * set, void * content){
+    if(!content) return false;
+    bl00mbox_ll_t * seek = set->start;
+    bl00mbox_ll_t * prev = NULL;
+    while(seek){
+        if(equals(seek->content, content, set->key)) break;
+        prev = seek;
+        seek = seek->next;
+    }
+    if(seek){
+        bl00mbox_ll_t ** target = prev ? &(prev->next) : &(set->start);
+        (* target) = seek->next;
+        set->len--;
+    }
+    free(seek);
+    return true;
+}
+
+void bl00mbox_set_iter_start(bl00mbox_set_iter_t * iter, bl00mbox_set_t * set){
+    iter->next = set->start;
+}
+
+void * bl00mbox_set_iter_next(bl00mbox_set_iter_t * iter){
+    if(!iter->next) return NULL;
+    void * ret = iter->next->content;
+    iter->next = iter->next->next;
+    return ret;
+}
+
+bl00mbox_array_t * bl00mbox_set_to_array(bl00mbox_set_t * set){
+    bl00mbox_array_t * ret = malloc(sizeof(bl00mbox_array_t) + set->len * sizeof(void *));
+    if(!ret) return NULL;
+    ret->len = set->len;
+    bl00mbox_set_iter_t iter;
+    bl00mbox_set_iter_start(&iter, set);
+    void * content;
+    size_t index = 0;
+    while((content = bl00mbox_set_iter_next(&iter))){
+        ret->elems[index++] = content;
+    }
+    return ret;
+}

components/bl00mbox/bl00mbox_os.c

+#include "bl00mbox_os.h"
+
+#ifdef BL00MBOX_FREERTOS
+bool bl00mbox_create_lock(bl00mbox_lock_t * lock){
+    assert(*lock == NULL);
+    * lock = xSemaphoreCreateMutex();
+    return(*lock != NULL);
+}
+void bl00mbox_delete_lock(bl00mbox_lock_t * lock){ vSemaphoreDelete(* lock); }
+void bl00mbox_take_lock(bl00mbox_lock_t * lock){ xSemaphoreTake(* lock, portMAX_DELAY); }
+void bl00mbox_give_lock(bl00mbox_lock_t * lock){ xSemaphoreGive(* lock); }
+#ifdef BL00MBOX_DEBUG
+void bl00mbox_wait() { vTaskDelay(10); }
+#endif
+#endif
+
+#if defined(BL00MBOX_ESPIDF)
+// macros in header
+#elif defined(BL00MBOX_PRINTF)
+#include <stdarg.h>
+#include <string.h>
+static void _bl00mbox_log(char * pre, char * txt, va_list args){
+    int len = strlen(pre) + strlen(txt) + 2;
+    char msg[len];
+    snprintf(msg, len, "%s%s\n", pre, txt);
+    vprintf(msg, args);
+}
+void bl00mbox_log_error(char * txt, ...){
+    va_list args;
+    va_start(args, txt);
+    _bl00mbox_log("bl00mbox error: ", txt, args);
+    va_end(args);
+};
+void bl00mbox_log_info(char * txt, ...){
+    va_list args;
+    va_start(args, txt);
+    _bl00mbox_log("bl00mbox info: ", txt, args);
+    va_end(args);
+};
+#else
+void bl00mbox_log_error(char * txt, ...){};
+void bl00mbox_log_info(char * txt, ...){};
+#endif

components/bl00mbox/bl00mbox_plugin_registry.c

 //SPDX-License-Identifier: CC0-1.0
 #include "bl00mbox_plugin_registry.h"
 
-bl00mbox_plugin_registry_t * bl00mbox_plugin_registry = NULL;
-uint16_t bl00mbox_plugin_registry_len = 0;
-bool bl00mbox_plugin_registry_is_initialized = false;
+static bl00mbox_plugin_registry_t * bl00mbox_plugin_registry = NULL;
+static uint16_t bl00mbox_plugin_registry_len = 0;
+static bool bl00mbox_plugin_registry_is_initialized = false;
 
 static void plugin_add(radspa_descriptor_t * descriptor){
+    if(descriptor->id == BL00MBOX_CHANNEL_PLUGIN_ID){
+        bl00mbox_log_error("plugin list id collision");
+    }
     if(bl00mbox_plugin_registry_len == 65535){
-        printf("too many plugins registered");
-        abort();
+        bl00mbox_log_error("too many plugins registered");
+        return;
     }
 
     // create plugin registry entry
     bl00mbox_plugin_registry_t * p = malloc(sizeof(bl00mbox_plugin_registry_t));
-    if(p == NULL){ printf("bl00mbox: no memory for plugin list"); abort(); }
+    if(!p){
+        bl00mbox_log_error("no memory for plugin list");
+        return;
+    }
     p->descriptor = descriptor;
     p->next = NULL;
 
@@ -22,7 +28,13 @@ static void plugin_add(radspa_descriptor_t * descriptor){
     if(plast == NULL){
         bl00mbox_plugin_registry = p;
     } else {
-        while(plast->next != NULL){ plast = plast->next; }
+        while(plast->next != NULL){
+            if(plast->descriptor->id == p->descriptor->id){
+                bl00mbox_log_error("plugin list id collision");
+                return;
+            }
+            plast = plast->next;
+        }
         plast->next = p;
     }
     bl00mbox_plugin_registry_len++;
@@ -52,7 +64,7 @@ radspa_descriptor_t * bl00mbox_plugin_registry_get_descriptor_from_index(uint32_
     for(uint16_t i = 0; i < index; i++){
         p = p->next;
         if(p == NULL){
-            printf("bl00mbox: plugin list length error");
+            bl00mbox_log_error("bl00mbox: plugin list length error");
             abort();
         }
     }
@@ -67,7 +79,7 @@ radspa_descriptor_t * bl00mbox_plugin_registry_get_id_from_index(uint32_t index)
     for(uint16_t i = 0; i < index; i++){
         p = p->next;
         if(p == NULL){
-            printf("bl00mbox: plugin list length error");
+            bl00mbox_log_error("bl00mbox: plugin list length error");
             abort();
         }
     }
@@ -81,17 +93,18 @@ radspa_descriptor_t * bl00mbox_plugin_registry_get_id_from_index(uint32_t index)
  * - use plugin_add in bl00mbox_plugin_registry_init as
  *   exemplified below
  *
- * NOTE: the plugin registry linked list is intended to be filled
- * once at boot time. dynamically adding plugins at runtime may or
- * may not work (but will call abort() if no memory is available),
+ * NOTE: the plugin registry linked list is intended to be filled once at
+ * boot time. dynamically adding plugins at runtime may or may not work,
  * removing plugins from the registry at runtime is not intended.
  */
 
 #include "osc_fm.h"
+#include "osc.h"
 #include "env_adsr.h"
 #include "ampliverter.h"
 #include "delay.h"
 #include "lowpass.h"
+#include "filter.h"
 #include "sequencer.h"
 #include "sampler.h"
 #include "flanger.h"
@@ -100,22 +113,35 @@ radspa_descriptor_t * bl00mbox_plugin_registry_get_id_from_index(uint32_t index)
 #include "distortion.h"
 #include "mixer.h"
 #include "multipitch.h"
+#include "trigger_merge.h"
 #include "slew_rate_limiter.h"
+#include "range_shifter.h"
+#include "poly_squeeze.h"
+#include "bl00mbox_line_in.h"
+#include "buffer.h"
 
 void bl00mbox_plugin_registry_init(void){
     if(bl00mbox_plugin_registry_is_initialized) return;
-    plugin_add(&osc_fm_desc);
-    plugin_add(&ampliverter_desc);
-    plugin_add(&env_adsr_desc);   
-    plugin_add(&delay_desc);   
-    plugin_add(&lowpass_desc);   
+    // do not add bl00mbox_channel_plugin, it is not to be spawned by users
+    plugin_add(&osc_desc);
+    plugin_add(&filter_desc);
     plugin_add(&sequencer_desc);
     plugin_add(&sampler_desc);
+    plugin_add(&multipitch_desc);
+    plugin_add(&trigger_merge_desc);
+    plugin_add(&bl00mbox_line_in_desc);
+    plugin_add(&buffer_desc);
+    plugin_add(&distortion_desc);
+    plugin_add(&mixer_desc);
     plugin_add(&flanger_desc);
     plugin_add(&noise_desc);
     plugin_add(&noise_burst_desc);
-    plugin_add(&distortion_desc);
-    plugin_add(&mixer_desc);
+    plugin_add(&env_adsr_desc);
+    plugin_add(&delay_desc);
+    plugin_add(&range_shifter_desc);
+    plugin_add(&poly_squeeze_desc);
     plugin_add(&slew_rate_limiter_desc);
-    plugin_add(&multipitch_desc);
+    plugin_add(&ampliverter_desc);
+    plugin_add(&osc_fm_desc);
+    plugin_add(&lowpass_desc);
 }