Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision

Target

Select target project
  • flow3r/flow3r-firmware
  • Vespasian/flow3r-firmware
  • alxndr42/flow3r-firmware
  • pl/flow3r-firmware
  • Kari/flow3r-firmware
  • raimue/flow3r-firmware
  • grandchild/flow3r-firmware
  • mu5tach3/flow3r-firmware
  • Nervengift/flow3r-firmware
  • arachnist/flow3r-firmware
  • TheNewCivilian/flow3r-firmware
  • alibi/flow3r-firmware
  • manuel_v/flow3r-firmware
  • xeniter/flow3r-firmware
  • maxbachmann/flow3r-firmware
  • yGifoom/flow3r-firmware
  • istobic/flow3r-firmware
  • EiNSTeiN_/flow3r-firmware
  • gnudalf/flow3r-firmware
  • 999eagle/flow3r-firmware
  • toerb/flow3r-firmware
  • pandark/flow3r-firmware
  • teal/flow3r-firmware
  • x42/flow3r-firmware
  • alufers/flow3r-firmware
  • dos/flow3r-firmware
  • yrlf/flow3r-firmware
  • LuKaRo/flow3r-firmware
  • ThomasElRubio/flow3r-firmware
  • ai/flow3r-firmware
  • T_X/flow3r-firmware
  • highTower/flow3r-firmware
  • beanieboi/flow3r-firmware
  • Woazboat/flow3r-firmware
  • gooniesbro/flow3r-firmware
  • marvino/flow3r-firmware
  • kressnerd/flow3r-firmware
  • quazgar/flow3r-firmware
  • aoid/flow3r-firmware
  • jkj/flow3r-firmware
  • naomi/flow3r-firmware
41 results
Select Git revision
Show changes
Commits on Source (1341)
1,241 additional commits have been omitted to prevent performance issues.
Show whitespace changes
Inline Side-by-side
Showing
with 4547 additions and 381 deletions
.clang-format 0 → 100644
View file @ 9ced463c
---
BasedOnStyle: Google
IndentWidth: 4
IncludeBlocks: Preserve
Cpp11BracedListStyle: false
.clang-tidy 0 → 100644
View file @ 9ced463c
# Don't care about deprecated APIs (noisy) and about memcpy/strcpy (we'll fix
# that later).
Checks: '-clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,-clang-diagnostic-deprecated-declarations'
.gitignore
View file @ 9ced463c
...@@ -4,15 +4,25 @@ sdkconfig ...@@ -4,15 +4,25 @@ sdkconfig
dependencies.lock dependencies.lock
build build
.sdkconfig.defaults.generated
# micropython # micropython
__pycache__ __pycache__
# editor crud # editor crud
.vscode .vscode
*swp *swp
*~
# Python # Python
.venv .venv
/venv/
# sphinx # sphinx
docs/_build/ docs/_build/
/tools/mypy.sh
# bl00mbox docs
components/bl00mbox/docs/
components/bl00mbox/public/
.gitlab-ci.yml
View file @ 9ced463c
stages: stages:
- check
- build - build
- deploy
build-p1: variables:
stage: build GIT_SUBMODULE_STRATEGY: recursive
tags: GIT_DEPTH: 0
- nixos
default:
# built via:
# docker load < $(nix-build nix/docker-image.nix)
image: registry.gitlab.com/flow3r-badge/flow3r-build:238576xsg79mjr2bkqg106qisvd3b5q9
clang-tidy:
stage: check
script: script:
- nix-shell nix/shell.nix --command "idf.py -g p1 build" - "bash tools/clang-tidy.sh"
- "python3 tools/codequal-report.py clang-tidy warnings.txt > cqual.json"
artifacts: artifacts:
expose_as: 'Proto 1 ELF' when: always
paths: ['build/badge23.elf'] reports:
expire_in: 5 hours codequality: cqual.json
format:
stage: check
script:
- "git clean -fdx"
- "bash tools/format.sh"
- "[ -z \"$(git status --porcelain)\" ] || (echo 'Differences found, please run tools/format.sh.' && git diff HEAD && exit 1)"
build-p3: build:
stage: build stage: build
tags:
- nixos
script: script:
- nix-shell nix/shell.nix --command "idf.py -g p3 build" - idf.py -g c23 build size
artifacts: artifacts:
expose_as: 'Proto 3 ELF' expose_as: 'firmware'
paths: ['build/badge23.elf'] paths: ['build/flow3r.bin']
expire_in: 5 hours expire_in: 5 hours
build-p4: build_recovery:
stage: build stage: build
tags:
- nixos
script: script:
- nix-shell nix/shell.nix --command "idf.py -g p4 build" - cd recovery
- idf.py build size
artifacts: artifacts:
expose_as: 'Proto 4 ELF' expose_as: 'Recovery'
paths: ['build/badge23.elf'] paths: ['recovery/build/flow3r-recovery.bin', 'recovery/build/partition_table/partition-table.bin', 'recovery/build/bootloader/bootloader.bin']
expire_in: 5 hours expire_in: 5 hours
build-p6: simulate:
stage: build stage: build
tags:
- nixos
script: script:
- nix-shell nix/shell.nix --command "idf.py -g p6 build" - python3 sim/run.py --screenshot
artifacts: artifacts:
expose_as: 'Proto 6 ELF' expose_as: 'Simulator Screenshot'
paths: ['build/badge23.elf'] paths: ['flow3r.png']
expire_in: 5 hours expire_in: 5 hours
pages:
stage: deploy
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 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']
.gitmodules
View file @ 9ced463c
[submodule "lib/berkeley-db-1.xx"] [submodule "lib/berkeley-db-1.xx"]
path = micropython/lib/berkeley-db-1.xx path = components/micropython/vendor/lib/berkeley-db-1.xx
url = https://github.com/pfalcon/berkeley-db-1.xx url = https://github.com/pfalcon/berkeley-db-1.xx
[submodule "lib/micropython-lib"] [submodule "lib/micropython-lib"]
path = micropython/lib/micropython-lib path = components/micropython/vendor/lib/micropython-lib
url = https://github.com/micropython/micropython-lib.git url = https://github.com/micropython/micropython-lib.git
CHANGELOG.md 0 → 100644
View file @ 9ced463c
# 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
View file @ 9ced463c
...@@ -4,4 +4,19 @@ set(IDF_TARGET esp32s3) ...@@ -4,4 +4,19 @@ set(IDF_TARGET esp32s3)
include($ENV{IDF_PATH}/tools/cmake/project.cmake) include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(badge23) project(flow3r)
# Make `1.1` literals into single-point precision float instead of double
# precision. Also warn any time something gets promoted to a double. We
# 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)
endif()
COPYING
View file @ 9ced463c
GNU GENERAL PUBLIC LICENSE GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007 Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed. of this license document, but changing it is not allowed.
...@@ -671,4 +671,4 @@ into proprietary programs. If your program is a subroutine library, you ...@@ -671,4 +671,4 @@ into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with 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 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 Public License instead of this License. But first, please read
<https://www.gnu.org/licenses/why-not-lgpl.html>. <http://www.gnu.org/philosophy/why-not-lgpl.html>.
COPYING.LESSER 0 → 100644
View file @ 9ced463c
GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.
0. Additional Definitions.
As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.
"The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.
An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.
A "Combined Work" is a work produced by combining or linking an
Application with the Library. The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".
The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.
The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.
1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.
2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:
a) under this License, provided that you make a good faith effort to
ensure that, in the event an Application does not supply the
function or data, the facility still operates, and performs
whatever part of its purpose remains meaningful, or
b) under the GNU GPL, with none of the additional permissions of
this License applicable to that copy.
3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from
a header file that is part of the Library. You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:
a) Give prominent notice with each copy of the object code that the
Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the object code with a copy of the GNU GPL and this license
document.
4. Combined Works.
You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:
a) Give prominent notice with each copy of the Combined Work that
the Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the Combined Work with a copy of the GNU GPL and this license
document.
c) For a Combined Work that displays copyright notices during
execution, include the copyright notice for the Library among
these notices, as well as a reference directing the user to the
copies of the GNU GPL and this license document.
d) Do one of the following:
0) Convey the Minimal Corresponding Source under the terms of this
License, and the Corresponding Application Code in a form
suitable for, and under terms that permit, the user to
recombine or relink the Application with a modified version of
the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.
1) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (a) uses at run time
a copy of the Library already present on the user's computer
system, and (b) will operate properly with a modified version
of the Library that is interface-compatible with the Linked
Version.
e) Provide Installation Information, but only if you would otherwise
be required to provide such information under section 6 of the
GNU GPL, and only to the extent that such information is
necessary to install and execute a modified version of the
Combined Work produced by recombining or relinking the
Application with a modified version of the Linked Version. (If
you use option 4d0, the Installation Information must accompany
the Minimal Corresponding Source and Corresponding Application
Code. If you use option 4d1, you must provide the Installation
Information in the manner specified by section 6 of the GNU GPL
for conveying Corresponding Source.)
5. Combined Libraries.
You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:
a) Accompany the combined library with a copy of the same work based
on the Library, uncombined with any other library facilities,
conveyed under the terms of this License.
b) Give prominent notice with the combined library that part of it
is a work based on the Library, and explaining where to find the
accompanying uncombined form of the same work.
6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser 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
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.
README.md
View file @ 9ced463c
## Demo Payload # flow3r badge
See python_payload/README.md for a demo application. See https://docs.flow3r.garden/badge/firmware-development.html for a firmware development guide.
Files can be transferred either by performing an `idf.py flash` or with mpremote, such as:
```
mpremote fs cp python_payload/main.py :main.py
```
Alternatively, adafruit-ampy may work more reliably sometimes:
```
ampy -p /dev/ttyACM0 -d3 put main.py
```
Please transfer all .py files in python_payload/ for using the demo payload.
## How to install dependencies
### Generic
1. install esp-idf v4.4:
(copied from https://www.wemos.cc/en/latest/tutorials/others/build\_micropython\_esp32.html)
```
$ cd ~
$ git clone https://github.com/espressif/esp-idf.git
$ cd esp-idf
$ git checkout v4.4.4
$ git submodule update --init --recursive
$ cd esp-idf
$ ./install.sh
$ source export.sh
```
best put something like "alias espidf='source ~/esp-idf/export.sh'" in your .bashrc etc,
you need to run it in every new terminal and adding it to autostart did bother us
### Nix(OS)
```
$ nix-shell nix/shell.nix
```
## How to build and flash
Standard ESP-IDF project machinery present and working. You can run `idf.py` from the git checkout and things should just work.
### Building
Prepare submodules:
```
git submodule update --init --recursive
```
Build normally with idf.py:
```
$ idf.py build
```
By default, code for the fourth generation prototype will be built. To select a different generation, either set `-g`/`--generation` during an `idf.py build` (which will get cached for subsequent builds) or set the BADGE_GENERATION environment variable to one of the following values:
| `-g` / `BADGE_GENERATION` value | Badge Generation |
|---------------------------------|------------------------------------|
| `p1` or `proto1` | Prototype 1 |
| `p3` or `proto3` | Prototype 3 (B3xx) |
| `p4` or `proto4` | Prototype 4 (B4xx) |
**Important**: when switching generations, do a full clean by running `rm -rf sdkconfig build`. Otherwise you will get _weird_ errors and likely will end up building for the wrong architecture.
### Flashing
Put badge into bootloader mode by holding left should button down during boot.
```
$ idf.py -p /dev/ttyACM0 flash
```
The following targets are available for flashing:
| Target | Flashes |
|--------------------|-------------------------------------------------|
| `idf.py flash` | Bootloader, C code, Python Code / FAT partition |
| `idf.py app-flash` | C code |
| `idf.py vfs-flash` | Python Code / FAT partition |
You can skip `-p /dev/ttyACM0` if you set the environment variable `ESPPORT=/dev/ttyACM0`. This environment variable is also set by default when using Nix.
After flashing, remember to powercycle your badge to get it into the user application.
### Cleaning
For a full clean, do **not** trust `idf.py clean` or `idf.py fullclean`. Instead, do:
```
$ rm -rf build sdkconfig
```
### Accessing MicroPython REPL:
```
$ picocom -b 115200 /dev/ttyACM0
$ # or
$ screen /dev/ttyACM0
$ # or (will eat newlines in REPL, though)
$ idf.py -p /dev/ttyACM0 monitor
```
### Use CMake
`idf.py` calls cmake under the hood for most operations. If you dislike using wrappers you can do the same work yourself:
```
mkdir build
cd build
cmake .. -G Ninja
ninja
```
There's `flash/monitor` targets, too (but no openocd/gdb...). To pick what port to flash to/monitor, set the ESPPORT environment variable.
## How to modify
### Structure
```
main/ - main module, starts micropython on core1 and continues
executing components/badge23/.
usermodule/ - `hardware`, `synth`, ... C modules exposed to micropython.
components/badge23/ - main ESP-IDF `app_main`, runs on core 0 after micropython
gets started on core1.
components/gc9a01/ - low-level LCD driver.
```
### General info
Global + micropython entry point: `app_main()` in `micropython/ports/esp32/main.c`, compiled into `main/` component.
C entry point, called by^: `os_app_main()` in components/badge23/espan.c
Register new C files for compilation: add to components/badge23/CMakelists.txt
Change output volume in the `set_global_vol_dB(int8_t)` call; -90 for mute
### Debugging
The badge is currently configured to run in HW USB UART/JTAG mode (vs. using TinyUSB and 'software' CDC/whatever using the generic OTG peripheral).
What this means:
1. You can use the MicroPython REPL over a USB console,
2. The MicroPython REPL will also print ESP-IDF logs, including panics,
3. You can use OpenOCD/GDB.
#### printf() debugging and logging in C-land
Given the above, you can do the following to get a log. This is part of ESP-IDF's standard logging functionality.
```
static const char *TAG = "misery";
// ...
ESP_LOGI(TAG, "i love C");
```
However, this will **only work** if you first set `CONFIG_LOG_DEFAULT_LEVEL_INFO=y` (which will likely break programs interacting with micropython REPL as many components of the ESP-IDF will suddenly become very chatty). But that's fine for troubleshooting some C-land bugs.
If you want to only log errors or just add temporary logs, use `ESP_LOGE` instead, which will always print to the USB console.
`printf()` also just works. But it should only be used for development debugging, for long-term logging statements please use `ESP_LOG*` instead.
#### Running OpenOCD+GDB
First, make sure your badge is running in application mode (not bootloader mode! that will stay in bootloader mode).
Then, start OpenOCD:
```
$ OPENOCD_COMMANDS="-f board/esp32s3-builtin.cfg" idf.py openocd
```
(you can skip setting `OPENOCD_COMMANDS` if you're using Nix)
Then, in another terminal:
```
$ idf.py gdb
```
Good luck. The idf.py gdb/openocd scripts seem somewhat buggy.
### ESP-IDF functionality
#### sdkconfig / menuconfig
We have an sdkconfig.default file per badge generation. See the build
instructions above to see how to select the generation to build against.
The build system will generate an sdkconfig, but it should not be committed into
version control. Instead, treat it like an ephemeral artifact that you can also
modify for your own needs during development.
To run menuconfig, do the usual::
```
$ idf.py menuconfig
```
(Specify -g or BADGE_GENERATION if you haven't built the firmware yet)
Then, either save into the temporary sdkconfig by using 'S', or save into a
defconfig by using 'D'. The resulting `build/defconfig` file can then be copied
into `sdkconfig.$generation` to change the defaults for a given generation.
### Badge link
Badge link lets you have UART between badges or other devices using a 3.5mm
audio cable.
Baud rates up to 5mbit are supported in theory, but data corruption is likely
with higher rates.
Use baud rate 31250 for MIDI.
Note that `badge_link.enable()` will refuse to enable line out if the cable is
not connected. Connect it first. Connecting headphones with badge link enabled
is not recommended, especially not when wearing them.
Example usage:
On both badges:
```
import badge_link
from machine import UART
badge_link.enable(badge_link.PIN_MASK_ALL)
```
On badge 1, connect the cable to line out, and configure uart with tx on tip
(as an example)
```
uart = UART(1, baudrate=115200, tx=badge_link.PIN_INDEX_LINE_OUT_TIP, rx=badge_link.PIN_INDEX_LINE_OUT_RING)
```
On badge 2, connect the cable to line in, and configure uart with tx on ring:
```
uart = UART(1, baudrate=115200, tx=badge_link.PIN_INDEX_LINE_IN_RING, rx=badge_link.PIN_INDEX_LINE_IN_TIP)
```
Then write and read from each side:
```
uart.write("hiiii")
uart.read(5)
```
### Documentation
To build sphinx docs:
```
cd docs
make html
firefox _build/html/index.html
```
To continuously build on change:
```
watchexec make html
```
## License ## License
All original source code in this reporitory is Copyright (C) 2023 Flow3r Badge Contributors. This source code is licensed under the GNU General Public License Version 3.0 as described in the file COPYING. All original source code in this repository is Copyright (C) 2023 Flow3r Badge Contributors. This source code is licensed under the GNU Lesser General Public License Version 3.0 as described in the file COPYING.
This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License Version 3.0 as published by the Free Software Foundation. This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License Version 3.0 as published by the Free Software Foundation.
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. 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 Lesser General Public License for more details.
You should have received a copy of the GNU General Public License Version 3.0 along with this program. If not, see <https://www.gnu.org/licenses/>. You should have received a copy of the GNU Lesser General Public License Version 3.0 along with this program. If not, see <https://www.gnu.org/licenses/>.
components/audio_mod/CMakeLists.txt 0 → 100644
View file @ 9ced463c
idf_component_register(
SRCS
audio_mod.c
INCLUDE_DIRS
.
../ctx
../st3m
)
components/audio_mod/audio_mod.c 0 → 100644
View file @ 9ced463c
#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 0 → 100644
View file @ 9ced463c
/* 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 0 → 100644
View file @ 9ced463c
idf_component_register(
SRCS
audio_mp3.c
INCLUDE_DIRS
.
../ctx
../st3m
)
components/audio_mp3/LICENSE 0 → 100644
View file @ 9ced463c
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 0 → 100644
View file @ 9ced463c
#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 0 → 100644
View file @ 9ced463c
#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/badge23/CMakeLists.txt deleted 100644 → 0
View file @ 579c9579
idf_component_register(
SRCS
apa102LEDStrip.c
audio.c
captouch.c
espan.c
leds.c
synth.c
spio.c
INCLUDE_DIRS
include
REQUIRES
flow3r_bsp
st3m
espressif__led_strip
)
components/badge23/README.md deleted 100644 → 0
View file @ 579c9579
badge23/espan
===
Transitional component containing all custom C code for badge23, including drivers for peripherals and 'espan' application leftovers.
This will be likely split up into sub-components.
components/badge23/apa102LEDStrip.c deleted 100644 → 0
View file @ 579c9579
#include "badge23/apa102LEDStrip.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
void initLEDs(struct apa102LEDStrip *ledObject, short int numLEDs, unsigned char bytesPerLED, unsigned char globalBrightness)
{
ledObject->_numLEDs = numLEDs;
ledObject->_bytesPerLED = bytesPerLED;
ledObject->_endFrameLength = 1;//round( (numLEDs/2)/8 );
ledObject->_frameLength = (1+numLEDs+ledObject->_endFrameLength)*bytesPerLED;
ledObject->_globalBrightness = globalBrightness;
ledObject->LEDs = (unsigned char *)malloc(ledObject->_frameLength*sizeof(unsigned char));
//Start Frame
ledObject->LEDs[0] = 0;
ledObject->LEDs[1] = 0;
ledObject->LEDs[2] = 0;
ledObject->LEDs[3] = 0;
//Driver frame+PIXEL frames
for(ledObject->_counter=ledObject->_bytesPerLED; ledObject->_counter<ledObject->_frameLength-(ledObject->_endFrameLength*ledObject->_bytesPerLED); ledObject->_counter+=ledObject->_bytesPerLED)
{
ledObject->LEDs[ledObject->_counter] = ledObject->_globalBrightness;
ledObject->LEDs[ledObject->_counter+1] = 0;
ledObject->LEDs[ledObject->_counter+2] = 0;
ledObject->LEDs[ledObject->_counter+3] = 0;
}
//END frames
for(ledObject->_counter=ledObject->_frameLength-(ledObject->_endFrameLength*ledObject->_bytesPerLED); ledObject->_counter<ledObject->_frameLength; ledObject->_counter+=ledObject->_bytesPerLED)
{
ledObject->LEDs[ledObject->_counter] = 255;
ledObject->LEDs[ledObject->_counter+1] = 255;
ledObject->LEDs[ledObject->_counter+2] = 255;
ledObject->LEDs[ledObject->_counter+3] = 255;
}
}
void setPixel(struct apa102LEDStrip *ledObject, short int pixelIndex, unsigned char *pixelColour)
{
ledObject->_counter = 4*(pixelIndex+1);
ledObject->LEDs[ ledObject->_counter + 1 ] = pixelColour[2];
ledObject->LEDs[ ledObject->_counter + 2 ] = pixelColour[1];
ledObject->LEDs[ ledObject->_counter + 3 ] = pixelColour[0];
}
void getPixel(struct apa102LEDStrip *ledObject, short int pixelIndex, unsigned char *pixelColour)
{
ledObject->_counter = 4*(pixelIndex+1);
pixelColour[2] = ledObject->LEDs[ ledObject->_counter + 1 ];
pixelColour[1] = ledObject->LEDs[ ledObject->_counter + 2 ];
pixelColour[0] = ledObject->LEDs[ ledObject->_counter + 3 ];
}